TypeScript checker parity: eliminate the remaining 30 failures

Parent: #67

Scope

Make ts_checker fully green by porting the remaining TypeScript semantics and exact diagnostic behavior. Do not weaken assertions or encode fixture-specific outcomes.

Current verified state

After fixing distributive-conditional union member ownership:

• 2,976 / 3,006 pass
• 30 fail
• 0 crash (down from 2 crashes)

The crash fix copies union member IDs before recursive conditional evaluation so interner reallocations cannot invalidate a borrowed slice.

Remaining failure clusters

• Enum/member literal assignment compatibility.
• Global-script this indexed access diagnostics.
• Generic defaults, conditional distribution, NonNullable, mapped and template types.
• Variadic tuple inference and callback arity.
• Overload diagnostic anchoring and CheckJS/JSDoc arity.
• Accessor read/write and spread typing.
• Alias/generic-instance diagnostic rendering.
• Recursive type depth/circular mapped diagnostics.

Completion gate

• ./pantry/.bin/zig build test -Dfilter=ts_checker --summary failures reports 3,006 / 3,006.
• No crash, timeout, or skipped parity assertion replaces a failure.
• Each semantic cluster lands in a focused conventional commit with regression coverage.

Crash-removal chunk landed in 5ed86afd3.

Verified:

• conditional union call signatures do not leak excess properties: 2/2 pass.
• distributive conditional yielding union of callables is callable: 2/2 pass.
• Full ts_checker: 2,976/3,006 pass, 30 fail, 0 crash.
• Net movement: 2 crashes flipped to passes; remaining failure list is unchanged.

Root cause was a borrowed unionMembers slice surviving recursive interning that could reallocate its backing pool. The evaluator now owns a copy for the recursive loop.

Enum-member identity chunk landed in 8ca140fee.

Verified delta:

• Checker regression enum assignment compat models enum value object and member literals: 2/2 pass.
• Compiler exact enumAssignmentCompat* cluster: 4/7 -> 6/7.
• enumAssignmentCompat and enumAssignmentCompat2 now pass exactly.
• Remaining enum fixture is enumAssignmentCompat5, whose only mismatch is the TypeScript rule allowing a broad number value to assign to numeric enum member type E.A.

Pushed 9f04059c0 (fix(ts-checker): allow number for numeric enum members).

This ports tsgo's bit-flag assignability rule: broad number is assignable to numeric enum-member types, while numeric literal sources still require an exact value match. enumAssignmentCompat5 flips to exact, taking the focused enum cluster from 6/7 to 7/7. Focused regression passes; full checker is 2,978/3,007 passing, 29 known failures, zero crashes.

Pushed 19c1c7aa5 (fix(ts-checker): diagnose global this computed writes).

Top-level this/globalThis computed writes now bypass the synthetic global-object index under noImplicitAny, preserving TS7053 with typeof globalThis. Full checker moves from 2,978/3,007 (29 failures) to 2,979/3,007 (28 failures), zero crashes.

Pushed 252b3902c (fix(ts-checker): elaborate generic parameter defaults).

Unsafe parameter defaults targeting bare type parameters now use the existing instantiation-mismatch diagnostics; constrained defaults such as U extends T remain valid. All 12 focused parameter-default tests pass. Full checker moves from 2,979/3,007 (28 failures) to 2,980/3,007 (27 failures), zero crashes.

Pushed 2b0e9d516 (fix(ts-checker): anchor overload errors on arguments).

TS2769 now carries the incompatible argument node out of overload applicability checks, preserving per-overload chains and related declarations while anchoring the diagnostic like tsgo. Corrected a legacy boolean-call assertion accidentally changed by an earlier construct-overload commit. All 4 focused overload-match tests pass. Full checker moves from 2,980/3,007 (27 failures) to 2,981/3,007 (26 failures), zero crashes.

Pushed 31886d9ba (fix(ts-checker): aggregate constructor overload arity).

When no constructor overload accepts a boundary arity, Home now aggregates the visible overload set's finite min/max instead of selecting the first signature. The JSDoc case now reports Expected 1-2 arguments, but got 0. All 5 focused constructor-overload tests pass. Full checker moves from 2,981/3,007 (26 failures) to 2,982/3,007 (25 failures), zero crashes.

Pushed bfec0b1d5 (fix(ts-checker): reject value-only type references).

Bare type references now resolve in the type namespace before accepting narrowed/cached value symbols, and unresolved annotations that bind only to vars/functions emit TS2749 with the typeof suggestion. All 3 focused value-only tests pass. Full checker moves from 2,982/3,007 (25 failures) to 2,983/3,007 (24 failures), zero crashes.

Pushed 885bf0dc3 (fix(ts-checker): preserve accessor reads in spreads).

Object-literal getters now infer read types, paired setters no longer overwrite those reads, and undefined-target object members use the actual relation in non-strict mode. The get/set spread regression flips while set-only spread and getter/indexer focused checks remain green. Full checker moves from 2,983/3,007 (24 failures) to 2,984/3,007 (23 failures), zero crashes.

Pushed 36407ef40 (fix(ts-checker): infer generic class variance).

• Added the missing class-body variance inference pass after the final instance shape is assembled, matching existing function/interface/type-alias behavior.
• Generic classes such as A<T> { foo: T } now infer T as covariant instead of falling through to bivariant relation.
• Flipped 2 checker tests: 2984/3007 -> 2986/3007.
• Covered both accessor read/write separation and nested TS2322 elaboration for List<string> versus List<number>.
• Focused regressions pass; full checker suite completes with 21 remaining failures and zero crashes.
• Commit author and committer are Chris <chrisbreuer93@gmail.com> with no coauthor trailers; pushed to origin/main.

Pushed 06317c43d (fix(ts-checker): scope mapped cycle diagnostics).

• Restricted TS2615 emission to materialized literal mapped properties.
• Broad string/number/symbol mapped-index evaluation still terminates recursive value lowering with any, but no longer emits a false property named after the key domain.
• Preserved the real concrete-property cycle diagnostic ("M") and the silent direct-recursive mapped-alias case.
• Flipped 1 checker test: 2986/3007 -> 2987/3007.
• Focused tests and the full 3,007-test checker suite completed; 20 failures remain, with zero crashes.
• Commit author and committer are Chris <chrisbreuer93@gmail.com> with no coauthor trailers; pushed to origin/main.

Pushed 9c8fb3dad (fix(ts-checker): prefer circular type argument errors).

• Made TS4109/TS4110 authoritative when eager instantiation has already emitted TS2589 at the same reference node.
• Removes only the same-node overflow diagnostic, then keeps the existing per-node suppression marker for later recursion.
• Preserves TS2589 at unrelated sites, finite deep generic instantiation, and legitimate body-recursive generic behavior.
• Flipped 1 checker test: 2987/3007 -> 2988/3007.
• Focused cycle/depth regressions and the full 3,007-test checker suite completed; 19 failures remain, with zero crashes.
• Commit author and committer are Chris <chrisbreuer93@gmail.com> with no coauthor trailers; pushed to origin/main.

Pushed 96cb0aaa3 (fix(ts-checker): name enums in overlap diagnostics).

• TS2367 now prefers nominal whole-enum identity before structurally rendering an enum's branded intersection.
• E versus string renders as such instead of exposing number & { readonly '__enum:...': never; }.
• Preserved Enum.Member rendering for enum literals and literal-text rendering for ordinary aliases.
• Flipped 1 checker test: 2988/3007 -> 2989/3007.
• Focused formatting regressions and the full 3,007-test checker suite completed; 18 failures remain, with zero crashes.
• Commit author and committer are Chris <chrisbreuer93@gmail.com> with no coauthor trailers; pushed to origin/main.

Pushed a1c625085 (fix(ts-checker): expand literal assignment aliases).

• Reordered TS2322 source display selection so concrete single-literal aliases inline before generic alias preservation.
• Added template-literal source rendering so aliases such as BT = \AA${Uppercase<string>}`` display their pattern body.
• Preserved union alias names such as B = 2 | 3 where the alias carries useful diagnostic identity.
• Flipped 2 checker tests: 2989/3007 -> 2991/3007.
• Focused alias-format regressions and the full 3,007-test checker suite completed; 16 failures remain, with zero crashes.
• Commit author and committer are Chris <chrisbreuer93@gmail.com> with no coauthor trailers; pushed to origin/main.

Pushed dd7600f0d (fix(ts-checker): reject readonly array type arguments).

• Allowed array-like constraints through TS2344 diagnostic naming instead of aborting on structural complexity.
• Unified array display with the checker’s readonly-array predicate, including tuple/shape-carried readonly metadata.
• V extends readonly unknown[] now fails T extends unknown[] with the expected header and readonly unknown[] mutability chain.
• Flipped 1 checker test: 2991/3007 -> 2992/3007.
• Focused readonly/rest regressions and the full 3,007-test checker suite completed; 15 failures remain, with zero crashes.
• Commit author and committer are Chris <chrisbreuer93@gmail.com> with no coauthor trailers; pushed to origin/main.

Pushed 364077008 (fix(ts-checker): inspect union index members safely).

• Handles union index types before their aggregate is_literal flag when selecting TS7053’s missing-property child.
• Prevents a union payload index from being read through the literal payload pool, which had leaked stale property text from an earlier access.
• Preserves union declaration order and now names the first missing property (b) in the chain.
• Flipped 1 checker test: 2992/3007 -> 2993/3007.
• Focused literal/union/broad index regressions and the full 3,007-test checker suite completed; 14 failures remain, with zero crashes.
• Commit author and committer are Chris <chrisbreuer93@gmail.com> with no coauthor trailers; pushed to origin/main.

Pushed b5d203180 (fix(ts-checker): infer callback rest tuples first).

Bare generic callback rest parameters now infer from the callback's complete positional signature before per-annotation scalar inference. This preserves fixed tuple arity and trailing void omission semantics.

Checker parity: 2993/3007 -> 2996/3007 (3 tests flipped), with zero crashes. Remaining: 11.

Pushed 9a6582ed7 (fix(ts-checker): preserve callback suffix mismatches).

Rest-tuple callback suffix checking now distinguishes non-applicable shapes from applicable callbacks whose annotations reject captured values, preventing generic fallback from erasing a real mismatch.

Checker parity: 2996/3007 -> 2997/3007 (1 test flipped), with zero regressions/crashes. Remaining: 10.

Pushed c25754232 (fix(ts-checker): accept string-like intersections).

Intrinsic string mappings now recognize intersection subtyping: S & string and intersected template literals satisfy the string constraint when a constituent is string-compatible, while unions still require every branch.

Checker parity: 2997/3007 -> 2999/3007 (2 tests flipped; 5 spurious TS2344 diagnostics removed). Remaining: 8.

Pushed ccb9d934a (fix(ts-checker): preserve mapped tuple positions).

Homomorphic mapped tuple instantiation now materializes concrete numeric members, preserves the mapped number index, and delays T[K] resolution until K is concrete. Per-position types no longer collapse to the tuple element union.

Checker parity: 2999/3007 -> 3000/3007 (1 test flipped). Remaining: 7.

Pushed 237840753 (fix(ts-checker): distinguish mapped key remaps).

Generic source assignments now resolve mapped alias bodies and distinguish identity/filter remaps from key-manufacturing remaps. Raw T remains assignable to homomorphic/filter mappings but not to p_${P} or fixed-key transforms.

Checker parity: 3000/3007 -> 3001/3007 (1 test flipped). Remaining: 6.

Pushed ad89f5cc9 (fix(ts-checker): prefer literals in mixed targets).

Mixed union/intersection assignment checking now tests fresh literals before widening into the structural fast path. Known keyof intersections and prefixed templates accept matching literals while mismatched placeholders remain rejected.

Checker parity: 3001/3007 -> 3002/3007 (1 test flipped). Remaining: 5.

Pushed be5c8b6e5 (fix(ts-checker): distribute concrete union checks).

Unwrapped concrete union checks now enter conditional distribution, while single-element tuple wrappers retain the explicit non-distributing path.

Checker parity: 3002/3007 -> 3003/3007 (1 test flipped). Remaining: 4.

Pushed 8ce2b9495 (test(ts-checker): count explicit literal call errors).

The local flow test now matches TypeScript-go's typeArgumentsWithStringLiteralTypes01 baseline: 3 invalid explicit initializer calls + 5 string assignment errors + 5 union-to-"Hello" call errors = 13. The three initializer diagnostics are pinned explicitly.

Checker parity: 3003/3007 -> 3004/3007 (1 test oracle corrected). Remaining: 3.

Pushed 287759a70 (fix(ts-checker): enforce generic NonNullable targets).

Bare type parameters now have to satisfy the {} member of T & {}; nullish-admitting constraints no longer pass T -> NonNullable<T>. The fixture oracle now matches TypeScript-go's 4-error conditionalTypes1 baseline.

Checker parity: 3004/3007 -> 3005/3007 (1 test flipped; 2 missing generic assignment errors added). Remaining: 2.

Pushed 40276e748 (fix(ts-checker): relate recursive alias wrappers).

Equal non-generic wrappers around recursive string-indexer unions now relate when one namespace instantiation is cycle-cut to an unresolved index. Direct generic aliases still preserve and compare type arguments.

Checker parity: 3005/3007 -> 3006/3007 (1 test flipped). Remaining: 1 (recursive PathKeys accepts tuple object path).

Checker unit parity is now fully green.

Pushed af498e5f2 (fix(ts-checker): preserve recursive path constraints):

• reuses the recursive dotted-path proof during the post-inference generic constraint audit
• prevents concrete tuple-object paths such as cars.1.make from being rejected by an eagerly truncated template-literal union
• flips the final checker regression from 3006/3007 to 3007/3007 passing
• full zig build test -Dfilter=ts_checker --summary failures exits 0 with zero failures

Authorship is Chris only, with no coauthors. Next I am widening verification to the documented TypeScript conformance/parity suites before closing this work.

Checker unit parity is now fully green.\n\nPushed ():\n- reuses the recursive dotted-path proof during the post-inference generic constraint audit\n- prevents concrete tuple-object paths such as from being rejected by an eagerly truncated template-literal union\n- flips the final checker regression from 3006/3007 to 3007/3007 passing\n- full exits 0 with zero failures\n\nAuthorship is Chris only, with no coauthors. Next I am widening verification to the documented TypeScript conformance/parity suites before closing this work.

Pushed c1d1729e9 (fix(ts-checker): allow loose null enum writes).

The assignment checker now applies loose-mode nullish semantics before nominal enum specialization, while strict mode and generic NonNullable<T> constraints keep rejecting the same writes.

Measured flips:

• checker remains fully green at 3008/3008 after adding one focused regression
• nullAssignableToEveryType now passes
• named-category aggregate advances 85/86 -> 86/86
• full ts_conformance harness failure count is expected to move 15 -> 13 because both the pin and aggregate entry flip

Commit author and committer are Chris only; no coauthors.

Pushed aec94acdf (fix(ts-checker): protect primitive type keywords).

Unqualified primitive type refs now resolve before visible value bindings, so constants named string, number, or boolean cannot shadow the corresponding type keywords inside unions and overload signatures. Genuine value-only type references still emit TS2749.

Measured flips:

• checker: 3009/3009 after adding one regression
• stringLiteralTypesOverloads01: pass
• stringLiteralTypesOverloads02: pass
• stringLiteral baseline-aware category: 31/33 -> 33/33
• baseline-aware aggregate: 578/586 -> 580/586

Authorship remains Chris only, with no coauthors.

Pushed b16523b1a (fix(ts-checker): resolve forward class static sides).

A forward typeof Class query now materializes the future class and returns its static constructor side even when an earlier instance-type reference pre-registered the instance cache. This prevents instance accessors from leaking into mapped constraints such as PropertiesOf<typeof ApiItem>.

Measured flips:

• checker: 3010/3010 after one new regression
• accessorsOverrideProperty9: false TS2345 removed, exact pin now passes

Author and committer are Chris only; no coauthors.

Pushed 0af5ba418 (fix(ts-checker): omit missing untyped IIFE params).

This directly ports tsgo getSignatureFromDeclaration: a direct IIFE parameter with no annotation and no corresponding call argument does not increase the minimum argument count. Annotated parameters remain required and still emit TS2554 when omitted.

Measured flips:

• checker: 3011/3011 after one regression
• always-on contextuallyTypedIife: pass
• exact corpus filter: 0/2 -> 2/2 (contextuallyTypedIife, contextuallyTypedIifeStrict)

Authorship is Chris only, with no coauthors.

Pushed 9da14fe0f (fix(ts-checker): narrow loose unassigned unions).

typeof guards now narrow annotated variables that remain pending definite assignment when strictNullChecks is disabled. The pending-assignment suppression is preserved under strict-null mode, where TS2454 semantics still apply.

Measured flips:

• checker: 3012/3012 after one regression
• typeGuardOfFormExpr1AndExpr2: pass
• typeGuardOfFormExpr1OrExpr2: pass
• removes the paired false TS2322/TS2741/TS2739 diagnostics

Author and committer are Chris only; no coauthors.

Pushed 7d32c0d65 (fix(ts-checker): prefer merged type declarations).

Signature preflight and normal type-ref lowering now resolve visible interfaces/classes/aliases/enums before value-only TS2749 checks. This preserves TypeScript separate type/value namespaces when an interface and runtime variable intentionally share a name.

Measured flips:

• checker: 3013/3013 after one regression
• newOperatorConformance: pass
• removes the sole false TS2749 on merged nestedCtor

Commit author and committer are Chris only; no coauthors.

Pushed dd5979b52 (fix(ts-checker): keep dynamic symbol keys distinct) after rebasing over the unrelated incoming MySQL fix on origin/main.

Broad symbol expressions no longer receive stable computed-member names. Only bindable unique-symbol names such as const sym = Symbol() and Symbol.iterator participate in TS2718 duplicate-kind checks.

Measured flips:

• checker: 3014/3014 after one regression
• positive unique-symbol TS2718 coverage remains green
• symbolProperty2: pass
• symbolProperty4: pass

The rebase restored the unrelated local Home test edits and .claude/ files unchanged. Author and committer are Chris only; no coauthors.

Pushed 952f61ace (fix(ts-checker): contextualize iterable array elements) after rebasing over unrelated incoming JSX-parser and HTTP/2 fixes.

Plain Iterable/AsyncIterable types now retain element metadata. Array-to-iterable assignment and function-valued array element contextual typing both consume that metadata.

Measured flips:

• checker: 3015/3015 after one noImplicitAny regression proving the arrow parameter is actually typed
• iterableContextualTyping1: exact pass, false TS2322 removed
• focused regression rechecked after the rebase

The autostash restored unrelated local edits unchanged. Authorship remains Chris only, with no coauthors.

Pushed 5407d0178 (fix(ts-checker): preserve tuple class field literals) after rebasing over an unrelated parser documentation commit.

Array-literal class field initializers now use the existing tuple-aware positional assignability path before structural Array<T> comparison, including readonly tuple targets.

Measured flips:

• checker: 3016/3016 after one strict regression
• readonlyArraysAndTuples2: exact pass, false TS2322 removed
• expected baseline-aware aggregate: 580/586 -> 581/586 (combined aggregate verification will follow the named-tuple fix)

Focused regression rechecked after rebase. Authorship remains Chris only, no coauthors; unrelated local edits were restored unchanged.

Pushed 149f152dd (fix(ts-checker): honor unbounded target rest arity).

Ported tsgo’s hasEffectiveRestParameter(target) arity rule into signature relation: an unexpanded target array rest now has unbounded effective arity, while tuple rests remain bounded. This lets a fixed callback such as (elem: object, index: number) => object satisfy (...args: any[]) => any.

Parity movement:

• namedTupleMembers: 2 unexpected TS2345 diagnostics -> clean
• direct always-on conformance fixture failures: 1 -> 0
• checker suite: 3016/3016 -> 3018/3018
• added relation-level and checker-level regressions

Focused namedTupleMembers and the complete checker suite both pass. Next I’m resolving the four remaining baseline-aware relation fixtures, then continuing through the exact corpus.

Pushed 674d2286a (fix(ts-checker): retain trailing tuple rest elements).

Ported tsgo’s literal tuple-index behavior into Home’s object-shaped tuple representation by retaining the exact trailing rest element type. Literal accesses beyond the fixed prefix now resolve to that rest element, while dynamic numeric indexing still returns the full element union.

Parity movement:

• genericRestParameters2: 1 unexpected TS2345 diagnostic -> clean
• baseline-aware relationship survey: 582/586 -> 583/586
• checker suite: 3018/3018 -> 3019/3019

The focused conformance pin and complete checker suite pass. Three baseline-aware fixtures remain: overloaded generic-call inference, union/intersection generic signature identity, and async iterator structural compatibility.

Pushed 7170e75f8 (fix(ts-checker): canonicalize generic signature relations).

Promoted the existing initializer-only generic signature matcher into the central checker relation. Generic parameter lists and recursive constraints are now alpha-renamed by position before directional constraint, parameter, and return checks, matching tsgo’s canonical-signature behavior. The full suite exposed and helped preserve the stronger-vs-weaker recursive constraint boundary during implementation.

Parity movement:

• unionAndIntersectionInference3: failing -> clean
• baseline-aware relationship survey: 583/586 -> 584/586
• checker suite: 3019/3019 -> 3020/3020
• existing directional recursive-constraint regression remains green

Two baseline-aware fixtures remain: overloaded generic-call inference and async iterator structural compatibility.

Pushed 64961afb0 (fix(ts-checker): relate contextual functions to overload sets).

Replaced the free-type-parameter callable-object shortcut with pairwise coverage of every target call signature. Contextual function arguments now satisfy overloaded parameter types only when their arity, parameter flow, and return type relate to each overload; the existing two-required-parameters negative remains green.

Parity movement:

• genericCallWithOverloadedFunctionTypedArguments: 2 unexpected TS2345 diagnostics -> clean
• baseline-aware relationship survey: 584/586 -> 585/586
• exact filtered overload pair: 0/2 -> 1/2
• checker suite: 3020/3020 -> 3021/3021

The only remaining baseline-aware failure is async iterator structural compatibility. The sibling exact fixture still needs diagnostic parity and remains queued for the exact-corpus phase.

Pushed 457e87727 (fix(ts-checker): model async iterator result promises).

Ported the async iterator protocol into generator and builtin iterator synthesis: async next/return/throw methods now return Promise-wrapped iterator results, TReturn/TNext arguments and defaults are retained, and iteration recovers the yield channel separately from completion values.

Parity movement:

• types.asyncGenerators.es2018.1: 10 unexpected TS2322 diagnostics -> clean
• asyncGenerators baseline category: 1/2 -> 2/2
• exact focused filter: 0/1 -> 1/1
• checker suite: 3021/3021 -> 3022/3022

The combined baseline survey remains 585/586 because clearing the earlier generic-signature diagnostics exposed a later intersection-inference failure in unionAndIntersectionInference3 at foo1(sa). That is the next isolated chunk.

Pushed eed40a682 (fix(ts-checker): infer through iterable intersections).

Ported iteration-aware inference and relation for array-like sources. Iterable<T> members now infer T from the source yield channel even though Home’s synthetic arrays expose a number index instead of a materialized Symbol.iterator, and iterable intersections validate that semantic member alongside ordinary structural members.

Parity movement:

• remaining unionAndIntersectionInference3 TS2345 -> clean
• typeInference baseline category: 51/52 -> 52/52
• combined baseline-aware relationship survey: 585/586 -> 586/586
• checker suite: 3022/3022 -> 3023/3023

This retires the full tracked 586-case relationship slice at 100%. I’m continuing directly into the broader 5,907-case exact corpus; issue #69 stays open until exact checker parity is complete.

Pushed 9dd3f11f8 (fix(ts-checker): snapshot JSX attrs across alias refresh).

The first unfiltered 5,907-case exact survey exposed a checker panic at case 5508. Generic JSX alias refresh could grow the shared object-member pool while excess checking still iterated a borrowed attribute-member slice, poisoning later StringIds. The loop now snapshots members before recursive lookups.

Measured movement:

• tsxStatelessFunctionComponentsWithTypeArguments2: process abort -> completed diagnostic comparison
• exact survey blocker: removed at 5508/5907
• checker suite: 3023/3023 -> 3024/3024

The fixture still has ordinary JSX diagnostic mismatches, so it remains in the parity backlog. I’m resuming the exact survey beyond this former crash point to establish the complete corpus total and discover any later blockers.

Exact-corpus baseline established after the JSX crash fix:

• total: 5,907
• passed: 4,868
• failed: 1,039
• skipped: 0
• exact pass rate: 82.4%
• checker unit suite: 3,024/3,024
• curated relationship survey: 586/586

This is the first complete post-fix survey; the prior attempt aborted at case 5,508 and was not counted. The remaining work is now the exact diagnostic/semantic backlog, and #69 remains open until 5,907/5,907.

Checker parity update pushed in 37154a4a9 (fix(ts-checker): preserve template interpolation braces).

• Made source-annotation normalization distinguish object braces from template interpolation braces, preventing ${T} / ${number} from being rendered as ${T;} / ${number;} while retaining object-member semicolon formatting.
• Added a focused regression covering generic template parameters, nested string mappings, and object types containing template literal members.
• Exact targeted window: 0/4 -> 3/4.
• Newly exact-passing fixtures: templateLiteralTypes5, templateLiteralTypes7, stringLiteralsAssignedToStringMappings.
• stringMappingOverPatternLiterals remains failing on independent alias-display differences; its interpolation punctuation mismatches are gone.
• Checker suite: 3,025/3,025 passing (up from 3,024).
• Last complete exact survey was 4,868/5,907; this verified chunk establishes a floor of 4,871/5,907 (82.46%), pending the next complete survey for any additional flips.

Documentation checkpoint pushed in 10e6c23e8 (docs(ts-parity): publish 82.5 percent exact baseline).

• Re-ran the complete unfiltered exact corpus after 37154a4a9.
• Result: 4,871/5,907 exact passing (82.46%), 1,036 failing, 0 skipped.
• This confirms the prior template-interpolation chunk added exactly 3 full-corpus passes with no regressions from the previous 4,868/5,907 survey.
• Updated README.md, docs/PARITY-TYPESCRIPT.md, and docs/CAPABILITY_MATRIX.md from stale 68.7-71.4% snapshots.
• Corrected the stale checker-failure note: focused checker suite is 3,025/3,025 passing.

Issue remains open for the remaining 1,036 exact fixtures.

Checker parity update pushed in 6fee3d5fc (fix(ts-checker): display computed string mappings).

• Ported the typescript-go alias-identity rule used by relation diagnostics: preserve the original annotation only when the resolved type retains alias identity.
• Template literals and intrinsic string mappings now render their computed shapes, including nested same-kind normalization and capitalize/uncapitalize template evaluation.
• Removed 13 diagnostic-line mismatches from stringMappingOverPatternLiterals.
• Exact fixture result: 0/1 -> 1/1.
• Projected aggregate from the last complete survey: 4,872/5,907 (82.48%), with 1,035 remaining; the next full survey will revalidate the aggregate.
• Checker suite: 3,026/3,026 passing.

Issue remains open.

Checker parity update pushed in 6dffa158e (fix(ts-checker): parenthesize callable union diagnostics).

• Applied TypeScript precedence while rendering union type annotations for TS2403.
• Function and constructor constituents now render as (() => A) | (() => B) and (new () => A) | (new () => B) rather than ambiguous unparenthesized text.
• Removed both exact diagnostic mismatches in unionTypeLiterals.
• Exact fixture result: 0/1 -> 1/1.
• Projected aggregate: 4,873/5,907 (82.50%), with 1,034 remaining pending the next full survey.
• Checker suite: 3,027/3,027 passing.

Issue remains open.

Checker parity update pushed in cf006bd75 (fix(ts-checker): parenthesize cached callable unions).

• Fixed the conditional-expression union display cache, which bypassed the general callable-union precedence renderer.
• bestCommonTypeOfConditionalExpressions now matches the exact TS2322 callable-union line.
• Measured movement: -1 diagnostic-line mismatch, +0 complete fixtures; the fixture now differs only by two missing unconstrained generic return diagnostics at line 25.
• Aggregate projection stays 4,873/5,907, with 1,034 remaining.
• Checker suite: 3,028/3,028 passing.

Issue remains open.

Checker parity update pushed in bc8cc74bf (fix(ts-checker): validate generic conditional returns).

• Added branch-level return validation for conditional expressions targeting builtin Object.
• Unconstrained generic branches now emit TS2322 at each branch expression; constrained branches are accepted through the existing relation engine.
• Added the two missing line-25 diagnostics in bestCommonTypeOfConditionalExpressions.
• Targeted exact pair: 1/2 -> 2/2 (+1 complete fixture).
• Projected aggregate: 4,874/5,907 (82.51%), with 1,033 remaining pending the next complete survey.
• Checker suite: 3,029/3,029 passing.

Issue remains open.

Checker parity update pushed in d3efb9cbb (fix(ts-checker): resolve Document from DOM lib).

• Added DOM-gated builtin type resolution for Document in virtual declaration modules.
• @lib: es2020,dom now resolves Document in .d.html.ts; explicit lib lists without dom still emit the missing-name diagnostic.
• Exact pair: 0/2 -> 2/2.
• Newly exact-passing fixtures: declarationFileForHtmlImport, declarationFileForHtmlFileWithinDeclarationFile.
• Projected aggregate: 4,876/5,907 (82.55%), with 1,031 remaining pending the next complete survey.
• Checker suite: 3,030/3,030 passing.

Issue remains open.

Checker parity update pushed in b774a24d5 (fix(ts-checker): infer overloaded class constructors).

• Aligned new applicability with ordinary-call and super inference by instantiating every construct signature from arguments before checking it.
• Class type parameters now infer without requiring a separate generic-signature side-table record.
• Newly exact-passing fixtures: constructSignaturesWithIdenticalOverloads, constructSignaturesWithOverloads, constructSignaturesWithOverloads2.
• Exact overload filter: 1/4 -> 4/4 (+3 complete fixtures).
• Projected aggregate: 4,879/5,907 (82.60%), with 1,028 remaining pending the next complete survey.
• Checker suite: 3,031/3,031 passing.

Issue remains open.

Checker parity update pushed in cfefae033 (fix(ts-checker): constrain template infer placeholders).

• Bare ${infer T} placeholders inside template-literal patterns now inherit TypeScript implicit string constraint.
• Explicit ${infer T extends X} constraints still take precedence; non-template infer declarations are unchanged.
• Removed four spurious TS2344 diagnostics from templateLiteralTypes1.
• Exact fixture result: 0/1 -> 1/1.
• Projected aggregate: 4,880/5,907 (82.62%), with 1,027 remaining pending the next complete survey.
• Checker suite: 3,032/3,032 passing.

Issue remains open.

Follow-up measurement for cfefae033: the same template-infer constraint fix also flips templateLiteralTypes3 to exact-pass by removing the spurious recursive Parts<Tail> TS2345.

• Additional verified fixture: templateLiteralTypes3 (0/1 -> 1/1).
• Total measured movement for cfefae033: +2 complete fixtures, not only the initially targeted +1.
• Corrected projected aggregate: 4,881/5,907 (82.63%), with 1,026 remaining.
• No code or history rewrite was needed; this is a broader verification of the pushed semantic rule.

Pushed a284a1abd (fix(ts-checker): preserve nonnullable string intersections).

This ports two connected TypeScript semantics:

• {} remains the empty-object/non-nullish type, so string & {} and template-string intersections stay inhabitable; lowercase object & string still reduces to never.
• A recognized NonNullable<X> -> X assignment updates X's flow type without relaxing unrelated generic-intersection assignment narrowing.

Measured exact flips:

• templateLiteralTypes2: 0/1 -> 1/1
• conditionalTypes1: 0/1 -> 1/1

Projected exact aggregate: 4,883/5,907 (82.66%), up from 4,881; 1,024 remain. The complete focused checker suite is green at 3,032/3,032. The 101-200 exact window is now projected at 98/100, with only the two this-type fixtures left.

Commit: https://github.com/home-lang/home/commit/a284a1abdd68be3c7fb6903a048d7eafbafecab1

Pushed 98e703f00 (fix(ts-checker): scope mapped key parameters).

This ports declaration-scoped mapped-key identity into Home: each mapped [K in ...] declaration now receives a stable fresh type-parameter ID, preventing same-named keys in earlier aliases from leaking substitutions into later reverse-mapped inference. It also avoids running the stale post-success nested diagnostic snapshot for the callable-or-Computed<T> accessor union shape, while a companion regression confirms genuinely incompatible accessor calls still report TS2322.

Measured parity impact:

• thisTypeInObjectLiterals2: exact 0/1 -> 1/1 (+1 fixture)
• projected aggregate: 4883/5907 -> 4884/5907 (82.68%), 1023 remaining
• checker coverage: 3032 -> 3034 tests; full checker suite 3034/3034 green
• post-rebase exact rerun: 1/1 green

No user-owned corpus runner changes were included in the commit.

Pushed 32c45e414 (fix(ts-checker): preserve class this identity).

• caches one polymorphic this type per class declaration so nested arrows, annotations, and receivers share identity
• routes polymorphic this call parameters through ordinary assignability instead of the unconstrained-generic shortcut
• exact thisTypeInClasses: 0/1 -> 1/1 (+1)
• exact 101-200 window: 99/100 -> 100/100 for this chunk (98/100 -> 100/100 across the paired mapped/class this fixes)
• projected aggregate: 4,884 -> 4,885 / 5,907 (82.70%), 1,022 remaining
• checker suite: 3,034 -> 3,035 tests, passing 3,035/3,035

Commit: https://github.com/home-lang/home/commit/32c45e41481f91e051742c41d0ea9ba8b2fc2553

Pushed ae52652ab (fix(ts-checker): preserve variadic mapped tuple tails).

• preserves trailing generic tuple operands separately from array rest elements through homomorphic mapping and substitution
• reverse-infers mapped array-literal tails as tuple slices
• applies existing mutable/readonly/constrained variadic relations when assignments involve bare type parameters
• exact variadicTuples1: 0/1 -> 1/1 (+1)
• diagnostic correction: 4 missing TS2322s added, 1 spurious TS2322 removed
• exact 201-300 window: 99/100 -> 100/100
• projected aggregate: 4,885 -> 4,886 / 5,907 (82.72%), 1,021 remaining
• checker suite: 3,035 -> 3,037 tests, passing 3,037/3,037
• conformance harness: 1,368/1,368, baseline-aware 586/586

Commit: https://github.com/home-lang/home/commit/ae52652abbd9a78750ad0714c7d6e40e1acb20c0

Pushed abb985e6c (fix(ts-checker): retain optionality in object literal relations).

• Preserves source-member optionality in the object-literal assignability fast path, so optional spread properties cannot satisfy required targets.
• Adds a strict-null regression for two optional spreads while retaining required-then-optional overwrite behavior.
• Exact parity: objectSpreadNegative 0/1 -> 1/1; window 301-400 87/100 -> 88/100.
• Projected aggregate: 4886 -> 4887/5907 (82.73%), 1020 remaining.
• Verification: ts_checker 3038/3038; ts_conformance package gate; exact 301-400 survey.

Pushed b5d3b59ce (fix(ts-checker): render optional parameter undefined types).

• Preserves the implicit | undefined constituent in optional-parameter diagnostic text across ordinary, nested, method, and construct callable renderers.
• Adds an interface-member assignment regression matching the upstream diagnostic path.
• Exact parity: assignmentCompatWithCallSignaturesWithOptionalParameters 0/1 -> 1/1; all 17 TS2322 headlines now match; window 301-400 88/100 -> 89/100.
• Projected aggregate: 4887 -> 4888/5907 (82.75%), 1019 remaining.
• Verification: ts_checker 3039/3039; ts_conformance package gate; exact 301-400 survey.

Pushed ecca733b4 (fix(ts-checker): nest type parameter instantiation diagnostics).

• Emits primary TS2322 for sibling type-parameter mismatches, with TS5075/TS5082 wording in the child chain.
• Keeps standalone TS5075/TS5082 for concrete sources and restores TS2208 related hints for unconstrained source parameters.
• Exact parity: typeParameterAssignability, typeParameterAssignability3, and unionTypesAssignability each 0/1 -> 1/1; window 301-400 89/100 -> 92/100.
• Projected aggregate: 4888 -> 4891/5907 (82.80%), 1016 remaining.
• Verification: ts_checker 3040/3040; ts_conformance package gate; exact 301-400 survey.

Pushed deecad45b (fix(ts-checker): preserve numeric property diagnostic spelling).

This ports TypeScript's distinction between canonical property identity and declaration spelling into TS2741 diagnostics: inferred object members retain their declaration nodes, quoted numeric keys remain quoted in structural shapes, numeric missing-property names preserve source spellings such as 1.0 and 1., compact optional members omit implicit | undefined, and namespace-scoped declaration names render in the expected bare form. Tuple and alias display paths remain protected.

Parity movement:

• assignmentCompatWithObjectMembersStringNumericNames: 0/1 -> 1/1
• exact fixtures 301-400: 92/100 -> 93/100
• aggregate exact parity: 4,891/5,907 -> 4,892/5,907 (82.82%)
• remaining exact fixtures: 1,015

Verification:

• checker: 3,041/3,041
• conformance package gate: passed
• exact 301-400 survey: 93/100

One focused checker regression now covers quoted numeric keys, original decimal spellings, compact optional shapes, namespace-local type names, and the legacy tuple/alias safeguards.

Pushed 7c6b4f523 (fix(ts-checker): preserve mutable object assignment slots).

This ports two related assignment-compatibility details: an existing flow-map entry only counts as an active narrow when it actually differs from the declared mutable slot, so a valid Base <- Derived write no longer changes later reads of that slot to Derived; and class instances nested in anonymous object diagnostics render by their leaf class name while retaining generic arguments.

Parity movement:

• assignmentCompatWithObjectMembers4: 0/1 -> 1/1
• exact fixtures 301-400: 93/100 -> 94/100
• aggregate exact parity: 4,892/5,907 -> 4,893/5,907 (82.83%)
• remaining exact fixtures: 1,014

Verification:

• checker: 3,042/3,042
• conformance package gate: passed
• exact 301-400 survey: 94/100

The focused regression verifies the valid subtype write, the invalid reverse write, the preserved mutable slot type, and bare nested class names in TS2322 prose.

Pushed 7bec2cf56 (fix(ts-checker): relate discriminated tuple conditionals).

• Ported equality OR-chain narrowing and flow-aware fixed tuple relation for conditional array branches.
• Routed namespace conditional initializers through contextual declaration checking.
• Added the required common-discriminant undefined diagnostic while preserving optional discriminants.
• Added focused GH39357 and GH12052 checker regressions.

Parity impact: assignmentCompatWithDiscriminatedUnion flips 0/1 -> 1/1; exact fixtures 301-400 improve 94/100 -> 95/100; canonical aggregate exact parity improves 4,893/5,907 -> 4,894/5,907 (82.85%), leaving 1,013.

Verification: ts_checker 3,044/3,044, ts_conformance package gate, exact 301-400 95/100, and baseline/current full-corpus failure-name comparison found no fixture-outcome regressions.

Pushed bca3f94ee (fix(ts-checker): reject void generic returns).

The generic alpha relater now applies the checker-owned type-parameter mismatch guard to substituted return types before the permissive low-level relation. This preserves alpha-equivalent generic returns while rejecting callable and construct signatures whose void return cannot satisfy an unconstrained type-parameter return.

Parity impact: assignmentCompatWithCallSignatures6 and assignmentCompatWithConstructSignatures5 each flip 0/1 -> 1/1; exact fixtures 301-400 improve 95/100 -> 97/100; canonical aggregate exact parity improves 4,894/5,907 -> 4,896/5,907 (82.88%), leaving 1,011.

Verification: ts_checker 3,045/3,045, ts_conformance package gate, exact 301-400 97/100.

Pushed e97dadc41 (fix(ts-checker): preserve enclosing construct generics).

This ports the construct-signature inference boundary more faithfully: only type parameters owned by a construct signature are inferred from new arguments, while type parameters captured from an enclosing generic scope remain fixed. Nullish argument checking now distinguishes unconstrained captured parameters, constrained captured parameters under legacy non-strict null behavior, and signature-owned generics, and TS2345 carries the arbitrary-instantiation child diagnostic. The chunk also makes the GH12052 required-discriminant undefined diagnostic structural, removing its dependence on leaked strict-null relation state.

Exact parity impact:

• genericCallWithFunctionTypedArguments2: 0/1 -> 1/1
• genericCallWithConstructorTypedArguments5: 0/1 -> 1/1
• exact fixtures 401-500: 68/100 -> 70/100
• canonical aggregate: 4,896/5,907 -> 4,898/5,907 (82.92%), 1,009 remaining
• implementation: 36 insertions, 12 deletions in packages/ts_checker/src/check.zig

Verification:

• ts_checker: 3,046/3,046
• ts_conformance package gate: green; baseline-aware survey 586/586
• named exact fixtures: 2/2
• finalized exact 401-500 survey: 70/100; the other 30 failure names are unchanged.

Pushed parity chunk 7d7121d89 (fix(ts-checker): anchor override diagnostics to fields).

This ports TypeScript's field-level diagnostic anchoring for TS2416: override mismatches now point at the written property key instead of the full declaration. That preserves the derived-field location while matching TypeScript's span and stable ordering when TS2416 is colocated with TS2564 or TS2411. The same anchor is used by ordinary heritage checks and generic-method constraint reports.

Measured exact flips:

• apparentTypeSubtyping: 0/1 -> 1/1
• apparentTypeSupertype: 0/1 -> 1/1
• subtypingWithObjectMembers: 0/1 -> 1/1
• Exact fixtures 401-500: 70/100 -> 73/100
• Canonical aggregate: 4,898/5,907 -> 4,901/5,907 (82.97%), 1,006 remaining

Change size:

• Production checker logic: 16 insertions and 2 call-site replacements
• Complete checker diff including regressions: 60 insertions, 6 deletions

Verification:

• ts_checker: 3,047/3,047
• Baseline-aware ts_conformance gate: 586/586
• Named exact fixtures: 3/3
• Final exact 401-500 survey: 73/100; the other 27 failure names are unchanged

Commit author and committer are Chris chrisbreuer93@gmail.com; there are no coauthor trailers.

Pushed parity chunk 433f27098 (fix(ts-checker): report generic defaults as assignments).

This ports TypeScript's parameter-initializer reporting path: annotated defaults now go directly through plain TS2322 assignment reporting, as upstream checkVariableLikeDeclaration does. It removes Home's specialized TS5075/TS5082 preflight while retaining the same assignability decision and parameter/property diagnostic anchors.

Measured exact flip:

• genericCallWithObjectTypeArgsAndInitializers: 0/1 -> 1/1
• Exact fixtures 401-500: 73/100 -> 74/100
• Canonical aggregate: 4,901/5,907 -> 4,902/5,907 (82.99%), 1,005 remaining

Change size:

• Production checker code: 9 insertions, 19 deletions
• Complete checker diff including the expanded regression: 18 insertions, 29 deletions

Verification:

• ts_checker: 3,047/3,047
• Baseline-aware ts_conformance gate: 586/586
• Named exact fixture: 1/1
• Final exact 401-500 survey: 74/100; the other 26 failure names are unchanged

Commit author and committer are Chris chrisbreuer93@gmail.com; there are no coauthor trailers.

Pushed parity chunk de6e1732b (fix(ts-checker): preserve tuple literal write bounds).

This ports TypeScript's fixed-tuple literal write behavior. Numeric literal write targets now bypass the broad number-index resolver and use the existing tuple slot/range path: in-range writes select the precise slot, rest writes retain the rest element, and out-of-bounds writes emit TS2493 while resolving the target to undefined. Negative tuple indices use the same fixed-range path.

Measured exact flip:

• genericCallWithTupleType: 0/1 -> 1/1
• Exact fixtures 401-500: 74/100 -> 75/100
• Canonical aggregate: 4,902/5,907 -> 4,903/5,907 (83.00%), 1,004 remaining

Change size:

• Production checker logic: 10 insertions and 1 replacement
• Complete checker diff including regression: 22 insertions, 1 deletion

Verification:

• ts_checker: 3,048/3,048
• Baseline-aware ts_conformance gate: 586/586
• Named exact fixture: 1/1
• Final exact 401-500 survey: 75/100; the other 25 failure names are unchanged

Commit author and committer are Chris chrisbreuer93@gmail.com; there are no coauthor trailers.

Pushed parity chunk 6a005d16d (fix(ts-checker): preserve generic instanceof identity).

This ports generic class identity through direct instanceof narrowing. Flow filtering now recovers class identity through substitutions and intersections, preserves the original matching generic union constituent, and uses the same identity for false-branch subtraction and heritage checks.

For a mismatching generic call with no inference candidate, diagnostic display now instantiates the target parameter from its default, constraint, or unknown. This produces TypeScript's B<T> -> A<unknown> diagnostic without tightening overloaded callback checking before Home has full multi-signature candidate merging.

Measured exact flip:

• narrowingGenericTypeFromInstanceof01: 0/1 -> 1/1
• genericCallWithFunctionTypedArguments3 remains 1/1 as a protected higher-order regression
• Exact fixtures 401-500: 75/100 -> 76/100
• Canonical aggregate: 4,903/5,907 -> 4,904/5,907 (83.02%), 1,003 remaining

Change size:

• Production checker logic: 39 insertions, 6 deletions
• Complete checker diff including regression: 55 insertions, 6 deletions

Verification:

• ts_checker: 3,049/3,049
• Baseline-aware ts_conformance gate: 586/586
• Named exact fixtures: 2/2
• Final exact 401-500 survey: 76/100; the other 24 failure names are unchanged

Commit author and committer are Chris chrisbreuer93@gmail.com; there are no coauthor trailers.

TypeScript parity progress: optional signature normalization

Pushed ae4d68ebf (fix(ts-checker): normalize optional signature displays).

This chunk ports TypeScript's optional-signature display normalization:

• union containers are now inspected before aggregate undefined flags, preventing unknown | undefined from collapsing to never
• optional callable parameters normalize unknown | undefined to unknown
• non-strict optional signatures omit their injected undefined
• strict ordinary unions such as string | undefined remain visible
• all callable diagnostic renderers now use the same normalization

Measured parity impact:

• flipped genericCallWithOverloadedConstructorTypedArguments2
• exact fixtures 401-500: 76/100 -> 77/100
• aggregate exact parity: 4904/5907 -> 4905/5907 (83.04%)
• 1002 exact fixtures remain

Implementation/test size:

• 31 production insertions, 10 production replacements/deletions
• 31 regression-test insertions
• 62 insertions, 10 deletions total

Verification:

• checker: 3050/3050
• baseline-aware conformance: 586/586
• focused upstream exact fixture: 1/1
• exact fixtures 401-500: 77/100

Commit author and committer are Chris <chrisbreuer93@gmail.com> with no coauthors.

Pushed c763f11dc (fix(ts-checker): defer contextual callback inference).

This ports TypeScript's two-pass generic-call inference ordering: ordinary argument candidates now precede callbacks whose parameters require contextual typing. Anonymous function declarations are recognized as function expressions, later scalar literals can fix contextual callback return types, and literal-target callback relations are rebuilt from checked syntax. Generic and fully annotated callbacks remain in the ordinary inference pass, preserving string-literal constraint behavior.

Parity impact:

• exact fixtures 401-500: 77/100 -> 79/100
• aggregate exact parity: 4905/5907 -> 4907/5907 (83.07%)
• remaining exact fixtures: 1002 -> 1000
• flipped genericCallWithFunctionTypedArguments
• flipped genericClassWithFunctionTypedMemberArguments
• no new exact failures

Scope:

• checker implementation: +88/-23 lines
• focused regression coverage: +18 lines

Verification:

• checker: 3051/3051
• baseline-aware conformance: 586/586
• exact 401-500 survey: 79/100

Pushed d14e61b00 (fix(ts-checker): instantiate overloaded callback signatures).

This ports contextual generic-signature instantiation for overloaded callback arguments. Every target call signature must now find a compatible source signature after source-owned type parameters are inferred from the target parameter and return types. Genuine mismatches also render full generic callback and anonymous overload-set names instead of the positional TS2345 fallback.

Parity impact:

• exact fixtures 401-500: 79/100 -> 80/100
• aggregate exact parity: 4907/5907 -> 4908/5907 (83.09%)
• remaining exact fixtures: 1000 -> 999
• flipped genericCallWithOverloadedFunctionTypedArguments2
• no new exact failures

Scope:

• checker implementation: +64 lines
• focused regression coverage: +17 lines

Verification:

• overload-focused checker tests: 68/68
• full checker: 3052/3052
• baseline-aware conformance: 586/586
• exact 401-500 survey: 80/100

Pushed d2433e3c1 (fix(ts-checker): block NoInfer inference candidates).

This ports real NoInfer<T> behavior into the Home TypeScript checker: a fresh branded internal wrapper blocks candidate collection through direct, array, object-property, whole-object, and callback-return positions, then erases during substitution, assignability, and display. Primitive-constrained inference now preserves literal candidates, and nested mismatches elaborate with TypeScript-compatible TS2322/TS2741 diagnostics. The fresh brand plus checker-owned payload map prevents ordinary source objects named __home_no_infer from colliding with the intrinsic.

Measured parity movement:

• exact fixtures 401-500: 80/100 -> 81/100
• flipped fixture: noInfer
• aggregate exact parity: 4908/5907 -> 4909/5907 (83.10%)
• remaining exact fixtures: 998
• checker diff: +141/-12 lines with 2 regression tests

Validation:

• focused NoInfer group: 6/6
• full checker: 3054/3054
• baseline-aware gate: 586/586
• exact-window failure-name delta: only noInfer was removed; the other 19 failures were unchanged.

Pushed 18937a534 (fix(ts-checker): instantiate generic heritage signatures).

This replaces the checker's blanket leniency for generic interface-member signatures with TypeScript-style contextual signature instantiation. Generic child call/construct signatures now infer from the base context, discard candidates that violate constraints, complete from defaults/constraints, compare parameters contravariantly and returns covariantly, and use alpha-renamed comparison for generic-to-generic signatures (including array return elements).

Measured parity movement:

• exact fixtures 401-500: 81/100 -> 83/100
• flipped fixtures: callSignatureAssignabilityInInheritance3, constructSignatureAssignabilityInInheritance3
• recovered exact diagnostics: 14 TS2430 headers
• aggregate exact parity: 4909/5907 -> 4911/5907 (83.14%)
• remaining exact fixtures: 996
• checker diff: +75/-3 lines with 1 focused regression test

Validation:

• focused heritage test: 2/2 including the checker root test
• full checker: 3055/3055
• baseline-aware gate: 586/586
• exact-window failure-name delta: only the two intended inheritance fixtures were removed; the other 17 failures were unchanged.

Pushed 857064666 (fix(ts-checker): report weak implements mismatches).

• Ports the relation-specific weak-type implements diagnostic: no shared properties against an all-optional target now emits TS2559, while overlapping incompatible properties retain TS2420.
• Applies consistently to initial, refined, and JSDoc class-implements paths.
• Flips subtypingWithObjectMembers5 and corrects 3 TS2420 diagnostics to TS2559.
• Exact 401-500: 83/100 -> 84/100.
• Aggregate exact parity: 4911/5907 -> 4912/5907 (83.16%, 995 remaining).
• Verification: checker 3056/3056, baseline gate 586/586.
• Scope: implementation +40/-25 lines, regression coverage +14 lines.

Pushed d679343f6 (fix(ts-checker): resolve overloaded callback methods).

This ports generic overloaded-callback method resolution: inference now uses the final source overload, preserves same-family generic instance arguments, instantiates member overloads before applicability checks, validates all source overloads, anchors TS2769 on the first argument, and renders deduplicated concrete overload diagnostics.

Parity impact:

• exact fixtures 401-500: 84 -> 85/100
• flipped: genericCallToOverloadedMethodWithOverloadedArguments (all 4 expected diagnostics)
• aggregate exact parity: 4912 -> 4913/5907 (83.17%)
• remaining: 994

Validation:

• checker: 3057/3057
• baseline gate: 586/586
• scope: checker implementation +148/-5 lines; focused regression coverage +31 lines

Commit: https://github.com/home-lang/home/commit/d679343f60bdf45f3490e62d1ae2430f4971f238

Pushed 108329e84 (fix(ts-checker): keep enum assignments nominal).

This narrows generic-intersection assignment acceptance to sources that actually contain the target type parameter, preventing branded numeric enums from flowing into arbitrary generic slots. Enum identities also bypass structural single-missing-property selection, preserving nominal TS2322 diagnostics for class/interface targets.

Parity impact:

• exact fixtures 401-500: 85 -> 86/100
• flipped: enumAssignability
• corrected diagnostics: 3 restored generic-target TS2322 errors + 2 TS2741 -> TS2322 corrections
• aggregate exact parity: 4913 -> 4914/5907 (83.19%)
• remaining: 993

Validation:

• focused exact filter: 2/2
• checker: 3058/3058
• baseline gate: 586/586
• scope: checker implementation +22/-13 lines; focused regression coverage +28 lines

Commit: https://github.com/home-lang/home/commit/108329e84ddedf000389261c7dc155160373eaf8

Pushed 764539742 (fix(ts-checker): preserve optional source signatures).

Assignment diagnostics now retain function-expression provenance: optional arrow/function parameters omit the checker-synthesized | undefined on the source side, while declared target signatures continue to use strict-null expansion.

Parity impact:

• exact fixtures 401-500: 86 -> 87/100
• flipped: assignmentCompatWithCallSignaturesWithRestParameters
• corrected: all 5 source-signature text mismatches
• aggregate exact parity: 4914 -> 4915/5907 (83.21%)
• remaining: 992

Validation:

• focused exact fixture: 1/1
• checker: 3059/3059
• baseline gate: 586/586
• scope: checker implementation +24/-1 lines; focused regression coverage +17 lines

Commit: https://github.com/home-lang/home/commit/7645397429024842002ea6e2f08052563c038b9e

Pushed 14219ab24 (fix(ts-checker): enforce constrained heritage relations).

• Heritage relations now treat target type parameters as declared slots rather than inference slots.
• Constrained source parameters recursively compare instantiated generic constraints, including mutual, reverse-mutual, self-recursive, and namespace-scoped cases.
• Equivalent substituted parameter IDs are preserved by declared name, while unrelated T/U/V parameters remain incompatible.
• TS2416 now renders child and extends names from syntax, retaining forms such as D2<T, U, V> and Base<T> inside namespaces.
• Restored the complete expected TS2411/TS2416 sets for subtypesOfTypeParameterWithRecursiveConstraints and subtypesOfTypeParameterWithConstraints4; the 33 prior baseline diff removals are now reduced to a separate same-position ordering mismatch.
• Scope: 144 insertions, 18 deletions, one regression covering all five constrained-relation shapes.

Verification: focused checker 2/2, full ts_checker 3060/3060, parity gate 586/586. The exact fixture flip is isolated to the next conformance ordering chunk.

Pushed 31b1fb5d0 (fix(ts-checker): compare generic heritage indexers).

The constrained-heritage relation now compares string, number, and symbol index signatures instead of returning success after an empty member walk. Number-index targets accept either a source number index or the JavaScript-compatible string-index fallback, while index value types remain universally quantified.

Measured impact:

• Restores the three missing generic TS2420 diagnostics in subtypingWithNumericIndexer5.
• Flips that exact fixture from failing back to passing.
• Adds 50 lines, including one regression with one concrete valid implementation and three invalid generic implementations.
• Focused checker 2/2, full ts_checker 3061/3061, parity gate 586/586.
• Combined affected exact set is 6/6; the remaining conformance ordering edit is still isolated and uncommitted.

Pushed dd878cfcd (fix(ts-conformance): order index member diagnostics).

The exact formatter now gives TS2411 priority only over TS2416 and TS2564 at the same property anchor. All other pairs retain the span-length tie-break, preserving TS2393-before-TS2411 for duplicate computed methods and TS2454-before-TS2322 for tuple assignments.

Measured impact:

• Flips subtypesOfTypeParameterWithRecursiveConstraints and subtypesOfTypeParameterWithConstraints4 exact.
• 401-500: 87/100 -> 89/100, with no regression among the other 98 fixtures.
• Affected exact set: 6/6.
• Full exact corpus: 4915/5907 (83.21%), 992 remaining.
• Scope: 6 inserted lines.

The paired old/current manifest audit also found and repaired the generic numeric-index regression in 31b1fb5d0; computed-property and tuple ordering remain exact.

Pushed 7709634ab (fix(ts-checker): preserve inferential callback annotations).

• Keeps explicit callback parameter annotations authoritative through contextual checking, generic inference, assignability, and TS2345 rendering.
• Preserves nested returned-function literal types, compares callable return shapes recursively, retains Object display identity, and emits structural argument-diagnostic chains.
• Exact flips: genericCallWithGenericSignatureArguments3 and typeArgumentInferenceErrors.
• Exact window 401-500: 89/100 -> 90/100.
• Full exact corpus: 4915/5907 -> 4917/5907 (+2, 990 remaining, no losses).
• Verification: focused fixture 1/1, callback family 3/3, checker 3062/3062, conformance gate 586/586, full exact 4917/5907.
• Change size: 174 insertions, 12 deletions, including one focused regression test.

Authored and committed as Chris with no co-author trailers.

Pushed 09a1ee0d18c72511c26cf78a2d541a9fc12a7194 (fix(ts-checker): instantiate generic callbacks contextually).

This ports contextual generic-signature instantiation semantics into the checker: parameter candidates are collected independently, compatible candidates merge to a common supertype, disjoint candidates fall back to unknown, and return inference remains lower priority. Failed callback instantiation now propagates to the enclosing call result, generic callable diagnostics retain <T>, and repeated-variable union display distinguishes canonical primitive ordering from source-preserved object-shape unions.

Measured parity impact:

• contextualSignatureInstantiation: exact 0/1 -> 1/1
• exact window 401-500: 90/100 -> 91/100
• full exact corpus: 4917/5907 -> 4918/5907
• remaining exact failures: 989
• failure-set comparison: only contextualSignatureInstantiation removed; no failures added
• checker: 3062/3062
• conformance: 1368/1368
• change size: 264 insertions, 11 deletions

Pushed 74509af8af90b4d4e3590fa89a3277c715198268 (fix(ts-checker): type callable unions contextually).

This ports contextual typing for concrete callable unions on direct function assignments and annotated initializers. Shared parameter types are installed when each union branch has a compatible signature, while generic call arguments remain on the staged inferential path. The function-expression classifier now rejects failed concrete primitive return relations instead of letting the structural object fallback accept them vacuously.

Measured parity impact:

• functionExpressionContextualTyping2: exact 0/1 -> 1/1
• full exact corpus: 4918/5907 -> 4919/5907
• remaining exact failures: 988
• failure-set comparison: only functionExpressionContextualTyping2 removed; no failures added
• inferential callback guard set: 5/5 exact
• checker: 3063/3063
• conformance: 1368/1368
• change size: 44 insertions, 0 deletions

Pushed 41830ce0f (fix(ts-checker): reject abstract constructor arguments).

This moves abstract-constructor compatibility ahead of structural constructor-signature matching for call arguments, reusing the existing TS2345 + TS2517 diagnostic chain while preserving concrete-to-abstract assignability.

Parity impact:

• classAbstractFactoryFunction: 0/1 -> 1/1 exact
• full exact corpus: 4919/5907 -> 4920/5907 (987 remaining, no added failures)
• checker: 3064/3064
• conformance: 1368/1368
• implementation: 34 insertions, 0 deletions, including focused bidirectional regression coverage

Pushed cd0a1abda (fix(ts-checker): require trailing overload implementation).

Bodyless class-method implementation requirements now follow the final overload declaration: trailing abstract signatures stay implementation-free, while trailing non-abstract signatures emit TS2391 even when the group begins abstract.

Parity impact:

• classAbstractInstantiations2: 0/1 -> 1/1 exact
• full exact corpus: 4920/5907 -> 4921/5907 (986 remaining, no added failures)
• focused TS2512 guard: 3/3
• checker: 3064/3064
• conformance: 1368/1368
• implementation: 3 insertions, 1 deletion

Pushed 94288a2bf (fix(ts-checker): compare accessor overrides directly).

Inherited members with different method kinds now use direct type assignability, preventing zero-argument signature return unwrapping from accepting () => number as an accessor number. Compatible method/function-property overrides and method bivariance remain unchanged.

Parity impact:

• derivedClassFunctionOverridesBaseClassAccessor: 0/1 -> 1/1 exact
• full exact corpus: 4921/5907 -> 4922/5907 (985 remaining, no added failures)
• focused override family: 4/4
• checker: 3064/3064
• conformance: 1368/1368
• implementation: 8 insertions, 0 deletions

Pushed 10ef66820 (fix(ts-checker): respect local heritage shadows).

Class heritage now resolves local variable declarations before global class tables, infers unannotated initializer types, widens mutable literal bindings, and restricts callable rendering so primitive TS2507 messages retain names such as number. Forward class references remain on their existing resolver path.

Parity impact:

• classExtendsShadowedConstructorFunction: 0/1 -> 1/1 exact
• full exact corpus: 4922/5907 -> 4923/5907 (984 remaining, no added failures)
• focused shadow and forward-class guards: 2/2
• checker: 3065/3065
• conformance: 1368/1368
• implementation: 49 insertions, 5 deletions, including one focused regression test

Pushed 215cb8a77 (fix(ts-checker): report non-constructor heritage expressions).

Literal and other non-identifier class heritage expressions now share TS2507 reporting with preserved source literal types. Local variable heritage also emits TS2454 for uninitialized non-nullish bindings, while extends null remains accepted as TypeScript requires.

Parity impact:

• classExtendingNonConstructor: 0/1 -> 1/1 exact
• full exact corpus: 4923/5907 -> 4924/5907 (983 remaining, no added failures)
• focused non-constructor heritage guard: 2/2
• checker: 3066/3066
• conformance: 1368/1368
• implementation: 52 insertions, 3 deletions, including one focused regression test

Pushed a3a463d6c (fix(ts-checker): distinguish runtime namespace assignments).

Namespace assignment targets now distinguish empty/type-only namespaces from runtime namespaces. Empty namespaces retain TS2708 without a duplicate TS2631; runtime namespaces continue to reject reassignment with TS2631. The commit body links back to #69.

Parity impact:

• assignments: 0/1 -> 1/1 exact
• full exact corpus: 4924/5907 -> 4925/5907 (982 remaining, no added failures)
• focused namespace assignment guard: 2/2
• checker: 3067/3067
• conformance: 1368/1368
• implementation: 26 insertions, 4 deletions, including one focused regression test

Pushed 02235ff63 (fix(ts-checker): resolve ordinary module augmentations).

String-literal module augmentations in ordinary external-module files now participate in TS2664 target resolution, including empty bodies. Resolved targets and declaration files remain exempt, and the commit body links back to #69.

Parity impact:

• ambientExternalModuleInsideNonAmbientExternalModule: 0/1 -> 1/1 exact
• full exact corpus: 4925/5907 -> 4926/5907 (981 remaining, no added failures)
• focused missing-augmentation guard: 2/2
• checker: 3068/3068
• conformance: 1368/1368
• implementation: 20 insertions, 3 deletions, including one focused regression test

Pushed 7fa91c13c (fix(ts-checker): merge ambient module export surfaces).

Home now aggregates export facts across every visible exact or wildcard ambient module declaration, including implicit interface/type exports and known missing names. Named-import diagnostics preserve wildcard module symbol names, emit bare TS2305 for trusted misses, and avoid unrelated local spelling suggestions. The commit body links back to #69.

Parity impact:

• ambientDeclarationsPatterns_merging1: 0/1 -> 1/1 exact
• ambientDeclarationsPatterns_merging2: 0/1 -> 1/1 exact
• focused ambient merging set: 1/3 -> 3/3 exact
• typeReferenceRelatedFiles guard: 1/1 exact
• full exact corpus: 4926/5907 -> 4928/5907 (979 remaining, no added failures)
• ts_program: 58/58
• checker: 3069/3069
• conformance: 1368/1368
• implementation: 197 insertions, 54 deletions, including two focused regression tests

Pushed 22768c8cf (fix(ts-checker): instantiate omitted generic class arguments).

Implicit-constructor generic classes now instantiate omitted type parameters through declared defaults, constraints, then unknown. Explicit-constructor classes remain on the established constructor-inference path, and explicit mapped-type class instantiations avoid redundant substitution. The commit body links back to #69.

Parity impact:

• callGenericFunctionWithZeroTypeArguments: 0/1 -> 1/1 exact
• full exact corpus: 4928/5907 -> 4929/5907 (978 remaining, no added failures)
• mappedTypeErrors stress guard: completes without a substitution crash
• checker: 3070/3070
• conformance: 1368/1368
• implementation: 77 insertions, 20 deletions, including one focused positive/negative regression test

Pushed df3d186d2 (fix(ts-checker): reject unrelated generic variable initializers).

This ports variable-declaration assignability for unrelated bare type parameters: a comma initializer whose value is T2 now correctly reports TS2322 when the declared slot is unrelated T1. The declaration path preserves valid same-parameter and transitive-constraint assignments, delegates inferred indexed-access values to structural relation, and excludes flow-narrowed union/intersection composites from the bare-parameter check.

Parity movement:

• commaOperatorOtherInvalidOperation: 0/1 -> 1/1 exact
• Full exact corpus: 4929/5907 -> 4930/5907 (+1)
• Remaining exact failures: 977
• Newly failing fixtures: 0
• Patch size: +48/-0 lines in packages/ts_checker/src/check.zig

Verification:

• focused checker regression: 2/2
• checker suite: 3071/3071
• conformance suite: 1368/1368
• exact corpus: 4930/5907, with a failure-set diff containing only the intended removal

Tracks #69.

Pushed 7e60d619a (fix(ts-parser): recover missing logical-not operands).

Parity impact:

• logicalNotOperatorInvalidOperations: 0/1 -> 1/1 exact
• Full exact corpus: 4930/5907 -> 4931/5907
• Remaining failures: 977 -> 976
• New failures: 0
• Change size: 38 insertions across 2 files

Implementation:

• Recover a lone logical-not operator at an operand stop token after emitting TS1109.
• Synthesize a checker-safe numeric operand so parsing retains the complete source file without secondary diagnostics.
• Add parser and checker regressions for the upstream malformed-initializer sequence.

Verification:

• parser: 736/736
• checker: 3072/3072
• conformance: 1368/1368
• exact TypeScript corpus: 4931/5907, no regressions

Tracks #69.

Pushed 1d52640e8 (fix(ts-parser): recover invalid bitwise-not declarations).

Parity impact:

• bitwiseNotOperatorInvalidOperations: 0/1 -> 1/1 exact
• Full exact corpus: 4931/5907 -> 4932/5907
• Remaining failures: 976 -> 975
• New failures: 0
• Change size: 30 changed lines in 1 file (29 insertions, 1 deletion)

Implementation:

• Recover stray and operand-less ~ forms while preserving the surrounding source file.
• Emit the upstream TS1005/TS1109 sequence for a stray initializer tail.
• Emit TS1134 for literal tokens in a variable declaration list and continue parsing.
• Add a parser regression covering all four expected diagnostics.

Verification:

• parser: 737/737
• checker: 3072/3072
• conformance: 1368/1368
• exact TypeScript corpus: 4932/5907, no regressions

Tracks #69.

Pushed 02914ab59 (fix(ts-parser): recover nested var initializers).

Parity impact:

• negateOperatorInvalidOperations: 0/1 -> 1/1 exact (all 11 expected diagnostics)
• Full exact corpus: 4932/5907 -> 4933/5907
• Remaining failures: 975 -> 974
• New failures: 0
• Change size: 101 changed lines across 2 files (100 insertions, 1 deletion)

Implementation:

• Preserve a nested var binding encountered in a malformed initializer expression.
• Attach recovered any metadata to the outer and nested declarations so the later binding naturally emits the upstream TS2403 mismatch.
• Continue through the malformed unary tail and subsequent nullish arithmetic expressions.
• Add parser-shape and checker-message regressions for the complete recovery sequence.

Verification:

• parser: 738/738
• checker: 3073/3073
• conformance: 1368/1368
• exact TypeScript corpus: 4933/5907, no regressions
• rebased focused exact fixture: 1/1

Tracks #69.

Pushed 6c251ce93 (fix(ts-checker): preserve strict-off nullish addition types).

Parity impact:

• bitwiseNotOperatorWithAnyOtherType: 0/1 -> 1/1 exact
• plusOperatorWithAnyOtherType: 0/1 -> 1/1 exact
• Full exact corpus: 4933/5907 -> 4935/5907
• Remaining failures: 974 -> 972
• New failures: 0
• Change size: 49 changed lines in 1 file (42 insertions, 7 deletions)

Implementation:

• Preserve null / undefined operand types for strict-off binary additions under selected unary parents.
• Emit whole-expression TS2365 under +, ~, and delete.
• Retain operand-level TS18050 under !, typeof, and void, avoiding the broader rule that regressed those fixtures during development.
• Add exact-message coverage for all three nullish operand pairs.

Verification:

• checker: 3074/3074
• conformance: 1368/1368
• focused parent-context matrix: 5/6 exact; only the independently failing delete fixture remains
• exact TypeScript corpus: 4935/5907, no regressions
• rebased focused unit test: 2/2

Tracks #69.

Pushed 9928e08be (fix(ts-checker): suppress invalid-radix duplicate cascades).

Parity impact:

• binaryIntegerLiteralError: 0/1 -> 1/1 exact
• octalIntegerLiteralError: 0/1 -> 1/1 exact
• Full exact corpus: 4935/5907 -> 4937/5907
• Remaining failures: 972 -> 970
• New failures: 0
• Change size: 35 changed lines in 1 file (34 insertions, 1 deletion)

Implementation:

• Detect recovered object literals containing 0b / 0o numeric property keys.
• Suppress the TS1117 cascade only when those keys coexist with parser diagnostics.
• Preserve ordinary numeric/string duplicate-property diagnostics during unrelated parse recovery.
• Add focused binary/octal and ordinary-duplicate regression coverage.

Verification:

• checker: 3075/3075
• conformance: 1368/1368
• focused exact slice: 2/2
• exact TypeScript corpus: 4937/5907, no regressions
• rebased TS1117 guards: 4/4 combined

Tracks #69.

Pushed b7f13027a (fix(ts-checker): prune impossible typeof assignment branches).

This ports the TS2454 control-flow behavior for impossible positive typeof branches. The assignment scanner now evaluates annotated primitive unions conservatively, treats empty enum constituents as having no reachable runtime tag, and removes a pending variable only from the proven-impossible branch clone. The guard itself and every reachable branch still report use-before-assignment. Unknown aliases and non-empty enums retain the existing behavior.

Parity impact:

• Exact corpus: 4937/5907 -> 4938/5907
• Resolved fixture: symbolType19
• New failures: 0
• Remaining failures: 969
• Change size: 112 inserted lines across implementation and focused test coverage

Verification:

• focused TS2454 checker regression: 2/2
• exact symbolType19 rerun after rebase: 1/1
• checker suite: 3076/3076
• conformance suite: 1368/1368
• full exact corpus: 5907 surveyed, 4938 passed, 969 failed, 0 skipped

The commit is authored and committed as Chris with no co-authors.

Pushed 5c86a75a3 (fix(ts-parser): recover invalid exported throw statements).

This ports TypeScript's malformed-throw recovery cascade end to end. A semicolon-only throw; now emits TS1109, synthesizes a zero-width undefined operand, and continues parsing. When the later export modifier precedes a statement-only keyword such as throw, the parser emits TS1128 at export and preserves the underlying statement rather than creating an invalid export wrapper.

Parity impact:

• Exact corpus: 4938/5907 -> 4939/5907
• Resolved fixture: invalidThrowStatement
• New failures: 0
• Remaining failures: 968
• Change size: 74 inserted lines across parser logic plus parser/driver regression coverage

Verification:

• focused parser regression: 2/2
• exact invalidThrowStatement: 1/1
• parser suite: 739/739
• driver suite: 136/136
• checker suite: 3076/3076
• conformance suite: 1368/1368
• full exact corpus: 5907 surveyed, 4939 passed, 968 failed, 0 skipped

The commit is authored and committed as Chris with no co-authors.

Pushed 6401fac61 (fix(ts-parser): gate labeled var errors by selected target).

This ports TypeScript's target-sensitive TS1344 behavior for labeled var statements: the legacy ES5 sloppy form stays valid, while strict source and ES2015+ targets report A label is not allowed here. The exact-corpus loader now also honors the chosen (target=es5) baseline instead of merging every value from a multi-target source directive into one syntax mode.

Parity impact:

• Exact corpus: 4939/5907 -> 4947/5907
• Resolved fixtures: 8
• invalidDoWhileContinueStatements
• invalidForContinueStatements
• invalidForInContinueStatements
• invalidWhileContinueStatements
• labeledStatementWithLabel
• labeledStatementWithLabel_es2015
• privateNameES5Ban
• privateNameInObjectLiteral-3
• New failures: 0
• Remaining failures: 960
• Change size: 38 lines (30 insertions, 8 deletions)

Verification:

• focused target-selection and fixture batch: 9/9
• parser suite: 740/740
• driver suite: 136/136
• checker suite: 3076/3076
• conformance suite: 1369/1369
• full exact corpus: 5907 surveyed, 4947 passed, 960 failed, 0 skipped

The commit is authored and committed as Chris with no co-authors.

Pushed aa0f6cea2 (fix(ts-parser): parse labeled bodies as nested statements).

This ports the TypeScript parser behavior that treats a labeled statement body as a nested statement. The existing block modifier validation now sees label: export ... and reports TS1184 (Modifiers cannot appear here) alongside the labeled-declaration diagnostic.

Exact parity impact:

• Aggregate: 4947/5907 -> 4948/5907
• Resolved: labeledStatementExportDeclarationNoCrash1
• New failures: 0

Verification:

• Parser: 741/741
• Driver: 136/136
• Checker: 3076/3076
• Conformance: 1369/1369
• Full exact TypeScript corpus: 4948 passed, 959 failed, 0 skipped

Scope: 1 parser file, 17 changed lines (10 insertions, 7 deletions).

Pushed 1e56b57e2 (fix(ts-parser): classify unresolved jumps by function scope).

This ports TypeScript's parent-chain grammar behavior for unresolved labeled jumps. Home now keeps only active labels: a jump that reaches a function boundary reports TS1107, while a source-level non-enclosing break reaches the source-file root and reports TS1116. This preserves the method-body TS1107 in plainJSBinderErrors while correcting the top-level invalid-break fixtures.

Exact parity impact:

• Aggregate: 4948/5907 -> 4952/5907
• Resolved: invalidDoWhileBreakStatements, invalidForBreakStatements, invalidForInBreakStatements, invalidWhileBreakStatements
• New failures: 0

Verification:

• Focused exact: 5/5 (four resolved fixtures plus plainJSBinderErrors regression guard)
• Parser: 741/741
• Driver: 136/136
• Checker: 3076/3076
• Conformance: 1369/1369
• Full exact TypeScript corpus: 4952 passed, 955 failed, 0 skipped

Scope: 1 parser file, 23 changed lines (4 insertions, 19 deletions).

Pushed 7c9ef92c9 (fix(ts-checker): walk object member type references).

This ports TypeScript's unresolved-type diagnostic traversal through structural object annotations. Home now visits object members plus index-signature key/value types and reports missing nested type names, while honoring enclosing type parameters. The diagnostic walk remains separate from the unresolved-type lowering predicate, preserving clean union-index and mapped-type semantics.

Exact parity impact:

• Aggregate: 4952/5907 -> 4953/5907
• Resolved: parserObjectType6
• New failures: 0

Verification:

• Focused checker regression: 2/2
• Focused exact: 1/1
• Union-index regression: 2/2
• Parser: 741/741
• Driver: 136/136
• Checker: 3077/3077
• Conformance: 1369/1369
• Full exact TypeScript corpus: 4953 passed, 954 failed, 0 skipped

Scope: 1 checker file, 21 inserted lines.

Pushed ccaf1196b (fix(ts-checker): resolve parameterized type roots).

This ports TypeScript's unresolved-name behavior for parameterized type references. Home now checks generic arguments and then resolves the root through enclosing type parameters, imports/reference libs, local generic declarations, and compiler/default-lib utility types. A root that still has no type-space resolution reports TS2304, so malformed X<T \ recovery preserves diagnostics for both X and T without flagging Record/Partial/Readonly/NoInfer/NonNullable/string-mapping or imported generic types.

Exact parity impact:

• Aggregate: 4953/5907 -> 4954/5907
• Resolved: parserSkippedTokens20
• New failures: 0

Verification:

• New parameterized-root checker regression: 2/2
• Focused generic resolver guards: NoInfer 6/6, NonNullable 4/4, Record 2/2, React reference-lib 2/2, mapped utility cases 2/2 each, intrinsic uppercase 2/2
• Focused exact: 1/1
• Parser: 741/741
• Driver: 136/136
• Checker: 3078/3078
• Conformance: 1369/1369
• Full exact TypeScript corpus: 4954 passed, 953 failed, 0 skipped

Scope: 1 checker file, 19 changed lines (18 insertions, 1 deletion).

Parity progress: assigned ECMAScript private names remain undeclared\n\nCommit: f6572c3\nConventional commit: fix(ts-checker): keep assigned private names undeclared\n\nWhat changed:\n- Constructor member inference no longer synthesizes this.#name assignments into a class shape.\n- Checked-JS cross-method member inference likewise excludes ECMAScript private identifiers.\n- Checked-JS constructor member access no longer short-circuits private names as ordinary inferred expandos.\n- Missing checked-JS private assignment targets now flow through normal TS2339 reporting.\n\nLogical parity:\nTypeScript private identifiers are introduced only by class-element declarations. Assigning this.#z cannot declare #z in either TypeScript or JavaScript, so the access must remain unresolved and report Property '#z' does not exist on type 'C'.\n\nExact corpus movement:\n- 4954/5907 -> 4956/5907 (+2)\n- Failures: 953 -> 951\n- Resolved: privateNameBadDeclaration\n- Resolved: privateNameJsBadDeclaration\n- Regressions: 0 (failure-set comparison)\n\nVerification:\n- Focused checker regressions: 2/2\n- Focused exact fixtures: 2/2\n- ts_parser: 741/741\n- ts_driver: 136/136\n- ts_checker: 3080/3080\n- ts_conformance: 1369/1369\n- Full exact TypeScript corpus: 4956/5907\n\nScope:\n- 1 file changed\n- 52 insertions, 3 deletions\n\nRemaining exact parity work: 951 fixtures.

Parity progress: private identifiers cannot create CommonJS exports\n\nCommit: 8ba43ca\nConventional commit: fix(ts-checker): reject private CommonJS export names\n\nWhat changed:\n- The implicit CommonJS exports exemption no longer applies when exports is the receiver of an ECMAScript private member.\n- exports.#name now reports the unresolved exports binding in addition to the private-name grammar/access diagnostic.\n- Ordinary exports.name assignments remain recognized as CommonJS export syntax.\n- A real local exports declaration continues to shadow the implicit fallback and does not report TS2304.\n\nLogical parity:\nA private identifier is lexical to a class and cannot name a CommonJS export property. Therefore exports.#name is not a valid CommonJS export assignment and must not manufacture an implicit exports binding.\n\nExact corpus movement:\n- 4956/5907 -> 4958/5907 (+2)\n- Failures: 951 -> 949\n- Resolved: privateNameBadAssignment\n- Resolved: privateNameJsBadAssignment\n- Regressions: 0 (failure-set comparison)\n\nVerification:\n- Focused checker regressions: 2/2\n- Focused exact fixtures: 2/2\n- ts_parser: 741/741\n- ts_driver: 136/136\n- ts_checker: 3082/3082\n- ts_conformance: 1369/1369\n- Full exact TypeScript corpus: 4958/5907\n\nScope:\n- 1 file changed\n- 43 insertions, 2 deletions\n\nRemaining exact parity work: 949 fixtures.

Parity progress: checked-JS private modifier diagnostics anchor at JSDoc tags\n\nCommit: 7bb2dd8\nConventional commit: fix(ts-checker): anchor private JSDoc modifier errors\n\nWhat changed:\n- Checked-JS JSDoc accessibility metadata now retains the source position of @public, @private, or @protected.\n- TS18010 diagnostics for private identifiers use that tag position instead of the following #name token.\n- Existing field, method, getter, and setter visibility inference continues to use the same accessibility value.\n\nLogical parity:\nFor JSDoc-derived modifiers, TypeScript attributes the incompatible modifier to the JSDoc tag that introduced it. All twelve field/method/accessor diagnostics now point at the modifier source.\n\nExact corpus movement:\n- 4958/5907 -> 4959/5907 (+1)\n- Failures: 949 -> 948\n- Resolved: privateNamesIncompatibleModifiersJs\n- Regressions: 0 (failure-set comparison)\n\nVerification:\n- Focused checker regression: 1/1\n- Focused exact fixture: 1/1\n- ts_parser: 741/741\n- ts_driver: 136/136\n- ts_checker: 3083/3083\n- ts_conformance: 1369/1369\n- Full exact TypeScript corpus: 4959/5907\n\nScope:\n- 1 file changed\n- 51 insertions, 7 deletions\n\nRemaining exact parity work: 948 fixtures.

Parity update: shipped bce7ef5 (fix(ts-checker): suppress invalid private declare cascades) to main.

Resolved fixture:

• privateNamesIncompatibleModifiers: FAIL -> PASS

Implementation:

• Recognizes bodyless ECMAScript private class members with a source-level declare modifier as parser-invalid ambient recovery shapes.
• Suppresses checker-only TS7010 and TS7033 implicit-any cascades after the parser has already emitted the canonical invalid-modifier diagnostics.
• Keeps malformed private methods out of class overload bookkeeping, preventing the following sibling method from receiving spurious TS2389.
• Adds a boundary test proving an ordinary bodyless ECMAScript private method still receives normal implicit-any checking.

Measured parity:

• exact corpus: 4959/5907 -> 4960/5907 (+1)
• remaining failures: 948 -> 947
• resolved set: privateNamesIncompatibleModifiers only
• newly failing fixtures: none
• regressions: 0

Verification:

• focused checker unit: pass
• focused exact fixture: 1/1
• checker: 3084/3084
• parser: 749/749
• driver: 136/136
• conformance: 1369/1369
• full exact corpus: 4960/5907

Change size:

• 1 file
• 58 insertions
• 6 deletions

The parity ledger now stands at 4960/5907 with 947 fixtures remaining.

Parity update: shipped fcd3be4 (fix(ts-checker): preserve empty class method semantics) to main.

Resolved fixtures:

• privateNameReadonly: FAIL -> PASS
• staticIndexSignature7: FAIL -> PASS

Implementation:

• Ordinary non-async, non-generator class methods with no value return now infer void, or never for definitely exiting bodies, during initial class-member shaping.
• Sibling method bodies and static index compatibility checks therefore see the same return type that the later body pass records.
• Anonymous class expressions now use a lexical private-method fallback when the named-class registry cannot identify an ECMAScript private method.
• Assignments to those anonymous private methods now emit canonical TS2803 while retaining normal assignment compatibility diagnostics.
• Added direct regression coverage for the exact privateNameReadonly messages and the staticIndexSignature7 () => void TS2411 message.

Measured parity:

• exact corpus: 4960/5907 -> 4962/5907 (+2)
• remaining failures: 947 -> 945
• resolved set: privateNameReadonly, staticIndexSignature7
• newly failing fixtures: none
• regressions: 0

Verification:

• anonymous private-method regression: pass
• static index void-return regression: pass
• focused exact privateNameReadonly: 1/1
• checker: 3086/3086
• parser: 749/749
• driver: 136/136
• conformance: 1369/1369
• baseline-aware conformance: 586/586
• full exact corpus: 4962/5907

Change size:

• 1 file
• 86 insertions
• 3 deletions

The parity ledger now stands at 4962/5907 with 945 fixtures remaining.

Parity update: shipped 6ecf6a5 (fix(ts-checker): name generic private classes canonically) to main.

Resolved fixture:

• privateNamesInGenericClasses: FAIL -> PASS

Implementation:

• TS18013 now renders the declaring class symbol name rather than appending its type-parameter list.
• Generic private access diagnostics therefore use class C, matching upstream, instead of the instantiated-looking C<t>.
• Synthetic anonymous class keys still render as the canonical (anonymous) label.
• Other diagnostic families continue using the existing generic-aware class display.
• Added a focused regression asserting the exact generic-class TS18013 message.

Measured parity:

• exact corpus: 4962/5907 -> 4963/5907 (+1)
• remaining failures: 945 -> 944
• resolved set: privateNamesInGenericClasses only
• newly failing fixtures: none
• regressions: 0

Verification:

• focused TS18013 regression: pass
• focused exact fixture: 1/1
• checker: 3087/3087
• parser: 749/749
• driver: 136/136
• conformance: 1369/1369
• baseline-aware conformance: 586/586
• full exact corpus: 4963/5907

Change size:

• 1 file
• 23 insertions
• 2 deletions

The parity ledger now stands at 4963/5907 with 944 fixtures remaining.

Parity update: shipped 8c75a5a (fix(ts-checker): preserve private brands through interfaces) to main.

Resolved fixture:

• privateNamesInterfaceExtendingClass: FAIL -> PASS

Implementation:

• The outside-class private-identifier path now recognizes interface receiver types whose visibility originates from an extended class.
• Those semantically resolved receivers bypass the generic TS18016 syntax fallback.
• Normal ECMAScript private-brand checking then emits canonical TS18013 against the declaring class.
• Genuinely unbound private identifiers outside class bodies remain eligible for TS18016.
• Added a focused precedence regression asserting one TS18013 and zero TS18016 diagnostics.

Measured parity:

• exact corpus: 4963/5907 -> 4964/5907 (+1)
• remaining failures: 944 -> 943
• resolved set: privateNamesInterfaceExtendingClass only
• newly failing fixtures: none
• regressions: 0

Verification:

• focused precedence regression: pass
• focused exact fixture: 1/1
• checker: 3088/3088
• parser: 749/749
• driver: 136/136
• conformance: 1369/1369
• baseline-aware conformance: 586/586
• full exact corpus: 4964/5907

Change size:

• 1 file
• 27 insertions
• 1 deletion

The parity ledger now stands at 4964/5907 with 943 fixtures remaining.

Parity update: shipped 9bb3ffdad (fix(ts-checker): preserve contextual assertion fields) to main.

Resolved fixture:

• privateNamesAssertion: FAIL -> PASS

Implementation:

• Annotated class-field arrow and function initializers now receive the callable type from their declared field annotation as contextual input.
• The checker validates the function body under that contextual signature before deriving the source initializer signature.
• Contextual asserts / type-predicate metadata is copied onto the derived signature together with its predicate return representation, preserving assertion semantics through assignability.
• Ordinary contextual functions still infer their actual body return, so incompatible fields such as () => string = () => { return 1; } continue to emit TS2322.
• Added focused regression coverage that asserts the private assertion field stays clean while the genuine return mismatch remains.

Measured parity:

• exact corpus: 4964/5907 -> 4965/5907 (+1)
• remaining failures: 943 -> 942
• resolved set: privateNamesAssertion only
• newly failing fixtures: none
• regressions: 0

Verification:

• focused exact fixture: 1/1
• checker: 3089/3089
• parser: 749/749
• driver: 136/136
• conformance: 1369/1369
• baseline-aware conformance: 586/586
• full exact corpus: 4965/5907

Change size:

• 1 file
• 48 changed lines
• 46 insertions
• 2 deletions

The parity ledger now stands at 4965/5907 with 942 fixtures remaining.

Tracks #69.

Parity update: shipped 13a2b020e (fix(ts-checker): resolve forward static private names) to main.

Resolved fixture:

• privateNameStaticFieldDerivedClasses: FAIL -> PASS

Implementation:

• A bare class-name receiver can now resolve through its visible forward class declaration before the class static type has been materialized.
• The syntax-backed fallback confirms the referenced ECMAScript private member is actually declared and static on that class.
• The recovered declaration identity flows through the normal TS18013 accessibility checker, preserving the declaring class name and private-brand semantics.
• Once TS18013 is emitted, the property access is terminal so the generic missing-member path cannot append a redundant TS2339.
• Ordinary any receivers, instance private names, and genuinely absent private names retain their existing behavior.
• Added focused coverage asserting one canonical TS18013 and zero TS2339 diagnostics for a forward Derived.#value access from Base.

Measured parity:

• exact corpus: 4965/5907 -> 4966/5907 (+1)
• remaining failures: 942 -> 941
• resolved set: privateNameStaticFieldDerivedClasses only
• newly failing fixtures: none
• regressions: 0

Verification:

• focused exact fixture: 1/1
• checker: 3090/3090
• parser: 749/749
• driver: 136/136
• conformance: 1369/1369
• baseline-aware conformance: 586/586
• full exact corpus: 4966/5907

Change size:

• 1 file
• 78 changed lines
• 77 insertions
• 1 deletion

The parity ledger now stands at 4966/5907 with 941 fixtures remaining.

Tracks #69.

Parity update: shipped 39c75822d (fix(ts-checker): keep static private brands class-local) to main.

Resolved fixtures:

• privateNameStaticAccessorssDerivedClasses: FAIL -> PASS
• privateNamesAndStaticFields: FAIL -> PASS

Implementation:

• ECMAScript private static members are now excluded from derived constructor shapes instead of being inherited structurally.
• Same-spelled private static declarations on base and derived classes remain distinct brands and no longer trigger a false TS2417 static-side compatibility error.
• Access to a base-only private static name through typeof Derived now emits TS2339 on the derived constructor rather than climbing to the base brand and emitting TS18013.
• The same ownership rule works when the derived constructor is only forward-declared: its syntax supplies the class and parent identity, while an own forward private static declaration still follows the normal TS18013 path.
• Synthetic structural member ids are checked through getOptional before inspecting source spelling, preserving internal constructor slots safely.
• Added focused coverage for materialized and forward derived constructors, both lexical access contexts, and incompatible same-spelled base/derived static private declarations.

Measured parity:

• exact corpus: 4966/5907 -> 4968/5907 (+2)
• remaining failures: 941 -> 939
• resolved set: privateNameStaticAccessorssDerivedClasses, privateNamesAndStaticFields
• newly failing fixtures: none
• regressions: 0

Verification:

• focused exact fixtures: 2/2
• checker: 3091/3091
• parser: 749/749
• driver: 136/136
• conformance: 1369/1369
• baseline-aware conformance: 586/586
• full exact corpus: 4968/5907

Change size:

• 1 file
• 82 changed lines
• 82 insertions
• 0 deletions

The parity ledger now stands at 4968/5907 with 939 fixtures remaining.

Tracks #69.

Parity update: shipped 97ce2fb4e (fix(ts-checker): apply lexical brands to derived instances) to main.

Resolved fixtures:

• privateNamesConstructorChain-1: FAIL -> PASS
• privateNamesConstructorChain-2: FAIL -> PASS

Implementation:

• Instance private access now resolves the nearest enclosing class that lexically declares the #name before considering a same-spelled private declaration on the receiver class.
• The lexical brand is valid when the receiver is the declaring class or derives from it, matching the runtime brand installed by the base constructor on derived instances.
• Forward child classes are supported by a bounded ancestry walk that prefers registered parent links and falls back to parsed extends syntax, including generic Child<T> extends Parent<T> forms.
• Resolution stops at the nearest lexical declaration, so unrelated or nested same-spelled brands do not fall through to an outer class.
• Static private ownership remains on the separate class-local path shipped in 39c75822d.
• Added focused coverage for a forward generic child that redeclares the same-spelled instance private name.

Measured parity:

• exact corpus: 4968/5907 -> 4970/5907 (+2)
• remaining failures: 939 -> 937
• resolved set: privateNamesConstructorChain-1, privateNamesConstructorChain-2
• newly failing fixtures: none
• regressions: 0

Verification:

• focused exact fixtures: 2/2
• checker: 3092/3092
• parser: 749/749
• driver: 136/136
• conformance: 1369/1369
• baseline-aware conformance: 586/586
• full exact corpus: 4970/5907

Change size:

• 1 file
• 64 changed lines
• 64 insertions
• 0 deletions

The commit was rebased conflict-free over unrelated f593e5e0e MySQL work before push; the TypeScript diff and measured corpus result are unchanged.

The parity ledger now stands at 4970/5907 with 937 fixtures remaining.

Tracks #69.

Pushed d03c1c6f0 (fix(ts-checker): exclude private names from keyof).

This chunk ports the remaining privateNamesAndkeyof behavior into Home:

• excludes ECMAScript #private fields, methods, and accessors from both checker and lowerer keyof key collection paths
• reduces an all-private object key set to never
• preserves symbolic named-object assignment diagnostics such as keyof A
• keeps TypeScript's expanded string | number | symbol diagnostic display for keyof any
• adds focused checker coverage for accepting a visible key and rejecting private/missing keys

Exact movement: 4,970/5,907 -> 4,971/5,907, with failures 937 -> 936. The sole resolved fixture is privateNamesAndkeyof; the complete failure-set comparison found zero new failures. The code delta is 40 insertions, 1 deletion across 2 files.

Verification:

• ts_checker: 3,093/3,093
• focused exact privateNamesAndkeyof: 1/1
• ts_parser: 749/749
• ts_driver: 136/136
• ts_conformance: 1,369/1,369
• baseline-aware: 586/586
• full exact corpus: 4,971/5,907

Authored and committed by Chris Breuer with no coauthors.

Pushed bff155e9a (fix(ts-checker): deduplicate static object rest prototype).

This small chunk fixes static class object-rest construction at the source:

• reuses the prototype member already present on a class static type
• synthesizes a fallback prototype only when the source static shape genuinely lacks one
• prevents residual types such as { prototype: C; prototype: C; }
• adds focused checker coverage for static private-field access through an object-rest binding

Exact movement: 4,971/5,907 -> 4,972/5,907, with failures 936 -> 935. The sole resolved fixture is privateNameAndObjectRestSpread; the complete failure-set comparison found zero new failures. The code delta is 29 insertions, 2 deletions in 1 file.

Verification:

• ts_checker: 3,094/3,094
• focused exact privateNameAndObjectRestSpread: 1/1
• ts_parser: 749/749
• ts_driver: 136/136
• ts_conformance: 1,369/1,369
• baseline-aware: 586/586
• full exact corpus: 4,972/5,907

The commit was rebased conflict-free over unrelated runtime work, then pushed with Chris Breuer as both author and committer and no coauthors.

Pushed e69959e93 (fix(ts-parser): reject bare private-name hashes).

This parser chunk ports the bare-hash private-name recovery used by TypeScript:

• classifies # without an identifier body as an invalid token
• preserves valid #name private identifiers and the existing #! shebang behavior
• recovers invalid hashes in class-member declarations and both member-access parser paths
• makes top-level #, class-body #, and this.# each emit exactly one TS1127
• prevents the previous TS1451, TS2304, and Property '#' checker cascades
• adds lexer and parser coverage for all three malformed positions

Exact movement: 4,972/5,907 -> 4,973/5,907, with failures 935 -> 934. The sole resolved fixture is privateNameHashCharName; the complete failure-set comparison found zero new failures. The code delta is 58 insertions across 2 files.

Verification:

• ts_lexer: 78/78
• ts_parser: 750/750
• ts_checker: 3,094/3,094
• focused exact privateNameHashCharName: 1/1
• ts_driver: 136/136
• ts_conformance: 1,369/1,369
• baseline-aware: 586/586
• full exact corpus: 4,973/5,907

Authored and committed by Chris Breuer with no coauthors.

Pushed 59a314bc3 (fix(ts-checker): align async private generator diagnostics) to main.

This chunk ports the remaining behavior needed by privateNameStaticMethodAsync:

• reports TS1029 when static follows async on a class member
• recognizes yield await Promise.resolve(value) as a concrete async-generator yield under noImplicitAny, avoiding the spurious TS7055
• adds focused parser and checker regression coverage

Exact parity movement:

• privateNameStaticMethodAsync: failing -> passing
• full exact corpus: 4973/5907 -> 4974/5907
• failures: 934 -> 933
• full failure-name set diff: exactly one removed, zero added
• source delta: 2 files, 71 insertions, 9 deletions

Validation:

• parser: 751/751
• checker: 3095/3095
• focused exact fixture: 1/1
• full exact corpus: 4974/5907
• driver: 136/136
• conformance: 1369/1369
• explicitly rooted baseline-aware corpus: 586/586

Pushed 9800b551a (fix(ts-checker): align private access on unknown and never) to main.

This chunk ports the private-name receiver semantics exercised by privateNameAndAny:

• explicit unknown receivers now report TS18046 for private-name access
• lexical private-name resolution continues after TS18046, so declared names remain valid while an undeclared name also reports TS2339 against any
• private-name access through never now consistently reports TS2339 against never
• focused checker coverage locks the unknown, any, and never diagnostic split

Exact parity movement:

• privateNameAndAny: failing -> passing
• all 12 expected diagnostics match byte-for-byte
• full exact corpus: 4974/5907 -> 4975/5907
• failures: 933 -> 932
• full failure-name set diff: exactly one removed, zero added
• source delta: 1 file, 38 insertions, 1 deletion

Validation:

• checker: 3096/3096
• focused exact fixture: 1/1
• full exact corpus: 4975/5907
• driver: 136/136
• conformance: 1369/1369
• explicitly rooted baseline-aware corpus: 586/586

Pushed b7c9392cb (fix(ts-checker): preserve cross-file private brands) to main.

This chunk ports the cross-module private-brand identity needed by privateNamesUnique-2:

• explicit relative import-type receivers are resolved against normalized virtual-file paths before accepting a lexical ECMAScript private brand
• same-named classes in different modules remain nominally distinct even when structural interning collapses their TypeIds
• TS18013 is emitted through the shared private-access reporter
• focused checker coverage locks the a.ts Foo vs b.ts Foo case

Exact parity movement:

• privateNamesUnique-2: failing -> passing
• full exact corpus: 4975/5907 -> 4976/5907
• failures: 932 -> 931
• full failure-name set diff: exactly one removed, zero added
• source delta: 1 file, 87 insertions, 5 deletions

Validation:

• checker: 3097/3097
• focused exact fixture: 1/1
• full exact corpus: 4976/5907
• driver: 136/136
• conformance: 1369/1369
• explicitly rooted baseline-aware corpus: 586/586

Pushed 6b57aee49 (fix(ts-checker): render private apparent source types) to main.

This chunk ports the apparent-type diagnostic provenance needed by privateNamesUnique-4:

• when a memberless interface has exactly one class base, missing ECMAScript-private property elaboration uses that base class as the apparent source name
• A2 extends A1 now reports TS2741 against A1, preserving the nominal private-brand identity
• ordinary missing-property source display remains unchanged
• focused checker coverage locks the interface-over-empty-class shape

Exact parity movement:

• privateNamesUnique-4: failing -> passing
• full exact corpus: 4976/5907 -> 4977/5907
• failures: 931 -> 930
• full failure-name set diff: exactly one removed, zero added
• source delta: 1 file, 43 insertions, 0 deletions

Validation:

• checker: 3098/3098
• focused exact fixture: 1/1
• full exact corpus: 4977/5907
• driver: 136/136
• conformance: 1369/1369
• explicitly rooted baseline-aware corpus: 586/586

TypeScript parity progress: legacy decorators on private names

Pushed fb5c3881e (fix(ts-checker): reject legacy decorators on private names) directly to main.

Logic ported

• Mirrored TypeScript's nodeCanBeDecorated legacy-decorator rule for every named ECMAScript-private class member.
• Private fields, methods, getters/setters, and auto-accessors now report TS1206 at the decorator token under experimentalDecorators.
• Validation stops before decorator expression/signature checking, suppressing the previous TS1240, TS1241, TS1270, and TS1271 cascades.
• Native decorator behavior remains unchanged.
• Added an exact checker regression for a private field and private method, including diagnostic-code and source-position assertions.

Exact parity movement

• Passed: 4977/5907 -> 4978/5907
• Failed: 930 -> 929
• Sole resolved fixture: privateNamesAndDecorators
• Newly failing fixtures: 0
• Remaining exact mismatches: 929

Verification

• Checker: 3099/3099
• Focused exact fixture: 1/1
• Driver: 136/136
• Conformance: 1369/1369
• Baseline-aware rooted survey: 586/586
• Full exact corpus: 4978/5907
• Failure-set comparison: one removal, zero additions
• git diff --check: clean

Scope

• 1 file changed
• 46 insertions, 8 deletions
• Authored and committed as Chris <chrisbreuer93@gmail.com>
• No coauthors

TypeScript parity progress: circular class-field inference

Pushed b8d911cad (fix(ts-checker): detect circular class field inference) directly to main.

Logic ported

• Added separate instance/static dependency graphs for unannotated class-field initializers.
• Followed this.member and this[key] references transitively through common expression forms.
• Reported TS7022 for every field participating in a direct or indirect inference cycle under noImplicitAny.
• Preserved computed diagnostic spelling such as ["#baz"] while anchoring at the field name.
• Pre-seeded statically known computed data fields in the class shape.
• Resolved known literal members from type-parameter constraints before TS7053 missing-index fallback.
• Excluded computed method-shaped declarations from field pre-seeding so overload resolution remains unchanged.

Exact parity movement

• Passed: 4978/5907 -> 4980/5907
• Failed: 929 -> 927
• Resolved fixtures: privateNameCircularReference, strictPropertyInitialization
• Newly failing fixtures: 0
• Remaining exact mismatches: 927

Regression audit

• The first full audit exposed a new symbolProperty40 failure despite a positive aggregate.
• Refined method-shape detection restored that fixture to 1/1 while preserving both intended gains.
• Final failure-set comparison: two removals, zero additions.

Verification

• Checker: 3100/3100
• privateNameCircularReference: 1/1
• strictPropertyInitialization: 1/1
• symbolProperty40: 1/1
• Driver: 136/136
• Conformance: 1369/1369
• Baseline-aware rooted survey: 586/586
• Full exact corpus: 4980/5907
• git diff --check: clean

Scope

• 1 file changed
• 168 insertions, 5 deletions
• Authored and committed as Chris <chrisbreuer93@gmail.com>
• No coauthors

TypeScript parity progress: nominal private-name receiver display

Pushed 2a537a156 (fix(ts-checker): render nominal type for private this misses) directly to main.

Logic ported

• Undeclared ECMAScript-private names accessed through class this now render against the enclosing nominal class in TS2339.
• Generic class parameters are preserved (A<T>), rather than collapsing to a bare class name.
• The branch runs only after private-member lookup fails and only for an actual this receiver, leaving public misses and successful private accesses unchanged.
• Added a generic A<T> regression asserting the complete diagnostic message.

Exact parity movement

• Passed: 4980/5907 -> 4981/5907
• Failed: 927 -> 926
• Sole resolved fixture: privateNameAndIndexSignature
• Newly failing fixtures: 0
• Remaining exact mismatches: 926

Verification

• Checker: 3101/3101
• Focused exact fixture: 1/1
• Driver: 136/136
• Conformance: 1369/1369
• Baseline-aware rooted survey: 586/586
• Full exact corpus: 4981/5907
• Failure-set comparison: one removal, zero additions
• git diff --check: clean

Scope

• 1 file changed
• 32 insertions, 0 deletions
• Authored and committed as Chris <chrisbreuer93@gmail.com>
• No coauthors

Pushed 9d863b8b6 (fix(ts-driver): resolve package tslib helper arity).

This parity chunk teaches the TypeScript driver to resolve imported private-field helper declarations from the package layout node_modules/tslib/index.d.ts, in addition to direct tslib.d.ts virtual files. It also classifies private member reads, simple writes, compound assignments, and updates so incompatible __classPrivateFieldGet and __classPrivateFieldSet diagnostics are anchored to the receiver that actually requires each helper, matching the upstream TS2807 baselines.

Exact corpus movement:

• Passing: 4981 -> 4983 / 5907
• Failing: 926 -> 924
• Newly passing: privateNameEmitHelpers, privateNameStaticEmitHelpers
• Newly failing: none

Verification:

• ts_driver: 137/137
• ts_checker: 3101/3101 (checker unchanged; cached gate)
• ts_conformance: 1369/1369
• Baseline-aware type relationships: 586/586
• Focused exact fixtures: 1/1 each
• Full exact corpus: 4983/5907

Change size: 84 insertions, 5 deletions across 1 file.

Tracks #69.

Pushed 7518edfd7 (fix(ts-checker): enforce destructured member accessibility).

This parity chunk unwraps polymorphic this markers before object-binding member lookup, preserving inherited private members for accessibility checks. It also recovers lexical this class identity when normal type maps are unavailable and anchors renamed destructuring diagnostics at their source property keys rather than the local binding targets.

Exact corpus movement:

• Passing: 4983 -> 4984 / 5907
• Failing: 924 -> 923
• Newly passing: privateProtectedMembersAreNotAccessibleDestructuring
• Newly failing: none

Verification:

• ts_checker: 3102/3102
• Focused checker regression: 2/2
• Exact upstream fixture: 1/1
• ts_conformance: 1369/1369
• Baseline-aware type relationships: 586/586
• Full exact corpus: 4984/5907
• Full audit ranges: 0-2999 = 2679/3000, 3000-5906 = 2305/2907
• Uncapped failure-name diff: only the intended fixture removed; no additions

Change size: 88 insertions, 6 deletions across 1 file.

Tracks #69.

Pushed 706613a45 (fix(ts-checker): infer generic class constructor instances) to main.

This chunk closes the generic-constructor/private-member mismatch in privateNamesAndGenericClasses-2:

• preserves the declaration-time constructor signature for class type-parameter inference;
• infers omitted class type arguments from constructor arguments;
• instantiates the generic class body with the inferred substitutions;
• substitutes concrete class arguments into accessor setter types;
• renders the expected nominal assignments (C<string> vs C<number>);
• removes the spurious TS5082 on a.baz = 5 while retaining the expected private-access and assignment diagnostics.

Exact parity moved 4984 -> 4985 / 5907, with failures dropping 923 -> 922. The sorted failure comparison removed exactly privateNamesAndGenericClasses-2 and added no failures.

Verification:

• checker: 3103/3103
• focused checker tests: 2/2
• exact target fixture: 1/1
• conformance: 1369/1369
• rooted type-relationship survey: 586/586
• full exact corpus: 4985/5907
  • fixtures 0-2999: 2680/3000
  • fixtures 3000-5906: 2305/2907

Change size: 1 file, 80 insertions, 6 deletions.

Pushed 41b7ae7d5 (fix(ts-parser): recover private indexed access syntax) to main.

This chunk closes privateNamesAndIndexedAccess end to end:

• indexed-access type parsing now stops before a private identifier instead of consuming it as unknown;
• the stranded #bar] = 3 tail is preserved for declaration recovery;
• parser recovery emits the upstream missing ], missing comma, and two invalid-declarator diagnostics without adding TS1155;
• the recovered private binding reaches noImplicitAny analysis and emits TS7005;
• string indexed access treats an ECMAScript #bar slot as distinct from an ordinary quoted "#bar" property;
• class-declaration fallback handles indexed access while the enclosing class is still being checked.

Exact parity moved 4985 -> 4986 / 5907, with failures dropping 922 -> 921. The sorted full-corpus comparison removed exactly privateNamesAndIndexedAccess and added no failures.

Verification:

• parser: 744/744
• checker: 3105/3105
• exact target fixture: 1/1
• conformance: 1369/1369
• rooted type-relationship survey: 586/586
• full exact corpus: 4986/5907
  • fixtures 0-2999: 2681/3000
  • fixtures 3000-5906: 2305/2907

Change size: 2 files, 209 insertions, 3 deletions.

Parity progress: privateIndexer2

Pushed 522dd0aef (fix(ts-parser): recover private indexer syntax) to main.

This chunk ports TypeScript's context-sensitive recovery for malformed private indexers:

• In type literals, adjacent private[index: Key]: Value syntax now consumes private and recovers the remaining member as an index signature without modifier diagnostics.
• In object literals, private [index: Key]: Value continues through malformed shorthand/computed-property recovery and emits the same parser diagnostic shape as TypeScript.
• Primitive type names encountered as values in that object-literal recovery remain TS2693 type-only value errors instead of becoming TS2552 name suggestions.

Exact corpus impact:

• Flipped: privateIndexer2
• Added failures: none
• Passing: 4986 -> 4987 / 5907
• Failing: 921 -> 920
• Split audit: 2682/3000 + 2305/2907 = 4987/5907

Verification:

• Parser: 745/745
• Checker: 3106/3106
• Focused exact fixture: 1/1
• Conformance: 1369/1369
• Rooted baseline-aware survey: 586/586
• Exact full corpus: 4987/5907, with the sorted failure diff removing only privateIndexer2

Scope: 2 files changed, 64 insertions, 2 deletions.

Parity progress: ES5 super-field accessibility

Pushed ee7326e90 (fix(ts-checker): align ES5 super field diagnostics) to main.

This chunk ports the connected parser/checker behavior behind private and protected base-field accessibility:

• this is now parsed as a complete primary type. In malformed a: this.foo, the dot receives TS1442 and recovery exposes foo as the next public class member, matching TypeScript's AST recovery and enabling the derived-class TS2415.
• ES5 super.field access to a base data property now emits TS2340 instead of the ES2015+ TS2855 diagnostic.
• Dotted typeof super.foo queries now diagnose the unresolved super root with TS2304 even when the class has a runtime super binding.
• Overlapping private-base redeclaration and heritage-accessibility paths no longer emit duplicate TS2415 diagnostics for the same class.

Exact corpus impact:

• Flipped: privateInstanceMemberAccessibility
• Flipped: protectedClassPropertyAccessibleWithinSubclass3
• Added failures: none
• Passing: 4987 -> 4989 / 5907
• Failing: 920 -> 918
• Split audit: 2684/3000 + 2305/2907 = 4989/5907

Verification:

• Parser: 746/746
• Checker: 3107/3107
• Focused exact fixture: 1/1
• Conformance: 1369/1369
• Rooted baseline-aware survey: 586/586
• Exact full corpus: 4989/5907, with the sorted failure diff removing exactly the two fixtures above and adding none

Scope: 2 files changed, 68 insertions, 11 deletions.

Pushed 01e808393 (fix(ts-parser): recover invalid private brand assignments) to main.

This ports the remaining syntax/checker behavior needed by privateNameInInExpressionTransform:

• assignment after a completed in expression now reports TS1005 at = and preserves the parsed expression instead of constructing an invalid assignment node;
• private identifiers nested beneath higher-precedence binary operators on the left side of in are recognized as brand-check syntax rather than ordinary unresolved names;
• those syntax-only private operands use any during checking, preventing spurious arithmetic-right-operand cascades while retaining the expected outer in diagnostics.

Exact parity moved 4989 -> 4990 / 5907 and exact failures moved 918 -> 917. The sorted corpus comparison removed exactly privateNameInInExpressionTransform and added no failures.

Verification:

• parser: 747/747
• checker: 3108/3108
• focused checker regression: 2/2
• focused exact fixture: 1/1
• broad conformance: 1369/1369
• rooted baseline-aware survey: 586/586
• exact corpus split: 2685/3000 + 2305/2907 = 4990/5907

Change size: 53 insertions, 7 deletions across 2 files. This builds directly on the private-name parser/checker work tracked in the preceding #69 updates.

Published 1dbc803cd (fix(ts-checker): align private in-expression semantics) directly to main as Chris, with no coauthor trailers.

Parity movement:

• Exact TypeScript conformance: 4990 -> 4991 / 5907
• Canonical failures: 917 -> 916
• Flipped exactly: privateNameInInExpression
• Added regressions: none

Logical port completed in this chunk:

• Align as and satisfies with relational precedence so prop in value as any forms the same tree as upstream TypeScript.
• Track explicit strict grammar separately from implicit module strictness, preserving non-strict transform recovery while emitting TS18016 for strict private brand checks outside classes.
• Match canonical TS1451 wording exactly.
• Resolve private brand names through enclosing classes and emit TS2339 against the RHS type for unresolved names.
• Reject private identifiers as for...in targets with TS2406.
• Port checkNonNullType ordering to both ordinary operands of in: accept never, report unknown and nullable diagnostics first, narrow nullable unions, and suppress secondary TS2322 cascades.
• Preserve the parenthesis-aware TS2571 anchor for non-entity unknown operands.

Verification on the final committed tree:

• ts_parser: 750/750
• parser precedence: 8/8
• ts_checker: 3110/3110
• focused private fixture regression preflight: 5/5
• default ts_conformance: 1369/1369
• baseline-aware survey: 586/586
• exact corpus split: 2686/3000 + 2305/2907 = 4991/5907
• sorted identity audit: 916 failures, exactly one removal and zero additions versus pushed baseline

Footprint: 3 files, 216 insertions, 28 deletions. This builds on 01e808393, which closed privateNameInInExpressionTransform; together the two small commits cover transform recovery and the broader checker/parser semantics without conflating their regression audits.

Published 606e3bd87 (fix(ts-conformance): strip ignoreDeprecations directives) directly to main as Chris, with no coauthor trailers.

Parity movement:

• Exact TypeScript conformance: 4991 -> 5020 / 5907
• Canonical failures: 916 -> 887
• Flipped fixtures: 29
• Added regressions: 0

Root cause and logical fix:

• TypeScript test fixtures treat // @ignoreDeprecations: ... as runner metadata and remove it from .errors.txt diagnostic line numbering.
• Home already used a shared runner-directive classifier for leading and later directive offsets, but the classifier omitted this valid compiler option.
• Adding ignoreDeprecations to that shared classifier now strips the directive and adjacent trailing blank consistently across exact baseline rendering.
• A regression test pins the canonical target + ignoreDeprecations + strict + alwaysStrict + blank shape at an offset of five lines.

Closed fixtures:

• arrowFunctionContexts
• FunctionDeclaration2_es6
• for-of56
• NonInitializedExportInInternalModule
• parserStatementIsNotAMemberVariableDeclaration1
• all 24 default/ES6 variants of emitArrowFunctionWhenUsingArguments{03..08,11,13..17}

Verification:

• focused directive helper: pass
• focused exact preflight: 7/7
• default ts_conformance: 1369/1369
• baseline-aware survey: 586/586
• exact first half: 2688/3000
• exact second half: 2332/2907
• aggregate: 5020/5907, 887 failures
• sorted identity audit: exactly 29 removals, 0 additions

Footprint: 1 file, 12 insertions. This is intentionally a standalone harness-parity commit following the private brand-check semantic work in 1dbc803cd, so each measured jump remains independently auditable.

Published b12145fad (fix(ts-conformance): complete runner directive matrix) directly to main as Chris, with no coauthor trailers.

Parity movement:

• Exact TypeScript conformance: 5020 -> 5032 / 5907
• Canonical failures: 887 -> 875
• Flipped fixtures: 12
• Added regressions: 0

Logical completion:

• Cross-checked Home against TypeScript ts.optionDeclarations, the harness option declarations, and the actual directive names present in the 5,907-case conformance corpus.
• Added 30 omitted compiler/harness options to the shared runner-directive classifier, covering emit, module resolution, strictness, JSX, library, and harness settings.
• Kept source pragmas and annotation comments out of metadata normalization: ts-check, ts-expect-error, ts-ignore, ts-nocheck, internal, readonly, reference, and todo remain source-visible.
• Added a table-driven unit test pinning both the accepted option set and the rejected pragma/comment set.

Closed fixtures:

• autoAccessor1
• autoAccessor3
• autoAccessor4
• decoratorMetadata-jsdoc
• decoratorOnClassMethod17
• destructuringArrayBindingPatternAndAssignment1ES5iterable
• destructuringVariableDeclaration1ES5iterable
• emptyVariableDeclarationBindingPatterns02_ES5iterable
• ES5For-of26
• overrideDynamicName1
• overrideLateBindableIndexSignature1
• overrideLateBindableName1

Verification:

• directive matrix unit test: pass
• affected-source exact preflight: 18 matched variants exact; deeper semantic mismatches remained visible
• default ts_conformance: 1369/1369
• baseline-aware survey: 586/586
• exact first half: 2696/3000
• exact second half: 2336/2907
• aggregate: 5032/5907, 875 failures
• sorted identity audit: exactly 12 removals, 0 additions

Footprint: 1 file, 51 insertions, 1 deletion. This follows the standalone ignoreDeprecations correction in 606e3bd87; separating them keeps the high-impact one-option discovery and the complete upstream matrix independently auditable.

Published 53be08b2b (fix(ts-parser): diagnose yield in type queries) directly to main as Chris, with no coauthor trailers.

Parity movement:

• Exact TypeScript conformance: 5032 -> 5033 / 5907
• Canonical failures: 875 -> 874
• Flipped exactly: generatorTypeCheck38
• Added regressions: none

Logical parser port:

• typeof yield now treats yield as a contextual identifier before generic invalid-operand recovery.
• Reserved uses reuse Home existing yield-name diagnostic machinery, preserving TS1212/TS1213/TS1214 selection for generator, strict, class, and module contexts.
• Recovery still produces an unknown type reference, preventing a secondary unresolved-name diagnostic.
• Sloppy ES5 typeof yield is accepted as an identifier query, matching the counterexample required by upstream grammar.

Verification:

• ts_parser: 752/752
• parser precedence: 8/8
• focused exact generatorTypeCheck38: 1/1
• default ts_conformance: 1369/1369
• baseline-aware survey: 586/586
• exact first half: 2696/3000
• exact second half: 2337/2907
• aggregate: 5033/5907, 874 failures
• sorted identity audit: exactly 1 removal, 0 additions

Footprint: 1 file, 34 insertions. This is the first semantic parser ratchet after completing the corpus runner metadata matrix in b12145fad.

Pushed 56719bc: fix(ts-conformance): honor combined ES5 target matrices\n\nParity movement\n- Exact parity: 5,033 -> 5,034 / 5,907\n- Exact failures: 874 -> 873\n- Closed exactly ES5For-of19\n- Added failures: none\n- Split totals: 2,696/3,000 and 2,338/2,907\n\nImplementation\n- TS1250/TS1251/TS1252 now use the effective ES5 emit target rather than the separate target-deprecation baseline switch.\n- The conformance loader parses target=es5 from any position in a combined baseline option tuple, including (alwaysstrict=true,target=es5).\n- ts_driver honors ignoreDeprecations: 6.0 for target, module, and outFile deprecations while retaining unrelated compatibility errors such as TS5105.\n- Added focused checker coverage for the for-of block container and target/deprecation separation, matrix-parser coverage, and driver tests for the 6.0 suppression and 5.0 non-suppression boundary.\n- Change size: 105 insertions, 22 deletions across 3 files.\n\nVerification\n- ts_parser: pass\n- ts_precedence: pass\n- ts_checker: pass\n- ts_driver: pass\n- Focused exact ES5For-of19: 1/1\n- Full exact split audit: 5,034/5,907, with zero added failures\n- Conformance test executable: 1,371/1,371 in both slices\n- Smoke: 16/16\n- Named categories: 86/86\n- Baseline-aware categories: 586/586\n\nTracks #69.

Progress: recover invalid decorated expressions

Pushed 4d67d38f3 (fix(ts-parser): recover invalid decorated expressions).

This ports typescript-go's parseDecoratedExpression recovery for decorator sequences encountered in expression position without a following class. Home now consumes the decorator sequence, emits zero-width TS1109 at its boundary, synthesizes an inert missing expression, and leaves the following token to outer statement recovery. For var F = @dec () => {}, that produces the upstream TS1109 after ) plus TS1005 on => instead of Home's custom lowercase diagnostic.

Parity impact:

• exact parity: 5,034/5,907 -> 5,035/5,907 (+1)
• exact failures: 873 -> 872
• split totals: 2,697/3,000 and 2,338/2,907
• removed exactly: decoratorOnArrowFunction
• newly failing fixtures: 0
• change size: 1 file, 36 insertions, 2 deletions

Verification:

• ts_parser: pass
• ts_parser_precedence: pass
• ts_checker: pass
• ts_driver: pass
• focused exact fixture: 1/1
• full exact TypeScript audit: 5,035/5,907, with no added failures

This continues the parser-diagnostic parity work tracked by #69 and leaves the refreshed canonical failure set at 872 fixtures.

Progress: recover variable-list declaration boundaries

Pushed e01b769e3 (fix(ts-parser): recover variable list boundaries).

This ports typescript-go's parsing-context recovery when a same-line declaration starter cannot continue a variable-declaration list. Home now emits TS1005 ',' expected., leaves the declaration token unread, and yields to the outer statement parser. In var F = @dec function () {}, that lets the following unnamed function declaration emit TS1003 at (, completing the upstream TS1109/TS1005/TS1003 sequence.

Parity impact:

• exact parity: 5,035/5,907 -> 5,036/5,907 (+1)
• exact failures: 872 -> 871
• split totals: 2,698/3,000 and 2,338/2,907
• removed exactly: decoratorOnFunctionExpression
• newly failing fixtures: 0
• change size: 1 file, 63 insertions, 1 deletion

Verification:

• ts_parser: pass
• ts_parser_precedence: pass
• ts_checker: pass
• ts_driver: pass
• focused exact decorated-expression fixtures: 2/2
• full exact TypeScript audit: 5,036/5,907, with no added failures

This builds directly on the decorated-expression recovery in 4d67d38f3 and continues the parser parity track in #69. The refreshed canonical failure set is now 871 fixtures.

Progress: yield decorators from enum-member lists

Pushed 17c6c01bf (fix(ts-parser): yield decorators from enum lists).

This ports typescript-go's nested parsing-context recovery for decorator tokens inside enum bodies. The enum-member list now emits TS1132 without consuming @; outer declaration parsing consumes the decorator sequence and emits zero-width TS1146 when no declaration follows; the trailing identifier and brace remain available for normal TS2304 and TS1128 handling. This replaces Home's early TS1003 abort with the complete upstream diagnostic flow.

Parity impact:

• exact parity: 5,036/5,907 -> 5,037/5,907 (+1)
• exact failures: 871 -> 870
• split totals: 2,699/3,000 and 2,338/2,907
• removed exactly: decoratorOnEnum2
• newly failing fixtures: 0
• change size: 1 file, 61 insertions, 1 deletion

Verification:

• ts_parser: pass
• ts_parser_precedence: pass
• ts_checker: pass
• ts_driver: pass
• focused exact decorator fixtures: 3/3
• full exact TypeScript audit: 5,037/5,907, with no added failures

This extends the same parser-context work from 4d67d38f3 and e01b769e3, all tracked by #69. The refreshed canonical failure set is now 870 fixtures.

Pushed 0ad1fec28 (fix(ts-checker): gate await errors on parse diagnostics).

This chunk ports the relevant typescript-go await diagnostic behavior across the parser, checker, and driver:

• recovers @dec\nawait as a missing declaration and emits TS1146 at the decorator boundary instead of the generic decorator-location diagnostic
• gates checker await-context diagnostics when the source has true parse diagnostics, while preserving unconditional static-block await errors
• classifies parser-emitted TS1163 and TS18028 as grammar-only diagnostics so they do not suppress sibling checker grammar errors

Exact parity impact:

• flipped exactly decoratorOnAwait from failing to exact
• moved exact parity from 5037/5907 to 5038/5907 (+1)
• reduced failures from 870 to 869
• split result: 2700/3000 and 2338/2907
• added 0 failures across the complete 5907-case audit

The first full audit caught awaitAndYield and awaitAndYieldInProperty regressing under a broader parse-diagnostic signal. Refining the driver classification restored both before commit; the final failure-list diff removed only decoratorOnAwait.

Change size: 3 files, 105 insertions, 8 deletions.

Verification:

• ts_parser
• ts_parser_precedence
• ts_checker
• ts_driver (139/139)
• focused exact guard set (6/6): decoratorOnAwait, the three previously closed decorator fixtures, awaitAndYield, and awaitAndYieldInProperty
• full exact conformance audit: 5038/5907

This follows the preceding parser parity chunks 4d67d38f, e01b769e, and 17c6c01b in the ongoing TypeScript parity work.

Pushed db1d16c31 (fix(ts-conformance): default alwaysStrict to enabled).

This chunk ports TypeScript's current alwaysStrict !== false default into the Home conformance path while preserving explicit @alwaysStrict matrix selections and the declaration-file exemption. It also aligns the diagnostics exposed by that default:

• labeled var statements report TS1344 only for ES2015+ targets, preserving TypeScript's ES5 recovery behavior;
• function expressions carry explicit HIR metadata so strict ES5 TS1250 remains declaration-only;
• outside-class private-brand TS18016 is treated as checker-owned grammar and is suppressed when the file has genuine parse diagnostics;
• grammar-only diagnostics no longer incorrectly suppress sibling await-context diagnostics in the driver.

The exact audit caught two intermediate regression shapes before this was committed:

• the first prototype fixed parserWithStatement2 but displaced privateNameInInExpressionTransform; deferred TS18016 suppression restored it while retaining ordinary privateNameInInExpression;
• enabling strict mode then exposed TS1344/TS1250 false positives in labeledStatementDeclarationListInLoopNoCrash1/2; target-aware label handling and expression-aware TS1250 restored both;
• a broad fn_decl -> fn_expr migration displaced classStaticBlock22, so the final implementation keeps existing node identity and adds only the narrow expression flag.

Exact parity moved 5038 -> 5039 / 5907 (+1) and failures fell 869 -> 868:

• first half: 2701/3000 (299 failures)
• second half: 2338/2907 (569 failures)
• sole removed failure: parserWithStatement2
• added failures: none

Verification on the final source:

• parser suite: pass
• HIR suite: pass
• checker suite: pass
• driver suite: pass
• conformance suite: 1372/1372
• focused exact regression matrix: 7/7
• full exact failure-identity audit: 5907 cases, zero regressions
• formatting and git diff --check: pass

Change size: 5 files, +130/-25.

This follows the preceding await-context parity chunk 0ad1fec28, which established the 5038 baseline.

Tracks #69.

Pushed 2aaf61e88 (fix(ts-conformance): honor selected module matrices).

This is a focused conformance-runner parity chunk. Multi-value fixtures such as:

// @module: preserve,esnext,nodenext,es2020,es2015,commonjs

produce separate TypeScript baselines. Home already selected one baseline filename, but it still compiled the first source directive value (preserve). For importDeferNamespace, the selected baseline was module=commonjs, so Home incorrectly omitted TS18060.

The runner now extracts the chosen (module=X) suffix and carries it through:

• owned and borrowed corpus entries;
• direct compileSource execution;
• full ts_program graph execution;
• resolver module-kind configuration;
• implicit resolver strategy selection.

Baseline selection now takes precedence over the original comma-separated directive, matching the existing target/module-resolution matrix model.

Exact parity moved 5039 -> 5040 / 5907 (+1) and failures fell 868 -> 867:

• first half: 2701/3000 (unchanged, identical 299-failure set)
• second half: 2339/2907 (568 failures, +1)
• sole removed failure: importDeferNamespace
• added failures: none

Verification:

• conformance suite: 1374/1374
• focused deferred-import filter: 2/3
• remaining focused failure: dynamicImportDefer, a separate missing checker path for dynamic import.defer() TS18060
• full exact failure-identity audit: 5907 cases, zero regressions
• formatting and git diff --check: pass

Change size: 1 file, +66/-10.

This follows db1d16c31, which established the 5039 baseline.

Tracks #69.

Dynamic deferred import parity

Landed fix(ts-checker): validate dynamic deferred imports (03020d236).

What changed:

• Ported the TypeScript checkGrammarImportCallExpression meta-property branch for import.defer(...).
• Home now reports TS18060 for dynamic deferred imports when module is not esnext or preserve.
• Added checker coverage for the CommonJS error path and the Preserve clean path.

Parity movement:

• Full corpus: 5,040 -> 5,041 passing out of 5,907.
• Failures: 867 -> 866.
• Sole removed failure: dynamicImportDefer.
• Added failures: 0.

Audit:

• First half: 2,701/3,000, failure identity unchanged.
• Second half: 2,340/2,907, removed only dynamicImportDefer.
• Combined failure list now has 866 entries.
• Focused exact filter dynamicImportDefer,importDeferNamespace: 3/3 passing.
• ts_conformance unit suite: passing.
• Checker suite: passing.

Diff size:

• packages/ts_checker/src/check.zig: +34/-0.

Tracks #69.

Import module-specifier diagnostic anchoring

Landed fix(ts-checker): retain import specifier positions (1eeadb6f0).

What changed:

• Ported TypeScript's structural ModuleSpecifier diagnostic anchoring by retaining the parser token position in Home's import HIR.
• Static imports, side-effect imports, and import = require(...) now carry the opening-quote position of their module string literal.
• The checker uses that position directly and keeps its existing source-search fallback for non-import nodes.
• Added a comment-heavy deferred-import regression that proves TS2307 lands on the quoted module token rather than the earlier a in as.

Parity movement:

• Full corpus: 5,041 -> 5,042 passing out of 5,907.
• Failures: 866 -> 865.
• Sole removed failure: importDeferComments.
• Added failures: 0.

Audit:

• First half: 2,701/3,000, all 299 failure identities unchanged.
• Second half: 2,340 -> 2,341 passing out of 2,907; failures 567 -> 566.
• Combined failure list now has 865 entries.
• Focused exact import-defer set: 4/4 passing.
• ts_parser suite: passing.
• ts_checker suite: passing.
• ts_conformance suite: passing.

Diff size:

• packages/hir/src/hir.zig: +4/-0.
• packages/ts_parser/src/ts_parser.zig: +10/-1.
• packages/ts_checker/src/check.zig: +25/-0.
• Total: +39/-1.

Tracks #69.

Import-clause comma and recovery parity

Landed fix(ts-parser): require commas before import bindings (d19cc2d03).

What changed:

• Ported TypeScript's parseImportClause gate: namespace and named bindings may follow a default import only when a comma was consumed.
• Malformed import defer type * as ns from "./a" no longer becomes a valid deferred default-plus-namespace import.
• Mirrored TypeScript's recovery by consuming the malformed * as module expression, reporting the missing terminator at the namespace name, preserving TS1434 on from, and continuing name checking for the trailing identifiers.
• Added parser coverage for the missing-from, string-literal, and unexpected-keyword diagnostics.

Parity movement:

• Full corpus: 5,042 -> 5,043 passing out of 5,907.
• Failures: 865 -> 864.
• Sole removed failure: importDeferTypeConflict2.
• Added failures: 0.

Audit:

• First half: 2,701/3,000, all 299 failure identities unchanged.
• Second half: 2,341 -> 2,342 passing out of 2,907; failures 566 -> 565.
• Combined failure list now has 864 entries.
• Focused import-defer exact set: 4/5 passing; only the separate importDeferTypeConflict1 import-equals branch remains.
• ts_parser suite: passing.
• ts_checker suite: passing.
• ts_conformance suite: passing.

Diff size:

• packages/ts_parser/src/ts_parser.zig: +52/-3.

Tracks #69.

Type-only import-equals recovery parity

Landed fix(ts-parser): recover type-only import assignments (ff2fe5586).

What changed:

• Ported TypeScript's parseImportDeclarationOrImportEqualsDeclaration disambiguation for a type-only imported identifier followed by *.
• Malformed import type defer * as ns1 from "./a" now enters import-equals recovery and reports TS1005 ('=' expected) at *.
• The recovery leaves as, ns1, and from available as identifier statements, preserving the upstream TS1005, TS1434, and TS2304 sequence.
• The former import-clause TS1005 ('from' expected) and TS1141 path is no longer taken.
• Added parser coverage for the missing-equals branch and its downstream recovery diagnostics.

Parity movement:

• Full corpus: 5,043 -> 5,044 passing out of 5,907.
• Failures: 864 -> 863.
• Sole removed failure: importDeferTypeConflict1.
• Added failures: 0.

Audit:

• First half: 2,701/3,000, all 299 failure identities unchanged.
• Second half: 2,342 -> 2,343 passing out of 2,907; failures 565 -> 564.
• Combined failure list now has 863 entries.
• Focused import-defer exact set: 5/5 passing.
• ts_parser suite: passing.
• ts_checker suite: passing.
• ts_conformance suite: passing.

Diff size:

• packages/ts_parser/src/ts_parser.zig: +57/-3.

Tracks #69.

Parity progress: typeofImportDefer now exact

Pushed e2115aecd (fix(ts-parser): recover deferred import type queries) to main.

TypeScript behavior ported

TypeScript's recoverable parseExpected flow does not stop after the missing ( in:

export type X = typeof import.defer("./a").Foo;

It reports the malformed import type, ends that type query at defer, and leaves ("./a").Foo to parse as a value expression. Home now mirrors that behavior:

• TS1005 "(" expected at .defer
• TS1141 String literal expected at .defer
• TS1005 ")" expected at the following (
• normal semantic member checking of ("./a").Foo, producing TS2339 against the literal type "./a"

The parser recovery preserves the trailing expression in HIR instead of hard-coding the semantic error. The checker also now retains a string literal's literal type while resolving a direct property access, so the diagnostic is produced through the normal member-lookup path with TypeScript's exact target text.

Coverage and verification

• ts_parser suite: pass
• ts_checker suite: pass
• ts_conformance package suite: pass
• focused exact import-defer run: 3/3
• full exact identity audit: 5,045/5,907
• failures: 863 -> 862
• first half: 2,701/3,000 (unchanged)
• second half: 2,343 -> 2,344/2,907
• failure-set delta: removed only typeofImportDefer; zero additions or changed identities
• change size: 2 files, +85/-0, including parser and checker regression tests

This follows the preceding import-defer chunks for dynamicImportDefer, importDeferComments, importDeferTypeConflict2, and importDeferTypeConflict1, completing the currently isolated typeof import.defer recovery gap while keeping the broader exact corpus stable.

Pushed 9f72dff (fix(ts-checker): stabilize recursive member lookup). Recursive union/intersection property lookup now snapshots constituent TypeIds before interning can reallocate the shared member pool, fixing the tsgo nestedSpreadsAndWidening poisoned-TypeId crash. Added an 11-way nested-spread regression. Verification: ts_checker passes; tsgo-native compiler testdata passes 299/299 exact; default ts_conformance passes smoke 16/16, category 86/86, and baseline-aware 586/586; inherited TypeScript parity remains 5,045/5,907 with all 862 failure identities unchanged across the exact 5,907-case audit. Delta: 1 file, +34/-2.

Pushed e154609 (chore(ts-parity): pin typescript-go upstream). Home now owns a reproducible recursive microsoft/typescript-go source pin at b8276f35cd288aa163fad0516b60ddaacec87ee7; tsgo pins the inherited TypeScript corpus at 4d4f005c8541e0255a9d8791205fdce326e462bc. Conformance and tsgo-derived generators default to _submodules/typescript-go, while explicit environment overrides remain available. This advances 107 tsgo commits and 23 nested TypeScript commits; the expanded corpus and error baselines remain unchanged at 5,907 cases. Generator audit: 139-option CLI table and diagnostic reachability (459 = 0 active + 4 effectively dead + 455 dead) are byte-identical. Verification: native compiler testdata 299/299 exact; smoke 16/16; category 86/86; baseline-aware 586/586; inherited exact 5,045/5,907 with all 862 failure identities unchanged. Delta: 9 files, +69/-53, including the new gitlink.

Parity wave: finite template-union inference

Pushed 8a369c718 (fix(ts-checker): preserve finite template unions) to main.

What changed

• Stop treating aggregate literal flags on union/intersection containers as one scalar literal payload.
• Enumerate finite template substitution unions under the existing 32-result bound.
• Relate a finite template-valued argument as its complete source set, so every generated string must fit the complete target union.
• Preserve all branches through generic inference while continuing to reject narrower subset targets.
• Added a focused regression covering a three-member inferred template union plus a two-member rejection.

Exact parity movement

• Flipped: templateLiteralTypes2
• Full tsgo exact: 5,045/5,907 -> 5,046/5,907 (+1)
• Failures: 862 -> 861
• First half: 2,701/3,000 -> 2,702/3,000
• Second half: unchanged at 2,344/2,907
• Failure identity audit: templateLiteralTypes2 was the only removed identity; no failures were added, and all 563 second-half identities were unchanged.

Verification

• ts_checker: 3,118 passing
• Focused exact fixture: 1/1
• Default smoke: 16/16
• Category survey: 86/86
• Baseline-aware survey: 586/586
• Full exact identity audit: 5,907 fixtures

Change size: 1 file, +67/-4, including one focused regression test.

Parity wave: generic class constructor overloads

Pushed e1648d3ce (fix(ts-checker): retain generic constructor metadata) to main.

What changed

• Preserve the owned class type-parameter list when bodyless constructor overload signatures are rebuilt with the completed instance return type.
• Let overload applicability and strict argument checking infer enclosing class parameters instead of treating them as fixed unresolved targets.
• Added a strict-null-check regression for duplicate generic class constructor overloads.

Exact parity movement

• Flipped: constructSignaturesWithIdenticalOverloads
• Flipped: constructSignaturesWithOverloads
• Flipped: constructSignaturesWithOverloads2
• Full tsgo exact: 5,046/5,907 -> 5,049/5,907 (+3)
• Failures: 861 -> 858
• First half: 2,702/3,000 -> 2,705/3,000
• Second half: unchanged at 2,344/2,907
• Failure identity audit: those three construct-signature fixtures were the only removed identities; no failures were added, and all 563 second-half identities were unchanged.

Verification

• ts_checker: 3,119 passing
• Focused exact construct-signature set: 4/4
• Default smoke: 16/16
• Category survey: 86/86
• Baseline-aware survey: 586/586
• Full exact identity audit: 5,907 fixtures

Change size: 1 file, +21/-0, including one strict generic-constructor regression test.

Parity wave: named class static TS2741 sources

Pushed de21f5e50 (fix(ts-checker): name class static missing-property types) to main.

What changed

• Render registered class static source types as typeof ClassName in missing-property diagnostics before anonymous object-shape fallback.
• Preserve class identity for constructor values assigned where an instance type is required.
• Added focused coverage requiring typeof A and typeof B in TS2741 prose.

Exact parity movement

• Flipped: stringIndexerConstrainsPropertyDeclarations2
• Full tsgo exact: 5,049/5,907 -> 5,050/5,907 (+1)
• Failures: 858 -> 857
• First half: 2,705/3,000 -> 2,706/3,000
• Second half: unchanged at 2,344/2,907
• Failure identity audit: stringIndexerConstrainsPropertyDeclarations2 was the only removed identity; no failures were added, and all 563 second-half identities were unchanged.

Verification

• ts_checker: 3,120 passing
• Focused exact fixture: 1/1
• Default smoke: 16/16
• Category survey: 86/86
• Baseline-aware survey: 586/586
• Full exact identity audit: 5,907 fixtures

Change size: 1 file, +27/-0, including one focused TS2741 rendering regression.

Parity wave: contextual generic interface heritage

Pushed f98355a8c (fix(ts-checker): refine generic heritage inference) to main.

What changed

• Treat an incomplete contextual-signature result as inconclusive only when both child and parent interface member signatures are generic.
• Detect child signatures that capture outer interface type parameters before applying generic fallback.
• Preserve free-child to concrete-parent return mismatches as real TS2430 errors.
• Expanded positive and negative generic call/construct heritage coverage.

Exact parity movement

• Flipped: callSignatureAssignabilityInInheritance4
• Flipped: constructSignatureAssignabilityInInheritance4
• Full tsgo exact: 5,050/5,907 -> 5,052/5,907 (+2)
• Failures: 857 -> 855
• First half: 2,706/3,000 -> 2,708/3,000
• Second half: unchanged at 2,344/2,907
• Failure identity audit: those two inheritance fixtures were the only removed identities; no failures were added, and all 563 second-half identities were unchanged.
• During refinement, the full identity audit caught five over-suppressed TS2430 fixtures; the final focused set and audit restored all five before commit.

Verification

• ts_checker: 3,120 passing
• Focused exact inheritance set: 7/7
• Default smoke: 16/16
• Category survey: 86/86
• Baseline-aware survey: 586/586
• Full exact identity audit: 5,907 fixtures

Change size: 1 file, +19/-5, with positive and negative generic heritage coverage.

Parity wave: nested type-parameter assignment details

Pushed 1fb06c633 (fix(ts-checker): nest type parameter assignment details) to main.

What changed

• Ported typescript-go's assignment relation-error chain shape: TS2322 remains the primary assignment diagnostic while TS5075/TS5082 are nested explanatory details.
• Applied the same reporting path to concrete and type-parameter sources.
• Preserved unconstrained source type-parameter related hints.
• Added positive and negative coverage for literal, constrained-object, unrelated-generic, and captured primitive assignments.

Exact parity movement

• Flipped: invalidNumberAssignments
• Flipped: invalidVoidAssignments
• Flipped: invalidBooleanAssignments
• Flipped: invalidStringAssignments
• Flipped: keyofAndIndexedAccess2
• Flipped: derivedClassWithoutExplicitConstructor
• Flipped: classWithoutExplicitConstructor
• Full tsgo exact: 5,052/5,907 -> 5,059/5,907 (+7)
• Failures: 855 -> 848
• First half: 2,708/3,000 -> 2,715/3,000
• Second half: unchanged at 2,344/2,907
• Failure identity audit: exactly those seven identities were removed; no failures were added, and all 563 second-half identities were unchanged.
• typeParameterAssignability2 now matches all TS5075/TS5082 primary-code positions; it remains open only for separate assignability extras.

Verification

• ts_checker: 3,121 passing
• Focused invalid exact sweep: all four primitive assignment fixtures pass
• Default smoke: 16/16
• Category survey: 86/86
• Baseline-aware survey: 586/586
• Full exact identity audit: 5,907 fixtures

Change size: 1 file, +89/-25, including positive and negative diagnostic-chain coverage.

Parity wave: computed TS2564 bracket anchors

Pushed 553b9afff (fix(ts-checker): anchor computed field diagnostics) to main.

What changed

• Routed strict-property-initialization diagnostics for computed class fields through the shared bracket-position lookup.
• Matched typescript-go by anchoring TS2564 at the opening [ for resolved and dynamic computed keys.
• Preserved ordinary field anchors and existing same-position diagnostic ordering.
• Added a focused unique-symbol computed-field position regression.

Exact parity movement

• Flipped: uniqueSymbols
• Flipped: uniqueSymbolsDeclarations
• Flipped: instanceMemberWithComputedPropertyName2
• Flipped: parserComputedPropertyName28
• Flipped: parserComputedPropertyName29
• Flipped: parserComputedPropertyName31
• Flipped: parserComputedPropertyName36
• Flipped: parserSymbolProperty5
• Flipped: parserES5SymbolProperty5
• Flipped: symbolDeclarationEmit1
• Flipped: symbolProperty6
• Flipped: symbolProperty7
• Full tsgo exact: 5,059/5,907 -> 5,071/5,907 (+12)
• Failures: 848 -> 836
• First half: 2,715/3,000 -> 2,724/3,000
• Second half: 2,344/2,907 -> 2,347/2,907
• Failure identity audit: exactly those twelve identities were removed; no failures were added.

Verification

• ts_checker: 3,122 passing
• Focused uniqueSymbols family: 6/7 exact; only the unrelated uniqueSymbolsPropertyNames duplicate-property fixture remains
• Default smoke: 16/16
• Category survey: 86/86
• Baseline-aware survey: 586/586
• Full exact identity audit: 5,907 fixtures

Change size: 1 file, +28/-3, with an explicit opening-bracket position regression.

Parity wave: stable unique-symbol object keys

Pushed e49bd1e63 (fix(ts-checker): detect stable symbol key duplicates) to main.

What changed

• Preserved late-bound unique-symbol identity for object-literal keys reached through interface-typed member access.
• Reused the existing canonical computed-symbol identity for calls returning typeof a unique-symbol binding.
• Reported TS1117 only for repeated data properties with the same proven stable key.
• Kept broad symbol variables and calls returning plain symbol dynamic and duplicate-free.

Exact parity movement

• Flipped: uniqueSymbolsPropertyNames
• Focused uniqueSymbols family: 6/7 -> 7/7 exact
• Full tsgo exact: 5,071/5,907 -> 5,072/5,907 (+1)
• Failures: 836 -> 835
• First half: 2,724/3,000 -> 2,725/3,000
• Second half: unchanged at 2,347/2,907
• Failure identity audit: uniqueSymbolsPropertyNames was the only removed identity; no failures were added.

Verification

• ts_checker: 3,123 passing
• Focused uniqueSymbols family: 7/7 exact
• Default smoke: 16/16
• Category survey: 86/86
• Baseline-aware survey: 586/586
• Full exact identity audit: 5,907 fixtures

Change size: 1 file, +54/-1, with HIR-backed member identity and broad-symbol negative coverage.

Parity batch: computed object index signatures

Pushed 7ed99c02e (fix(ts-checker): relate computed object indexers) to main.

This ports tsgo's structural treatment of fresh object-literal indexers into the checker-owned object-literal assignment path. Source string, number, and symbol indexers are now compared directly with target index signatures before named-member checks. The scope deliberately stays out of the general relation engine, preserving specialized array and class behavior.

Exact fixture movement

• Flipped 6 fixtures: computedPropertyNamesContextualType8_ES5, computedPropertyNamesContextualType8_ES6, computedPropertyNamesContextualType9_ES5, computedPropertyNamesContextualType9_ES6, computedPropertyNamesContextualType10_ES5, and computedPropertyNamesContextualType10_ES6.
• First-half failure identity set remained unchanged.
• Second-half failure identity set removed exactly those six fixtures with no additions.
• Exact parity: 5,072/5,907 -> 5,078/5,907.
• Remaining exact mismatches: 829.

Verification

• ts_checker: 3,124/3,124
• focused exact contextual computed-property family: 20/20
• smoke: 16/16
• category: 86/86
• baseline-aware: 586/586
• full exact split audit: 2,725/3,000 + 2,353/2,907 = 5,078/5,907

Change size: +39/-0 in packages/ts_checker/src/check.zig.

Parity batch: computed class-key TDZ

Pushed 5e829ad48 (fix(ts-checker): report computed class key tdz) to main.

Direct computed class member keys now treat the class's own binding as uninitialized, matching tsgo's TS2449 behavior. The reference walk visits bracketed getter, setter, and method names but still stops before deferred function bodies. Ordinary class self-references in decorators and static initializers remain legal, and nested object keys cannot be mistaken for direct class members.

Exact fixture movement

• Flipped computedPropertyNamesWithStaticProperty.
• Restored all 6 expected TS2449 diagnostics across the named class declaration and named class expression.
• First-half failure identity set remained unchanged.
• Second-half failure identity set removed exactly this fixture with no additions.
• Exact parity: 5,078/5,907 -> 5,079/5,907.
• Remaining exact mismatches: 828.

Verification

• ts_checker: 3,125/3,125
• focused exact fixture: 1/1
• smoke: 16/16
• category: 86/86
• baseline-aware: 586/586
• full exact split audit: 2,725/3,000 + 2,354/2,907 = 5,079/5,907

Change size: +74/-2 in packages/ts_checker/src/check.zig.

Parity batch: inferred computed class indexers

Pushed 38702f9e4 (fix(ts-checker): infer computed class indexers) to main.

Simple broad computed class field keys now establish instance or static index signatures as the class body is checked. Later dynamic fields are compared against those accumulated constraints, while invalid complex computed keys consume existing constraints without redefining the class shape. Numeric-key conflicts report number-index compatibility before string-index compatibility, matching tsgo ordering. TS2564 also renders computed field names from source text, preserving brackets around numeric keys such as [0].

Exact fixture movement

• Flipped computedPropertyNames12_ES5 and computedPropertyNames12_ES6.
• Restored both expected TS2411 diagnostics on [+s] in number-then-string order.
• Restored Property '[0]' TS2564 rendering.
• First-half failure identity set remained unchanged.
• Second-half failure identity set removed exactly these two fixtures with no additions.
• Exact parity: 5,079/5,907 -> 5,081/5,907.
• Remaining exact mismatches: 826.

Verification

• ts_checker: 3,126/3,126
• focused exact family: 2/2
• smoke: 16/16
• category: 86/86
• baseline-aware: 586/586
• full exact split audit: 2,725/3,000 + 2,356/2,907 = 5,081/5,907

Change size: +77/-15 in packages/ts_checker/src/check.zig.

Parity checkpoint: callable assertion contextual typing

Pushed 58ec543d7 (fix(ts-checker): contextualize asserted callables) directly to main.

This ports TypeScript's target-first contextual typing behavior for arrow/function operands of type assertions:

• lowers the asserted callable target before checking the operand;
• supplies target parameter types to unannotated source parameters;
• preserves the operand body's inferred return type and source parameter names in the source signature;
• routes incompatible source/target return signatures through TS2352 overlap instead of emitting TS7006 or TS2322;
• narrows the global Function overlap exemption to the exact builtin object;
• anchors parenthesized function-like assertion diagnostics at the opening parenthesis, matching the upstream baseline without changing primitive assertion anchors.

Parity movement:

• asOperatorContextualType: failing -> passing
• exact full corpus: 5,081 -> 5,082 / 5,907 (+1)
• failures: 826 -> 825
• regression identity audit: zero regressions; the only removed failure identity was asOperatorContextualType
• change size: +75/-4 in packages/ts_checker/src/check.zig

Verification:

• ts_checker: 3,127/3,127
• smoke: 16/16
• category: 86/86
• baseline-aware: 586/586
• exact split audit: 2,725/3,000 and 2,357/2,907

The canonical conformance source remains the pinned microsoft/typescript-go (tsgo) main submodule.

Parity checkpoint: nested namespace assignment and value merging

Pushed 4389ddeea (fix(ts-checker): merge nested namespace values) directly to main.

This closes the four missing diagnostics in assignmentToParenthesizedIdentifiers by porting the relevant nested namespace value behavior:

• resolves bare nested namespace assignment targets through the enclosing namespace scope, producing TS2631 for M3 = ...;
• preserves exported nested namespaces as precise value objects instead of collapsing them to any;
• carries { x: number } through M2.M3, (M2).M3, and (M2.M3) assignment targets, producing the three upstream TS2322 diagnostics;
• merges nested namespace value contributions across virtual files by intersecting each matching object shape, so declarations such as A.Utils.mirror and A.Utils.Plane remain jointly visible.

The first full audit caught two temporary regressions in cross-file namespace-merging fixtures because the initial precise implementation returned only the first A.Utils contribution. The final implementation adds a focused virtual-file regression and restores both identities before landing.

Parity movement:

• assignmentToParenthesizedIdentifiers: failing -> passing
• exact full corpus: 5,082 -> 5,083 / 5,907 (+1)
• failures: 825 -> 824
• final identity audit: zero regressions; the only removed failure identity was assignmentToParenthesizedIdentifiers
• change size: +99/-1 in packages/ts_checker/src/check.zig

Verification:

• ts_checker: 3,129/3,129
• focused target: 1/1 exact
• focused TwoInternalModules* cluster: both audit regressions restored; pre-change failure identities preserved
• smoke: 16/16
• category: 86/86
• baseline-aware: 586/586
• exact split audit: 2,725/3,000 and 2,358/2,907

The canonical conformance source remains the pinned microsoft/typescript-go (tsgo) main submodule.

Parity update: paired accessor contextual returns

Pushed 3fb6f3167 (fix(ts-checker): contextualize getter returns).

What changed

• Read paired setter parameter types from the class accessor pre-scan.
• Use that type as the contextual return contract for an unannotated getter.
• Carry an explicit paired-setter context flag through getter body checking so incompatible primitive returns produce TypeScript's TS2322 diagnostic.
• Preserve nested function state, explicitly annotated getters, untyped setter pairs, and compatible getter returns.

Exact parity movement

• getSetAccessorContextualTyping: failing -> passing
• Passing fixtures: 5,083 -> 5,084 / 5,907 (+1)
• Remaining failures: 824 -> 823
• Regressions: 0
• Source delta: 1 checker file, +51/-1

Verification

• ts_checker: 3,130/3,130
• Focused exact fixture: 1/1
• Smoke: 16/16
• Category: 86/86
• Baseline-aware: 586/586
• Full 5,907-fixture identity audit: 2,725/3,000 + 2,359/2,907 = 5,084/5,907

The canonical conformance source remains the microsoft/typescript-go (tsgo) main submodule.

Parity update: contextual fixed tuple spreads

Pushed 5efce8bfa (fix(ts-checker): expand fixed tuple spreads).

What changed

• Reconstruct contextual array literal diagnostics by expanding a genuine fixed tuple spread into its known positional element types.
• Compute tuple width diagnostics from the expanded arity rather than the array literal's raw syntax element count.
• Require a recorded tuple origin before flattening, so custom array-like objects with literal length members are not mistaken for tuples.
• Preserve the existing widened T[] diagnostic path for open-ended array spreads.
• Added a two-path checker regression covering both fixed tuple expansion and unchanged open-array widening.

Exact parity movement

• arrayLiteralExpressionContextualTyping: failing -> passing
• Passing fixtures: 5,084 -> 5,085 / 5,907 (+1)
• Remaining failures: 823 -> 822
• Regressions: 0
• Source delta: 1 checker file, +66/-13

Verification

• ts_checker: 3,131/3,131
• Focused exact fixture: 1/1
• Smoke: 16/16
• Category: 86/86
• Baseline-aware: 586/586
• Full 5,907-fixture identity audit: 2,725/3,000 + 2,360/2,907 = 5,085/5,907
• Failure-name comparison: the sole removal was arrayLiteralExpressionContextualTyping

The canonical conformance source remains the microsoft/typescript-go (tsgo) main submodule.

Parity update: binding-pattern tuple origins

Pushed 3657b14f0 (fix(ts-checker): preserve binding tuple origins).

What changed

• Register synthesized array binding-pattern parameter types as tuple origins at construction time.
• Nested structural diagnostics now render those types with tuple syntax such as [any, any] instead of leaking { length: 2; 0: any; 1: any; }.
• Added an exact nested TS2345 regression for an inferred destructured parameter with a tuple-valued property.

Exact parity movement

• argumentExpressionContextualTyping: failing -> passing
• destructuringParameterDeclaration3ES6: failing -> passing
• destructuringParameterDeclaration3ES5iterable: failing -> passing
• destructuringParameterDeclaration3ES5: failing -> passing
• Passing fixtures: 5,085 -> 5,089 / 5,907 (+4)
• Remaining failures: 822 -> 818
• Regressions: 0
• Source delta: 1 checker file, +20/-1

Verification

• ts_checker: 3,132/3,132
• Focused exact fixture: 1/1
• Smoke: 16/16
• Category: 86/86
• Baseline-aware: 586/586
• Full 5,907-fixture identity audit: 2,725/3,000 + 2,364/2,907 = 5,089/5,907
• Failure-name comparison: exactly the four fixtures above were removed; no names were added

The canonical conformance source remains the microsoft/typescript-go (tsgo) main submodule.

Parity update: shorthand excess-property precedence

Pushed c8336be89 (fix(ts-checker): prioritize shorthand excess properties).

What changed

• Run fresh-object excess-property checking before the generic missing-property fallback for failed variable initializers.
• Suppress the competing TS2741 only when the direct excess property uses shorthand syntax.
• Preserve missing outer-property diagnostics when an excess property is nested or explicitly declared.
• Added a shorthand data-property regression while retaining the existing callable-excess and generic namespace regressions.

Exact parity movement

• objectLiteralShorthandPropertiesAssignmentError: failing -> passing
• objectLiteralShorthandPropertiesAssignmentErrorFromMissingIdentifier: failing -> passing
• Passing fixtures: 5,089 -> 5,091 / 5,907 (+2)
• Remaining failures: 818 -> 816
• Regressions: 0
• Source delta: 1 checker file, +30/-1

Verification

• ts_checker: 3,133/3,133
• Focused exact fixtures: 2/2
• Smoke: 16/16
• Category: 86/86
• Baseline-aware: 586/586
• Full 5,907-fixture identity audit: 2,725/3,000 + 2,366/2,907 = 5,091/5,907
• Failure-name comparison: exactly the two fixtures above were removed; no names were added

The canonical conformance source remains the microsoft/typescript-go (tsgo) main submodule.

Parity checkpoint: computed enum accessor keys

Pushed 67e41823d (fix(ts-checker): canonicalize enum accessor keys) to main.

This ports tsgo's canonical computed-property behavior into paired accessor contextual typing:

• paired getter lookup now uses the same canonical class member-name resolver as the accessor pre-scan;
• recorded numeric enum values are converted to their runtime string property keys;
• recorded string enum values are used directly as runtime property keys;
• computed enum setter/getter pairs therefore share the setter's contextual return type during getter checking.

Exact parity movement

• Flipped constEnumPropertyAccess1 from failing to passing.
• Advanced from 5,091/5,907 to 5,092/5,907 exact fixtures.
• Reduced failures from 816 to 815 (+1, zero regressions).
• Lower shard remained identity-stable at 2,725/3,000 with the same 275 failures.
• Upper shard advanced to 2,367/2,907; its only removed failure identity was constEnumPropertyAccess1.

Verification

• ts_checker: 3,133/3,133
• focused exact fixture: 1/1
• smoke gate: 16/16
• category gate: 86/86
• baseline-aware gate: 586/586
• full exact identity audit: 5,092/5,907

Source delta: 1 file, +14/-3. Commit author and committer are Chris <chrisbreuer93@gmail.com> with no coauthor trailers.

Parity checkpoint: type-only namespace value access

Pushed 2c49b6fa4 (fix(ts-checker): exclude type-only namespace values) to main.

This ports tsgo's type-space/value-space distinction for namespace imports:

• named-export discovery remains broad enough to validate imports of type-only exports;
• namespace value property access now rejects definitive type_only_decl and type_only_alias statuses;
• runtime values and ambient const enums remain accessible;
• missing/unknown resolutions retain the existing fallback scan.

This covers direct export type { A } and transitive export type * paths without changing ordinary namespace runtime exports.

Exact parity movement

• Flipped namespaceMemberAccess from failing to passing.
• Also flipped exportNamespace11 and exportNamespace12, which exercise the same rule through export type * re-exports.
• Advanced from 5,092/5,907 to 5,095/5,907 exact fixtures.
• Reduced failures from 815 to 812 (+3, zero regressions).
• Lower shard remained identity-stable at 2,725/3,000 with the same 275 failures.
• Upper shard advanced from 2,367/2,907 to 2,370/2,907; the only removed identities were the three fixtures above.

Verification

• ts_checker: 3,134/3,134
• focused exact fixture: 1/1
• smoke gate: 16/16
• category gate: 86/86
• baseline-aware gate: 586/586
• full exact identity audit: 5,095/5,907

Source delta: 1 file, +21/-1. Commit author and committer are Chris <chrisbreuer93@gmail.com> with no coauthor trailers.

Parity checkpoint: object-literal switch cases

Pushed 8511cf7b2 (fix(ts-checker): contextualize object switch cases) to main.

This ports the observable result of tsgo's reverse switch comparability elaboration:

• fresh object-literal case expressions are checked for excess properties against the switch discriminant type;
• ordinary case overlap checking and discriminant narrowing remain unchanged;
• permissive targets such as empty object shapes still follow the existing excess-property exemptions.

The upstream switchStatements fixture now reports TS2353 on the name property of case { id: 12, name: '' } against class C, with the exact tsgo anchor and message.

Exact parity movement

• Flipped switchStatements from failing to passing.
• Advanced from 5,095/5,907 to 5,096/5,907 exact fixtures.
• Reduced failures from 812 to 811 (+1, zero regressions).
• Lower shard remained identity-stable at 2,725/3,000 with the same 275 failures.
• Upper shard advanced from 2,370/2,907 to 2,371/2,907; its only removed identity was switchStatements.

Verification

• ts_checker: 3,135/3,135
• focused exact fixture: 1/1
• smoke gate: 16/16
• category gate: 86/86
• baseline-aware gate: 586/586
• full exact identity audit: 5,096/5,907

Source delta: 1 file, +19/-0. Commit author and committer are Chris <chrisbreuer93@gmail.com> with no coauthor trailers.

Parity checkpoint: noImplicitAny indexed-access variants

Pushed e60ef187d (fix(ts-parity): align indexed access option variants) to main.

This closes both sides of tsgo's noImplicitAny option matrix for literal element access:

• the conformance loader now applies the noimplicitany=true|false value encoded by the selected variant baseline, matching its existing isolated/verbatim baseline overrides;
• false mode permits a missing quoted element access and infers any;
• true mode emits TS7053 with a nested TS2339 missing-property explanation instead of emitting TS2339 as the top-level diagnostic;
• union-index TS7053 property chains retain their existing behavior.

Exact parity movement

• Flipped propertyAccessStringIndexSignature from failing to passing.
• Also flipped lateBoundAssignmentDeclarationSupport4 and lateBoundAssignmentDeclarationSupport5, which expected the same true-mode TS7053 shape.
• Advanced from 5,096/5,907 to 5,099/5,907 exact fixtures.
• Reduced failures from 811 to 808 (+3, zero regressions).
• Lower shard advanced from 2,725/3,000 to 2,727/3,000 by removing the two late-bound fixtures.
• Upper shard advanced from 2,371/2,907 to 2,372/2,907 by removing propertyAccessStringIndexSignature.

Verification

• ts_checker: 3,136/3,136
• focused exact fixture: 1/1
• smoke gate: 16/16
• category gate: 86/86
• baseline-aware gate: 586/586
• full exact identity audit: 5,099/5,907

Source delta: 2 files, +48/-4. Commit author and committer are Chris <chrisbreuer93@gmail.com> with no coauthor trailers.

Parity checkpoint: consumed generic yield contexts

Pushed ecbca98b8 (fix(ts-checker): diagnose generic yield contexts) to main.

This ports tsgo's TS7057 decision for consumed yield results in unannotated generators:

• a yield passed to an any, unresolved, or unfixed type-parameter call argument has no concrete contextual next type and reports TS7057;
• a concrete overload parameter supplies context and suppresses TS7057;
• existing nested-yield and implicit-any identifier paths are deduplicated against the new call-context path;
• the rule remains gated by noImplicitAny and by the existing unannotated-generator pass.

The generatorReturnTypeInference fixture now reports the exact TS7057 at f2(yield 1) while leaving f1(yield 1) clean.

Exact parity movement

• Flipped generatorReturnTypeInference from failing to passing.
• Advanced from 5,099/5,907 to 5,100/5,907 exact fixtures.
• Reduced failures from 808 to 807 (+1, zero regressions).
• Lower shard remained identity-stable at 2,727/3,000 with 273 failures.
• Upper shard advanced from 2,372/2,907 to 2,373/2,907; its only removed identity was generatorReturnTypeInference.

Verification

• ts_checker: 3,137/3,137
• focused exact fixture: 1/1
• smoke gate: 16/16
• category gate: 86/86
• baseline-aware gate: 586/586
• full exact identity audit: 5,100/5,907

Source delta: 1 file, +49/-0. Commit author and committer are Chris <chrisbreuer93@gmail.com> with no coauthor trailers.

TypeScript parity progress: optional-chain false-branch narrowing

Pushed 805b32d83 (fix(ts-checker): preserve optional chain false branches).

What changed

• Negative optional-chain discriminant comparisons now narrow receiver unions per variant instead of dropping every non-object constituent.
• Nullish receivers survive when optional short-circuit undefined makes the comparison fail.
• Optional members remain possible when absence can make the comparison fail.
• Object variants are removed only when their discriminant definitely matches the compared literal.
• Loose == null / != null comparisons account for JavaScript's undefined == null behavior.
• Added paired || / && checker coverage so options?.a === false || options.b reports TS18048 while the true branch used by && still establishes a defined receiver.

Parity movement

• Flipped controlFlowOptionalChain3 from failing to passing: +1 fixture
• Exact tsgo parity: 5,100/5,907 -> 5,101/5,907
• Remaining failures: 807 -> 806
• Full failure-set comparison: only controlFlowOptionalChain3 was removed; zero additions/regressions
• Source delta: 1 checker file, +92/-3

Verification

• ts_checker: 3,138/3,138
• Focused controlFlowOptionalChain2: 1/1
• Focused controlFlowOptionalChain3: 1/1
• Smoke gate: 16/16
• Category gate: 86/86
• Baseline-aware gate: 586/586
• Full exact audit: 2,727/3,000 + 2,374/2,907 = 5,101/5,907

The worktree is otherwise clean apart from the pre-existing untracked .claude/ directory, which remains untouched.

TS parity update: inline JSDoc cast semantics

Pushed b5fafe9fdfadc3338849a963e7dda6828fbe38c7 (fix(ts-checker): apply inline JSDoc cast types) directly to main.

What changed

• Recovered checked-JavaScript /** @type {...} */ (expr) casts from source wrappers after parser lowering removes comments and parentheses.
• Applied nested casts inner-to-outer so the outer annotation wins, matching TypeScript.
• Routed module-only JSDoc import types through existing export = target resolution before CommonJS object synthesis.
• Kept type/value spaces distinct: import("./mod") resolves the exported instance type; typeof import("./mod") resolves the expression/static value type.
• Added two focused checker regressions covering nested inline casts and export = import-type casts.

Scope

• 1 file changed
• 96 lines touched (+93/-3)
• 2 checker regression tests added

Exact parity movement

• Before: 5,101/5,907, 806 failures
• After: 5,102/5,907, 805 failures
• Flipped exact: assertionTypePredicates2
• Full failure-identity diff: exactly that fixture removed, zero regressions added

Verification

• ts_checker: pass
• Focused exact assertionTypePredicates2: 1/1
• Smoke: 16/16
• Category: 86/86
• Baseline-aware: 586/586
• ts_conformance: 1,374/1,374
• Exact lower split: 2,727/3,000
• Exact upper split: 2,375/2,907
• Full inherited TypeScript exact audit: 5,102/5,907

TS parity update: positive guard definite-assignment flow

Pushed a98e02d8662ce29f52f3e60ef0b77da945993952 (fix(ts-checker): honor guard proofs in assignment flow) directly to main.

What changed

• Branch-local TS2454 state now honors positive facts from declared type-predicate calls.
• typeof equality/inequality guards clear pending state only in the branch where the tested runtime tag is proven.
• Unary ! carries the branch polarity through to the guarded predicate.
• Arbitrary boolean-returning calls are not treated as predicates; resolution uses existing fn_predicates metadata.
• The guard-site TS2454, negative-branch TS2454, and outer post-if pending state are preserved.
• Added a focused checker regression covering predicate and typeof positive branches.

Scope

• 1 file changed
• 67 lines added
• 1 checker regression test added

Exact parity movement

• Before: 5,102/5,907, 805 failures
• After: 5,108/5,907, 799 failures
• Flipped exact:
  • typeGuardEnums
  • typeGuardNarrowsPrimitiveIntersection
  • typeGuardNarrowsToLiteralType
  • typeGuardNarrowsToLiteralTypeUnion
  • typeGuardsInExternalModule
  • typeGuardsInGlobal
• Full failure-identity diff: exactly those six fixtures removed, zero regressions added

Verification

• ts_checker: pass
• Focused exact guard cluster: 3/3
• Smoke: 16/16
• Category: 86/86
• Baseline-aware: 586/586
• ts_conformance: 1,374/1,374
• Exact lower split: 2,727/3,000
• Exact upper split: 2,381/2,907
• Full inherited TypeScript exact audit: 5,108/5,907

TS parity update: mismatched JSDoc heritage resolution

Pushed 93d649df06913f2b4101191223c85c5ee8c9a9c0 (fix(ts-checker): resolve mismatched JSDoc heritage types) directly to main.

What changed

• Mismatched attached @extends / @augments targets now pass through the normal JSDoc type resolver.
• An unresolved tag target emits TS2304 before the existing TS8023 heritage mismatch, matching upstream ordering and source position.
• Declared alternate bases still emit only TS8023.
• Matching JSDoc/class heritage names remain on the unchanged path.
• Extended the existing checker mismatch regression to require the unresolved-name diagnostic.

Scope

• 1 file changed
• 4 lines added: 3 implementation lines and 1 regression assertion

Exact parity movement

• Before: 5,108/5,907, 799 failures
• After: 5,109/5,907, 798 failures
• Flipped exact: extendsTagEmit
• Full failure-identity diff: exactly that fixture removed, zero regressions added

Verification

• ts_checker: pass
• Focused exact extendsTagEmit: 1/1
• Smoke: 16/16
• Category: 86/86
• Baseline-aware: 586/586
• ts_conformance: 1,374/1,374
• Exact lower split: 2,727/3,000
• Exact upper split: 2,382/2,907
• Full inherited TypeScript exact audit: 5,109/5,907

TypeScript parity update: direct CommonJS aliases in JSDoc

Pushed b814f38ee335c4cbb29570e940bbee3b0f8a501c (fix(ts-checker): resolve direct require aliases in JSDoc) to main.

This ports tsgo behavior for whole-name JSDoc references backed by direct require() aliases. The checker now:

• preserves a concrete local/late-bound JSDoc type before attempting module synthesis;
• resolves module.exports = NamedClass and anonymous exported class expressions to their instance types;
• falls back through export-assignment and existing CommonJS object synthesis only when needed;
• keeps qualified require(...).member aliases on their established path;
• verifies both member access and strict undefined rejection, so the parity win is not produced through any.

Exact parity movement

• Before: 5,109/5,907 exact, 798 failures
• After: 5,111/5,907 exact, 796 failures
• Flipped: jsdocImportType, jsdocImportType2
• Added failure identities: none
• Lower split: 2,727/3,000, unchanged at 273 failures
• Upper split: 2,384/2,907, improved to 523 failures

The first broad candidate exposed jsDeclarationsTypedefAndLatebound; the final ordering preserves its concrete local LazySet type, and it remains exact. varRequireFromTypescript also remains exact as the qualified-module guard.

Scope

• 1 checker file
• 84 additions, 4 removals
• 1 focused regression test covering named and anonymous CommonJS class exports

Verification

• ts_checker: 3,142/3,142
• focused exact set: 8/8
• smoke: 16/16
• category: 86/86
• baseline-aware: 586/586
• ts_conformance: 1,374/1,374
• exact corpus identity audit: 5,111/5,907, with exactly the two intended removals and zero additions

Next frontier: 796 exact-parity failures remain against the canonical typescript-go/tsgo corpus.

TypeScript parity update: invalid @augments diagnostic anchor

Pushed 25c57be889835e7cfd76aaf68c5d8e77bf0d5657 (fix(ts-checker): anchor invalid augments on declarations) to main.

This ports tsgo diagnostic placement for TS8022 when @augments/@extends is attached to a non-class function. Home previously pointed inside the JSDoc tag; it now anchors on the function declaration name while leaving the separate unattached-comment path unchanged.

Exact parity movement

• Before: 5,111/5,907 exact, 796 failures
• After: 5,112/5,907 exact, 795 failures
• Flipped: jsdocAugments_notAClass
• Added failure identities: none
• Lower split: 2,727/3,000, unchanged at 273 failures
• Upper split: 2,385/2,907, improved to 522 failures

Scope

• 1 checker file
• 2 additions, 2 removals
• Existing unit assertion updated from the tag position to the declaration-name position

Verification

• ts_checker: 3,142/3,142
• focused exact: 1/1
• smoke: 16/16
• category: 86/86
• baseline-aware: 586/586
• ts_conformance: 1,374/1,374
• exact corpus identity audit: 5,112/5,907, exactly one intended removal and zero additions

Next frontier: 795 exact-parity failures remain against the canonical typescript-go/tsgo corpus.

TypeScript parity update: weighted override spelling suggestions

Pushed 55d49646ffafd568ddde635f660ea9db782d1646 (fix(ts-checker): weight override spelling substitutions) to main.

This ports tsgo's spelling-suggestion distance for class override members. Home previously used ordinary case-insensitive Levenshtein distance; tsgo charges substitutions as two edits, insertions/deletions as one, and case-only changes as zero.

That distinction matters at short names: baz → bar has weighted distance 2 and exceeds the three-letter suggestion threshold, so JSDoc override diagnostics stay on TS4122. Longer doSomethang → doSomething remains within threshold and continues to use TS4123. The metric is scoped to override-member suggestions.

Exact parity movement

• Before: 5,112/5,907 exact, 795 failures
• After: 5,113/5,907 exact, 794 failures
• Flipped: jsdocOverrideTag1
• Preserved exact: override_js4
• Added failure identities: none
• Lower split: 2,727/3,000, unchanged at 273 failures
• Upper split: 2,386/2,907, improved to 521 failures

Scope

• 1 checker file
• 40 additions, 1 removal
• Documented weighted-distance helper plus one focused short-name regression test

Verification

• ts_checker: 3,143/3,143
• focused exact: 2/2
• smoke: 16/16
• category: 86/86
• baseline-aware: 586/586
• ts_conformance: 1,374/1,374
• exact corpus identity audit: 5,113/5,907, exactly one intended removal and zero additions

Next frontier: 794 exact-parity failures remain against the canonical typescript-go/tsgo corpus.

TS parity: circular type-only alias cycles

Pushed 8bc137c47 (fix(ts-checker): resolve circular type-only aliases) directly to main.

What changed

• Ported tsgo's alias-target cycle behavior for named type-only imports and re-exports.
• Resolves relative virtual-module export aliases across files.
• Collapses local export type { X as Y } aliases through the local import binding, matching tsgo's symbol indirection.
• Emits TS2303 on the alias whose target closes the active resolution chain.
• Deduplicates the diagnostic across all members of the same cycle.
• Keeps runtime/value re-export cycles outside this rule.
• Added focused tests for direct type-only re-export cycles and import-plus-local-re-export cycles.

Exact parity movement

• Overall: 5,113 -> 5,115 / 5,907
• Failures: 794 -> 792
• Lower half: 2,727 / 3,000, unchanged at 273 failures
• Upper half: 2,386 -> 2,388 / 2,907, failures 521 -> 519
• Flipped fixtures: circular1, circular3
• Failure identity audit: no additions or other removals
• Scope: 187 insertions in one checker file, including two regression tests

Verification

• Focused exact fixtures: 2/2
• ts_checker: 3,145/3,145
• ts_conformance: 1,374/1,374
• Smoke: 16/16
• Category: 86/86
• Baseline-aware: 586/586
• Full exact TypeScript corpus: 5,115/5,907

Next I am ranking the remaining 792 failures by the smallest coherent diagnostic families and will continue landing independently verified conventional commits.

TS parity: distinct ArrayBuffer and SharedArrayBuffer shapes

Pushed 13f217d2d (fix(ts-checker): model shared array buffer identity) directly to main.

What changed

• Ported the structural ArrayBuffer and SharedArrayBuffer instance shapes from TypeScript's libs.
• new ArrayBuffer(...) and new SharedArrayBuffer(...) now produce modeled instances instead of the same empty object type.
• Added standard byteLength/slice members and distinct Symbol.toStringTag literal members, which makes the two buffer types structurally non-assignable like tsgo.
• Added modern ArrayBuffer resizable/transferable members and SharedArrayBuffer growable members.
• Preserved valid modern APIs caught by the broad default suite: transfer, detached, resizable, resize, maxByteLength, growable, and grow.
• Added a focused regression test covering valid shared-buffer members, invalid .length, and SharedArrayBuffer-to-ArrayBuffer assignment.

The first default-suite run correctly exposed missing modern ArrayBuffer members in transferableArrayBuffer and resizableArrayBuffer; those shapes were completed before the final audit.

Exact parity movement

• Overall: 5,115 -> 5,117 / 5,907
• Failures: 792 -> 790
• Lower half: 2,727 -> 2,729 / 3,000, failures 273 -> 271
• Upper half: 2,388 / 2,907, unchanged at 519 failures
• Flipped fixtures: assignSharedArrayBufferToArrayBuffer, useSharedArrayBuffer6
• Failure identity audit: no additions or other removals
• Remaining buffer diagnostic deltas in the exact dump: none
• Scope: 67 insertions, 1 deletion in one checker file

Verification

• Focused exact fixtures: 2/2
• ArrayBuffer default regressions: 4/4
• ts_checker: 3,146/3,146
• ts_conformance: 1,374/1,374
• Smoke: 16/16
• Category: 86/86
• Baseline-aware: 586/586
• Full exact TypeScript corpus: 5,117/5,907

Next I am ranking the remaining 790 failures for another small tsgo behavior family.

TS parity: ES5 async arguments restriction

Pushed d9aad604a (fix(ts-checker): reject arguments in es5 async functions) directly to main.

What changed

• Added TS2522 for arguments references in async functions/methods downleveled to ES5.
• Restricts the diagnostic to a nearest enclosing function that is async and non-arrow; async arrows retain the existing TS2496 path.
• Preserves the IArguments type after reporting so downstream call/assignment diagnostics still match.
• Stops at ordinary nested function boundaries, where a fresh local arguments object is valid.
• Added a focused regression test covering both the direct error and nested-function suppression.

Exact parity movement

• Overall: 5,117 -> 5,118 / 5,907
• Failures: 790 -> 789
• Lower half: 2,729 -> 2,730 / 3,000, failures 271 -> 270
• Upper half: 2,388 / 2,907, unchanged at 519 failures
• Flipped fixture: asyncFunctionDeclarationCapturesArguments_es5
• Failure identity audit: no additions or other removals
• Scope: 43 insertions in one checker file

Residual diagnostic improvement

classStaticBlock6 still fails on unrelated parser/static-block diagnostics, but its previously missing TS2522 line now matches exactly. There are no remaining TS2522 plus/minus deltas in the full exact dump.

Verification

• ts_checker: 3,147/3,147
• ts_conformance: 1,374/1,374
• Smoke: 16/16
• Category: 86/86
• Baseline-aware: 586/586
• Focused exact: 1 fixture flipped + 1 residual diagnostic improved
• Full exact TypeScript corpus: 5,118/5,907

Continuing from 789 remaining failures with the next smallest coherent tsgo rule.

TS parity: JSDoc constructor object-method this

Pushed 4d4bc8af3 (fix(ts-checker): close jsdoc constructor method this) directly to main.

What changed

• A checked-JavaScript object-literal method carrying @constructor now keeps the object literal's closed this shape during contextual body checking.
• Missing properties on both reads and writes report TS2339 once that shape is known.
• The initial inference pass remains open, preserving ordinary checkJs expando behavior for untagged object methods.
• Added a bound checked-JavaScript regression test using the upstream CRLF source shape, exact TS2339 prose, and the companion TS7009 assertion.

Exact parity movement

• Overall: 5,118 -> 5,119 / 5,907
• Failures: 789 -> 788
• Lower half: 2,730 / 3,000, unchanged at 270 failures
• Upper half: 2,388 -> 2,389 / 2,907, failures 519 -> 518
• Flipped fixture: constructorTagOnObjectLiteralMethod
• Failure identity audit: no additions or other removals
• Scope: 49 insertions, 2 deletions in one checker file

Verification

• ts_checker: 3,148/3,148
• ts_conformance: 1,374/1,374
• Smoke: 16/16
• Category: 86/86
• Baseline-aware: 586/586
• Focused exact: 1/1
• Full exact TypeScript corpus: 5,119/5,907

Continuing from 788 remaining failures with the next smallest coherent tsgo rule.

Parity checkpoint: checked-JS JSDoc arrow parameter context

Pushed 934b61837 (fix(ts-checker): contextualize jsdoc arrow parameters) to main.

What changed

• Variable-level /** @type {...} */ function signatures now contextually type arrow/function initializer parameters inside their bodies, matching tsgo's checked-JS behavior.
• Nested Closure-style function parameter types such as function((string)): string retain the whole callable type; their return colon is no longer mistaken for a named-parameter separator.
• Added a bound regression covering both number-to-string body assignments and higher-order callback callability.

The first implementation flipped the target but exposed jsdocParseHigherOrderFunction as a new failure. The exact identity audit caught that trade before commit; the nested-function parser was corrected, and both focused upstream fixtures now pass.

Exact movement

• Overall: 5,119 -> 5,120 / 5,907 exact passes
• Failures: 788 -> 787
• Lower shard: 2,730/3,000, 270 failures (unchanged)
• Upper shard: 2,389 -> 2,390/2,907, failures 518 -> 517
• Removed failure identity: jsdocTypeTagParameterType
• Added failure identities: none
• Guarded passing identity: jsdocParseHigherOrderFunction

Scope

• 1 checker file
• 46 insertions, 1 deletion

Verification

• focused exact jsdocTypeTagParameterType: 1/1
• focused exact jsdocParseHigherOrderFunction: 1/1
• ts_checker: 3,149/3,149
• smoke: 16/16
• category: 86/86
• baseline-aware: 586/586
• ts_conformance: 1,374/1,374
• exact corpus: 5,120/5,907, 787 failures

Parity checkpoint: JSDoc @satisfies property context

Pushed 06b65cb17 (fix(ts-checker): contextualize jsdoc satisfies properties) to main.

What changed

• Checked-JS @satisfies object targets now feed matching member signatures into function-valued properties during signature construction.
• Arrow/method parameters receive the real contextual type through the existing union/intersection/mapped/callable member lookup pipeline.
• TS7006 is suppressed only when a concrete JSDoc contextual parameter type was actually selected.
• The bound regression verifies the parameter HIR type is string, not merely that the diagnostic disappeared, and confirms excess-property checking still fires for an invalid sibling object.

The broader 15-fixture satisfies cluster now reports 9/15. checkJsdocSatisfiesTag3 also improved by losing its spurious standalone-method TS7006, but it remains in the failure set for a separate missing expected TS7006; it is not counted as closed.

Exact movement

• Overall: 5,120 -> 5,121 / 5,907 exact passes
• Failures: 787 -> 786
• Lower shard: 2,730/3,000, 270 failures (unchanged)
• Upper shard: 2,390 -> 2,391/2,907, failures 517 -> 516
• Removed failure identity: checkJsdocSatisfiesTag13
• Added failure identities: none

Scope

• 1 checker file
• 40 insertions, 1 deletion

Verification

• focused exact checkJsdocSatisfiesTag13: 1/1
• focused checkJsdocSatisfiesTag* cluster: 9/15
• ts_checker: 3,150/3,150
• smoke: 16/16
• category: 86/86
• baseline-aware: 586/586
• ts_conformance: 1,374/1,374
• exact corpus: 5,121/5,907, 786 failures

Parity checkpoint: inline @satisfies precedence

Pushed 2f68304e1 (fix(ts-checker): prioritize inline jsdoc satisfies context) to main.

What changed

• A nested checked-JS @satisfies object target now takes precedence over an outer variable-level @type when deciding whether function-valued object members have contextual parameter types.
• Members absent from the closer satisfies target no longer inherit context from the outer type.
• The bound regression mirrors checkJsdocSatisfiesTag3 under noImplicitAny and proves the actual HIR split: f retains any and reports TS7006, while g receives the inline string context.

The focused checkJsdocSatisfiesTag* cluster advances from 9/15 to 10/15; the remaining five identities are unchanged.

Exact movement

• Overall: 5,121 -> 5,122 / 5,907 exact passes
• Failures: 786 -> 785
• Lower shard: 2,730/3,000, 270 failures (unchanged)
• Upper shard: 2,391 -> 2,392/2,907, failures 516 -> 515
• Removed failure identity: checkJsdocSatisfiesTag3
• Added failure identities: none

Scope

• 1 checker file
• 40 insertions

Verification

• focused exact checkJsdocSatisfiesTag3: 1/1
• focused checkJsdocSatisfiesTag* cluster: 10/15
• ts_checker: 3,151/3,151
• smoke: 16/16
• category: 86/86
• baseline-aware: 586/586
• ts_conformance: 1,374/1,374
• exact corpus: 5,122/5,907, 785 failures

Parity update: JSDoc @satisfies diagnostic anchors

Pushed bfc747d3f (fix(ts-checker): anchor jsdoc satisfies diagnostics) to main.

This change preserves the absolute source offset of leading JSDoc bodies while resolving both inline and declaration-level @satisfies tags. Fallback TS1360 diagnostics now anchor on the satisfies tag name, matching tsgo, while property-specific diagnostics keep their existing expression/property anchors.

Parity movement

• Full exact corpus: 5,122/5,907 -> 5,123/5,907 passing
• Total failures: 785 -> 784
• Lower shard: 2,730/3,000, unchanged at 270 failures
• Upper shard: 2,392/2,907 -> 2,393/2,907, failures 515 -> 514
• Removed failure identity: checkJsdocSatisfiesTag4
• Added failure identities: none
• Focused checkJsdocSatisfiesTag* cluster: 10/15 -> 11/15

Scope

• 1 checker file
• 61 insertions, 15 deletions
• Added a bound checker regression asserting TS1360 starts at the JSDoc tag name

Verification

• Exact checkJsdocSatisfiesTag4: 1/1
• Focused checkJsdocSatisfiesTag*: 11/15
• ts_checker: 3,152/3,152
• Smoke: 16/16
• Category: 86/86
• Baseline-aware: 586/586
• Default ts_conformance: 1,374/1,374
• Exact full corpus: 5,123/5,907

The remaining focused failures are checkJsdocSatisfiesTag1, checkJsdocSatisfiesTag11, checkJsdocSatisfiesTag12, and checkJsdocSatisfiesTag15; their TS1360 positions are now closer/correct where applicable, but they retain separate type/prose or extra-diagnostic gaps.

Parity update: effective JSDoc @satisfies duplicate ordering

Pushed d439f3da7 (fix(ts-checker): order jsdoc satisfies duplicates) to main.

This ports tsgo's effective-tag ordering for duplicate @satisfies checks: initializer-inline tags are collected before declaration-leading tags, and every effective tag after the first emits TS1223 at the tag name. This covers both repeated tags in one declaration comment and declarations that combine a leading tag with an inline initializer tag.

Parity movement

• Full exact corpus: 5,123/5,907 -> 5,124/5,907 passing
• Total failures: 784 -> 783
• Lower shard: 2,730/3,000, unchanged at 270 failures
• Upper shard: 2,393/2,907 -> 2,394/2,907, failures 514 -> 513
• Removed failure identity: checkJsdocSatisfiesTag11
• Added failure identities: none
• Focused checkJsdocSatisfiesTag* cluster: 11/15 -> 12/15

Scope

• 1 checker file
• 75 insertions, 26 deletions
• Replaced count-only duplicate detection with ordered tag reporting
• Added a bound regression for both TS1223 ordering/position cases

Verification

• Exact checkJsdocSatisfiesTag11: 1/1
• Focused checkJsdocSatisfiesTag*: 12/15
• ts_checker: 3,153/3,153
• Smoke: 16/16
• Category: 86/86
• Baseline-aware: 586/586
• Default ts_conformance: 1,374/1,374
• Exact full corpus: 5,124/5,907

The remaining focused failures are now checkJsdocSatisfiesTag1, checkJsdocSatisfiesTag12, and checkJsdocSatisfiesTag15.

Parity update: contextual JSDoc @satisfies object literals

Pushed 7c3a923de (fix(ts-checker): preserve jsdoc satisfies literals) to main.

This change validates JSDoc @satisfies object literals property by property when their inferred object type has widened scalar members. Literal syntax is checked against each contextual target member, including union/intersection targets, before the widened structural fallback. It also matches tsgo's declaration-tag behavior: property and excess-property diagnostics remain active, but declaration-level missing keys do not synthesize the inline-expression TS1360 fallback.

That declaration-level rule intentionally follows tsgo's checked behavior rather than the divergent nested original-TypeScript TS2741 baseline.

Parity movement

• Full exact corpus: 5,124/5,907 -> 5,126/5,907 passing
• Total failures: 783 -> 781
• Lower shard: 2,730/3,000, unchanged at 270 failures
• Upper shard: 2,394/2,907 -> 2,396/2,907, failures 513 -> 511
• Removed failure identities: checkJsdocSatisfiesTag1, checkJsdocSatisfiesTag12
• Added failure identities: none
• Focused checkJsdocSatisfiesTag* cluster: 12/15 -> 14/15

Scope

• 1 checker file
• 86 insertions
• Added a bound regression for contextual literal members and declaration-level missing-key behavior

Verification

• Both targeted exact fixtures pass
• Focused checkJsdocSatisfiesTag*: 14/15
• ts_checker: 3,154/3,154
• Smoke: 16/16
• Category: 86/86
• Baseline-aware: 586/586
• Default ts_conformance: 1,374/1,374
• Exact full corpus: 5,126/5,907

checkJsdocSatisfiesTag15 is now the only remaining failure in the focused cluster.

TS parity checkpoint: direct JSDoc satisfies function types

Pushed 0e037b874 (fix(ts-checker): resolve jsdoc satisfies function types) to main.

What changed

• Contextually type direct arrow initializers from leading JSDoc @satisfies signatures while preserving tsgo's uncontextualized function-declaration behavior.
• Resolve sibling function signatures on demand for JSDoc typeof references used before the function's ordinary checker pass.
• Reduce JSDoc Parameters<T> utility types to tuple types and enforce JSDoc-derived tuple targets positionally for array initializers.
• Preserve source parameter names, including rest parameter names, when rendering JSDoc function signatures in diagnostics.
• Accept unbraced @type T tags in the shared JSDoc parser, including the form used by typedefTagTypeResolution.

Exact parity movement

• Full corpus: 5,126/5,907 -> 5,128/5,907
• Failures: 781 -> 779
• Lower shard: 2,730/3,000 unchanged; the complete 270-failure identity set is identical
• Upper shard: 2,396/2,907 -> 2,398/2,907; failures 511 -> 509
• JSDoc satisfies cluster: 14/15 -> 15/15

Removed failure identities:

• checkJsdocSatisfiesTag15
• typedefTagTypeResolution

Added failure identities: none.

Validation

• checkJsdocSatisfiesTag15 exact focused run: 1/1
• typedefTagTypeResolution exact focused run: 1/1
• complete checkJsdocSatisfiesTag exact cluster: 15/15
• ts_parser: 769/769
• ts_checker: 3,155/3,155
• default conformance smoke: 16/16
• default conformance category: 86/86
• default conformance baseline-aware: 586/586
• default conformance package total: 1,374/1,374
• exact corpus shards: 2,730/3,000 and 2,398/2,907

Scope: 122 insertions, 7 deletions across 2 files.

Current exact parity: 5,128/5,907 (86.81%), with 779 fixtures remaining.

TS parity checkpoint: JSDoc generic constraint anchors

Pushed 38a9e1c0e (fix(ts-checker): anchor jsdoc generic constraints) to main.

What changed

• Carry raw JSDoc generic type-argument offsets alongside lowered argument types.
• Anchor newly emitted TS2344 constraint diagnostics on the offending JSDoc argument for both nominal generic aliases and generic JSDoc typedefs.
• Preserve existing relation logic and prose; only the source anchor changes from the following declaration to the exact type argument.
• Strengthen the existing checker regression to pin both A<number> and B<number> argument offsets.

Exact parity movement

• Full corpus: 5,128/5,907 -> 5,129/5,907
• Failures: 779 -> 778
• Lower shard: 2,730/3,000 unchanged; complete 270-failure identity set unchanged
• Upper shard: 2,398/2,907 -> 2,399/2,907; failures 509 -> 508
• checkJsdocTypeTag cluster: 4/10 -> 5/10

Removed failure identity:

• checkJsdocTypeTag4

Added failure identities: none.

Validation

• checkJsdocTypeTag4 exact focused run: 1/1
• complete checkJsdocTypeTag exact cluster: 5/10, with one clean identity removal
• ts_checker: 3,155/3,155
• default conformance smoke: 16/16
• default conformance category: 86/86
• default conformance baseline-aware: 586/586
• default conformance package total: 1,374/1,374
• exact corpus shards: 2,730/3,000 and 2,399/2,907

Scope: 39 insertions, 6 deletions in 1 file.

Current exact parity: 5,129/5,907 (86.83%), with 778 fixtures remaining.

TS parity checkpoint: spaced Closure JSDoc function types

Pushed 0d0802015 (fix(ts-checker): parse spaced jsdoc function types) to main.

What changed

• Recognize Closure-style JSDoc function signatures with whitespace after function, such as function (number): string.
• Use the same parser rule for signature lowering, nested function parameters, function-declaration compatibility, return-type positions, and TS7014 missing-return detection.
• Read function-type return annotations from an arrow/function expression's JSDoc-owning variable.
• Suppress a redundant declaration-level TS2322 only for a direct JSDoc-typed variable function initializer whose body already reports the precise return mismatch.
• Strengthen checker coverage for contextual parameter typing, TS7014, and invalid-call TS2345 on spaced Closure syntax.

During verification, an initially broader duplicate-suppression rule regressed contextuallyTypeCommaOperator02 and contextuallyTypeLogicalAnd02. The exact lower-shard audit caught both; the rule was narrowed to direct JSDoc-owned variable initializers, and the full contextuallyType family returned to 18/18 before commit.

Exact parity movement

• Full corpus: 5,129/5,907 -> 5,130/5,907
• Failures: 778 -> 777
• Lower shard: 2,730/3,000 unchanged; complete 270-failure identity set unchanged
• Upper shard: 2,399/2,907 -> 2,400/2,907; failures 508 -> 507
• checkJsdocTypeTag cluster: 5/10 -> 6/10

Removed failure identity:

• checkJsdocTypeTag2

Added failure identities: none.

Validation

• checkJsdocTypeTag2 exact focused run: 1/1
• complete checkJsdocTypeTag exact cluster: 6/10, one clean identity removal
• contextual function regression family: 18/18
• ts_checker: 3,155/3,155
• default conformance smoke: 16/16
• default conformance category: 86/86
• default conformance baseline-aware: 586/586
• default conformance package total: 1,374/1,374
• exact corpus shards: 2,730/3,000 and 2,400/2,907

Scope: 53 insertions, 15 deletions in 1 file.

Current exact parity: 5,130/5,907 (86.84%), with 777 fixtures remaining.

TS parity progress: broad JSDoc callable semantics

Pushed 452441eae (fix(ts-checker): distinguish broad jsdoc callable types) to main.

What changed

• Treats bare JSDoc ? as any, matching tsgo/TypeScript wildcard semantics.
• Keeps @type {Function} and @type {function} broad rather than contextually typing arrow parameters, so their parameters correctly emit TS7006 under noImplicitAny.
• Preserves concrete Closure/TypeScript callable annotations as contextual signatures, including multiline @type blocks.
• Recognizes raw @type fallback markers only at real tag boundaries, avoiding false matches on longer text such as @typescript.
• Preserves raw object versus Object spelling across repeated script var declarations so TS2403 renders and fires exactly.
• Strengthens the existing checker regression around callable arity, wildcard assignment, broad-callable implicit-any, and wrapper/object redeclaration behavior.

Exact movement

• Exact parity: 5,130/5,907 -> 5,131/5,907 (86.85% -> 86.86%)
• Failures: 777 -> 776
• checkJsdocTypeTag cluster: 6/10 -> 7/10
• Removed failure identity: checkJsdocTypeTag1
• Added failure identities: none
• Lower split remains identity-exact at 2,730/3,000 with the same 270 failures.
• Commit scope: 1 file, 82 insertions, 9 deletions.

Verification

• Focused exact (checkJsdocTypeTag1, destructuringParameterDeclaration9): 2/2
• JSDoc type-tag cluster: 7/10; remaining misses are Tag5, Tag6, and object-property Tag2
• ts_checker: 3,155/3,155
• Default conformance: 1,374/1,374
  • smoke: 16/16
  • category: 86/86
  • baseline-aware: 586/586
• Full 5,907-case split identity audit completed against the tsgo-pinned TypeScript corpus.

TypeScript parity progress: JSDoc callable aliases

Pushed ecd66f833 (fix(ts-checker): resolve jsdoc callable aliases).

Logic ported

• Bare @type references to single-signature callable typedefs now publish the typedef return contract onto the function signature.
• Arrow-style JSDoc function types bind a following union as the return type, so (x: T) => A | B no longer becomes a union containing a partial function signature.
• Callable-object aliases are counted structurally. Single signatures provide contextual typing; overloaded callable objects do not incorrectly contextually select the first overload.
• Unsupported overloaded function annotations now emit exact TS8030 while preserving literal implementation return unions for downstream calls.
• Explicit JSDoc return contracts are no longer overwritten by body inference.
• Added a focused checker regression covering both a single callable alias and an overloaded callable object alias.

Parity movement

• Pushed exact parity: 5,131 -> 5,132 / 5,907 (+1, 86.86% -> 86.88%)
• Pushed failures: 776 -> 775
• checkJsdocTypeTag cluster: 7/10 -> 8/10
• Exact identity removed: checkJsdocTypeTag5
• Exact identities added: none
• Local combined tree measured 5,138 / 5,907; that includes six concurrent unstaged JSX closures and is not attributed to this commit.

Validation

• checkJsdocTypeTag5: 1/1 exact
• ts_checker: 3,156/3,156
• default ts_conformance: 1,374/1,374
• exact lower slice: 2,730/3,000, identity unchanged
• exact upper slice: 2,408/2,907, only checkJsdocTypeTag5 removed
• staged scope: 1 file, +125/-14

The remaining failures in this focused cluster are checkJsdocTypeTag6 and checkJsdocTypeTagOnObjectProperty2.

Pushed e93190680 (fix(ts-checker): enforce jsdoc function arity).

This ports the remaining declaration-side JSDoc @type arity behavior needed by tsgo:

• reports TS8030 for non-callable annotations on named functions;
• reports TS8030 when the annotated callable provides fewer parameters than the implementation;
• keeps checked-JS parameters required when a JSDoc type tag is present;
• emits type-aware TS2322 diagnostics for function-valued object properties, including exact source/target signatures.

Parity movement:

• exact TypeScript parity: 5,132 -> 5,134 / 5,907 (+2, 86.88% -> 86.91%);
• exact failures: 775 -> 773;
• checkJsdocTypeTag cluster: 8/10 -> 9/10;
• removed failure identities: checkJsdocTypeTag6, typeTagCircularReferenceOnConstructorFunction;
• added failure identities: none;
• local combined tree: 5,140 / 5,907, including six concurrent unstaged JSX closures that are not part of this commit.

Validation:

• focused checkJsdocTypeTag6: 1/1 exact;
• ts_checker: 3,157/3,157;
• default ts_conformance: 1,374/1,374;
• exact lower slice: 2,730/3,000, identity set unchanged;
• exact upper slice: 2,410/2,907, with only the two named failures removed;
• staged scope: 1 file, +79/-3.

The only remaining fixture in this ten-test cluster is checkJsdocTypeTagOnObjectProperty2.

Pushed 7eaedbabf (fix(ts-checker): contextualize jsdoc object properties).

This completes the ten-fixture checkJsdocTypeTag cluster by porting tsgo's object-property behavior:

• carries a property's JSDoc callable type into method/arrow parameters and parameter defaults;
• validates default initializers against the contextual parameter type;
• keeps precise return-value diagnostics while suppressing redundant whole-function TS2322 reports;
• models a pre-assignment shorthand read of an evolving uninitialized variable as undefined;
• renders primitive assignment mismatches with the same concrete source and non-nullish target constituent as tsgo.

Parity movement:

• exact TypeScript parity: 5,134 -> 5,135 / 5,907 (+1, 86.91% -> 86.93%);
• exact failures: 773 -> 772;
• checkJsdocTypeTag cluster: 9/10 -> 10/10;
• removed failure identity: checkJsdocTypeTagOnObjectProperty2;
• added failure identities: none;
• local combined tree: 5,141 / 5,907 (87.03%), including six concurrent unstaged JSX closures outside this commit.

Validation:

• focused checkJsdocTypeTagOnObjectProperty2: 1/1 exact;
• ts_checker: 3,158/3,158;
• default ts_conformance: 1,374/1,374;
• exact lower slice: 2,730/3,000, identity set unchanged;
• exact upper slice: 2,411/2,907, with only the named failure removed;
• committed scope: 1 file, +130/-22.

The full exact identity audit added no regressions.

Reserved namespace declaration parity

Pushed 0307656ed (fix(ts-parser): recover reserved namespace names) to main.

This ports tsgo declaration-scan and recovery behavior for reserved identifiers in namespace paths:

• contextual identifier names still commit namespace/module declarations;
• a leading reserved name such as debugger recovers declare and namespace as value statements, then emits TS2819 and TS1005 at the upstream locations;
• Home flattened dotted ambient namespaces now preserve the upstream allowance for an inner declare modifier;
• malformed template module names remain on the dedicated TS1443 recovery path.

The first full identity audit caught a two-fixture regression in templateStringInModuleName and templateStringInModuleNameES6: the new invalid-name lookahead had shadowed the existing TS1443 branch. Reordering the recovery checks and adding a focused parser regression restored both before the final audit.

Attributable parity movement

• exact passes: 5,135 -> 5,137 / 5,907 (+2, 86.96%)
• exact failures: 772 -> 770
• removed identities: ambientModuleDeclarationWithReservedIdentifierInDottedPath, ambientModuleDeclarationWithReservedIdentifierInDottedPath2
• added identities: none
• combined local tree: 5,143 / 5,907 (87.07%), including six concurrent JSX closures that were not part of this commit

Commit scope

• packages/ts_parser/src/ts_parser.zig
• 80 insertions, 4 deletions

Verification

• parser: 763 / 763
• checker: 3,158 / 3,158
• default conformance: 1,374 / 1,374
• smoke: 16 / 16
• category: 86 / 86
• baseline-aware: 586 / 586
• focused ambient fixtures: 2 / 2
• focused template recovery fixtures: 2 / 2
• exact lower slice: 2,732 / 3,000
• exact upper slice: 2,411 / 2,907

The exact failure-name comparison removed only the two targeted ambient namespace identities and introduced no new failures.

Abstract modifier line-break parity

Pushed e25c1893d (fix(ts-parser): stop abstract modifiers at line breaks) to main.

This ports tsgo contextual-modifier scanning for abstract class: the class token must follow abstract on the same line. The rule is shared across statement dispatch, class parsing, export/decorator recovery, expression parsing, and labeled-statement detection.

For newline-separated input, Home now preserves abstract as a value expression, emits the expected unresolved-name diagnostic downstream, and parses the following class as non-abstract. This removes the two spurious abstract-instantiation errors that previously appeared for the following classes.

Attributable parity movement

• exact passes: 5,137 -> 5,138 / 5,907 (+1, 86.98%)
• exact failures: 770 -> 769
• removed identity: classAbstractSingleLineDecl
• added identities: none
• combined local tree: 5,144 / 5,907 (87.08%), including six concurrent JSX closures not staged in this commit

Commit scope

• packages/ts_parser/src/ts_parser.zig
• 33 insertions, 6 deletions

Verification

• parser: 764 / 764
• checker: 3,158 / 3,158
• default conformance: 1,374 / 1,374
• smoke: 16 / 16
• category: 86 / 86
• baseline-aware: 586 / 586
• focused fixture: 1 / 1
• classAbstract* family: 25 / 30, with only classAbstractSingleLineDecl removed from the failure set
• exact lower slice: 2,733 / 3,000
• exact upper slice: 2,411 / 2,907

The full 5,907-case failure-name comparison removed exactly the targeted fixture and introduced no regressions.

Malformed abstract declaration recovery parity

Pushed 5f414b24c (fix(ts-parser): recover malformed abstract declarations) to main.

This ports two tsgo parser recovery decisions used by classAbstractManyKeywords:

• a bare top-level default is a source-element list error, so Home now emits TS1005 (export expected) and continues into the following declaration;
• an imported identifier followed by another declaration starter selects import-equals recovery when the next token is neither comma nor from, so Home emits TS1005 (= expected) and leaves the declaration starter untouched.

The second rule is bounded to declaration starters and preserves valid default imports, deferred imports, comma clauses, and from clauses. The HIR regression verifies that default abstract class C still produces an abstract class and import abstract class D preserves a separate non-abstract class declaration.

Attributable parity movement

• exact passes: 5,138 -> 5,139 / 5,907 (+1, 87.00%)
• exact failures: 769 -> 768
• removed identity: classAbstractManyKeywords
• added identities: none
• combined local tree: 5,145 / 5,907 (87.10%), including six concurrent JSX closures not staged in this commit

Commit scope

• packages/ts_parser/src/ts_parser.zig
• 56 insertions, 2 deletions

Verification

• parser: 765 / 765
• checker: 3,158 / 3,158
• default conformance: 1,374 / 1,374
• smoke: 16 / 16
• category: 86 / 86
• baseline-aware: 586 / 586
• focused fixture: 1 / 1
• classAbstract* family: 26 / 30, with only classAbstractManyKeywords removed from the failure set
• exact lower slice: 2,734 / 3,000
• exact upper slice: 2,411 / 2,907

The full exact failure-name comparison removed exactly the targeted fixture and introduced no new failures.

Malformed try-statement recovery parity

Pushed bd6ec65cd (fix(ts-parser): recover stray try clauses) to main.

This ports tsgo malformed try-statement recovery:

• statement dispatch now routes stray catch and finally tokens through the try parser;
• the parser emits TS1005 (try expected), synthesizes an empty missing try block, and then consumes the real clause normally;
• adjacent catch and finally clauses remain attached to the same recovered statement, preventing the first malformed clause from swallowing the rest of the function;
• catch () now emits TS1003 at the closing parenthesis while preserving that token for normal header recovery.

The parser regression mirrors the complete upstream malformed shape and asserts the seven-code sequence: six missing-try/missing-clause diagnostics plus the empty-binding TS1003.

Attributable parity movement

• exact passes: 5,139 -> 5,140 / 5,907 (+1, 87.02%)
• exact failures: 768 -> 767
• removed identity: invalidTryStatements
• added identities: none
• combined local tree: 5,146 / 5,907 (87.12%), including six concurrent JSX closures not staged in this commit

Commit scope

• packages/ts_parser/src/ts_parser.zig
• 46 insertions, 4 deletions

Verification

• parser: 766 / 766
• checker: 3,158 / 3,158
• default conformance: 1,374 / 1,374
• smoke: 16 / 16
• category: 86 / 86
• baseline-aware: 586 / 586
• focused fixture: 1 / 1
• exact lower slice: 2,734 / 3,000
• exact upper slice: 2,412 / 2,907

The full exact failure-name comparison removed exactly invalidTryStatements and introduced no new failures.

Invalid deferred export recovery parity

Pushed c9c6b3e60 (fix(ts-parser): recover invalid deferred exports) to main.

This ports tsgo recovery for the invalid export defer * as ns from form:

• export defer * now emits TS1128 and recovers the tail as ordinary statements instead of creating an expression-shaped export_decl;
• removing that export HIR shape prevents the checker from misclassifying the recovery as an export assignment and emitting TS1203;
• shared * as ns from statement-terminator recovery now emits the missing TS1434 at from only when import recovery has not already emitted the same code at the same position;
• the parser regression asserts TS1128/TS1005/TS1434 and verifies no recovered top-level statement is an export_decl.

Attributable parity movement

• exact passes: 5,140 -> 5,141 / 5,907 (+1, 87.03%)
• exact failures: 767 -> 766
• removed identity: exportDeferInvalid
• added identities: none
• combined local tree: 5,147 / 5,907 (87.13%), including six concurrent JSX closures not staged in this commit

Commit scope

• packages/ts_parser/src/ts_parser.zig
• 32 insertions, 0 deletions

Verification

• parser: 767 / 767
• checker: 3,158 / 3,158
• default conformance: 1,374 / 1,374
• smoke: 16 / 16
• category: 86 / 86
• baseline-aware: 586 / 586
• focused fixture: 1 / 1
• exact lower slice: 2,734 / 3,000
• exact upper slice: 2,413 / 2,907

The full exact failure-name comparison removed exactly exportDeferInvalid and introduced no new failures.

Pushed 3d01042eac15c14c1106ff3cb627543746258ba5 (fix(ts-parser): disambiguate type-only specifiers) to main.

What changed

• Ported the shared tsgo parseImportOrExportSpecifier ambiguity logic for contextual type and as sequences.
• Preserved the correct imported name, public alias, and type-only phase for all four ambiguous forms, including type as, type as as, and type as as name.
• Changed bare named-export locality checks to resolve across value, type, namespace, and alias spaces, matching the tsgo symbol mask even for type-only syntax.
• Removed checker source-text reparsing for exported aliases; the checker now consumes the parser-owned HIR alias directly.
• Added parser ambiguity matrices and a virtual-module checker regression covering TS1362, TS2661 suppression, and aliased export publication.
• Flipped 189 insertions and 65 deletions across ts_parser and ts_checker.

Exact parity movement

Attributable pushed baseline:

• Before: 5,141 / 5,907 exact fixtures passing (87.03%), 766 failures.
• After: 5,142 / 5,907 exact fixtures passing (87.05%), 765 failures.
• Removed failure identity: exportSpecifiers.
• Added failure identities: none.

Combined local tree, including six concurrent JSX closures deliberately excluded from this commit:

• 5,148 / 5,907 exact fixtures passing (87.15%), 759 failures.
• Lower slice: 2,734 / 3,000, 266 failures.
• Upper slice: 2,414 / 2,907, 493 failures.

Verification

• ts_parser: 769 / 769
• ts_checker: 3,159 / 3,159
• Default conformance: 1,374 / 1,374
• Smoke: 16 / 16
• Category: 86 / 86
• Baseline-aware: 586 / 586
• Focused exact exportSpecifiers: 2 / 2
• Full exact identity audit: 5,148 / 5,907 in the combined local tree

Commit author and committer are Chris <chrisbreuer93@gmail.com> with no coauthor trailers.

Pushed 7526fe9302e2ffe3387e96e2ca4cdbf2ae0623ad (fix(ts-checker): validate incomplete index signatures) to main.

What changed

• Retained incomplete index-signature HIR when the key type requires semantic checker resolution instead of dropping the node after a missing result annotation.
• Applied tsgo grammar ordering in the checker: validate the parameter key first, then report TS1021 only when the key is valid and the result annotation is missing.
• Invalid object keys such as RegExp now produce TS1268 without an incorrect replacement TS1021.
• Valid direct and aliased string keys still produce TS1021.
• Preserved parser-owned TS1268/TS1337 behavior for syntactically invalid keys so no duplicate checker diagnostics are introduced.
• Added parser incomplete-HIR coverage plus checker regressions for direct string, string alias, and object key semantics.
• Flipped 44 insertions and 13 deletions across ts_parser and ts_checker.

Exact parity movement

Attributable pushed baseline:

• Before: 5,142 / 5,907 exact fixtures passing (87.05%), 765 failures.
• After: 5,143 / 5,907 exact fixtures passing (87.07%), 764 failures.
• Removed failure identity: parserIndexSignature8.
• Added failure identities: none.

Combined local tree, including six concurrent JSX closures deliberately excluded from this commit:

• 5,149 / 5,907 exact fixtures passing (87.17%), 758 failures.
• Lower slice: 2,735 / 3,000, 265 failures.
• Upper slice: 2,414 / 2,907, 493 failures.

Verification

• ts_parser: 769 / 769
• ts_checker: 3,160 / 3,160
• Default conformance: 1,374 / 1,374
• Smoke: 16 / 16
• Category: 86 / 86
• Baseline-aware: 586 / 586
• Focused exact parserIndexSignature8: 1 / 1
• Full exact identity audit: 5,149 / 5,907 in the combined local tree

Commit author and committer are Chris <chrisbreuer93@gmail.com> with no coauthor trailers.

Pushed 3197770d4 (fix(ts-parser): recover malformed switch clauses) directly to main as Chris, with no coauthors.

This ports tsgo switch-clause list recovery: malformed clause tokens now advance to the next case, default, close brace, or EOF boundary; EOF blocks remain attached as partial HIR; and duplicate same-position class-close TS1005 diagnostics are suppressed. The regression verifies the recovered switch is reachable through source root -> class -> constructor -> body and retains discriminant e.

Delta: 63 insertions / 14 deletions in packages/ts_parser/src/ts_parser.zig.

Exact tsgo parity: 5,152/5,907 -> 5,154/5,907 (87.22% -> 87.25%), reducing failures 755 -> 753. Identity diff removes only:

• parserErrorRecovery_SwitchStatement2
• tsxErrorRecovery1

No exact failures were added.

Verification:

• parser: 770/770
• checker: 3,160/3,160
• conformance: 1,374/1,374
• smoke: 16/16
• category: 86/86
• baseline-aware: 586/586
• full exact: 5,154/5,907