bench(ts): expose large type-predicate scaling costs

Track under #416 alongside #455. The 256-family predicate workload has a narrow Home lead, but the identical generator scaled to 2,048 families exposes superlinear work. After function-declaration indexing (983c2c5), a five-run round-robin probe after three warmups records Home 801.0 ± 22.4 ms, native TS 7.0.2 369.4 ± 15.4 ms, and JavaScript TS 6.0.3 1063.8 ± 43.0 ms: a 2.17× Home loss. All three compilers accept the same source silently and reject all four guard/assertion negative controls. Accepted large source: 106,496 lines, 3,032,376 bytes, SHA-256 9966d3e8933894a6a67f4f28c606765df0a7650f6cef429a758797151c2f6bca. Add it as a separate scaling workload without changing the original 256-family project. Run the complete 18-workload suite and publish every result, including the loss, in README and detailed docs. Preserve corpus/flags/gates while profiling and optimizing remaining general costs such as first-time named-shape searches and lexical value-declaration scans. Use small linked conventional commits on main as the configured user, without coauthors.

Frozen scaling workload and shared negative controls landed in 932797b. The generated large file exactly matches the accepted SHA-256 9966d3e8933894a6a67f4f28c606765df0a7650f6cef429a758797151c2f6bca; the original small-workload hash is unchanged. All three compilers accept the large project silently and emit exactly two TS2322 plus two TS2339 diagnostics for the untimed guard/assertion mutations. Full 18-workload snapshot is running with 30 interleaved samples after 3 warmups. Remaining scaling optimization will be based on this preserved input and the existing profile, without weakening the workload.

Published the full 18-workload baseline in 5df5a8b, raw snapshot 20260827T165255Z. Large predicates: Home 855.8 ± 42.1 ms, native TS 7.0.2 382.3 ± 25.1 ms, JavaScript TS 6.0.3 1125.6 ± 54.6 ms. Home loses by 2.24×; the loss is explicit in the README table and prose as well as docs/docs/TS_PERFORMANCE.md. All 30 round-robin samples after 3 warmups are retained. The complete suite is 17/18 lower Home means. Verified all 1620 timed samples exited successfully, both tables exactly match the raw data, all 18 positive projects pass, and all 13 automatic negative controls pass in every compiler. Accepted large and original small hashes remain unchanged. Issue remains OPEN for general scaling improvements; first-time named-shape searches and local declaration scans are the next profiled targets.

Fresh profile on the frozen large corpus confirms remaining named-shape searches (102 samples in objectTypeHasNamedShape plus 84 in objectTypesSameDisplayShape) and local declaration scans (84). Implementing a conservative member-fact index, maintained when type names are registered. Each fact includes object member count, all three index signatures, member name/type, and optional/readonly/method flags. Missing facts prove no exact named display shape can match. Facts from replaced bindings and hash collisions only permit an extra original full comparison; they never accept a type. This necessary-condition design also preserves the original asymmetric duplicate-member behavior without adding a quadratic uniqueness scan. Allocation failure disables the filter. Regression coverage checks permutations, duplicates, modifiers/indexers, ignored metadata, rebinding, combined false positives, source reset, and OOM fallback.

Necessary named-shape member filtering landed in 0494dc6 after all 4,201 checker tests, the release build, 18 shared positive projects, and 13 negative controls per compiler passed. Alternating preserved binaries (3 warmups) reduced large predicates from 800.16 ± 62.91 to 645.06 ± 13.10 ms over 10 samples each; small predicates were 67.73 ± 2.85 versus 66.13 ± 6.46 ms over 30 samples each. These are development comparisons, not a new full competitor snapshot. Next: index first local declarations and exact statement-order boundaries per container/virtual section. Preserve the nearest-container rule, export wrappers, first-match ordering, and original scanner on allocation failure. Focused differential and OOM tests pass; full checker/release validation is running. Inputs and compiler pins remain unchanged.

Pushed 3c6f4e6: local declaration indexing with exact first-match/statement-boundary/virtual-section semantics and scanner fallback on OOM. All 4,203 checker tests, release build, 18 positive projects, and 13 negative controls per compiler pass. Alternating preserved member-fact-only/new binaries after 3 warmups: large 740.15 ± 51.21 → 632.05 ± 22.70 ms (10 samples each); small 83.09 ± 20.83 → 84.58 ± 26.97 ms (30 each). Small is noisy and does not show improvement; retained all samples including 206.09 ms on new binary. Unrelated concurrent workstation jobs observed. Frozen small/large SHA-256s unchanged. Full 18-workload 30-run round-robin snapshot is now running with TS 6.0.3 and native TS 7.0.2. Issue remains open; further profiled costs include knownTypeDisplayName scans and relation-cache pressure.

Published the complete snapshot in e3bd826 (measured 3c6f4e6), raw ID 20260827T172600Z. Large predicates: Home 592.0 ± 14.6 ms, native TS 7.0.2 377.6 ± 18.3 ms, JS TS 6.0.3 1105.1 ± 100.4 ms: still 1.57× slower, down from the prior 2.24× loss. Both README and docs/docs/TS_PERFORMANCE.md show the loss explicitly and retain the earlier snapshot. 17/18 lower Home means overall. Verified both tables against all 1620 successful timing samples; 30 unfiltered interleaved rounds after 3 warmups. All 4,203 checker tests, 18 shared positive projects, and 13 negative controls per compiler pass; input hashes unchanged. Small predicates are noisy (74.1 ± 27.2 vs 91.7 ± 47.2 ms), so no robust margin claim. Issue remains OPEN. Next profile targets are the knownTypeDisplayName full type-name scan and relation-cache pressure; any absence index must preserve rebinding/alias witnesses and allocation-failure fallback.

Fresh profile of the current 3c6f4e6 release on the frozen large workload still shows knownTypeDisplayName as a remaining hotspot (36 sampled leaves). The exact-ID fallback scans every type name even for never-registered anonymous types. Implementing a monotonic registered-TypeId set maintained at the single type-name registration path. A missing ID proves the scan cannot match; present/obsolete IDs still run the original scan. Do not substitute the existing reverse map: rebinding its selected alias can remove that witness while another name still refers to the same type. Preserve alias/class/structural-name precedence, source-reset lifetime, and conservative fallback after allocation failure. Corpus and compiler pins remain unchanged.

Confirmed a second general scaling cause with a deterministic FIFO-map churn diagnostic using the production capacities and packed relation-key shape. After 16×capacity unique inserts with half-cache eviction, the 4096-entry cache has 8192 slots: 4096 live, 4096 tombstones, zero free slots. The 16384-entry cache has only one free slot out of 32768. Missing-key probes can therefore traverse nearly the entire backing table. Zig provides allocation-free in-place rehash for exactly this repeated insert/delete pattern. Rehashing after each existing half-eviction keeps identical live entries/FIFO order and restores 4096/16384 free slots. Plan: apply this at both cache eviction boundaries, retain result/pending/promotion semantics, and test repeated churn plus overwrite/FIFO behavior. This is cache maintenance, not capacity tuning or a benchmark-specific path.

Pushed 403482530 after all 4,206 checker tests, release build, 18 shared positive projects, and 13 negative controls per compiler passed. Alternating preserved before/after binaries (3 warmups) gave small 73.89 ± 15.23 vs 74.79 ± 20.16 ms (30 each), large 679.77 ± 165.58 vs 556.70 ± 27.55 ms (10 each). Retain all noisy observations, including 1128.47 ms old-large and 155.18 ms new-small; no small improvement claim. The cache-churn regression has now failed on the old implementation and passed with in-place rehashing. It checks both levels over 512 insertions, all retained/evicted result values, pending markers, overwrite/FIFO behavior, tombstone reclamation, and zero allocations after capacity reservation. Full checker/release validation of cache maintenance is running before timing.

Pushed 8187216 after 4,207/4,207 checker tests, release build, all 18 positive workloads, and all 13 negative controls per compiler passed. Isolated cache-maintenance timing is noisy and NOT a demonstrated win: small 112.81 ± 19.02 → 114.80 ± 29.86 ms (30 each), large 940.16 ± 112.91 → 1009.84 ± 243.44 ms (10 each), with 3 warmups. All samples retained, including 225.53 ms small and 1537.53 ms large after-change observations. Substantial unrelated builds/tests were active. The deterministic regression proves tombstone reclamation with unchanged results/FIFO and no allocations, not end-to-end speedup. Capturing the post-change scaling profile and then the full 18-workload round-robin snapshot; will report all rows, not infer improvement from the cache invariant alone.

Published full snapshot 20260827T174752Z in 311cf8b, measured at 8187216. Home large predicates: 557.5 ± 157.8 ms; native TS 7.0.2: 380.1 ± 23.4 ms; JS TS 6.0.3: 1152.4 ± 255.2 ms. Still a 1.47× loss, with substantial variance. Overall 17/18 lower Home means. Both README and docs tables mechanically match all 1620 successful samples; 30 unfiltered round-robin runs after 3 warmups, fixed source hashes and all 13 negative controls per compiler. Full checker passes 4,207/4,207. Docs retain every prior loss and the isolated cache comparison that did NOT show an improvement. Post-change 8192-family diagnostic profile now leads with objectTypesSameDisplayShape (390 sampled leaves) and string comparisons (338); exact-name scans/cache probes no longer lead. Keep this issue OPEN. Next investigate named-shape candidate rejection/indexing while preserving duplicate-member asymmetry, member order, class preference, name-selection order, rebinding, and OOM fallback. Profiles identify work; they do not substitute for matched timing.

Next optimization design: upgrade the existing necessary-member-fact set into candidate buckets backed by a contiguous list. For a query, choose the smallest bucket among all its member facts; every valid match must be in that bucket, including asymmetric duplicate-member matches. Validate current name→TypeId bindings and class preference, then retain the original full shape comparison. Return directly only for a unique matching name; if multiple distinct names match, use the original type-name table scan to preserve diagnostic-name selection order. Obsolete bindings and hash collisions only add rejected candidates. Registration allocation failure disables the index and retains the original scanner. No source/config/gate changes. Testing will cover candidate completeness, ambiguous names, duplicate members, rebinding, source lifetime, collisions, and partial-allocation fallback.

Candidate-bucket implementation passes eight focused tests. It preserves the original asymmetric duplicate-member comparison, excludes exact-self TypeIds, validates live name bindings/class preference, and only bypasses table order for a unique matching name. Differential tests compare indexed and original scans across rebinding, source resets, member permutations/duplicates, and table growth with multiple matching names. Forced bucket collisions still require full equality; allocation failures in both the bucket map and contiguous candidate list disable indexing and retain the scanner. Full checker tests and ReleaseFast build are running; no benchmark inputs or flags changed.

Pushed 4fccb47 after 4,209 passing checker tests and all benchmark correctness gates. Alternating before/after: small 78.63 ± 16.01 → 80.22 ± 21.36 ms (30 samples each), large 547.59 ± 51.70 → 535.67 ± 38.06 ms (10 each), after 3 warmups. Retained every sample; this modest large difference is not a robust timing claim. Fresh 8192-family profile no longer lists named-shape comparison among leading leaves; string comparison leads (420), and isBuiltinName appears repeatedly as its caller (49 direct leaves). Next: replace the fixed builtin-name linear scan with a compile-time string set, preserving the exact spelling list, case sensitivity, special names, and source-dependent ITextWriter behavior. No benchmark input changes.

Builtin-name static lookup passes focused tests. Mechanically verified the original 308 list entries (266 distinct spellings, comments excluded) are unchanged. The lookup table is compile-time/static; no runtime allocation or source-specific cache was added. Tests cover every entry, prefixed/suffixed misses, case variants, empty/non-ASCII names, and unchanged ITextWriter/Iterator/fetch/Image behavior across source resets and @lib directives. Full checker and release builds are running before the before/after and full competitor measurements.

Pushed 5a537e0 after 4,211/4,211 checker tests, ReleaseFast build, 18 positive projects, and 13 negative controls per compiler passed. Isolated static-builtin lookup comparison after 3 warmups: small 74.68 ± 5.84 → 69.55 ± 5.19 ms (30 each); large 550.26 ± 33.58 → 501.64 ± 11.87 ms (10 each). All observations retained. Full 18-workload, 30-run round-robin TS 6.0.3/native TS 7.0.2 snapshot is now running. Candidate indexing and builtin lookup are separate commits with separate validation and development timings. Large scaling is not yet resolved.

Published full snapshot 20260827T181303Z in a7867e5, measured at 5a537e0. Large predicates: Home 549.4 ± 87.3 ms, native TS 7.0.2 460.4 ± 126.6 ms, JS TS 6.0.3 1369.6 ± 302.2 ms: still 1.19× slower. Overall 17/18 lower Home means. All 1620 samples succeeded; both tables mechanically match raw data; 30 unfiltered round-robin samples after 3 warmups, frozen predicate hashes unchanged, 18 positive projects and 13 negative controls per compiler pass. Full checker 4,211/4,211. High variance and unrelated workstation activity are explicit; the smaller ratio is not a stable cross-session speedup claim. Separate candidate-index and builtin-map timings, including the higher small mean in the candidate comparison, remain documented. Post-builtin profile attributes 294 string-equality samples to substring searches; first non-memory callers include Checker.setSource (68), ts_driver.compileSource (63), Checker.checkSourceFile (28), program collection passes, and directive queries. Next investigate repeated whole-source searches/shared source facts while preserving exact substring and directive-selection semantics. Issue stays OPEN.

Investigating the repeated whole-source scans identified in the last profile. Checker.setSource currently makes separate exact substring searches for filename markers, declarations, imports, namespaces, classes/enums, prototype use, and modifiers. Plan: collect the first occurrence of a fixed set of byte patterns in one allocation-free compiled automaton pass, then reuse those facts for setup and directive-presence queries. Keep exact substring behavior (including comments/strings and overlapping markers); identifier boundaries and directive-value/case/first-occurrence rules still use their existing parsers. Differential tests will compare every indexed result to std.mem.indexOf, including overlaps, EOF, non-ASCII bytes, and generated byte strings. Start with checker integration and measure before widening reuse to driver/program paths.

Pushed b1fe7c9 (perf(ts): share exact source marker searches). An allocation-free compiled byte automaton collects first positions once; setup and selected directive queries reuse them without changing comments/string matching, require identifier boundaries, directive casing/first-match precedence, or source reset semantics. Differential tests cover overlaps, arbitrary bytes, every feature flag, and directive quirks. All 4,216 checker tests, the release build, 18 shared projects, and 13 negative controls per compiler pass. Alternating preserved binaries after three warmups: small 76.87 ± 8.88 -> 72.92 ± 9.33 ms (30 each); large 522.19 ± 26.59 -> 511.00 ± 59.31 ms (10 each). All samples retained, including the new-binary 667.54 ms large sample; these noisy differences do not establish a robust speedup. Starting the full 18-workload, 30-round TS 6.0.3 / native TS 7.0.2 comparison now. Issue remains open.

Full result published in e1a9e8f: snapshot 20260827T183613Z at b1fe7c9 retains all 30 interleaved samples after three warmups. Large predicates: Home 491.0 ± 54.1 ms, native TS 7.0.2 430.2 ± 40.9 ms, TS 6.0.3 1278.3 ± 203.3 ms, still 1.14x slower than the faster competitor. Suite: 17/18 lower Home means. All 1620 samples succeeded; raw-table correspondence, balanced order, exact versions, and unchanged predicate hashes verified. Full 4216 checker tests plus all 18 positive projects/13 negative controls per compiler pass. No samples discarded, and cross-session variance prevents attributing the changed ratio solely to this optimization.

A separate same-generator 8192-family diagnostic profile attributes 151 of 188 string-equality samples to substring searches. Recurring callers include checker/driver setup, program namespace/interface/class collection, and source-based self-assignment checks. These are attribution counts, not speedups or an added benchmark. Next investigate sharing immutable source facts across driver/program collection and the remaining repeated prefix searches while preserving parser/directive rules and update lifetimes. Issue stays open.

Next driver optimization: the post-source-marker profile attributes 32 scalar-search samples to compilerOptionDirectiveValue, 14 to directiveBool, six to directiveValue, and three to JSX directive detection. These parsers repeatedly split entire sources into lines although every accepted directive requires @. Implementing an allocation-free candidate-line iterator that jumps to the next @ with byte search and returns its complete original line once. Existing directive parsing, first-@-per-line behavior, casing, whitespace, precedence, and malformed-line handling stay unchanged. Differential tests will compare its returned slices against splitScalar filtered for @, including arbitrary bytes and newline edge cases. Program fact sharing remains a separate profiled target.

The candidate-line iterator passes all 173 driver tests and five benchmark-harness tests. The release build and all 18 shared projects plus 13 negative controls per compiler pass; predicate hashes are unchanged. Alternating preserved binaries after three warmups measured small predicates at 57.39 ± 3.51 -> 54.55 ± 3.26 ms (30 samples each), large at 461.76 ± 56.34 -> 426.87 ± 25.74 ms (10 each). All observations are retained, including the 613.49 ms baseline large sample; variance/outliers limit the strength of the end-to-end inference. Starting the full 30-round TS 6.0.3 versus native TS 7.0.2 comparison next. No benchmark inputs or compiler options changed.

Published 6a78f4e after f18dd56 (candidate directive-line iteration). Full snapshot 20260827T185149Z retains all 30 interleaved samples after three warmups: large predicates Home 399.7 ± 25.6 ms, native TS 7.0.2 338.0 ± 16.1 ms, TS 6.0.3 969.2 ± 31.0 ms, still 1.18x slower than the faster competitor. Suite: 17/18 lower Home means. All 1620 samples succeeded; both tables, exact versions, balanced ordering, and frozen hashes verified. All shared-project/negative controls, 173 driver tests, and five harness tests pass; unchanged checker gate passes from cache. No samples dropped. Cross-session absolute decreases do not isolate this commit effect.

The post-run 8192-family diagnostic profile has only five scalar-search samples under the three changed value/boolean parsers. Program/source-prefix scans still recur. Raw builtin lowering has 109 inclusive samples, with leading entries at the fixed Function signature construction (check.zig around 81926/81928). predicateTargetIsFunctionObject reconstructs that same builtin on predicate-target comparisons. Next investigate reusing successful immutable Function shape construction, preserving rest_signatures metadata, checker/interner lifetime, and OOM behavior. Then reassess program collection and self-conditional-assignment prefix scans. This issue stays open.

Auditing the next hotspot exposed an identity constraint: internObjectType deliberately bypasses deduplication, and predicateTargetIsFunctionObject compares TypeIds. Caching the entire Function object would change those identity-based checks. Before choosing the reuse boundary, checking actual Function predicate behavior against pinned TS 6/7, and auditing metadata/interned-component lifetimes. No whole-object cache will be accepted merely because it improves timings; semantic equivalence or a separately justified correctness fix must be demonstrated.

The audited implementation now reuses only the fixed Function member recipe (private any[] and two rest signatures) while allocating a fresh outer Function object on every call. This preserves the deliberate object-identity behavior. Cache publication occurs only after full successful construction, and cache lifetime matches the interner/rest-signature metadata, not source text. Added structural equivalence, distinct outer IDs, metadata/source-reset, and cold/warm allocation-failure sweeps with recovery and leak checks. Separately recorded the pre-existing direct/aliased Function predicate discrepancy in #467; the empty versus callable declared global shape matters, so whole-object caching is not being used as a shortcut.

Commit b5b5bd9 reuses the immutable builtin Function member recipe (private any[] and two rest signatures) while retaining a fresh outer object per request. All 4,219 checker tests, 173 driver tests, five harness tests, 18 positive projects, and 13 negative controls per compiler pass. Allocation-failure sweeps cover cold and cached construction, recovery, and leak checks. Frozen source hashes remain unchanged. Alternating preserved binaries after three warmups: large predicates 387.24 ± 4.63 ms before vs 361.42 ± 7.86 ms after (10 each). Small predicates 59.61 ± 25.74 vs 58.96 ± 33.74 ms (30 each), with retained outliers up to 168.10/222.29 ms: no clear small-case mean improvement claimed. Full 30-run interleaved TS 6.0.3 / native TS 7.0.2 comparison is running; results will be published without filtering. The #467 semantic discrepancy remains unchanged and open.

Published the complete snapshot 20260827T191750Z in f65df92 after optimization b5b5bd9, both pushed to origin/main. All 30 interleaved samples after three warmups are retained for every workload: 17/18 lower Home means. Large predicates: Home 379.3 ± 15.8 ms, native TS 7.0.2 356.0 ± 20.1 ms, JS TS 6.0.3 1012.4 ± 56.3 ms; the loss remains 1.07×, so this issue stays open. Small predicates: Home 47.4 ± 0.9 vs native TS 69.5 ± 2.3 ms (1.47× lead). Verified all 1,620 successful timed samples, 540 complete balanced rounds, exact compiler versions, both complete tables, and unchanged predicate hashes. All positive projects/negative controls pass. README and docs retain the loss and variance; no samples were filtered. The separate post-run 8,192-family diagnostic profile records 28 inclusive raw-builtin-lowering samples; source-prefix and program collection scans remain targets. These profile counts are not speedup measurements. Next: investigate general collection/prefix reuse with visibility and source-update tests; #467 remains a separate open semantic correction. Results: https://github.com/home-lang/home/blob/main/docs/docs/TS_PERFORMANCE.md

Next profile-guided change: sourceHasDirectSelfConditionalAssignmentBeforeUse spends recurring samples searching identifier text in the preceding semicolon-delimited segment before testing for a conditional RHS. A literal question-mark byte is a necessary condition for the existing helper to return true. I will add an exact shared-source absence gate plus a preceding-segment gate, preserving the complete existing RHS and boundary checks. Differential tests will compare against the unoptimized scanner over every use offset, comments/strings, punctuation, repeated assignment candidates, and source replacement. No benchmark input, compiler flags, or type-checking rules will change.

The conditional-assignment absence filters pass all 4,221 checker tests, 173 driver tests, five harness tests, the release build, all 18 positive projects, and all 13 negative controls per compiler. Both frozen predicate hashes are unchanged. Two new regressions compare the original scanner with the optimized helper across every offset (including beyond EOF), generated bytes, comments/strings, identifier boundaries, assignment lookalikes, marker-cache fallback, and source replacement. Alternating old/new binaries after three warmups: small predicates 49.30 ± 0.32 vs 45.39 ± 0.37 ms (30 each); large 415.61 ± 44.11 vs 375.56 ± 46.66 ms (10 each, including a retained 500.35 ms candidate sample); control flow 36.30 ± 2.84 vs 35.45 ± 0.83 ms (30 each). Full interleaved comparison is running. The lower large-case mean is encouraging but noisy; no samples will be filtered and the full loss/win will be published.

Published snapshot 20260827T193257Z in 1ec7cfd after optimization dad87a6, all pushed to origin/main. Large predicates now measure Home 326.0 ± 10.0 ms vs native TS 7.0.2 326.6 ± 8.3 ms (JS TS 6.0.3 956.6 ± 37.9 ms). Home has the lower mean by only 0.2%; medians are 323.18/324.02 ms. This is a near tie, not a convincing win, so #457 stays open. Small predicates: 42.8 ± 1.7 vs 68.4 ± 2.0 ms, a 1.60× mean lead. All 18 Home means are lower, but no all-benchmark-leadership claim is made. All 1,620 samples are retained; 540 complete balanced rounds, exact compiler versions, both tables, and frozen hashes are verified. All 4,221 checker tests, 173 driver tests, 10 harness/report tests, and positive/negative workload controls pass. Commit 999258e labels ratios rounding to 1.00× as near ties symmetrically; it changes presentation only and is not a significance test. Post-run diagnostic profiling records only two inclusive samples in the changed helper; remaining repeated program collection/source searches are next, with source replacement, redirects, and visibility audited before reuse. Full results: https://github.com/home-lang/home/blob/main/docs/docs/TS_PERFORMANCE.md

Program-source audit selected exact byte-marker reuse for the existing collection prefilters (namespace/module/global/declare/interface/class/export/exports/=). Facts will be rebuilt at each serial, streaming, or parallel compilation entry and cleared on all exits; redirected files remain skipped before reading source, and private collector calls without a snapshot retain original byte searches. This avoids retaining stale facts across compiles or public source replacement. No collection parser, visibility rule, benchmark input, or compiler option will change. Separate pre-existing updateSource allocation/redirect-borrow risks have been filed for dedicated correctness work.

The transient program-source marker implementation now passes all 99 program tests, including four new regressions: exact first-position equivalence on generated byte inputs; identical nonempty collection metadata with/without snapshots for namespaces, function expandos, interface augmentations, classes, ambient interfaces, and CommonJS; source replacement and redirect exclusion; and snapshot cleanup after successful or allocation-failing serial/streaming/parallel entry points. Driver 173/173 and harness/report 10/10 also pass. Full checker/release gates are still running. This reuses the existing matcher implementation and changes 19 existing byte prechecks only; parsers and collected metadata remain unchanged. Separate source-update atomicity/redirect-borrow audit is #472, not claimed fixed here.

Committed/pushed d330198: exact program-source marker snapshots replace 19 repeated byte prechecks while preserving collection parsers and output. All 99 program, 4,221 checker, 173 driver, and 10 harness/report tests pass; the final ReleaseFast build and all 18 positive projects plus 13 negative controls per compiler pass. Frozen predicate hashes unchanged. Alternating preserved binaries after three warmups: small predicates 46.73 ± 6.07 vs 43.23 ± 0.75 ms (30 each; baseline max 77.06 retained), large 355.52 ± 21.14 vs 332.16 ± 7.11 ms (10 each; baseline max 413.82 retained), many-files 32.21 ± 1.53 vs 30.88 ± 1.35 ms (30 each). Full interleaved TS 6.0.3/native TS 7.0.2 comparison is running. The byte snapshots do not add an allocation path; source-update risks in #472 remain separate and open.

Closing the scoped large-predicate scaling gap after auditing the original issue requirements. The original 256-family project and separate 2,048-family generator/configuration are unchanged; the accepted large SHA-256 still matches this issue. All three pinned compilers accept the same projects and reject the guard/assertion negative controls. The full 18-workload snapshot 20260827T195539Z retains all 30 interleaved rounds after three warmups: 18/18 lower Home means, large predicates Home 323.8 ± 10.2 ms vs native TS 7.0.2 351.4 ± 15.2 ms (1.09× lead). The predeclared independent confirmation 20260827T200026Z records 327.1 ± 10.4 vs 359.7 ± 14.2 ms (1.10×). Home is faster in 29/30 and 30/30 paired large-case rounds. All 1,710 samples are retained; 540 full-suite rounds and 30 confirmation rounds, exact versions, balanced order, tables, hashes, and release binary were verified. All 99 program, 4,221 checker, 173 driver, and 16 harness/report tests pass. Commits d330198, d8e32bd, and 20084a4 are pushed to origin/main as Chris Breuer, without coauthors. README and detailed docs publish every workload, the confirmation separately, and the earlier losses/near tie: https://github.com/home-lang/home/blob/main/docs/docs/TS_PERFORMANCE.md . This closes this frozen local scaling case only; #416 remains open for expanded coverage, #473 async/await coverage is next, and #467/#472/#464 remain unresolved.