Track TypeScript frontend benchmark leadership

Goal

Maintain a fair, reproducible TypeScript frontend performance suite and improve Home until it leads JavaScript tsc 6 and stable native TypeScript 7 across every accepted workload.

Benchmark rules

• All compilers receive identical valid source graphs and compiler options.
• Every compiler must validate successfully and silently before timing, and reject the same invalid controls with the expected diagnostics.
• All selected workloads must pass admission before any timing or result-directory creation; no failing row is silently omitted.
• Compiler versions and generated workloads are pinned.
• JavaScript TypeScript 6 and native TypeScript 7 are installed in isolated prefixes.
• Measurements rotate compiler order within every round to balance workstation load.
• Workloads represent general compiler behavior, never benchmark-specific shortcuts.
• Results, environment details, caveats, and reproduction commands stay documented.

Landed foundation

• Nineteen deterministic workloads covering startup, files, complex types, module graphs, TSX, inference, control flow, predicates at two scales, null-safe access, destructuring, overloads, classes, structural objects, interface composition, variadic tuples, checked JavaScript, and recursive generic consumers
• Pinned JavaScript tsc 6.0.3 and stable native TypeScript 7.0.2 toolchain
• Interleaved Hyperfine measurement schedule and silent-success validity gate
• Release allocator, reusable source I/O, and bounded large-program parallelism
• Cached source facts, bind-only export analyses, and projected export-name sets
• Indexed lexical declarations, interface merge predecessors, namespaces, annotations, and validated type display names
• Pruned provably irrelevant overload, inference, import, expando, and compatibility work
• Relation-cache working-set retention and single-probe insertion
• Full performance documentation and linked README summary

Current correctness and measured status

Implementation 1cfc33c (#536), audit d95dfaa (#541), and verified README/report 707045c are pushed to main as Chris with no coauthors. TS 6.0.3 and native TS 7.0.2 are verified; TS7/tsgo is one competitor.

The prepared-owner CommonJS display query removes the extra full source compilation and raw-text recovery. Program140/140, conformance1418/1418, CLI69/69 and harness75/75 pass; unchanged checker/driver targets verify from cache. All19 unchanged admission gates and all15 complete audit case sets preserve every previously passing case. Disk-interrupted logs remain alongside complete retries; no partial audit was accepted.

Same-correctness 30-round alternating comparison: import graph32.4±1.7ms to28.4±0.6ms, 12.4% less time and30/30 paired wins. Barrel27.9±5.2ms to27.3±4.2ms, only2.3% lower with17/30 paired wins: inconclusive, not a reliable improvement. All60 rounds/120 successful samples retained.

Full measurement20260828T234350Z validates570 rounds/1710 successful finite samples, with all513 input files byte-for-byte unchanged. Home has lower means on19/19: import graph28.1ms vs TS7 47.0ms (1.67x), barrel25.6ms vs42.7ms (1.67x), large predicates340.5±18.2ms vs362.2±30.4ms (1.06x;29/30 paired wins). Several rows have substantial shared-host variance. Independent confirmation20260828T234818Z retains30 rounds/90 samples: large predicates Home358.6±11.7ms vs TS7 388.5±16.7ms (1.08x;30/30 paired wins). It is separate, not substituted or pooled. Selected compiler/native-payload/runtime/launcher paths and hashes match before and after both measurements; automated harness provenance is tracked by#544.

CommonJS instance typing is NOT admitted for timing: TS6/TS7 pass66/66, Home22/66, with all44 missing wrong-type/missing-member rejections retained under#541. Export-list controls remain80/96 (#540). Other remaining gaps include owners12/20, nominal origins44/52, globals32/56 and bound globals44/56. The broader goal stays open: real projects, additional rejection coverage, other platforms and semantic correctness remain unproven. Next priorities are actual source-owned CommonJS require types#541 and precise external hidden-binding diagnostics#540.

Frozen candidate commonjs-query.hyU20d/release-v1/bin/home-tsc, SHA-256573257a819a178c9387f6d02a7992c08f995185f5dbc94034eb5eadc0ae956c0. Full results, retained history and reproduction.

Historical indexed-export checkpoint

Implementation b7b9dd9 (#537) and parser ownership fix d6878e8 (#538), with verified README/report 24a34f4, are pushed to main. Compiler versions are verified TS 6.0.3 and native TS 7.0.2; TS 7/tsgo is one competitor.

All 19/19 unchanged workload admission gates pass. Full measurement 20260828T231439Z validates 570 rounds / 1,710 successful finite samples; fresh generation matches 513 measured input files. Home has lower means on 19/19 workloads, but large predicates have only a noisy 1.02x lead: 371.6 ± 125.5 ms versus TS 7 377.7 ± 66.4 ms, 25/30 paired wins. Independent 30-round confirmation 20260828T231856Z retains all 90 samples: Home 320.4 ± 2.8 ms versus TS 7 331.4 ± 4.6 ms (1.03x; 29/30 paired wins). Confirmation is separate, not substituted into the full table.

The same-correctness alternating before/after comparison for #537 improves 525.6 ± 12.4 ms to 353.5 ± 10.5 ms, 32.7% less time and 30/30 paired wins. Deterministic source visits drop 65,536 to 256 for 128 independent exports. Bound-owner edge indexing preserves semantic query work; no control or failed observation was removed.

New exported-variable-list audit improves 0/96 to 80/96. All 32 positives, 32 wrong-type controls and 16 barrel hidden-name controls pass; 16 direct-hidden diagnostics remain TS2305 instead of TS2459 (#540). Existing audit scores remain: factory 240/240, recursive 288/288, generic classes 120/120, static 84/84, bound classes 52/52, callable identity 56/56, callable unions 256/256, graph discovery 28/28, export origins 32/32, owners 12/20, nominal origins 44/52, globals 32/56, bound globals 44/56. Both competitors pass every audit.

Verified suites: checker 4286, conformance 1417, Program 137, parser 891, driver 187, CLI 69, emitter 499 and benchmark harness 72 tests all pass. Pickier reports no errors and one pre-existing README fragment warning. Frozen evidence export-index.NVcIdu, SHA-256 615e9fa1f78c2cad17a0b8911b897ede73c00422138d6ecbb2b74801d4564f14.

Next: #536 removes redundant CommonJS export-query compilation; #540 adds external owner-local diagnostic facts. Correctness gaps, expanded rejection coverage, real projects and cross-platform measurements keep the overall goal open. Shared-host synthetic results are not universal benchmark leadership. Full results and reproduction.

Historical exported-factory checkpoint

Implementation de8fe28 (#534), documentation/README f3740df. Executables are verified TS 6.0.3 and native TS 7.0.2; native TS7/tsgo is one competitor.

All 19/19 workload admission gates now pass for all three compilers. Both original graph projects and their unchanged TS2322/TS2339 rejection controls pass; no failing workload was removed. The 240 exported-factory controls improve from Home130/240 to240/240. Recursive288/288, generic classes120/120, static84/84, bound classes52/52, callable identity56/56, callable unions256/256, graph discovery28/28 and export origins32/32 remain passing. Imported owners improve10/20 to12/20; nominal origins44/52, globals32/56 and bound globals44/56 remain incomplete. Both competitors pass all these audit cases.

Full relevant suites: checker4286/4286, conformance1417/1417, Program133/133, driver187/187, CLI69/69, source-owned focus10/10, harness69/69.

Complete measurement 20260828T224220Z: 30 interleaved rounds after3 warmups, all570 round files /1710 samples validate; fresh generation matches all513 measured input files. Shared Apple M3 Pro workstation with unrelated CPU/filesystem activity. Home has lower means on 18/19 workloads, not universal leadership. Import graph33.7ms vs TS7 50.8ms (1.51x); barrel graph25.1ms vs41.1ms (1.63x). Large predicates lose: Home541.3 ±50.7ms vs TS7 380.6 ±44.8ms, 1.42x slower and0/30 paired wins. That losing row is retained in README and full docs.

Next: #537 establishes and fixes the large-predicate scaling cause against a same-correctness controlled baseline; #536 removes redundant CommonJS export-query compilation. Remaining semantic failures, broader rejection coverage, real-project and cross-platform measurements keep the overall goal open. Frozen evidence: graph-types.4EsbvV; binary SHA256 9f5e333beaf9828a9720ce260ae05a872ebcea3bb51bf5785ffa3ccd7b72f1bc. Documentation: docs/docs/TS_PERFORMANCE.md#exported-factory-checkpoint-performance.

Historical checkpoint before exported-factory typing

Checkpoint: implementation 3b7f0ea (#524), recursive throughput workload de72563, report-integrity fix 74d1163, and documentation/README 91d6ca8. Pinned executables are TS 6.0.3 and native TS 7.0.2; TS 7 and tsgo are one competitor.

The original admission set remains 16/18 for Home: both imported graph rejection gates fail and were not timed. The added recursive workload passes its positive and nine appended negative controls, making expanded admission 17/19 (both competitors 19/19). No failure is removed by expanding the denominator.

Lazy source-owned definitions improve recursive controls from 112/288 to 288/288 and imported generic classes from 118/120 to 120/120. Local non-exported classes remain non-exported; transparent aliases preserve their target's origin. No fixed-depth unfolding or new permissive fallback. Inheritance, global/owner typing, broader generic forms and original graph linkage remain open (#521, #480, #487).

Fresh full timing 20260828T221149Z has lower Home means on 17/17 admitted timed workloads, with 510 complete round files and 1,530 successful samples. Apple M3 Pro, 30 interleaved runs after three warmups, shared-workstation load. Recursive generics: Home 29.7 ± 0.2 ms, native TS 7 71.8 ± 1.1 ms, TS 6 151.7 ± 2.2 ms (2.42× lower mean). Large predicates: Home 377.0 ± 100.9 ms, native TS 7 393.6 ± 94.1 ms (1.04× lower mean; noisy). Other rows also have substantial variance.

Independent confirmation 20260828T221611Z retains 60 complete rounds / 180 successful samples. Recursive generics: Home 29.6 ± 0.7 ms vs native 73.1 ± 3.9 ms (2.47×; Home faster in 30/30 paired rounds). Large predicates: Home 349.9 ± 17.0 ms vs native 392.7 ± 83.0 ms (1.12×; 28/30 paired rounds). Confirmation does not replace or get averaged into the full run. The predecessor fails recursive rejection controls and is ineligible for a before/after timing claim.

Exact-source tests: checker 4285/4285, conformance 1417/1417, Program 131/131, driver 187/187, CLI 69/69, focused source-owned 9/9, harness 66/66. Release SHA-256: 267691e33056e2c4a8b23b757bc3eed19c8b3d90fa9407120b8985834a844ccd. Reporting now rejects incomplete/extra rounds, incorrect compiler coverage/order, malformed JSON, and failed/invalid samples instead of publishing partial averages.

Full results, variance, preserved history and reproduction. Correctness details.

Not complete: these are local synthetic observations under shared-host load, not universal, real-project or cross-platform leadership. The two original graph gates and broader semantic coverage still fail or remain unverified. The tracker stays open.

Historical measured snapshot (not current admission)

Apple M3 Pro, 30 interleaved runs after three warmups; raw full-suite result 20260827T202656Z, compiler commit 9e45e10, documentation commit 75e02f3. Every observation is retained, including variance and outliers.

Historical snapshot: 18/18 lower Home means were recorded, with stronger primitive-return checking. This is not current acceptance: the two graph claims were subsequently withdrawn and later compiler changes have not been retimed. Large predicates have a 1.08× mean lead. The predeclared independent 30-round confirmation 20260827T203044Z records Home 342.5 ± 29.3 ms vs native TS 7 370.2 ± 22.0 ms (1.08× lead); TS 6 is 1086.3 ± 96.2 ms. Home is faster than native in 29/30 paired large-case rounds in the full run and 26/30 in the confirmation. The confirmation does not replace or get averaged into the full table. All 1,710 timed samples succeeded; exact versions, balanced ordering, published tables, preserved binary, and frozen predicate hashes were verified.

All 99 program, 4,226 checker, 173 driver, and 16 harness/report tests pass, as do all 18 shared positive projects and 13 negative controls per compiler. Five new return-contract regression groups have been independently checked with the same CLI inputs against both TS baselines (#474). Async is not an accepted workload: #475 and #476 still fail semantic controls, and #478 tracks diagnostic wording. Do not infer full TypeScript parity from these counts.

These are local synthetic results, not proof of universal, real-project, or cross-platform leadership. Several rows have substantial variance; no observations were discarded. The correctness fix is not itself claimed as a performance optimization. Full methods, history, and reproduction.

Next coverage

• Preserve actual global declaration types, merging and lexical isolation across files (#480)

• Preserve generic imported/re-exported types and owner metadata, including source-order/cycle handling; readmit graph timing only after the unchanged controls pass (#487)

• Add shared async/await and Promise type-propagation coverage with negative controls (#473; remaining #475, #476, #478)

• Validate the legacy container path before claiming cross-platform results (#464)

• Resolve independently tracked semantic/source-lifetime gaps (#467, #472)

• Add a fair emit workload when output semantics are validated across all compilers

• Add pinned real-world projects only where all compilers accept the same graph and configuration

• Profile and resolve every regression or loss introduced by accepted workloads

• Keep README and detailed performance documentation synchronized

Commit links and before/after measurements are maintained in the issue comments. The tracker remains open while coverage expands.

Published another evidence-led TypeScript frontend optimization.

• 46c382bb2 (perf(ts): index strict mode directives (#416)) adds both accepted @strict: false spellings to the existing exact source-marker automaton and reuses that index instead of rescanning every source. The uncached fallback remains and has indexed/unindexed equivalence coverage.
• Fresh 16,384-family profile: substring-search leaf samples fell from 62 to 24, and the sourceHasStrictFalseDirective full-source scan disappeared.
• Same-host scaled A/B, all samples retained: 2919.9 ± 146.3 ms before vs 2802.2 ± 73.9 ms after (1.042×, 17/20 paired wins).
• Qualified focused result 20260830T231822Z: Home 328.8 ± 6.8 ms vs native TS 7.0.2 at 370.8 ± 14.2 ms (1.13×).
• Full qualified result 20260830T231959Z: pinned TS 6.0.3 vs the single native TS 7.0.2 (tsgo) vs Home; 30 rounds after 3 warmups; provenance verified; all 600 round files / 1,800 finite samples retained. Home has the lowest mean on 20/20 workloads and 597/600 paired wins. The three paired losses are documented: deep_types 29/30 and checkjs_jsdoc 28/30 amid higher host variance.
• edb783faf refreshes the detailed report and concise README tables without hiding the noisier full run.

Validation: source-marker randomized equivalence tests, focused indexed/fallback directive test, complete ReleaseFast checker suite, Zig formatting, Pickier, and all 95 benchmark-harness tests.

Rejected a follow-up @target marker-index candidate after isolated measurement; it is not in the tree.

The post-change profile attributed a smaller full-source scan to sourceHasTargetEs2016OrLaterDirective, so I tested routing that exact lookup through the existing marker index with indexed/unindexed equivalence coverage. Against the preserved 46c382bb2 binary on the same 16,384-family corpus, all 20 alternating pairs were retained: 2757.5 ± 26.4 ms baseline vs 2749.2 ± 28.5 ms candidate (1.003×, 12/20 paired wins). That is noise, not a defensible improvement.

I removed the candidate and restored the exact published binary (ba83523099e133f1aab69283304f3568c31f947069c29455b849b70eca01b5b6). No commit or benchmark claim was made for it.

Published the HIR-backed recovered-parameter index and its benchmark evidence.

Commits:

• 18bd0c4ee — perf(ts): index recovered parameters from HIR (#416)
• ffccfbb08 — docs(bench): publish HIR parameter results (#416)

The checker now builds recovered annotation candidates from actual HIR parameter nodes, retains the existing source-syntax checks, reuses the interned parameter name, and excludes object-property lookalikes before containment filtering.

Isolated unchanged-input Home A/B on the 16,384-family predicate stress project (3 alternating warmup pairs, 20 alternating-order measured pairs, all 40 samples retained):

• published baseline: 2749.3 ± 27.7 ms
• candidate: 2717.8 ± 33.4 ms
• speedup: 1.0116x; candidate lower in 16/20 pairs
• mean paired reduction: 31.5 ms; 95% paired t CI 11.7–51.4 ms; exact two-sided sign-test p=0.0118
• fresh 1 ms profile: recoveredSourceParameterAnnotationType leaf samples 31 -> 10

Official pinned comparison remains TS 6.0.3 versus native TS 7.0.2 (tsgo):

• focused 20260831T000811Z: tsc 1048.0 ± 23.2 ms, tsgo 365.3 ± 6.8 ms, Home 322.0 ± 5.1 ms; Home 1.13x faster and 30/30 paired wins
• full 20260831T000957Z: Home lower mean on 20/20 workloads and lower time in 599/600 rounds; 600 round files / 1,800 finite samples retained; provenance verified unchanged
• narrowest mean lead: type_predicates_large, 1.12x (325.1 ± 5.1 ms versus tsgo 363.9 ± 5.6 ms)

Validation:

• focused recovery tests pass, including both legacy flow regressions and the new object-property exclusion case
• full ReleaseFast checker suite passes
• benchmark harness 95/95 passes
• targeted Pickier passes for all three changed Markdown files; the mandated whole-tree command aborts at its own 100,000-file safety cap after discovering 188,706 files and makes no tracked changes
• git diff --check passes

The README keeps the concise platform table and links to the detailed report. The eligible Linux ARM64 checkpoint remains 20260829T035150Z at 20/20; this macOS host currently has no native Linux/container runtime, so I have not represented it as a current-code Linux rerun.

Rejected follow-up experiment: per-identifier caching of visibleAnnotatedIdentifierTypeNode hits and misses.

The implementation cached only immutable annotation NodeId results and cleared on setModule / setSource; its focused lifecycle test passed. It was measured against the exact published 18bd0c4ee binary on the unchanged 16,384-family predicate project after three alternating warmup pairs and 20 alternating-order measured pairs. All 40 samples were retained.

• baseline: 2762.0 ± 80.1 ms
• cache candidate: 2798.3 ± 50.0 ms
• baseline/candidate: 0.9870x (candidate is 1.3% slower)
• candidate lower in only 4/20 pairs
• paired regression: 36.3 ms, 95% paired t CI 14.0–58.6 ms; exact two-sided sign-test p=0.0118

Conclusion: the first-query hash-map probe and storage cost outweigh repeated scope/index reuse. This is not a valid performance improvement. The source/test changes were fully removed, the published binary was restored byte-for-byte (faccb14ac520cd8a37d14246635089d36345ddf3c6d40d8630c59fcf5a73849e), and no commit was created.

Rejected follow-up experiment: reuse an existing unqualified zero-argument HIR type_ref StringId when recovered parameter source text matches byte-for-byte, instead of interning the spelling again.

The focused recovery suite passed. The unchanged 16,384-family project was measured against the exact published faccb14... binary after three alternating warmup pairs and 20 alternating-order measured pairs; all 40 samples were retained.

• baseline: 2738.6 ± 68.5 ms
• candidate: 2739.1 ± 45.8 ms
• baseline/candidate: 0.99984x
• candidate lower in 8/20 pairs
• paired difference: -0.4 ms, 95% paired t CI -42.8 to +41.9 ms; exact two-sided sign-test p=0.5034

Conclusion: indistinguishable from noise, with no mean improvement. The source change was fully removed, the published binary was restored byte-for-byte (faccb14ac520cd8a37d14246635089d36345ddf3c6d40d8630c59fcf5a73849e), and no commit was created.

Published the exact instanceof fallthrough negative guard and its benchmark evidence.

Commits:

• 238cc88fc — perf(ts): skip impossible instanceof fallthrough checks (#416)
• 757292ae1 — docs(bench): publish instanceof marker results (#416)

Mechanism: the exact instanceof substring is now part of the existing one-pass source marker automaton. Specialized member-access fallthrough-join analysis returns before flow and visible-annotation work only when attached source bytes cannot contain that spelling. Sources containing it, including conservative comment/string matches, retain the full path.

Isolated unchanged-input Home A/B on the same 16,384-family predicate project (3 alternating warmup pairs, 20 alternating-order measured pairs, all 40 samples retained):

• published HIR-index baseline: 2738.5 ± 31.3 ms
• marker candidate: 2704.2 ± 38.5 ms
• speedup: 1.0127x; candidate lower in 15/20 pairs
• mean paired reduction: 34.3 ms; 95% paired t CI 15.0–53.6 ms; exact two-sided sign-test p=0.0414
• fresh 1 ms profile removes the baseline downstream visible-annotation-lowering stack under identifierHasInstanceofFallthroughJoin

Official pinned comparison is TS 6.0.3 versus native TS 7.0.2 (tsgo):

• focused 20260831T005513Z: tsc 1048.1 ± 15.7 ms, tsgo 365.1 ± 8.1 ms, Home 318.1 ± 4.6 ms; Home 1.15x faster and 30/30 paired wins
• full 20260831T005639Z: Home lower mean on 20/20 workloads and lower time in 598/600 rounds; only one CheckJS and one large-predicate round go to tsgo
• narrowest mean lead: type_predicates_large, 1.14x (323.5 ± 13.4 ms versus tsgo 370.4 ± 6.9 ms)
• 600 round files / 1,800 successful finite samples retained; provenance verified unchanged; candidate SHA-256 842310b6c24e1e788c33d756bbff0e7df0b0bc60c261d4dcb8552f8c09ccb2cd

Validation:

• source-marker equivalence tests pass
• focused instanceof checker regression group passes
• full ReleaseFast checker suite passes
• benchmark harness 95/95 passes
• targeted Pickier and git diff --check pass

README and benchmark README now point to the full detailed snapshot. The eligible Linux ARM64 checkpoint remains 20260829T035150Z at 20/20; no current-code Linux claim was added from this macOS-only host.

Accepted and published the tiny annotated-scope index optimization.

Code/test commit: 96d05423e (perf(ts): avoid indexing tiny annotated scopes (#416)) Docs commit: 3fbfd5ffa (docs(bench): publish tiny-scope results (#416))

General change: one- and two-statement lexical containers now use the existing bounded direct annotated-value scan instead of allocating entries in both persistent index maps. Containers with three or more statements retain the indexed path, including virtual-section semantics and the original direct fallback. A focused regression proves TS2322 behavior and that a two-statement body remains unindexed.

Isolated Home A/B on the unchanged 16,384-family predicate project, 3 alternating warmup pairs + 20 alternating-order measured pairs, all 40 samples retained:

• exact baseline SHA-256 842310b6c24e1e788c33d756bbff0e7df0b0bc60c261d4dcb8552f8c09ccb2cd: 2699.9 ± 54.0 ms
• candidate SHA-256 1b401eb95d51702a1a3467c80aede41dfe4107defb690c34f2420194cc2f4fdf: 2651.6 ± 42.2 ms
• 1.0182× faster, 16/20 paired wins
• paired reduction 48.3 ms, 95% paired t CI 23.5–73.1 ms, exact two-sided sign p=.0118

Verification: focused ReleaseFast regression, complete ReleaseFast checker suite, targeted Pickier, diff validation, and benchmark harness 95/95 all pass.

Official exact-pin results compare JavaScript TypeScript 6.0.3 with the single native TypeScript/tsgo 7.0.2 competitor:

• focused 20260831T012734Z: tsc 1053.2 ± 18.7 ms, tsgo 365.7 ± 7.8 ms, Home 314.6 ± 4.8 ms; 1.16× lead, 30/30 paired wins
• full 20260831T012857Z: Home lowest mean on 20/20 rows and 599/600 individual paired wins; narrowest row type_predicates_large is 315.7 ± 9.5 ms vs tsgo 369.5 ± 8.7 ms, a 1.17× lead

Both official runs retain every sample and verified unchanged compiler provenance before admission and after measurement. The README summary/table and detailed performance document now point to the new full result.

Prepared source-marker reuse is implemented and published.

• Code: 1ae4ecf (perf(ts): reuse prepared source markers)
• Docs: 753beaf (docs(bench): publish prepared marker results)
• The driver now computes the exact marker index once during preparation, uses conservative @ / <reference @filename gates, and passes the same index into checker. config-originated compiler type references remain unconditional. />
• Focused ReleaseFast driver tests and the supplied-marker checker regression pass; Pickier, zig fmt, and diff checks pass. The unchanged 16,384-family corpus has byte-identical output and exit status before/after.

Same-correctness Home A/B (3 alternating warmup pairs, 20 alternating measured pairs, all samples retained):

• baseline 2666.8 ± 35.7 ms
• candidate 2596.0 ± 34.1 ms
• 1.0273x, 20/20 paired wins
• paired reduction 70.8 ms; 95% paired t CI 57.2–84.4 ms; exact two-sided sign p=0.0000019

Official exact-pin results (TS 6.0.3 vs native TS/tsgo 7.0.2):

• focused 20260831T020935Z: 1051.0 ± 22.2 / 367.2 ± 6.5 / Home 305.2 ± 3.7 ms, a 1.20x Home lead, 30/30
• full 20260831T021055Z: Home lowest mean on 20/20 workloads and lower individual time in 600/600 rounds; provenance verified unchanged before/after

README and detailed benchmark docs now point to the new full result and retain the prior checkpoint as history.

Rejected follow-up: bypassing the annotated-index function/hash probe at callers for one/two-statement scopes.

The change was a semantic no-op and the 24 MB / 16,384-family corpus produced byte-identical output and exit status, but the performance result was not decisive. Same frozen published baseline and candidate, three alternating warmup pairs plus 20 alternating measured pairs, all samples retained:

• baseline 2661.3 ± 68.8 ms
• candidate 2644.4 ± 61.3 ms
• mean ratio 1.0064x
• 12/20 paired wins
• paired reduction 16.9 ms, 95% paired t CI -10.0 to 43.9 ms
• exact two-sided sign p=0.5034

Rejected with no commit. Source was reverted and zig-out/bin/home-tsc was restored byte-for-byte to published SHA-256 161e0142518e25a29cc2f60cff18364a2dbcff0719b89a9fec795dba9a195bfa. Raw rounds are retained locally as rejected-tiny-index-probe-ab.sFlTch.

Rejected follow-up: passing precomputed virtual-filename and JSDoc-presence facts into parser initialization.

The 24 MB / 16,384-family corpus produced byte-identical output and exit status, but the balanced A/B did not establish an improvement. Three alternating warmup pairs plus 20 alternating measured pairs, all samples retained:

• baseline 2691.5 ± 103.9 ms
• candidate 2671.8 ± 106.4 ms
• mean ratio 1.0074x
• 11/20 paired wins
• paired reduction 19.7 ms, 95% paired t CI -34.0 to 73.4 ms
• exact two-sided sign p=0.8238

Rejected with no commit. Source was reverted and the published Home binary restored at SHA-256 161e0142518e25a29cc2f60cff18364a2dbcff0719b89a9fec795dba9a195bfa. Raw rounds are retained locally as rejected-parser-source-facts-ab.yOnydh.

Accepted and pushed the exact import-equals presence optimization.

• Code: 3454bba (perf(ts): cache exact import-equals presence)
• Docs: 4a83239 (docs(bench): publish exact import scan results)
• Exact final binary SHA-256: 6182abe599c8ee69a16161f061010ea7fc0232928748a887201321c9048491f3
• Fair unchanged 4,096-family recursive-generic Home A/B: 2063.9±199.4 ms → 1205.9±115.5 ms (1.7115×), 20/20 paired wins; paired reduction 858.0 ms, 95% CI 774.6–941.3 ms, exact sign p=.0000019. Both binaries produced identical exit status/stdout/stderr.
• Exact pinned focused run 20260831T030019Z: TS 6.0.3 175.6±51.9 ms, native TS 7.0.2 81.5±24.3 ms, Home 17.1±2.3 ms (4.76×), 30/30 paired wins.
• Exact pinned full run 20260831T030052Z: Home lowest mean on 20/20 workloads and 598/600 individual rounds. Both retained losses and the control-flow host outlier are documented without filtering.
• Validation: exact-fact regression, existing ReleaseFast import-equals test group, ReleaseFast production build, scoped Pickier, formatting, diff checks, and before/after benchmark provenance verification all pass.

The optimization is semantic: ordinary imports plus unrelated assignments now pay one exact HIR scan instead of repeated statement-list searches; real namespace and require import-equals declarations keep the original resolution path.

Rejected and fully reverted a checked-JS declaration-space candidate; no commit created.

The candidate added an exact declaration-kind gate for empty/non-declaration statement lists and indexed same-name interfaces instead of comparing every class with every statement. A five-second 16,384-family profile reduced checkDeclarationSpaceDiagnosticsImpl from 1,517 top-of-stack samples to 7, but the fair unchanged 2,048-family wall-clock A/B did not clear the acceptance bar: baseline 3550.6±270.2 ms, candidate 3448.4±271.3 ms (1.0296×), only 13/20 paired wins, mean paired reduction 102.2 ms with 95% CI −20.9 to 225.4 ms and exact sign p=.2632. All samples were retained.

The candidate produced identical exit status/stdout/stderr, but profile movement alone is insufficient without decisive end-to-end wall-time evidence. Source is clean and zig-out/bin/home-tsc is restored byte-for-byte to published SHA-256 6182abe599c8ee69a16161f061010ea7fc0232928748a887201321c9048491f3. Raw local rounds are retained in ignored declaration-space-index-ab.2048.

Accepted and pushed the JSDoc global duplicate-name index.

• Code: 800fff7 (perf(ts): index JSDoc global duplicate names)
• Docs: abfacb3 (docs(bench): publish JSDoc name index results)
• Exact final binary SHA-256: b02ecda7944783f0437b8c205177fb66b4b09aa6e9ddaf5d331161114626a633
• Fair unchanged 2,048-family CheckJS/JSDoc Home A/B: 1857.4±94.4 ms → 1793.6±48.8 ms (1.0356×), 17/20 paired wins; paired reduction 63.9 ms, 95% CI 24.1–103.7 ms, exact sign p=.0026. CPU time independently fell 3.25% with the same direction and a positive paired interval.
• Baseline/candidate exit status, stdout, and stderr match on the valid stress corpus; a deliberately invalid multi-file duplicate fixture also emits byte-identical diagnostics in the same order.
• Exact pinned focused run 20260831T040831Z: TS 6.0.3 245.1±92.0 ms, native TS 7.0.2 59.7±3.1 ms, Home 40.7±9.4 ms (1.47×), 29/30 paired wins.
• Exact pinned full run 20260831T040903Z: Home lowest mean on 20/20 workloads and 600/600 individual rounds.
• Validation: focused diagnostic-order regression, broader ReleaseFast JSDoc typedef checker subset, ReleaseFast production build, scoped Pickier, formatting/diff checks, and before/after provenance verification all pass.

The change replaces all-pairs unequal-name rejection with source-ordered same-name chains; every relevant pair and observable diagnostic order is preserved.

Accepted and pushed 12e4f73efa1206bde64959141cfd1c1b787695ee (perf(ts): fast-path ASCII identifier scans (#416)).

The scanner previously called both UTF-8 whitespace probes for every byte of every identifier before testing the ordinary ASCII continuation case. The change takes a cheap ASCII path while preserving escaped identifiers and the existing non-ASCII whitespace/line-terminator path. A regression test now verifies that U+00A0 and U+2028 still terminate identifiers and that U+2028 preserves the newline flag.

Validation:

• ReleaseFast ts_lexer tests passed.
• ReleaseFast home-tsc production build passed.
• zig fmt --check and git diff --check passed.
• On the unchanged official generator scaled to 32,768 type-predicate families, baseline and candidate both exited 0 with byte-identical empty stdout/stderr.
• Exact-final A/B (b02ecda… -> aae87472…), 3 balanced warmup pairs + 20 alternating measured pairs: CPU 7,353.4 ± 112.6 ms -> 7,129.1 ± 108.2 ms (1.0315×), 20/20 paired wins, paired reduction 224.3 ms, 95% CI 178.9–269.7 ms, exact sign p=0.0000010. Wall time had 17/20 wins but two retained early machine-stall outliers widened its t-interval; no samples were discarded.
• An independent pre-test-layout run of the same production logic had wall 5,327.9 ± 338.9 ms -> 5,114.1 ± 261.0 ms (1.0418×), 17/20 wins, paired 95% CI 100.7–326.8 ms; CPU agreed at 1.0391×.
• Exact committed-binary official result 20260831T050122Z (30 interleaved runs after 3 warmups, provenance verified before/after at aae87472…): TS 6.0.3 1,017.3 ± 46.6 ms, native TS 7.0.2 (tsgo) 351.6 ± 8.1 ms, Home 288.4 ± 5.7 ms; Home is 1.22× faster.

I’ll publish the new full-suite snapshot and README/doc table in a separate small docs commit after the full 20-workload run.

Published and pushed the benchmark record in 25437ff35d0b96a5a9e0fc942ef81bb29b506bb3 (docs(bench): publish ASCII scanner results (#416)).

Fresh exact-binary full-suite result: 20260831T050307Z.

• TS 6.0.3 vs the single native TS 7.0.2 (tsgo) vs Home.
• 20/20 workloads have the lowest Home mean.
• 600/600 individual rounds are Home wins.
• 600 round files / 1,800 successful finite samples retained.
• Home SHA-256 remained aae87472b82685d59b37aa53218173120f8e6df190a473ca04477cf3b46637d6 before admission and after measurement.
• Narrowest row: type_predicates_large, 1,018.1 ± 18.0 ms / 360.7 ± 18.3 ms / 290.0 ± 3.8 ms (Home 1.24× faster than native TS 7.0.2).
• Strongest mean lead: startup, Home 12.27× faster.

The detailed docs now include the complete 20-row table, exact A/B hashes and schedules, the retained wall outliers, the inconclusive shorter confirmation, test gates, and raw result IDs. The root README contains the concise platform summary and links to the detailed report; the harness README points at the new qualified checkpoint.

Statistical precision: the earlier acceptance comment's p=0.0000010 value was the one-sided 20/20 sign tail. The durable docs use the exact two-sided sign-test value, p=0.0000019.

Docs: https://github.com/home-lang/home/blob/main/docs/docs/TS_PERFORMANCE.md#ascii-identifier-scanner-checkpoint README snapshot: https://github.com/home-lang/home#typescript-frontend-benchmark-snapshot

Accepted and pushed 43e1f1ea8156299740b16376b162204713d0f5e8 (perf(ts): gate builtin object name lowering (#416)).

Profiling after the ASCII scanner change showed lowerBuiltinObjectTypeRaw and its failed string comparisons as the next general hotspot. User-defined names previously traversed the complete builtin recipe chain before returning null. The new exact static gate contains all and only the 44 names recognized by the existing specialized and fallback implementations; real builtin names still execute the original recipes unchanged. A focused regression resolves all 44 recipes and rejects prefixed/suffixed lookalikes.

Validation:

• Mechanical implementation audit: gate 44/44, no missing or extra names.
• Focused completeness regression passed.
• Broader ReleaseFast checker builtin subset passed.
• ReleaseFast production build, formatting, and diff checks passed.
• Exact-final scaled valid corpus output is byte-identical (both exit 0; empty stdout/stderr).
• Exact-final 32,768-family A/B (aae87472… -> 58b48a6…), 3 balanced warmup pairs + 20 alternating measured pairs:
  • wall: 4,981.9 ± 172.9 ms -> 4,890.1 ± 149.9 ms (1.0188×), 17/20 wins, paired reduction 91.9 ms, 95% CI 30.2–153.6 ms, exact two-sided sign p=0.0025768;
  • CPU: 4,960.5 ± 157.6 ms -> 4,866.9 ± 135.7 ms (1.0192×), 16/20 wins, paired reduction 93.6 ms, 95% CI 39.2–148.0 ms, exact two-sided sign p=0.0118179.
• Independent pre-test-layout run agreed: 1.0207× wall and 1.0202× CPU, both 19/20 wins with positive paired intervals.
• Exact committed-binary official result 20260831T053315Z: TS 6.0.3 999.6 ± 27.0 ms, native TS 7.0.2 (tsgo) 349.9 ± 11.5 ms, Home 280.7 ± 6.7 ms; Home is 1.25× faster. Provenance stayed 58b48a6… before/after.

A fresh complete 20-workload snapshot and docs/README update are next as a separate small commit.

Published the exact builtin-object-name-gate checkpoint in dc6101a.

• Detailed A/B mechanism, 44-name completeness audit, hashes, paired confidence intervals, and exact two-sided sign tests: https://github.com/home-lang/home/blob/dc6101a630190235ebdd0381674b052dda94c910/docs/docs/TS_PERFORMANCE.md#builtin-object-name-gate-checkpoint
• Latest unfiltered TS 6.0.3 vs native TS 7.0.2 (tsgo) snapshot: 20260831T053521Z
• Result: Home has the lowest mean on 20/20 workloads and wins 600/600 individual paired rounds.
• README summary and benchmark checkpoint table now point to the same result ID.

Accepted and pushed 94a5b3589 (perf(ts): reuse string interner hashes).

Mechanism: compute Wyhash once, preserve the identical low-bit shard selection, and pass that exact hash through adapted read lookup, write-lock double-check, insertion, and lookup operations. Locking, byte equality, stable IDs, and allocation ordering are unchanged.

Validation: ReleaseFast interner suite, ReleaseFast type-predicate checker subset, ReleaseFast production build, formatting/diff checks, and byte-identical successful output.

Exact baseline/candidate SHA-256: 58b48a6b39d76c7ffa6cf3343490bd7da423692135076f3cbee6da8b54aa8206 / 977e3cc7ab65ff1c0e1f7f382aebd8258e45baea5ed1fb2b03892b44c11fa9f0.

Independent retained A/B evidence (three warmup pairs, 20 alternating measured pairs each):

• 32,768 families: CPU 4730.5 ± 34.8 ms -> 4706.2 ± 45.5 ms (1.0052x; paired reduction 24.3 ms, 95% CI 0.5–48.2 ms).
• 65,536 families: CPU 9824.1 ± 84.5 ms -> 9764.4 ± 73.6 ms (1.0061x; 15/20; paired reduction 59.8 ms, 95% CI 4.7–114.9 ms; exact two-sided sign p=0.0414).
• Wall means were lower at both scales but their confirmatory intervals narrowly crossed zero, so the CPU evidence is the retention basis.

A fresh profile removes the duplicated string-map get leaf and reduces Wyhash leaf samples from 34 to 16. Official TS 6.0.3 vs native TS 7.0.2 (tsgo) confirmation and docs follow in a separate commit.

Published the complete prehashed-interner benchmark record in a5db3b597.

• Detailed mechanism, two independent confirmatory A/B scales, confidence intervals, exact sign tests, profile evidence, validation, and both reverted flat probes: https://github.com/home-lang/home/blob/a5db3b597b36f38068f38b4eb4c4c1753b7b0bda/docs/docs/TS_PERFORMANCE.md#prehashed-string-interner-checkpoint
• Exact committed focused result: 20260831T063321Z (TS 6.0.3 980.1 ± 15.5 ms; native TS 7.0.2 342.9 ± 7.2 ms; Home 274.2 ± 3.7 ms, 1.25x lead).
• Latest complete result: 20260831T063443Z; Home has the lowest mean on 20/20 workloads and wins 600/600 paired rounds.
• README and benchmark checkpoint table now point to the same detailed snapshot.
• Candidate provenance before/after: 977e3cc7ab65ff1c0e1f7f382aebd8258e45baea5ed1fb2b03892b44c11fa9f0.

Pushed 79b6b6360 (perf(ts): reuse type interner hashes (#416)) directly to origin/main as Chris Breuer.

This checkpoint carries the already-computed TypeKey Wyhash through every sharded type-map probe and publication. It preserves the same 64-shard selection, structural TypeKey.eql checks, owned slice keys, locks, stable TypeIds, and pool publication semantics. It also reserves shard-table capacity before pool publication so insertion remains allocation-free after the type becomes visible.

Exact binaries:

• baseline 977e3cc7ab65ff1c0e1f7f382aebd8258e45baea5ed1fb2b03892b44c11fa9f0
• candidate e313cd557ae66e601792c947eff07a06c8a19b3421c7537623be3d2f9f85899b

Exact-output checks on the unchanged 32,768- and 65,536-family predicate corpora: both binaries exit 0 with identical empty stdout/stderr at both scales.

32,768 families, 3 alternating warmup pairs + 20 retained alternating measured pairs (bench/vs_tsgo/results/type-interner-prehash.FxAMAs/final-ab.32768):

• wall: 4689.7 ± 29.9 ms -> 4648.9 ± 33.4 ms, 1.0088x, 16/20 lower candidate pairs, paired reduction 40.8 ms, paired 95% CI 19.8-61.8 ms, exact two-sided sign p=0.0118
• process CPU: 4681.0 ± 27.3 ms -> 4639.9 ± 32.7 ms, 1.0089x, 16/20 lower candidate pairs, paired reduction 41.1 ms, paired 95% CI 19.9-62.3 ms, exact two-sided sign p=0.0118

65,536 families, unchanged generator with only family count doubled, 3 alternating warmup pairs + 20 retained alternating measured pairs (bench/vs_tsgo/results/type-interner-prehash.FxAMAs/final-ab.65536):

• wall: 9679.6 ± 100.9 ms -> 9611.4 ± 77.8 ms, 1.0071x, 16/20 lower candidate pairs, paired reduction 68.2 ms, paired 95% CI 16.3-120.1 ms, exact two-sided sign p=0.0118
• process CPU: 9664.1 ± 93.1 ms -> 9596.5 ± 72.6 ms, 1.0070x, 16/20 lower candidate pairs, paired reduction 67.6 ms, paired 95% CI 21.3-114.0 ms, exact two-sided sign p=0.0118

The unfiltered 10-pair screen was also positive (wall 1.0110x, CPU 1.0100x, both paired intervals positive). The post-change sample profile removes the old 58-sample TypeKey map getIndex leaf; normal map growth remains.

Validation passed:

• ReleaseFast full uppercase and lowercase type-interner test groups, including concurrency and allocation-failure coverage
• ReleaseFast checker type predicate subset
• ReleaseFast production home-tsc build
• exact output/exit checks at both scales
• zig fmt --check, git diff --check

Next: official TypeScript 6.0.3 vs native TypeScript 7.0.2 (tsgo) benchmark and documentation refresh.

Published the official TS 6.0.3 vs native TS 7.0.2 (tsgo) results and documentation in 2f6c5924e (docs(bench): publish type interner prehash results (#416)), pushed directly to origin/main as Chris Breuer.

Official focused result 20260831T071216Z (30 fresh processes after 3 warmups):

• TS 6.0.3: 977.9 ± 10.1 ms
• native TS 7.0.2 / tsgo: 343.3 ± 7.9 ms
• Home: 274.5 ± 8.4 ms
• Home lead over the fastest competitor: 1.25x

Official complete result 20260831T071413Z:

• exact pins verified: TS 6.0.3 and native TS 7.0.2
• compiler/tool provenance identical before and after measurement
• 20/20 workloads have the lowest Home mean
• Home wins 600/600 individual interleaved rounds
• strongest mean lead: startup, 12.16x
• narrowest mean lead: type_predicates_large, 1.26x
• all 600 round files / 1,800 successful finite samples retained without filtering
• candidate SHA-256 verified before and after: e313cd557ae66e601792c947eff07a06c8a19b3421c7537623be3d2f9f85899b

Documentation now includes the full current 20-row table, the exact A/B method and statistics at both scales, profile evidence, validation, hashes, raw-result IDs, and limitations. The root README keeps the requested brief platform table and links to the detailed report; the benchmark README points to the new qualified result. The published table was programmatically checked against all 20 rows generated from the raw result. Targeted Pickier passes on all three edited Markdown files; the repository-wide invocation safely refused the 195,534-file ignored-artifact scan before linting.

Current pushed head: 2f6c5924e. Native Linux rerun for this exact binary remains pending an eligible native Linux filesystem/host; the existing qualified Linux checkpoint still wins 20/20.

Recorded and fully reverted the next profile-guided probe in ca52f435f (docs(bench): record annotated lookup probe (#416)), pushed to origin/main as Chris Breuer.

Probe: remove a duplicate top-level annotated-variable lookup after visibleAnnotatedIdentifierTypeNode had already traversed the same parent chain through the root block. The cleanup was logically valid, preserved exact outputs at 32,768 and 65,536 families, and passed the focused ReleaseFast annotation suite.

The unfiltered 10-pair screen looked strong (wall 1.0108x, CPU 1.0106x, 10/10 lower candidate pairs, positive paired intervals), so it advanced to independent confirmations.

32,768 families, 3 warmup pairs + 20 alternating measured pairs:

• wall 4638.4 ± 41.2 -> 4611.3 ± 48.4 ms, 1.0059x, 15/20, paired CI -7.0 to 61.1 ms
• CPU 4631.7 ± 39.5 -> 4603.9 ± 45.9 ms, 1.0060x, 15/20, paired CI -5.0 to 60.6 ms

65,536 families, 3 warmup pairs + 20 alternating measured pairs:

• wall 9632.2 ± 79.7 -> 9582.9 ± 75.1 ms, 1.0052x, 13/20, paired CI -6.9 to 105.6 ms
• CPU 9619.1 ± 72.4 -> 9568.6 ± 69.9 ms, 1.0053x, 14/20, paired CI -1.5 to 102.5 ms

The means remained positive, but both independent scale intervals crossed zero. Per the established acceptance rule, the code change was reverted rather than claimed as a win. All raw rounds remain under bench/vs_tsgo/results/annotated-root-lookup.3jRs1g; the production binary is restored to accepted SHA-256 e313cd557ae66e601792c947eff07a06c8a19b3421c7537623be3d2f9f85899b. Current tracked compiler remains the type-interner prehash checkpoint.

Pushed 7f02a93dd (perf(ts): cache hot string interner lookups (#416)).

This adds a 64-entry direct-mapped hint per string-interner shard (32 KiB total). Each entry stores a hash fingerprint plus local index; every possible hit is checked against the canonical owned bytes while holding the existing shared shard lock. Fingerprint/slot collisions therefore fall through to the canonical prehashed map and cannot alter string identity, IDs, ownership, or locking semantics.

Controlled A/B against accepted baseline e313cd557ae66e601792c947eff07a06c8a19b3421c7537623be3d2f9f85899b; candidate be09b86b82af35703a8f812dad92014ddf5250e0c9e721c2078bc82a791ac35d. Exact output and exit status matched at both scales.

• 32,768 declarations, 20 alternating measured pairs after 3 warmups: wall 4715.364±52.290 ms → 4583.652±51.235 ms (1.028735×; 19/20 pairs; paired delta 131.712 ms, 95% CI 97.091–166.334; sign p=.0000401). CPU 4706.648±50.162 → 4574.956±47.673 ms (1.028785×; 20/20; paired delta 131.692 ms, CI 98.453–164.932; p=.0000019).
• 65,536 declarations, independent 20-pair scale check: wall 9776.164±93.619 → 9527.935±122.345 ms (1.026053×; 18/20; paired delta 248.229 ms, CI 162.192–334.266; p=.0004025). CPU 9720.355±90.044 → 9465.296±111.810 ms (1.026947×; 19/20; paired delta 255.059 ms, CI 176.910–333.208; p=.0000401).
• Profile evidence: string_interner.Interner.internAt leaf samples fell 220 → 92; byte-equality samples stayed essentially flat (207 → 205), consistent with avoiding map probes while preserving exact-byte verification.

Validation: ReleaseFast string-interner suite, ReleaseFast checker type-predicate subset, production build, exact-output comparisons, zig fmt --check, and git diff --check all pass. Raw artifacts: bench/vs_tsgo/results/string-interner-hot-cache.T0d2PQ/ (gitignored). Next I am running the official TypeScript 6.0.3 vs native TypeScript/tsgo 7.0.2 focused and complete benchmark suites, then will publish the tables.

Published the official TS 6.0.3 vs native TS/tsgo 7.0.2 results in 768c0d388 (docs(bench): publish string cache results (#416)).

Focused 30-round result 20260831T081314Z:

• TS 6.0.3: 985.8 ± 14.9 ms
• native TS/tsgo 7.0.2: 342.1 ± 5.5 ms
• Home: 257.3 ± 3.1 ms
• Home lead over the fastest competitor: 1.33×

Complete 20-workload result 20260831T081507Z:

• Home has the lower mean on 20/20 admitted workloads.
• Home has the lower individual time in 599/600 retained interleaved rounds.
• The only individual loss is a retained 49.96 ms Home outlier in tsx_components round 5 versus 47.83 ms for tsgo; Home still wins that workload mean 22.2 ± 5.2 ms versus 47.0 ± 1.2 ms (2.11×).
• The narrowest mean lead is type_predicates_large: 263.5 ± 8.2 ms versus tsgo 345.9 ± 9.1 ms (1.31×).
• Strongest mean lead is startup: 3.5 ± 1.0 ms versus tsgo 40.9 ± 8.4 ms (11.68×).

Every sample is retained. Compiler and tool identities were verified unchanged before admission and after measurement; the Home payload is the committed 7f02a93dd binary with SHA-256 be09b86b82af35703a8f812dad92014ddf5250e0c9e721c2078bc82a791ac35d. The detailed A/B statistics, current 20-row table, focused/full IDs, fairness caveats, and validation are in docs/docs/TS_PERFORMANCE.md; the root README table links there, and bench/vs_tsgo/README.md indexes the new qualified snapshot.

Measured and rejected a follow-on checker-local memoization for containsFreeTypeParameter; the source change is fully reverted and the accepted be09…35d binary restored.

On the unchanged 32,768-family predicate corpus after three alternating warmup pairs and ten measured alternating pairs:

• wall: accepted 4497.1 ± 37.4 ms vs candidate 4517.5 ± 79.8 ms (0.9955×; candidate lower in 4/10; paired delta -20.4 ms, 95% CI -88.2–47.5)
• process CPU: accepted 4486.4 ± 35.9 ms vs candidate 4501.7 ± 64.9 ms (0.9966×; 3/10; paired delta -15.3 ms, CI -71.1–40.4)

Exact output/exit status matched and the focused ReleaseFast predicate suite passed, but the checker-local hash-map lookup/maintenance did not justify the graph walks it avoided. Raw rounds: bench/vs_tsgo/results/free-type-param-cache.Npjpjh/preliminary-ab.32768/ (gitignored). The negative result is documented in 4272ee9d5 (docs(bench): record free type cache probe (#416)).

Pushed efdf8b574 (perf(ts): skip unicode probes at ascii boundaries (#416)).

skipTrivia now returns immediately at ordinary ASCII token boundaries. Every supported non-ASCII whitespace or line terminator starts with a high byte, so the existing UTF-8 recognition remains unchanged; this only avoids probing all fixed Unicode sequences when the current byte is ASCII.

Exact Home A/B against accepted baseline be09b86b82af35703a8f812dad92014ddf5250e0c9e721c2078bc82a791ac35d; candidate 150c2206d8d38990a2d0054d03c8939357960d5a26c0e6c0b9ca560d7fc8581b. Output and exit status match at 32,768 and 65,536 families.

• 32,768 independent confirmation (3 warmup pairs, 20 alternating pairs): wall 4477.425±35.909 → 4435.052±44.260 ms (1.009554×; 18/20; paired delta 42.372 ms, 95% CI 15.916–68.829; sign p=.0004025). CPU 4466.503±34.587 → 4426.825±42.372 ms (1.008963×; 18/20; paired delta 39.678 ms, CI 14.283–65.073; p=.0004025).
• 65,536 first confirmation retained one 11.51 s baseline outlier: wall 9357.467±511.103 → 9133.129±49.292 ms (1.024563×; 19/20; paired CI -5.927–454.604); CPU 9300.721±327.117 → 9118.373±45.452 ms (1.019998×; 19/20; CI 31.738–332.957). No samples were filtered.
• Independent 65,536 repeat with reversed starting order: wall 9212.690±54.990 → 9079.151±52.445 ms (1.014708×; 20/20; paired delta 133.540 ms, CI 100.998–166.082; p=.0000019). CPU 9200.369±53.627 → 9064.588±51.233 ms (1.014979×; 20/20; paired delta 135.781 ms, CI 104.171–167.392; p=.0000019).

A fresh profile at 65,536 families reduces unicodeWhitespaceLengthAt from 35 leaf samples in the prior 32,768 profile to 3 total stack occurrences despite double the workload. Validation: complete ReleaseFast lexer suite, ReleaseFast parser suite, ReleaseFast checker predicate subset, production build, exact-output gates at both scales, formatting, and diff checks. Raw artifacts: bench/vs_tsgo/results/ascii-trivia-fast-path.IbEFgd/ (gitignored). I am now rerunning the official TS 6.0.3 vs native TS/tsgo 7.0.2 suite.

Published the ASCII-trivia checkpoint and refreshed official results in 6c29e04d5 (docs(bench): publish ascii trivia results (#416)).

Focused result 20260831T091833Z (30 interleaved cold-process rounds after 3 warmups):

• TS 6.0.3: 980.2 ± 14.7 ms
• native TS/tsgo 7.0.2: 345.0 ± 13.2 ms
• Home: 256.2 ± 8.2 ms
• Home lead over fastest competitor: 1.35×

Complete result 20260831T091953Z:

• Home lower mean on 20/20 admitted workloads.
• Home lower individual time in 599/600 retained rounds.
• Sole individual loss: retained commonjs_graph round 15, Home 64.27 ms vs tsgo 47.58 ms; Home still wins the workload mean 33.7 ± 5.8 ms vs 48.6 ± 0.9 ms (1.44×).
• Narrowest mean lead: type_predicates_large, Home 257.1 ± 11.4 ms vs tsgo 339.7 ± 4.6 ms (1.32×).
• Strongest mean lead: startup, Home 3.4 ± 1.1 ms vs tsgo 41.9 ± 13.6 ms (12.20×).

Every sample is retained. Compiler/tool provenance was verified unchanged before admission and after measurement; the Home payload is the committed efdf8b574 binary with SHA-256 150c2206d8d38990a2d0054d03c8939357960d5a26c0e6c0b9ca560d7fc8581b. The detailed A/B table includes both independent 65,536-family confirmations, including the unfiltered noisy one. The root README table links to the full report and bench/vs_tsgo/README.md indexes the new snapshot.

Measured and rejected replacing the lexer keyword length buckets with std.StaticStringMap; the behavior change is fully reverted and the accepted 150c…581b binary restored.

32,768-family screen after 3 alternating warmup pairs and 10 alternating measured pairs:

• wall: accepted 4425.8 ± 44.9 ms vs candidate 4441.2 ± 40.6 ms (0.9965×; candidate lower in 6/10; paired delta -15.4 ms, 95% CI -61.2–30.4)
• process CPU: accepted 4415.4 ± 43.2 ms vs candidate 4432.3 ± 40.5 ms (0.9962×; 5/10; paired delta -17.0 ms, CI -61.0–27.1)

Exact output/exit status matched and the complete ReleaseFast lexer suite passed, but the static-map lookup cost exceeded the comparisons it avoided. Raw rounds: bench/vs_tsgo/results/static-keyword-map.7qVurl/preliminary-ab.32768/ (gitignored). d10962278 documents the rejection and corrects the existing lookup comment: the largest length bucket has 16 candidates, not 6.

Measured and rejected a purpose-built collision-free keyword index; the implementation is fully reverted and the accepted 150c2206d8d38990a2d0054d03c8939357960d5a26c0e6c0b9ca560d7fc8581b binary restored.

The candidate used a compile-time-verified 256-byte index keyed by identifier length, first two bytes, and final byte, followed by an exact byte comparison. It preserved all 81 keyword round trips, the complete ReleaseFast lexer suite, and exact compiler output.

32,768-family screen after 3 alternating warmup pairs and 10 alternating measured pairs:

• wall: accepted 4701.1 ± 166.1 ms vs candidate 4749.8 ± 303.7 ms (0.9897×; candidate lower in 5/10; paired delta -48.7 ms, 95% CI -229.5–132.1)
• process CPU: accepted 4666.3 ± 148.6 ms vs candidate 4700.7 ± 253.9 ms (0.9927×; 5/10; paired delta -34.4 ms, CI -180.4–111.6)

The host was slower than the prior batch, so only paired within-batch differences are interpreted. The arithmetic/table load did not justify replacing the inlined length buckets, and the candidate did not proceed to larger-scale confirmation. Raw rounds: bench/vs_tsgo/results/perfect-keyword-index.YBAnkb/preliminary-ab.32768/ (gitignored). The negative result is documented in 4f1d9e7ec (docs(bench): record perfect keyword probe (#416)).

Rejected and fully reverted the exact source-marker gate for legacy inline @target scans.

The candidate used the existing exact Aho–Corasick marker index to skip the raw @target search only when the source contained no @; sources containing @ retained the original parser. Fixed baseline/candidate binaries produced byte-identical output at 32,768 and 65,536 families.

Ten paired 32,768-family rounds after three alternating warmup pairs:

• wall: accepted 5133.2 ± 503.0 ms, candidate 5178.6 ± 505.6 ms (0.9912×; 5/10 candidate wins; paired 95% CI -242.1–151.3 ms)
• process CPU: accepted 5027.4 ± 401.3 ms, candidate 5020.1 ± 321.2 ms (1.0015×; 6/10 candidate wins; paired 95% CI -140.5–155.2 ms)

Neither interval excluded zero, so the branch did not earn its keep. Raw rounds are retained under target-option-gate.shBw7j/preliminary-ab.32768; the compiler remains on the accepted implementation. Documentation: https://github.com/home-lang/home/commit/34e52b8ca

Rejected and fully reverted the parser virtual-section fact probe.

The candidate reused the driver's exact one-pass marker index instead of rescanning every source for @filename: and @Filename: in Parser.init, while preserving the scanning initializer for direct parser callers. ReleaseFast parser/driver suites and exact output at 32,768 and 65,536 families passed.

The 10-pair 32,768 screen and independent 20-pair repeat showed attractive ~1.5–2.0% lower candidate means, but every paired interval crossed zero. The decisive 20-pair 65,536 run did not reproduce the margin:

• wall: accepted 10054.8 ± 378.2 ms, candidate 10039.3 ± 372.8 ms (1.0015×; 13/20 candidate wins; paired 95% CI -120.8–151.7 ms)
• process CPU: accepted 9911.9 ± 309.1 ms, candidate 9908.9 ± 323.3 ms (1.0003×; 10/20 candidate wins; paired 95% CI -107.2–113.3 ms)

No scale-consistent win, so the API change did not earn its keep. All raw rounds remain under parser-virtual-section-fact.BUr50C; documentation: https://github.com/home-lang/home/commit/b9b344ea1

Rejected and fully reverted the declaration-diagnostic pass census.

The candidate classified top-level HIR kinds once and skipped each of eight specialized merge passes only when its prerequisite kinds were absent. The full ReleaseFast checker suite passed, and fixed binaries produced byte-identical output at 32,768 and 65,536 families.

Ten paired 32,768-family rounds after three alternating warmup pairs:

• wall: accepted 4762.9 ± 84.4 ms, candidate 4757.8 ± 128.0 ms (1.0011×; 6/10 candidate wins; paired 95% CI -107.5–117.8 ms)
• process CPU: accepted 4732.5 ± 60.6 ms, candidate 4725.7 ± 101.0 ms (1.0014×; 6/10 candidate wins; paired 95% CI -81.3–94.9 ms)

The census cost offset the empty passes, so there is no defensible win. Raw rounds remain under declaration-pass-gates.4tu8mP/preliminary-ab.32768; documentation: https://github.com/home-lang/home/commit/a278ea4cb

Accepted source-marker reuse in 5efbd19 (pushed directly to main).

What changed:

• Program now borrows the SourceMarkerIndex already produced by ts_driver.prepareSource instead of rescanning every file with a second matcher.
• The shared matcher now includes the two Program-only facts, interface and exports.
• Pre-compilation helper callers retain an owned-scan fallback; compilation replacement clears borrowed indexes before freeing storage.
• A regression assertion verifies prepared files point at Compilation.source_markers rather than an owned rescan.

Correctness gates:

• focused source_markers tests: 3/3
• full ReleaseFast ts_program suite: pass
• full ReleaseFast ts_checker suite: pass
• fixed baseline/candidate output at 32,768 and 65,536 families: identical exit 0, stdout, and stderr
• benchmark harness: 95/95; installed baselines report Version 6.0.3 and Version 7.0.2. Native TS 7 and tsgo remain one competitor; the superseded 7.0.0-dev.20260707.2 build is rejected by the harness.

Fixed binaries:

• baseline SHA-256: 150c2206d8d38990a2d0054d03c8939357960d5a26c0e6c0b9ca560d7fc8581b
• candidate SHA-256: 0d2aed7253152acb66965e5148d09c5a50bf7512e9062faecee0daa70caa3f60

Paired A/B, three alternating warmup pairs, reversed order each measured round, no samples removed:

• 32,768 families, 20 pairs: wall 5389.9 ± 460.6 ms -> 4961.4 ± 296.3 ms (1.0864x, 19/20 wins, paired 95% CI +242.7..+614.2 ms); CPU 5256.2 ± 355.2 -> 4856.8 ± 236.2 ms (1.0822x, 19/20, CI +255.4..+543.4 ms).
• 65,536 families, 20 pairs: wall 10967.9 ± 968.4 ms -> 10533.7 ± 979.8 ms (1.0412x, 12/20 wins, paired 95% CI +4.4..+864.0 ms); CPU 10703.8 ± 782.2 -> 10202.3 ± 746.9 ms (1.0492x, 16/20, CI +187.9..+815.0 ms).

The larger run saw unrelated builds begin during measurement; all samples remain retained and the paired wall and CPU intervals both stay positive. Raw evidence is under bench/vs_tsgo/results/program-source-marker-reuse.Ii55xS. Next: fresh official TS 6.0.3 / native tsgo 7.0.2 focused and full checkpoints, then docs + README table update.

Official checkpoints and documentation are now published in 363cb64 (pushed to main).

Focused checkpoint 20260831T214804Z, 30 interleaved rounds after 3 warmups:

• TS 6.0.3: 1185.5 ± 109.7 ms
• native tsgo 7.0.2: 408.2 ± 33.7 ms
• Home: 284.6 ± 25.9 ms
• Home is 1.43x faster than the fastest competitor, wins 30/30 pairs, paired 95% fastest-competitor-minus-Home interval +113.7..+133.6 ms.
• 30 round files / 90 finite successful samples; provenance verified unchanged.

Full checkpoint 20260831T215035Z, same immutable Home binary:

• lower Home mean on 20/20 admitted workloads
• 600/600 paired round wins
• 600 round files / 1800 finite successful samples, zero failures, no filtering
• every row has a positive paired 95% competitor-minus-Home interval
• strongest mean lead: startup 12.06x
• narrowest mean lead: 1.50x, shared by commonjs_graph and type_predicates_large
• compiler provenance verified unchanged before admission and after measurement

The benchmark reports and metadata confirm the exact comparison is JavaScript TS 6.0.3 versus the single native TS 7/tsgo 7.0.2 competitor. The superseded 7.0.0-dev.20260707.2 build remains a rejection-test input only.

Docs:

• README concise cross-platform table and link updated
• bench/vs_tsgo/README.md qualified result updated
• docs/docs/TS_PERFORMANCE.md contains the complete 20-row table, source-marker A/B hashes/method/intervals, focused result, fairness caveat, raw IDs, and reproduction details
• docs/docs/PARITY-STATUS.md updated to the same checkpoint

Validation: 95/95 harness tests and pickier on all edited Markdown files pass. Next cross-platform target remains the pinned Linux ARM64 checkpoint, whose older CheckJS lead is only 1.02x.

Follow-up marker-index probes are documented in b5a7346 (pushed to main); production source remains unchanged from the accepted 5efbd19 optimization.

Rejected alternative 1: replace the combined marker pass with 39 independent exact indexOf searches. On the unchanged 100,993,656-byte source, three invocations of ten alternating in-process rounds measured Aho at 311.855 / 266.118 / 268.457 ms versus independent searches at 1367.862 / 1389.771 / 1424.940 ms. The alternative is roughly 5x slower.

Rejected alternative 2: specialize this 244-state automaton to u8 transitions. Direct marker timings improved to 240.446 / 250.990 / 240.570 ms; focused marker tests passed and fixed compiler output was exact at both scales. The 10-pair end-to-end screen was slightly positive, but the independent 20-pair 32,768-family confirmation failed the admission rule:

• wall: 4553.0 ± 160.8 ms before, 4523.3 ± 139.6 ms after; 1.0066x, 10/20 wins, paired 95% CI -17.5..+77.0 ms
• CPU: 4529.0 ± 149.5 ms before, 4502.1 ± 135.6 ms after; 1.0060x, 10/20 wins, CI -13.6..+67.4 ms

No samples were removed. The u8 change was fully reverted and no 65,536 confirmation was run after the 32,768 gate failed. Raw evidence: bench/vs_tsgo/results/source-marker-state-width.iZsnJ1.

Documented and rejected two exact source-marker trie candidates in 4ea479f (pushed directly to main). Both retained one outer source pass; v2 additionally pruned prefix subtrees whose markers were already found. Production source was fully reverted because neither met the whole-compiler admission gate.\n\nFixed binaries:\n- accepted baseline: 0d2aed7253152acb66965e5148d09c5a50bf7512e9062faecee0daa70caa3f60\n- plain trie: e07847318a52844f4222433db674027b9c2a4604cea3963f496a09c489da2e1c\n- pruned trie: 1657f5c3532fcfd2d4fe97ef3a2754ff62f128fc2c9055f987e5aaa5d619ffbb\n\nCorrectness: both candidates exited 0 with byte-identical stdout/stderr at 32,768 and 65,536 families; focused marker tests, full ReleaseFast checker and Program suites, and 95/95 harness tests passed.\n\nAll A/B runs used three alternating warmup pairs, reversed order each measured round, and no filtering. Plain-trie 32,768 confirmation (20 pairs): wall 4827.5 ± 324.7 -> 4770.7 ± 310.9 ms (1.0119x, 14/20, paired 95% CI -8.0..+121.5); CPU 4754.0 ± 256.0 -> 4707.1 ± 269.6 ms (1.0100x, 13/20, CI -8.4..+102.2). Its 65,536 ten-pair screen was positive, but was not accepted without smaller-scale confirmation.\n\nPruned-trie screens also failed admission: 32,768 wall 4666.1 ± 238.8 -> 4628.9 ± 239.4 ms (1.0080x, 5/10, CI -70.4..+144.7); 65,536 wall 9417.7 ± 179.4 -> 9318.2 ± 165.7 ms (1.0107x, 4/10, CI -116.6..+315.6). CPU intervals crossed zero at both scales too.\n\nThe README now has a concise rejection table and links to the full report. Raw evidence remains under bench/vs_tsgo/results/source-marker-trie.20260831T153305.99359 and source-marker-pruned-trie.20260831T160024.69935. The qualified TS 6.0.3 vs native TS 7.0.2 snapshot is unchanged.

Parser-local interner cache probe is documented in e008b3e (pushed directly to main) and fully reverted from production.\n\nThe 64-entry parser-local cache required an exact hash, length, and full source-byte match before reusing an already-published StringId; misses reused the precomputed hash in the canonical shared interner. Focused ReleaseFast parser and interner suites passed, and fixed output was byte-identical at 32,768 and 65,536 families. Candidate SHA-256: 60ceb2f534ee01859e27f4ac3fabbd6630679b7361e90852f423bbdec087d97a; baseline: 0d2aed7253152acb66965e5148d09c5a50bf7512e9062faecee0daa70caa3f60.\n\nThe initial 32,768-family gate failed after three alternating warmup pairs and ten reversed-order measured pairs with no filtering: wall 4716.3 ± 154.9 ms vs 4721.7 ± 276.3 ms (0.9989x, 5/10 candidate wins, paired 95% CI -123.8..+112.9); CPU 4665.3 ± 127.3 ms vs 4666.0 ± 234.1 ms (0.9999x, 5/10, CI -99.6..+98.2). No confirmation or 65,536 timing was run after the gate failed. Raw evidence: bench/vs_tsgo/results/parser-local-interner-cache.20260831T162449.18110.

Declaration-space marker gate probe is documented in 06bfab5 (pushed directly to main) and fully reverted.\n\nThe candidate conservatively skipped sibling namespace/class-interface/enum/type-alias merge passes only when attached exact source markers made the declaration kind impossible; false positives and source-less checker callers retained the old path. The merge-focused ReleaseFast checker gate passed, and fixed output matched exactly at 32,768 and 65,536 families. Candidate SHA-256: 41b9d70b977818d1548ae375d98ff3858a4a02e266b11c40130babfc6b984ad5; baseline: 0d2aed7253152acb66965e5148d09c5a50bf7512e9062faecee0daa70caa3f60.\n\nThe initial 32,768 screen failed after three alternating warmup pairs and ten reversed-order measured pairs, no filtering: wall 4699.2 ± 166.2 -> 4810.0 ± 287.3 ms (0.9770x, 3/10 candidate wins, paired 95% CI -318.8..+97.1); CPU 4656.6 ± 143.0 -> 4736.5 ± 221.4 ms (0.9831x, 3/10, CI -248.6..+88.7). No confirmation or larger-scale timing was run. Raw evidence: bench/vs_tsgo/results/declaration-pass-gates.20260831T163650.42200.

Accepted and pushed the CommonJS program import-resolution cache.

• Source: 49641900e (perf(ts): cache program import resolutions (#416))
• Results/docs: f46d54599 and the detailed report
• Design: cache the immutable external + fallback normalized paths per exact (import node, specifier); target-specific matching still uses the existing path-equivalence rule, and source/resolver/importer changes clear the cache.
• Standard 128-owner A/B, 30 pairs: 36.5 ± 3.1 ms -> 30.1 ± 2.0 ms (1.212x, 30/30 wins, paired 95% CI +5.3..+7.5 ms).
• Scaled 2,048-owner confirmation, 20 pairs: 3471.2 ± 261.2 ms -> 1565.2 ± 183.4 ms (2.218x, 20/20 wins, paired 95% CI +1810.0..+2001.9 ms).
• Pinned schema-3 checkpoint 20260901T012536Z: TS 6.0.3 263.0 ± 48.8 ms, native TS/tsgo 7.0.2 83.9 ± 27.9 ms, Home 42.9 ± 10.5 ms (1.95x faster than tsgo; 30/30 paired wins).
• Correctness: byte-identical output and exit status on the scaled project; full ReleaseFast checker suite; 95/95 benchmark-harness tests; 198/198 CommonJS, 132/132 discovery, and 720/720 graph-type cross-compiler audit checks.

Full 20-workload macOS checkpoint refreshed after the accepted import-resolution cache.

• Docs commit: 8777ff699
• Raw result: 20260901T013443Z
• Exact pins: TS 6.0.3 and native TS/tsgo 7.0.2
• Admission/provenance: schema 3; 600 round files; 1,800 successful finite samples; compiler and tool payloads unchanged before/after
• Result: Home lower mean on 20/20 workloads; 598/600 individual paired wins; every workload paired 95% CI remains above zero
• commonjs_graph: 55.7 ± 2.4 ms tsgo vs 30.4 ± 3.0 ms Home (1.83x)
• New narrowest mean lead: type_predicates_large, 484.6 ± 128.8 ms tsgo vs 329.4 ± 93.3 ms Home (1.47x; paired CI +115.0..+195.4 ms)
• The two individual non-wins were retained: one control_flow round and one type_predicates_large round.

The current snapshot, parity mirror, root README table, and benchmark README now point to this checkpoint.

Rejected and fully reverted a new type_predicates_large probe; documented in f11985cd2.

Fresh accepted-binary profiling showed prepareSource down from 316 to 23 exclusive samples after the marker work, while visibleAnnotatedIdentifierTypeNode had 68. I tested a 256-slot, collision-verified, allocation-free per-node annotation cache. Exact output/exit status matched and the focused ReleaseFast predicate gate passed, but the whole-process screen failed:

• Wall: 5155.6 ± 318.3 ms baseline vs 5175.6 ± 235.3 ms candidate (0.9961x, 5/10 wins, paired 95% CI -295.3..+255.3 ms)
• CPU: 5024.3 ± 250.2 ms vs 5014.0 ± 151.9 ms (1.0021x, 5/10, CI -181.4..+202.1 ms)

Both intervals cross zero and wall mean regressed, so no confirmation or larger-scale run was justified. Raw evidence: visible-annotation-hot-cache.20260901T020323Z; current profile: predicate-current-profile.20260901T014600Z.

Accepted and pushed dependency-free declaration-schema optimization.

• Source: e0f2fb6d7 (perf(ts): skip unused declaration schemas (#416))
• Docs: ee99421e5 (docs(bench): publish declaration schema results (#416))
• Exact competitors: JavaScript TS 6.0.3 vs native TS/tsgo 7.0.2 (one TS7 competitor)
• Candidate SHA-256: 83f48045ba8dc697177eb2d6d453409cb06ae44167d094b6d70ed6e1dec25e7e
• Baseline SHA-256: ec99b3fcca63f39d97f147bbe2ad5139bf5e53a22f885e25bd1f6eb971386789

Fair unchanged official type_predicates_large A/B, 3 alternating warmup pairs + 30 reversed-order measured pairs, no filtering:

• wall: 258.315 ± 7.221 ms -> 246.859 ± 4.718 ms (1.0464x, 30/30 wins, paired 95% CI +9.586..+13.325 ms)
• process CPU: 256.033 ± 7.037 ms -> 244.838 ± 4.605 ms (1.0457x, 30/30, CI +9.428..+12.962 ms)

Focused pinned result 20260901T024321Z: TS6 1147.4 ± 290.2 ms, native TS7 398.4 ± 50.3 ms, Home 266.8 ± 50.8 ms (1.49x faster than TS7; paired CI +111.5..+151.8 ms).

Full schema-3 result 20260901T024535Z: Home lowest mean on 20/20 workloads and 600/600 paired wins; all paired 95% intervals positive. Narrowest mean lead is 1.50x on large predicates. All 600 round files / 1,800 successful finite samples retained, with provenance verified unchanged before/after.

Correctness: ReleaseFast Program suite, focused predicate checker suite, harness 95/95, all 20 positive/negative admissions, and byte-identical exact output at official, 32,768-, and 65,536-family scales.

Detailed report and the concise root README table are updated on main.

Accepted and pushed exact source-marker root-gap fast-forward.

• Source: 7ca9946c8 (perf(ts): skip source marker root gaps (#416))
• Docs: c2c12ee81 (docs(bench): publish marker root-gap results (#416))
• Baseline SHA-256: 83f48045ba8dc697177eb2d6d453409cb06ae44167d094b6d70ed6e1dec25e7e
• Candidate SHA-256: 60e10affa923acd3265511f91f248277cf7bbf70e28508ff1bf903b8761bf2a2

This keeps the exact Aho-Corasick matcher. Only root-state byte runs that cannot begin any registered marker are skipped in bulk; every possible prefix/failure/overlap/suffix and first position uses the unchanged automaton. This is distinct from the previously rejected trie probes.

Unchanged official type_predicates_large, 3 alternating warmup pairs + 30 reversed-order measured pairs, no filtering:

• wall: 240.611 ± 3.256 ms -> 237.311 ± 5.460 ms (1.0139x, 27/30, paired 95% CI +1.558..+5.040 ms)
• CPU: 238.928 ± 3.153 ms -> 235.592 ± 4.990 ms (1.0142x, 26/30, CI +1.716..+4.956 ms)

Independent 65,536-family screen, all 10 pairs retained:

• wall: 8747.426 ± 109.663 -> 8626.257 ± 116.604 ms (1.0140x, 8/10, CI +40.535..+201.804 ms)
• CPU: 8715.280 ± 81.749 -> 8591.872 ± 96.556 ms (1.0144x, 9/10, CI +65.075..+181.743 ms)

Pinned focused result 20260901T031352Z: TS 6.0.3 1242.7 ± 414.8 ms, native TS/tsgo 7.0.2 413.2 ± 84.6 ms, Home 267.8 ± 36.4 ms (1.54x faster; TS7-minus-Home paired CI +111.6..+179.2 ms).

Correctness: byte-identical official and 65,536-scale output; focused exact marker tests; full ReleaseFast checker, driver, and Program suites; harness 95/95; all 20 workload admissions.

Rejected and reverted a larger canonical string-interner hint after a fair retained screen.

• Exact probe: 64 -> 256 entries per shard; full byte equality and canonical prehashed fallback unchanged
• Correctness: byte-identical empty output at 2,048 and 32,768 predicate families; ReleaseFast interner suite passed
• 32,768 families, 10 reversed-order pairs after 3 alternating warmup pairs, no filtering
• CPU: 6215.600 ± 107.917 ms baseline vs 6307.875 ± 115.115 ms candidate (0.9854x, 4/10; paired CI -209.220 to +24.670 ms)
• Wall: 7727.518 ± 414.303 ms vs 8069.492 ± 701.373 ms (0.9576x, 4/10; paired CI -706.254 to +22.306 ms)

The gate failed, so no confirmation was run and the 64-entry production capacity remains. Raw evidence: bench/vs_tsgo/results/string-interner-cache-capacity.20260901T033000Z/. README and detailed docs: commit 79d9509.

Measured and reverted an exact one-pass special-identifier classification in typeOfIdentifier.

• Candidate classified this, await, arguments, and new.target once by mutually exclusive length plus full byte equality; existing branch/diagnostic order stayed unchanged
• Exact byte-identical empty output at 2,048 and 32,768 predicate families
• Official 2,048-family screen: 10 reversed-order pairs after 3 alternating warmup pairs, no filtering
• Wall: 246.588 ± 9.418 ms vs 243.908 ± 5.698 ms (1.0110x, 6/10; paired CI -6.114 to +11.473 ms)
• CPU: 244.176 ± 8.272 ms vs 241.710 ± 5.238 ms (1.0102x, 6/10; paired CI -5.188 to +10.121 ms)

The lower means were inconclusive and failed the initial paired gate, so no scale/confirmation run was admitted and the probe was fully reverted. Raw evidence: bench/vs_tsgo/results/special-identifier-classification.20260901T035000Z/. README and detailed docs: commit 18844bd.

Measured and reverted exact pre-sizing of the three temporary declaration-space diagnostic maps.

The probe counted eligible HIR declaration kinds, reserved map capacity, then used the unchanged diagnostic passes/insertion order. Exact official output remained byte-identical.

Initial 10-pair screen after 3 alternating warmup pairs (all retained):

• Wall: 327.868 ± 16.578 ms vs 318.948 ± 17.585 ms (1.0280x, 8/10; CI -10.141 to +27.981 ms)
• CPU: 316.272 ± 13.006 ms vs 307.522 ± 9.762 ms (1.0285x, 8/10; CI -2.358 to +19.858 ms)

Independent 30-pair confirmation after fresh warmups (not pooled):

• Wall: 250.214 ± 9.998 ms vs 248.246 ± 13.890 ms (1.0079x, 23/30; CI -3.764 to +7.700 ms)
• CPU: 246.950 ± 8.510 ms vs 244.955 ± 10.931 ms (1.0081x, 24/30; CI -2.315 to +6.305 ms)

The confirmation failed the paired-mean admission rule, so no scale run was performed and the probe was fully reverted. Raw evidence: bench/vs_tsgo/results/declaration-map-presize.20260901T041500Z/. README and detailed docs: dd6e64c.

Measured and reverted exact reuse of isDeclNameSlot(node) inside typeOfIdentifier.

The candidate evaluated the immutable HIR predicate once at its first use and reused it in 36 later branches. Early special-case exits stayed before the computation; there was no cache, semantic gate, or diagnostic reordering.

Correctness:

• Official 2,048-family and unchanged 32,768-family predicate projects both exited 0
• Baseline/candidate stdout and stderr were byte-identical at both scales

Official screen: 10 reversed-order pairs after 3 alternating warmup pairs, all retained:

• Wall: 292.454 ± 28.421 ms vs 300.577 ± 30.022 ms (0.9730x, 4/10; paired CI -33.078 to +16.832 ms)
• CPU: 283.171 ± 19.615 ms vs 284.514 ± 15.643 ms (0.9953x, 5/10; paired CI -19.859 to +17.172 ms)

The initial gate failed, so the probe was fully reverted with no confirmation or scale timing. Raw evidence: bench/vs_tsgo/results/identifier-decl-slot-reuse.20260901T035734Z/. README and detailed docs: 7c2d11f.

Measured and reverted parser reuse of the scanner’s exact identifier escape flag.

The one-line probe replaced indexOfScalar(raw_identifier, \\) with tok.flags.has_escape under the same .identifier guard; decoder, fallback, and interning stayed unchanged.\n\nCorrectness:\n- Full ReleaseFast parser suite passed, including bare/escaped/invalid identifier controls\n- Byte-identical empty output at 2,048, 32,768, and 65,536 predicate families\n\nOfficial screen: 10 reversed-order pairs after 3 alternating warmup pairs, all retained:\n- Wall: 440.866 ± 24.461 ms vs 452.033 ± 25.669 ms (0.9753x, 5/10; paired CI -34.149 to +11.814 ms)\n- CPU: 377.824 ± 11.665 ms vs 383.668 ± 19.005 ms (0.9848x, 5/10; paired CI -24.280 to +12.592 ms)\n\nThe initial gate failed, so the probe was fully reverted with no confirmation or scale timing. Raw evidence: bench/vs_tsgo/results/parser-escape-flag-reuse.20260901T040925Z/. README and detailed docs: 93d9577.

Accepted and pushed a CheckJS/JSDoc scaling fix in 532373ee1; detailed evidence and the README row are in a64c2964a.

Cause: checkJSDocImportTypeModuleTargets resolved a top-level statement anchor for every ordinary JSDoc block before checking for import(...) / typeof import(...), creating a comments-by-statements path. The checker now reuses the exact source import marker and resolves an anchor lazily only for a relevant tag. No result cache, feature workaround, or benchmark-only behavior.

Validation:

• focused ts_checker tests matching JSDoc import pass
• official 128-family and deterministic 4,096-family baseline/candidate stdout and stderr are byte-identical and empty
• official screen: 1.0161x wall, 1.0150x CPU; both paired 95% CIs positive
• independent clean 30-pair confirmation: 1.0145x wall, 1.0158x CPU; CIs +0.035..+0.971 ms and +0.151..+0.916 ms
• the earlier noisy 30-pair confirmation was retained and documented separately, not filtered or pooled
• 4,096-family diagnostic scale: 1.2149x wall and 1.2143x CPU, 10/10 wins
• pinned schema-3 checkpoint 20260901T044935Z: TS 6.0.3 241.3 +/- 59.1 ms, native TS7/tsgo 7.0.2 64.7 +/- 19.5 ms, Home 39.8 +/- 16.9 ms (1.63x faster than the fastest competitor)

Raw A/B identifier: checkjs-import-type-gate.20260901T043158Z. The detailed tables, hashes, fairness notes, and reproduction provenance are in docs/docs/TS_PERFORMANCE.md.

Accepted and pushed the exact diagnostic-reconciliation marker gate.

• Source: https://github.com/home-lang/home/commit/587c64343
• Docs/README: https://github.com/home-lang/home/commit/ae6044248
• Design: every exact reconciliation branch now has a necessary sentinel in the existing one-pass source-marker index; ordinary files skip the otherwise repeated post-check scan. The original exact conditions and uncached fallback remain intact.
• Correctness: byte-identical output at 2,048, 32,768, and 65,536 predicate families; focused marker coverage, full ReleaseFast ts_checker suite, and all 95 benchmark-harness tests pass.
• Official 2,048-family confirmation: wall 248.825 ± 3.471 ms -> 242.644 ± 8.619 ms (1.0255x, 28/30 wins, paired 95% CI +2.540 to +9.822 ms); CPU 1.0265x with a positive CI.
• 32,768 families: wall 1.0232x and CPU 1.0236x, 10/10 wins, both paired CIs positive.
• 65,536 families: lower candidate means, but both CIs cross zero; all samples are retained and the run is documented as inconclusive rather than used for acceptance.
• Pinned checkpoint 20260901T051415Z: JavaScript TypeScript 6.0.3 1178.4 ± 145.4 ms, native TypeScript 7.0.2 / tsgo 401.6 ± 32.8 ms, Home 267.2 ± 55.9 ms. Home retains a 1.50x lead and wins 29/30 paired wall rounds against tsgo; paired CI +120.576 to +148.318 ms.

Full methodology, hashes, raw-result identifiers, and tables are in docs/docs/TS_PERFORMANCE.md.