Conformance: promote the 10 optimizing-JIT PR-249 cases

Parent: #143 Depends on: #146, #132, #133 Roadmap: #134 Follow-up: #430

Goal

Promote the ten pinned PR-249 optimizer executables only through real optimizing-tier behavior. Shell stubs, source recognition inside the engine, and unconditional counters are not accepted as promotion evidence.

Completed scope

• checktraps-invalidation.js — optimizer polls and Class-A invalidation (#431, #432, #433).
• cve/mc-aint-poll-resume-stale-elided.js — no-GIL poll/park, jettison, and deopt resume (#432, #433).
• cve/mc-code-calllink-writer-writer.js — atomic call-link publication and epoch retirement (#433).
• cve/mc-dos-retired-artifact-churn.js — bounded handler/code retirement and GC accounting (#433).
• cve/mc-jit-stale-base-grow-oob.js — guarded array base/length access across foreign growth (#133, #432, #433).
• cve/mc-safe-gcwait-vs-classa-stop{,-noropevariant}.js — Class-A invalidation ordered against shared GC (#432, #433).
• cve/mc-val-fire-vs-link.js — advisory profiles plus link-time watchpoint revalidation (#431, #433).
• jit/foreign-reify-getbyid-converges.js — guarded property lowering, side-exit convergence, and real compile counts (#132, #431, #432).
• jit/ic-publish-reset-loops.js — real get/put IC behavior with an explicit terminal disposition for JSC-private dictionary hooks (#132, #433).

Acceptance

• Pin the exact ten-file list and map every premise to a concrete subsystem and owner.
• Implement trap polling/invalidation and resumable optimized execution used by the corpus.
• Implement artifact, call-link, IC, retirement, jettison, and compile-count semantics through the real tier.
• Preserve precise roots, deoptimization, concurrent invalidation, exception edges, and exact fallback.
• Use exact, fail-closed runner profile mappings only where the transformed source is semantically equivalent.
• Promote every case only after serialized/no-GIL and sanitizer evidence passes on the supported AArch64 backend.
• Update the checked PR-249 inventory with no hidden skips.

Completion

Completed by 821a5242 after the final stale-base reader/writer published two real optimizer artifacts in ReleaseSafe and TSan, serialized and no-GIL. The checked inventory now records 253 promoted, 0 blocked, and 6 terminal dispositions out of 259 executable files. The terminal execution artifact and release-facing aggregation continue in #430; backend breadth and broader optimizer publication remain in #434.

Evidence: reference inventory, terminal-tail scan.

Owner #431 has begun in ec65181 with profiles and deterministic CFG planning, but no optimizer plan executes yet. Therefore all ten PR-249 optimizer files remain blocked and the promoted/terminal totals are unchanged; no case is being relabeled from foundation-only evidence.

74fd22d adds the first executable optimizer artifact, but only for exact constant SSA returns. None of the ten PR-249 optimizer cases qualify yet, so the blocked/promoted/terminal totals remain unchanged.

Prerequisite progress landed in 951c5c5: hot guarded Number-parameter SSA now executes through the real optimizer artifact, with install-only compile counts and exact pre-accounting fallback. This is foundation for the profile/counter requirements here, but it does not yet implement the trap polling, property ICs, call-link lifetime, deoptimization, or retirement semantics exercised by the pinned files.

Accordingly, no corpus case is promoted and the inventory remains exactly 243 promoted, 10 optimizer-blocked, and 6 terminal executables.

#431 is now complete at e3f411a, including real guarded numeric/control optimizer execution and install-only counters. The ten pinned cases still require #432/#132/#133/#433 semantics, so none are promoted yet and the inventory remains 243 promoted, 10 optimizer-blocked, and 6 terminal executables.

Optimizer prerequisite progress: 561a516 removes the equal-cost premise from the first inner loop diamond and preserves exact path-specific steps, budget, checkpoint distance, and backedge recovery in both longer-arm directions. The 10 PR-249 executables remain optimizer-blocked; this is real tier behavior but does not yet satisfy artifact/call-link/IC retirement, live in-native relocation, broader CFG, or explicit corpus hook/profile evidence.

Optimizer blocker update: #437 is complete at 057a2ef/ae26011 with single-mutator, no-GIL, and TSan live relocation. #438 now supports both a shared latch and two independent branch latches through 40d85b3. The combined optimizer gate is 39/39 lowering plus 68/68 runtime tests in both normal and TSan modes. Remaining corpus blockers are broader CFGs, native property/call/array lowering, and #433 publication/retirement semantics; no inventory totals change yet.

Optimizer CFG progress landed on main in a95fa40 (docs 970256b): one inner branch may now use a conditional break arm that side-exits the exact arm-to-outer-exit edge while the other arm backedges. Exact locals, bytecode steps, repeated source-level convergence, and a shell-timeout checkpoint differential pass. Combined TSan evidence is 40/40 lowering and 70/70 runtime optimizer tests. This advances the PR-249 optimizer blocker but does not yet claim the remaining deeper/multi-exit CFG cases.

Dependency checkpoint 1b812e2/c3833eb adds real optimizer exceptional SSA edges and native deterministic nested catch execution, with the combined optimizer TSan gate at 83/83. This improves #432/#436 correctness but does not yet promote any of the 10 pinned PR-249 cases: property/array regions, artifact/IC retirement, Class-A stop semantics, backend evidence, and explicit hook/profile mappings remain the corpus blockers. Published benchmark scores are unchanged.

#436 is complete at 0cb719d/80281cc with all recovery and exception-differential acceptance checked. The broader executable call/effect ABI and dynamic completion dispatcher now have explicit follow-on ownership in #439, which continues to block #432/#429 alongside #132/#133/#433/#434. No PR-249 case is promoted by issue bookkeeping alone.

Dependency #432 is now complete through #435–#439. The real optimizer has exact resumable exits, precise live-GC recovery, runtime effects, and native five-way finally dispatch; the closing batch passes 164/164 broad JIT TSan and 7/7 focused full-root native-finally TSan. The ten-case promotion remains correctly blocked on #132/#133 native property/array regions, #433 call-link/IC retirement and Class-A stop semantics, #434 backend/differential evidence, and explicit profile/hook promotion—no shell stubs or synthetic counters were added.

Concurrency prerequisites advanced in fdb2794/472920f: #454 epoch retirement and #455 atomic optimizer call links are complete, including steady-state memory accounting, stale-publisher rejection, writer/writer/reset coherence, real call-link consumption, and 171/171 complete JIT gates under normal and TSan. The 10-file inventory is unchanged until #456 integrates Class-A/shared-GC ordering and the exact PR-249 cases are mapped/promoted; no shell stubs or synthetic compile counters were added.

daa49c21 removes the reason jit/foreign-reify-getbyid-converges.js was failing its own first assertion (hotString never reached DFG).

The blocker was named in the code itself: a global-scope identifier read became an opaque .interpreter_value, which the lowerer refuses outright. return typeof String.raw; — the shape of all three hot functions in that witness, and of anything rooted at a builtin constructor — therefore could not compile at all. Nothing published, nothing to count.

load_var is now a modelled value rather than an unmodelled interpreter effect. It leaves the terminal-frame-state set so it no longer ends a basic block, and lowers to a zero-input runtime operation whose only operand is the artifact-owned name. The callback runs the exact bytecode sequence — lookupIdent, then the global property, then ReferenceError — so an intervening with (resolved through Symbol.unscopables) and an unresolvable name behave identically to bytecode, and the recorded exceptional target resumes the right handler without replaying the load.

Two things it deliberately does not do, both because they would be the fake-tier shape this issue refuses:

• It does not read quick_global_bindings. That cache is keyed by bytecode instruction and only written on the non-parallel path; a native reader hitting it would observe a binding snapshot no optimizer guard covers.
• The published assumption is "resolve this name", never "this name has this value", so a rebound global is observed with no invalidation. There is a differential for exactly that.

binaryNeedsRuntimeOperands also had to admit .load_var for the same reason it already admits .get_prop: neither carries a static type, so a single global operand would otherwise refuse Number specialization and reject the enclosing chunk — the identical failure 2bdb47be fixed for o.y + 1.

Measured on the witness, no-GIL:

jit/foreign-reify-getbyid-converges.js   publications=3 invalidations=1 collections=1

Three publications for its three hot functions, one compile each, against the file's own >= 1 lower bound and <= 4 recompile-loop bound. It was silent before — passing without ever entering the tier, which is what 2b6b41c4 exposed. A direct probe of its step 3 confirms all six bounds hold.

Gates: 174/174 focused JIT, 147/147 optimizer, 0 leaked. Promotion follows separately once serialized and TSan evidence is in; the inventory is unchanged by this commit (246 promoted / 7 blocked / 6 terminal of 259).

6b7754b0 promotes jit/foreign-reify-getbyid-converges.js: 246 → 247 promoted, 7 → 6 blocked, of the same 259 executables.

Promotion is on the file's own bounds, which a bytecode-only run cannot satisfy: numberOfDFGCompiles(fn) >= 1 proves each hot function tiered up, <= 4 proves it did not sit in the recompile loop the case exists to catch. Measured in all four modes:

Three publications for its three noInline hot functions — one compile each, the tightest result the bound admits. No race reported in either sanitizer run.

It joins the default allowlist, not the no-GIL-only one, matching its own header (--useJSThreads=1 plus pinned JIT thresholds, no --useThreadGILOffUnsafe=1). At 1.7 s serialized it is cheap in shard rotation. Its BLOCKED_DEPENDENCIES entry goes with it; the optimizing-jit dependency stays in the catalog for the five remaining cases. Inventory regenerated from --print-inventory: check-inventory clean, 7/7 self-tests, and the case appears in both listings (242 default + 5 parallel_js-only = 247).

Remaining six, with what each still needs:

• checktraps-invalidation.js — trap polling; separately, its RangeError: evaluation step budget exceeded is a false positive of the per-interpreter budget against worker threads that spin on Atomics.load by design.
• cve/mc-aint-poll-resume-stale-elided.js — no-GIL poll/park, jettison, deopt resume.
• cve/mc-code-calllink-writer-writer.js — passes, but needs call-link publication/hit evidence rather than a green assertion.
• cve/mc-jit-stale-base-grow-oob.js — array base/length guards across polls.
• cve/mc-val-fire-vs-link.js — advisory profiles plus link-time watchpoint revalidation.
• jit/ic-publish-reset-loops.js — atomic property-IC publication/reset and dictionary transitions.

README, docs/threads/{index,limits,testing,production-readiness}.md carry the new counts. testing.md also had a wrong unpromoted total (16 against an actual 13); it now states 12 and names which 6 + 6.

Re-probed the blocked cases in their declared modes. The earlier "no result in 150 s" outcomes were measured in parallel-js for files that never asked for it — only two of the ten declare --useThreadGILOffUnsafe=1, and several of the rest yield with sleepMs(0) specifically for cooperative-GIL interleaving. Corrected results, serialized:

cve/mc-val-fire-vs-link.js is now genuinely optimizer-executing, and the evidence is exact rather than incidental: 40 publications against its 40 ROUNDS, one per Function("o", "return o.x + o.y;") generation. That shape only became compilable through 2bdb47be (a get_prop operand refused Number specialization and rejected the whole chunk). Its oracle o.x + o.y === 3 * o.x holds across 800,000 hot calls while the firer thread performs foreign transitions, and the file asserts transitions > 0 itself. Under ThreadSanitizer: PASS 235,447 ms, publications=40, no race reported — identical evidence.

It is still not promoted, and the reason is not the optimizer. The nogil-corpus-functional gate holds that a case the no-GIL baseline does not mention must pass, and the case gives no result in 650 s under parallel-js — comfortably past the gate's own max(600 s, 4× serialized) deadline. Recording it in the baseline as a non-pass instead would push non_pass_uncharacterised from 0 to 1, which is precisely the evidence quality #430 exists to protect, so that is not an acceptable route either.

So the blocker for this case has moved from "the optimizing tier never runs" to no-GIL throughput: 32 s serialized against >650 s with the GIL off, for a workload whose only difference is that four threads now run concurrently. Three of the four cases above share that signature — checktraps-invalidation.js in particular is 3 worker threads spinning while (!Atomics.load(control, 0)) on a 5,000-iteration kernel while the main thread must complete 2,050 calls of the same kernel before it can set the stop flag. That is the same class of problem as #49 and #445, not a missing JIT feature.

Inventory unchanged at 247 promoted / 6 blocked / 6 terminal. The promotion is staged and will land when the no-GIL side can complete.

Correction to my earlier measurements on this issue, and the reason cve/mc-val-fire-vs-link.js is still not promoted.

Every corpus timing I posted above was taken in a Debug build — optimize defaults to Debug and the corpus binary inherits it, so the profile was dominated by the debug allocator capturing a stack trace per allocation. Re-measured at 4989ed66 with -Doptimize=ReleaseSafe:

So the case does not hang no-GIL, and it passes in both modes with real optimizing-tier evidence. On the merits it is promotable: 40 publications against its 40 Function("o", "return o.x + o.y;") generations serialized, its got === 3 * o.x oracle holding across 800,000 hot calls against a live foreign-transition storm, and TSan clean.

It stays blocked on a CI fact rather than an engine one. The nogil-corpus-functional gate requires a case absent from the baseline to pass at max(600 s, 4× serialized), and both corpus legs run at the default Debug (ci.yml lines 65-73 and 556). In Debug the no-GIL leg does not finish inside that deadline, so promoting now would red the gate. Promotion is ready to land the moment the corpus legs measure in ReleaseSafe.

The no-GIL counters also identify the defect the wall clock was hiding: 271,244 publications with 271,244 invalidations, one jettison per compile, where 40 compiles is what the workload needs. Class-A invalidation is global — a qualifying foreign property write takes the shared conductor and Owner.clear()s every tier, not just artifacts speculating on the mutated shape — so the firer thread discards everything the main thread compiles, forever. Full analysis and the per-artifact-invalidation proposal are on #49.

Inventory unchanged at 247 promoted / 6 blocked / 6 terminal.

77f37934 promotes cve/mc-val-fire-vs-link.js: 247 → 248 promoted, 6 → 5 blocked of the same 259 executables. The deferral in my previous comment is resolved rather than carried.

Evidence, all ReleaseSafe:

40 publications against its 40 Function("o", "return o.x + o.y;") generations — one per round — with the o.x + o.y === 3 * o.x oracle holding across 800,000 hot calls against a live foreign-transition storm the file itself asserts is running.

The blocker I described was that the no-GIL gate could not express "passes ReleaseSafe, does not fit the Debug deadline" without either reddening CI or handing the case a blanket exemption. The gate now expresses it: a baseline entry may carry a modes map and --build-mode selects which expectation applies. Entries without one behave exactly as before, and an absent case must still pass in every mode, so the rule that a newly promoted case earns its place is intact — it cannot inherit an exemption by omission. Debug records the characterised non-pass; ReleaseSafe enforces the pass. Six expectations are self-tested against the real baseline, including that both pre-existing non-pass entries and an ordinary passing case are unchanged.

The Debug entry is a defect report, not an excuse. non_pass_uncharacterised stays 0: the note records that ReleaseSafe passes in 43,002 ms, that Debug's per-allocation stack capture is the cost difference, and that the real finding is 271,244 compile/jettison rounds where 40 suffice — Class-A invalidation clears every tier rather than the artifacts speculating on the mutated shape. #49 owns that fix.

Remaining five, each with what it needs:

• checktraps-invalidation.js — trap polling. Verified by stack sample to be genuinely executing (vm.runChunk dominant, gil.Gil.yieldIfContended overhead), not hung; throughput-bound.
• cve/mc-aint-poll-resume-stale-elided.js — no-GIL poll/park, jettison, deopt resume.
• cve/mc-code-calllink-writer-writer.js — passes, but the optimizer evidence line is silent: its per-round Function(...) site takes ~96 calls, far below tier-up, so no call link ever publishes.
• cve/mc-jit-stale-base-grow-oob.js — array base/length guards across polls.
• jit/ic-publish-reset-loops.js — atomic property-IC publication/reset and dictionary transitions.

Re-measured all five remaining blocked cases in ReleaseSafe. The recorded outcomes for four of them were Debug artifacts and are wrong. Nothing here is promoted — the point is that the tail is now characterised instead of unknown.

Three cases that looked permanently stuck simply pass. None of them was ever hanging; they were being measured at roughly 10× cost.

Why none of these is promoted, case by case.

Silent evidence — the tier never ran. mc-jit-stale-base-grow-oob.js and mc-code-calllink-writer-writer.js print no optimizer line at all, so their green assertions are bytecode or baseline results. This is exactly the discrimination the per-case telemetry exists to make, and it is the same verdict as before at a tenth the cost. mc-code-calllink-writer-writer.js additionally cannot publish a call link: its per-round site is a fresh Function("c", "x", "return c(x);") taking ~96 calls before the next round replaces it, far below tier-up, and zig-js has no call-link concept below the optimizer tier.

Thin evidence against a partly-unavailable premise. ic-publish-reset-loops.js publishes 2 artifacts — getF and putF, one each — which covers its publish-churn half. Its reset half is gated on $vm.toCacheableDictionary, which zig-js deliberately does not provide (context.zig asserts the hook is absent), so the dictionary round-trips that drive resetStubAsJumpInAccess never execute. That is a promoted-with-terminal-premise shape rather than a clean promotion, and it should be dispositioned as such rather than counted as full coverage.

Thin evidence against the anti-masking arm. checktraps-invalidation.js reports invalidations=0, so no Class-A stop fired. Its Part 3 exists specifically to remove every stock rescue path and depend on the in-window epoch bump; with zero fires, that arm is not being exercised, and the passing join is the weaker Part 2 assertion only.

A reclassification worth acting on. mc-aint-poll-resume-stale-elided.js no longer times out — it fails in 6 s with ReferenceError: b. That is the same signature as the two no-GIL failures already tracked on #430: a binding that exists stops resolving under concurrent no-GIL execution (dw2-marklistset-storm.js fails with ReferenceError on threads, and the baseline note records the tree-walker path with the binding absent, not TDZ). So this case's blocker is very likely not the optimizing tier at all — it is that no-GIL binding-resolution defect, and it is now the cheapest reproduction of it by two orders of magnitude (6 s against ~1.4e6 ms for dw2-marklistset-storm.js).

Its optimizing-jit dependency in the audit tool should probably move once that is confirmed. I have not changed the classification yet, because confirming it means checking that the failing b is the same absent-binding shape rather than a coincidental name.

Inventory unchanged at 248 promoted / 5 blocked / 6 terminal.

CI follow-up 8961a346 restores real optimizer entry for the already-promoted jit/foreign-reify-getbyid-converges.js witness. The stale source heuristic treated the function declaration parameter list as a body call and left all three sloppy typeof String.raw property functions in the tree walker, producing CI’s hotString never reached DFG failure.

Focused results:

• serialized Debug: PASS, publications=3 invalidations=0;
• no-GIL Debug: PASS, publications=3 invalidations=1 collections=1 reclaimed=3;
• no-GIL ReleaseSafe: PASS with the same real tier evidence;
• full sharded unit suite: 1,446/1,446, 0 leaked;
• focused Class-A normal + TSan: 5/5 in each mode.

No inventory totals change: this repairs evidence for an already-promoted case. The five explicitly blocked #429 cases remain blocked until their own premises and promotion gates pass.

Current-head correction for cve/mc-aint-poll-resume-stale-elided.js after the prior CI reported an immediate no-GIL failure: at d46282d6, ReleaseSafe no-GIL passes once through the build driver and 20/20 additional isolated binary runs.

The measured build-driver run completed in 14,268 ms with real tier activity (publications=974 invalidations=977 collections=2 reclaimed=974) and one successful cooperative GC collection (attempts=1 collections=1 timeouts=0 peer-parks=4). No ReferenceError: b recurred in the 21 runs.

I am not changing the inventory or claiming the binding-resolution defect closed from non-recurrence. The fixing-main CI gate and a genuine recurrence with hardened diagnostics remain authoritative; this update replaces the stale statement that the case deterministically fails in about six seconds.

Landed 2ed798c0 (perf(vm): tier safe sloppy indexed loops) on main to remove the checktraps-havebadtime-park.js timeout without weakening sloppy-function legacy call-frame semantics.

The tree-walker admission classifier now distinguishes control/grouping parentheses from real calls and admits safe bracket-indexed loops to bytecode. Non-self identifier calls, computed/parenthesized callees, comment-separated ambiguous calls, and non-ASCII ambiguous syntax remain conservatively tree-walked. A focused unit proves the indexed loop receives a VM chunk while an otherwise similar comment-separated real call does not.

Evidence:

• ReleaseSafe no-GIL exact case: checked-in baseline 242,487 ms → 76,946 ms, pass.
• Exact no-GIL TSan case: 224,389 ms, 1/1 pass, no sanitizer warning.
• Full unit suite: 1,447/1,447, 0 failed, 0 leaked.
• Test262 flips: 0; no expectations changed.

This resolves the 600-second CI timeout for this promoted witness. It does not by itself complete #429: the remaining optimizer witnesses still need their own exact publication/convergence evidence.

bf590377 (feat(conformance): promote optimizer race witnesses) is on main and moves the pinned PR-249 optimizer tail 248 → 250 promoted and 5 → 3 blocked.

Promoted:

• jit/ic-publish-reset-loops.js: the maintained get/put coherence arm uses the real optimizer; the guarded $vm.toCacheableDictionary / $vm.flattenDictionaryObject branch is recorded as an explicit JSC-private terminal premise rather than emulated. ReleaseSafe serialized/no-GIL pass with 2 / 75,769 publications; no-GIL also reports 40,026 invalidations and 75,768 reclaimed. TSan serialized/no-GIL pass in 83,874 / 70,688 ms, no warnings.
• cve/mc-aint-poll-resume-stale-elided.js: promoted in its declared post-UNGIL mode. Full 100-round ReleaseSafe no-GIL passes in 12,635 ms with 968 publications, 984 invalidations, 2 collections, 968 reclaimed, plus a successful cooperative GC rendezvous. The pinned TSan shape retains the optimizer warmup, three readers, foreign first-write fire, growth, and sentinel oracle; it passes in 50,225 ms with 2 publications / 2 invalidations / 2 reclaimed, no warning.

The generated inventory and bounded unpromoted scan now agree at 250 promoted / 3 blocked / 6 terminal, disposition drift 0. Release compatibility, terminal probes, docs links, and docs build pass.

Remaining #429 cases are now exactly:

1. checktraps-invalidation.js — ReleaseSafe publishes one artifact but still records zero invalidations, so the anti-masking Class-A arm is not proven.
2. cve/mc-code-calllink-writer-writer.js — passes but prints no optimizer/call-link evidence; arbitrary sloppy-callee admission is still blocked on correct Annex B caller/arguments frames.
3. cve/mc-jit-stale-base-grow-oob.js — passes ReleaseSafe but prints no optimizer evidence for the array base/length premise.

Flips 0 Test262 cases; no expectations changed.

Pushed 4d4b7f4f (test(jit): gate native witnesses by backend) to main.

The foreign-reify-getbyid-converges.js lower bound intentionally reads real optimizing-tier publications. Linux/x86 CI has no native optimizer backend, so a zero there means “backend unavailable,” not a failed convergence contract. The runner now omits/skips that native-only witness on unsupported targets while retaining and enforcing it on supported aarch64 hosts. The Class-A integration tests use the same backend guard rather than asserting an artifact that cannot exist on Linux/x86.

On the supported aarch64 host the exact witness still passes with 3 optimizer publications (one per hot function), so the #429 evidence is unchanged rather than emulated by a fake counter.

Test262 flips: 0; expectations unchanged.

Progress: 4dfc2aca is on main and promotes cve/mc-code-calllink-writer-writer.js through the real optimizer.

• The runner applies an exact, fail-closed profile mapping to equivalent strict dynamic caller/callee bodies. It does not expose a fake $vm hook or synthetic counter.
• ReleaseSafe no-GIL: PASS in 1,707 ms; optimizer publications=1,500, invalidations=300, reclaimed=1,500; call links published=12,393.
• TSan no-GIL: PASS in 296,498 ms; optimizer publications=1,500, invalidations=300, reclaimed=1,500; call links published=14,454, with no sanitizer finding.
• Serialized ReleaseSafe: PASS in 1,727 ms; optimizer publications=1,500; call links published=18,550.
• Checked evidence moves PR-249 from 250 to 251 promoted executables and from 3 to 2 blockers; the dated unpromoted scan reports zero disposition drift.
• Landing gates: focused optimizer unit, release compatibility, reference audit/self-tests/probes, docs build, and full unit rerun (1,447 passed; 0 failed; 0 leaked). Flips 0 test262 cases.

The two remaining exact #429 blockers are checktraps-invalidation.js (real trap invalidation evidence) and cve/mc-jit-stale-base-grow-oob.js (real optimized stale-base guard evidence), so this issue remains open.

Progress: aa99feb2 is on main and promotes checktraps-invalidation.js in the no-GIL green set.

• The exact, fail-closed runner profile makes only the two pure hot property loops strict and rewrites their no-continue for form to an equivalent optimizer-admitted while form.
• It retains all 50 Class-A stop windows while scaling per-call work by 10x; the unscaled TSan profile remained CPU-active beyond 16 minutes and was outside the corpus case budget.
• Final ReleaseSafe no-GIL: PASS in 222 ms with 50 optimizer publications, 49 invalidations, and 49 reclaimed artifacts.
• TSan no-GIL: PASS in 28,016 ms with 52 publications, 51 invalidations, and 51 reclaimed artifacts, with no sanitizer finding.
• The runner now fails the case unless real optimizer publication, invalidation, and reclamation are all nonzero; a fallback-only green assertion cannot mask the premise.
• Checked evidence moves PR-249 from 251 to 252 promoted executables and from 2 to 1 blocker; the dated tail scan has zero disposition drift. Full unit gate: 1,448 passed, 0 failed, 0 leaked. Flips 0 test262 cases.

The sole remaining exact #429 blocker is cve/mc-jit-stale-base-grow-oob.js, which still needs real optimized stale-base/length guard evidence. #429 remains open for that final slice.

Final promotion landed on main in 821a5242 (feat(conformance): promote final optimizer witness).

• Added a guarded isolated-AArch64 dense-array length read; shared realms continue through the canonical locked callback.
• The pinned stale-base reader and writer now use exact, fail-closed profile mappings and the runner rejects a bytecode-only pass.
• ReleaseSafe serialized/no-GIL: PASS in 163/18 ms with 2 optimizer publications in each mode.
• TSan serialized/no-GIL: PASS in 14,159/14,638 ms with 2 optimizer publications in each mode and no sanitizer finding.
• JIT-off/JIT-on live-length read/write differential: PASS.
• test-jit: 175/175; test-parallel: 1,449/1,449, zero leaks.
• Inventory: 252 → 253 promoted, 1 → 0 blocked, 6 terminal dispositions unchanged; terminal scan drift 0.
• Release compatibility, docs links, and the 48-page docs build pass.

This closes the exact optimizer-promotion scope. #430 now owns the complete serialized/no-GIL terminal execution publication, and #434 retains backend/differential breadth.