Roadmap: implement every README-declared missing runtime surface

[chrisbbreuer]

Goal

Implement every runtime and platform surface currently called out in the README's What Is Not Implemented section, with checked-in compatibility inventories and reproducible evidence, so that the section can be removed without qualification.

This is an umbrella issue. Each independently reviewable implementation slice should have its own linked child issue before substantial work begins.

Scope

1. JavaScriptCore compatibility surfaces

• Check in a versioned inventory of the public JavaScriptCore C API and implement every symbol in the declared target.
• Check in version-pinned inventories for the private framework/internal surfaces we intentionally target, then implement every inventoried entry.
• Implement and test the Objective-C bridge, including object/value conversion, exceptions, lifetimes, blocks/callables, and cross-runtime identity.
• Implement inspector/debugger APIs and protocol behavior, including attach/detach, breakpoints, stepping, evaluation, stack/scope inspection, pause/resume, and exception events.
• Define version-pinned Bun and Home private-JSC ABI compatibility profiles and implement every symbol and behavior in those profiles.
• Reject unsupported ABI versions explicitly; no silent no-ops or accidental partial compatibility.

Complete here means complete for the exact checked-in target inventories. Private ABIs are moving targets, so each supported revision must be named and auditable rather than described as universal compatibility.

2. WebAssembly

• Parser, binary decoder, validator, and deterministic malformed-module diagnostics.
• Module compilation/instantiation and JS-facing Module, Instance, Memory, Table, Global, and Function behavior.
• Imports, exports, start functions, traps, growth, bounds checks, numeric conversions, and JS/Wasm exception boundaries.
• Declare and implement the chosen post-MVP feature set (reference types, bulk memory, multi-value, SIMD, threads, exceptions, GC, etc.) in versioned feature profiles.
• Run the applicable upstream WebAssembly specification tests with an explicit zero-hidden-skip inventory for the supported profiles.

3. PR-249 reference corpus and shell hooks

• Inventory every WebAssembly/JIT shell hook used by the PR-249 reference corpus.
• Promote each relevant reference-only hook into maintained runtime functionality with tests and documentation.
• Remove or explicitly disposition every corpus exclusion; no untracked skip lists.

4. Production generational GC

• Automatic moving/compacting collection with correct root, stack-map, handle, weak-reference, and interior/reference rewriting (GC: implement moving and compacting collection #144 explicit compaction complete; GC: enable automatic compaction at shared precise safepoints #446 automatic shared safepoints open).
• Multi-age generational policy with a moving nursery and measured promotion/tenuring behavior (GC: implement multi-age generations and parallel mid-script minor collection #145 nonmoving age-three policy complete; GC: make the multi-age nursery moving #447 moving nursery open).
• Correct remembered sets and barriers across interpreter, baseline JIT, optimizing JIT, native embeddings, and concurrent host threads.
• Parallel minor collection that may safely occur mid-script, including safepoints, mutator coordination, and bounded failure recovery.
• Stress, fault-injection, leak, TSan, and long-running mutation tests covering relocation and concurrent collection.

5. Optimizing JIT

• Optimizing IR and lowering pipeline beyond the verified baseline regions tracked in JIT: lower guarded property regions into the native tier #132 and JIT: lower verified packed-array regions into the native tier #133.
• Type/value profiling, guarded speculation, deoptimization, OSR entry/exit, stack maps, exception edges, and precise GC integration (JIT: add optimizing profiles, IR, and tier publication #431, JIT: implement OSR exits, deoptimization, and precise GC #432).
• Property/shape and call inline caches with invalidation that remains correct under mutation and concurrency.
• Code lifetime management, executable-memory policy, architecture backends for every declared supported target, and interpreter/baseline fallback.
• Differential correctness testing against the interpreter plus reproducible performance evidence against JavaScriptCore.

Removal gate

The README section may be removed only when all of the following are true:

• Every checklist item above is complete or decomposed into completed linked child issues.
• A checked-in compatibility matrix names exact OS, architecture, JSC, Bun/Home ABI, WebAssembly feature, GC, and JIT targets.
• Normal, thread-heavy, no-GIL, leak, sanitizer/TSan, differential, inspector, bridge, API/ABI, WebAssembly, and JIT suites pass for the declared matrix.
• Relevant upstream/reference corpora publish machine-readable pass/fail/skip inventories, with no unexplained exclusions.
• Benchmarks and README claims are regenerated from committed artifacts and clearly distinguish correctness coverage from performance coverage.
• Unsupported hosts or revisions fail clearly at build or runtime rather than exposing partial behavior.

Related work

• Canonical: JavaScript multithreading support #1 — threads/GC roadmap
• Perf: outperform JavaScriptCore across the verified benchmark matrix #44 — performance umbrella
• Perf: remove no-GIL scaling bottlenecks in the comparison workloads #49 — no-GIL scaling
• JIT: lower guarded property regions into the native tier #132 — native guarded-property regions
• JIT: lower verified packed-array regions into the native tier #133 — native packed-array regions

Child issue map

Public and private embedding

• C API: define and enforce the complete public JavaScriptCore target inventory #135 — complete public JavaScriptCore C API inventory and verifier
  • C API: implement the JSTypedArray and ArrayBuffer embedding surface #136 — JSTypedArray and ArrayBuffer embedding surface
  • C API: implement JSClassRef definitions, callbacks, and property-name APIs #137 — JSClassRef callbacks and property-name APIs
  • C API: implement context groups, global metadata, and syntax checking #148 — context groups, global metadata, syntax checking, and inspectability
  • C API: implement UTF-16, borrowed-character, sizing, and string equality APIs #149 — UTF-16 and string completeness
  • C API: implement remaining value, BigInt, comparison, and JSON APIs #150 — remaining value/BigInt/comparison/JSON APIs
  • C API: implement remaining ordinary object constructors and property APIs #151 — remaining ordinary-object APIs
• Bridge: implement the Objective-C JavaScriptCore embedding surface #138 — Objective-C bridge
  • Bridge: pin the Objective-C API inventory and build gate #157 — pinned Objective-C inventory and build gate
  • Bridge: implement JSContext, JSVirtualMachine, and JSValue behavior #158 — JSContext, JSVirtualMachine, and JSValue behavior
  • Bridge: implement managed references, identity, and lifetime semantics #159 — managed references, identity, and lifetime semantics
    • Bridge: add collection epochs and arena reachability for managed values #161 — collection epochs and arena reachability
  • Bridge: implement JSExport, Objective-C blocks, and interop completion evidence #160 — JSExport, blocks, interop, and completion evidence
• Inspector: implement debugger and inspector protocol support #139 — inspector/debugger protocol
  • Inspector: versioned sessions, transport, and Runtime domain #152 — versioned sessions, transport, and Runtime domain
  • Inspector: pause, breakpoints, stepping, scripts, and exception control #153 — execution control, breakpoints, stepping, and exceptions
  • Inspector: call frames, scopes, workers, GC roots, and completion gate #154 — call frames, scopes, roots, isolated-worker boundary, and completion evidence
  • Inspector: register dynamic and module-generated scripts #155 — historical, dynamic eval, module, and generated-function script registration
  • Inspector: worker target discovery and cross-thread transport #156 — worker target discovery and cross-thread inspector transport
• ABI: define and implement versioned Bun and Home private-JSC profiles #140 — versioned Bun and Home private-JSC ABI profiles
  • ABI: implement the pinned Home private-JSC profile #163 — pinned Home private-JSC profile
  • ABI: implement the pinned Bun private-JSC profile #164 — pinned Bun private-JSC profile
  • ABI: implement private VM pending exceptions #180 — VM-shared pending exceptions and stable exception cells
  • ABI: implement private arrays and indexed access #181 — exact arrays and indexed access
  • ABI: implement private JSArray constructors #182 — failure-atomic packed and hole-only JSArray constructors
  • ABI: implement private ToNumber coercion #183 — full ECMAScript ToNumber coercion
  • ABI: implement private instanceof and iterator predicates #184 — JSC-exact has-instance and iterator-method predicates
  • ABI: implement private UTF-16 string inclusion #185 — ordered UTF-16 string inclusion
  • ABI: implement private class and AggregateError classification #186 — class/AggregateError classification and shared Symbol identity
  • ABI: implement private Date parsing and ISO formatting #187 — exact Date parsing, UTC extraction, and ISO buffer formatting
  • ABI: implement private Object keys and values #188 — exact private Object.keys/Object.values reflection
  • ABI: implement private Promise creation, downcasts, and wrapping #189 — private Promise creation, downcasts, and wrapping
  • ABI: audit Home private profile revision 4389ddee #190 — explicit Home private profile alias for revision 4389ddee
  • ABI: implement the Home private JSMap boundary #191 — exact Home private JSMap boundary
  • ABI: implement exact FFI 64-bit slow conversions #192 — exact FFI signed/unsigned 64-bit slow conversions
  • ABI: exclude consumer-generated JSFunctionCall from private imports #193 — exclude consumer-generated JSFunctionCall from private imports
  • ABI: implement exact CommonAbortReason DOMException conversion #194 — exact CommonAbortReason DOMException conversion
  • ABI: return owned BunString values for private BigInt conversion #195 — owned BunString BigInt decimal conversion
  • ABI: convert BunString values and arrays into native JS cells #196 — BunString value, transfer, length, and array conversion
  • ABI: construct selected-realm Error instances from ZigString #197 — ZigString Error/TypeError/RangeError/SyntaxError construction
  • ABI: implement the complete ZigString DOMException code matrix #198 — complete ZigString DOMException code matrix
  • ABI: implement copied, atomic, and rope string construction #199 — copied, atomic, and rope string construction
  • ABI: implement stable borrowed ZigString output views #200 — stable borrowed ZigString output views
  • ABI: implement ZigString and BunString error factories #201 — ZigString and BunString error factories
  • ABI: implement exact AggregateError construction and access #202 — exact AggregateError construction and access
  • ABI: implement exact private property access and mutation #203 — exact private property access and mutation
  • ABI: implement exact fast built-in property reads #204 — exact fast built-in property reads
  • ABI: implement exact Symbol registry and description bridges #205 — exact Symbol registry and description bridges
  • ABI: implement exception scopes and termination control #206 — exception scopes and termination control
  • ABI: implement VM GC, memory accounting, and idle scheduling #207 — VM GC, memory accounting, and idle scheduling
  • ABI: implement VM jobs, module registry, and code invalidation #208 — VM jobs, module registry, and code invalidation
  • ABI: implement strong and weak embedding references #209 — strong and weak embedding references
  • ABI: implement the pinned native StringBuilder boundary #210 — pinned native StringBuilder boundary
  • Tooling: audit private exports across both pinned profiles #211 — cross-profile private-export audit
  • ABI: implement rooted native value containers #212 — rooted native value containers
  • ABI: implement exact Yarr RegularExpression boundary #213 — exact Yarr RegularExpression boundary
  • ABI: implement exact WTF parsing, CPU, allocator, and HTTP-date helpers #214 — exact WTF runtime helpers
  • ABI: implement Uint8Array constructors and Buffer identity #215 — Uint8Array constructors and Buffer identity
  • ABI: complete JSBuffer allocation and external ownership #216 — complete JSBuffer allocation and external ownership
  • ABI: implement true uninitialized Uint8Array allocation #217 — true uninitialized Uint8Array allocation
  • ABI: implement generic no-copy ArrayBuffer and TypedArray adoption #218 — generic no-copy ArrayBuffer and TypedArray adoption
  • ABI: implement exact JSValue ArrayBuffer view projection #219 — exact JSValue ArrayBuffer view projection
  • ABI: implement exact private typeof string projection #220 — exact private typeof string projection
  • ABI: implement exact VM entry-state query #221 — exact VM entry-state query
  • ABI: implement exact JSFunction source and tier-up controls #222 — exact JSFunction source and tier-up controls
  • ABI: implement exact internal length projection #223 — exact internal length projection
  • ABI: implement exact private property-path traversal #224 — exact private property-path traversal
  • ABI: implement exact private class and display names #225 — exact private class and display names
  • ABI: implement exact private JSON stringification #226 — exact private JSON stringification
  • ABI: implement exact private record construction #227 — exact private record construction
  • ABI: implement exact JSX element predicate #228 — exact JSX element predicate
  • ABI: implement exact deep equality and matching #229 — exact deep equality and matching
  • ABI: implement exact SQL object structures and offset writes #411 — exact SQL object structures and offset writes
  • ABI: implement exact global-object lifecycle #412 — exact global-object lifecycle
  • ABI: implement process initialization and shell-timeout trap #417 — process initialization and shell-timeout trap
• ABI: implement exact remote inspector process controls #232 — exact remote inspector process controls
• ABI: implement exact proxy internal-field projection #233 — exact proxy internal-field projection
• ABI: implement stable script execution context identifiers #234 — stable script execution context identifiers
• ABI: implement exact no-side-effects value stringification #235 — exact no-side-effects value stringification
• ABI: implement exact unhandled-rejection error-like classification #236 — exact unhandled-rejection error-like classification
• ABI: implement exact iterable callback traversal #237 — exact iterable callback traversal
• ABI: implement exact ZigString JSON parsing #238 — exact ZigString JSON parsing
• ABI: implement Bun process warnings and rejection event hooks #239 — Bun process warnings and rejection event hooks
• ABI: implement process nextTick scheduling #243 — process nextTick scheduling
• ABI: implement IPC process event dispatch #244 — IPC process event dispatch
• ABI: implement private module-loader evaluation and import #245 — private module-loader evaluation and import
• ABI: implement the private JSString backing iterator #247 — private JSString backing iterator
• ABI: create callable JSFunctions from Zig host functions #248 — Zig host-function creation and exact CallFrame callbacks
• ABI: retain and export structured JSC exception stack frames #249 — structured JSC exception stack frames
• ABI: project complete ZigException metadata and source lines #250 — complete ZigException metadata and source-line projection
• ABI: expose exact native CallFrame caller metadata #251 — native CallFrame caller metadata
• ABI: implement FFI host functions with native data #252 — FFI host functions with native data
• ABI: bridge private Promise reactions to JSHostFn callbacks #253 — queued Promise JSHostFn reactions
• ABI: reconstruct async Error stacks from Promise await chains #254 — async Error stack reconstruction from Promise await chains
• ABI: expose revalidated contiguous JSArray vectors #255 — revalidated contiguous JSArray vectors
  • ABI: import ArrayBuffer values from shared memfd mappings #256 — shared-memfd ArrayBuffer and Uint8Array import
  • ABI: implement generated native ArrayBuffer backing handles #257 — generated native ArrayBuffer backing handles
  • ABI: expose exact accessor cells during non-indexed property traversal #258 — accessor cells and non-indexed property traversal
  • ABI: preserve debugger async-call lifecycle and stacks #259 — debugger async-call lifecycle and stacks
  • ABI: implement counted private JSValue protection #367 — counted private JSValue protection
  • ABI: implement exact private property iteration #368 — exact private property iteration
  • ABI: implement ArrayBuffer copy and allocator ownership #369 — ArrayBuffer copy and allocator ownership
  • ABI: implement value-key property query and BunString upsert #370 — value-key property query and BunString upsert
  • ABI: implement private C-API call and proxy extensions #371 — private C-API call and proxy extensions
  • ABI: implement exact JSC Math.pow operation #372 — exact JSC Math.pow operation
• Home: pin and verify the public C embedding profile #162 — pinned Home public C embedding profile (kept separate from private ABI)

WebAssembly and reference corpus

• WebAssembly: implement the MVP runtime and JavaScript API #141 — WebAssembly MVP runtime and JavaScript API
  • WebAssembly: pin and score the upstream MVP specification corpus #260 — pinned upstream wg-1.0 corpus and machine-readable inventory
  • WebAssembly corpus: add a bit-exact runner for NaN payload assertions #261 — bit-exact NaN payload/sign corpus runner
  • Wasm decoder: reject hostile declarations before pathological allocation #317 — failure-atomic hostile declaration decoding
• WebAssembly: implement versioned post-MVP feature profiles #142 — versioned post-MVP feature profiles
  • WebAssembly profile: multi-memory binary, runtime, and corpus #305 — independent multi-memory profile and 829/829 terminal corpus
  • Wasm GC: make the canonical recursive identity witness spec-correct #318 — spec-correct Wasm GC canonical identity witness
  • Wasm corpus: surface evaluator runner errors in CI summaries #319 — durable corpus evaluator diagnostics
  • Wasm: lazily construct profile-specific spectest imports #320 — lazy profile-specific spectest imports
  • Wasm threads: merge nested evaluator reports without source-index crash #321 — nested threads evaluator report flattening
  • WebAssembly Core 3: add an exact wg-3.0 conformance profile #366 — exact WebAssembly Core 3 profile and upstream-main drift report
  • Wasm Threads: synchronize memory wrapper growth publication #315 — race-free no-GIL Wasm Memory growth publication
• Conformance: promote PR-249 WebAssembly, JIT, and shell hooks #143 — PR-249 WebAssembly/JIT/shell-hook promotion
  • Conformance: pin the complete PR-249 reference inventory #311 — pinned complete PR-249 reference inventory and drift gate
  • No-GIL debugger: make script and statement registries race-free #314 — race-free shared no-GIL debugger script/location registries
  • Wasm: implement streaming compilation and private compiler feed #406 — streaming WebAssembly compilation and private compiler feed
    • Fetch: preserve ReadableStream body lifecycle #407 — preserve ReadableStream Fetch Body lifecycle
    • Wasm: add compileStreaming and instantiateStreaming #408 — add compileStreaming and instantiateStreaming
    • ABI: implement lifetime-safe Wasm StreamingCompiler feed #409 — lifetime-safe private StreamingCompiler feed
    • Wasm: feed Response chunks directly into StreamingCompiler #410 — feed Response chunks directly into StreamingCompiler
  • Conformance: resolve the 14 non-JIT PR-249 reference cases #428 — resolve the 14 non-JIT reference executables
  • Conformance: promote the 10 optimizing-JIT PR-249 cases #429 — promote the 10 optimizing-JIT executables
  • Conformance: publish terminal PR-249 execution inventory #430 — publish the terminal 259-executable runtime inventory

GC and JIT

• GC: implement moving and compacting collection #144 — moving/compacting collection
  • GC: enable automatic compaction at shared precise safepoints #446 — automatic compaction at shared precise safepoints
  • GC: enforce the Object slab class without host-layout pinning #316 — restore Object cold sidecar to its 256-byte GC class
  • GC: preserve the 128-byte Object allocation with stable zig-gc IDs #413 — preserve the 128-byte Object allocation with stable zig-gc IDs
  • GC: make same-VM replacement realms precisely collectable #414 — make same-VM replacement realms precisely collectable
    • GC: add one ownership-aware heap across sibling realms #415 — ownership-aware precise heap across sibling realms
      • GC: register and trace live precise sibling realms #420 — register and trace live precise sibling realms
      • GC: route shared-heap cells to their allocating realm #421 — route shared-heap cells to their allocating realm
      • GC: retire and destroy precise sibling realms safely #419 — retire and destroy precise sibling realms safely
    • ABI: migrate private global lifecycle to shared precise GC #416 — migrate private global lifecycle to shared precise GC
  • CI: eliminate mid-GC seed-1 teardown stall on current Zig #418 — eliminate current-Zig mid-GC seed-1 teardown stall
  • Wasm: synchronize shared writes with relocating memory growth #425 — synchronize shared writes with relocating Wasm memory growth
• GC: implement multi-age generations and parallel mid-script minor collection #145 — multi-age generations and parallel mid-script minor collection
  • GC: make the multi-age nursery moving #447 — moving multi-age nursery
• JIT: build the optimizing tier with deoptimization and precise GC #146 — optimizing JIT with deoptimization and precise GC
  • JIT: add optimizing profiles, IR, and tier publication #431 — optimizing profiles, IR, and tier publication
  • JIT: implement OSR exits, deoptimization, and precise GC #432 — OSR exits, deoptimization, and precise GC
    • JIT: execute optimizer loop bodies with resumable invalidation polls #435 — resumable optimizer loop bodies and invalidation polls
    • JIT: reconstruct calls, exceptions, catch, and finally on deoptimization #436 — calls, exceptions, catch, and finally recovery
    • JIT: execute calls, effects, and completion dispatch inside exception regions #439 — native calls, effects, and completion dispatch
    • JIT: trace and relocate movable values in live optimized frames #437 — live optimized-frame tracing and relocation
    • JIT: lower general reducible loop CFGs with path-exact safepoints #438 — general reducible loop CFGs
  • JIT: lower guarded property regions into the native tier #132 — guarded named-property regions
    • JIT: snapshot named-property ICs into optimizer artifacts #440 — immutable optimizer property-IC snapshots and guarded callback fast paths
  • JIT: lower verified packed-array regions into the native tier #133 — verified packed-array regions
  • JIT: make trap polling and optimized artifact lifetime concurrency-safe #433 — concurrency-safe trap polling and optimized artifact lifetime
  • JIT: complete optimizer backends and publish differential evidence #434 — backend completion and differential evidence

Completion evidence

• Release: enforce the #134 compatibility matrix and README removal gate #147 — compatibility matrix and README removal gate
• Docs: remove What Is Not Implemented after all release gates pass #246 — final evidence-backed removal of README missing-surface section

Latest evidence

WebAssembly MVP #141 and its exact wg-1.0 corpus chain #260/#261 remain complete. The versioned post-MVP foundation #262, Core 2 numeric operations #269, and complete structural baseline #263/#270-#278 are now complete. The committed Core 2 inventory at 12ce485e pins official wg-2.0 and WABT 1.0.39 exactly: 27,437/27,437 applicable commands pass across all 90 files, 581 text-format commands are explicitly not applicable, and failures/runner errors are zero. Bounded CI landed in a593fdea; README and detailed evidence were refreshed in 66a953a6. The most recent batched full engine checkpoint remains 1,002/1,002 at af689c4a, and the general JavaScript comparison remains the validated 1,540-sample July 17 matrix because these WebAssembly paths do not execute in its workloads. Fixed-width SIMD #264/#279-#283 is now complete: the exact pinned 56-file score is 25,466/25,466 applicable commands with zero failures/runner errors, and the separate July 18 SIMD matrix preserves 224 scalar/JSC samples with every median above 50 ms. Terminal inventory, CI, architecture/fallback declarations, raw artifacts, README, and reproduction landed through be438ae0. Multi-memory #305 is complete with 829/829 pinned commands and documented robustness/sanitizer gates. Remaining WebAssembly roadmap work is #265-#268. PR-249 foundation #311 pins and checksums all 339 vendored files. #428 is complete at e6d15b1e/fa71b012: the verifier classifies all 259 executables as 243 promoted, 10 optimizing-JIT blocked by #429, and 6 executable terminal dispositions; all five helpers remain classified, and inventory/hook/disposition/evidence drift fails closed. Private property iteration #368 is complete at 4be4789d with its evidence label refreshed at 01cfa77b: Home is now 352/471 private symbols implemented (119 pending), Bun is 344/461 (117 pending), the shared Home consumer links 339/339 symbols, and a dedicated Bun compile-link-runtime fixture passes in Debug and ReleaseSafe.

ArrayBuffer ownership #369 is complete at 07a3e398: Home is 356/471 private symbols implemented (115 pending), Bun is 348/461 (113 pending), both inventories have zero unclassified entries, the Home consumer links 343/343, and the focused engine plus dedicated Bun fixtures pass in Debug and ReleaseSafe.

Value-key property work #370 is complete at 01b3aef3: Home is 359/471 private symbols implemented (112 pending), Bun is 351/461 (110 pending), both inventories have zero unclassified entries, the Home consumer links 346/346, and focused engine plus Bun-profiled fixtures pass in Debug and ReleaseSafe.

Private C-API extensions #371 are complete at 930f177b: Home is 361/471 private symbols implemented (110 pending), Bun is 353/461 (108 pending), both inventories have zero unclassified entries, the Home consumer links 348/348, and focused engine plus dedicated Bun fixtures pass in Debug and ReleaseSafe.

Exact JSC Math.pow operation #372 is complete at 3e96dde2: the private C export and JavaScript builtin share one edge-correct implementation; Home is 362/471 (109 pending), Bun is 354/461 (107 pending), Home links 349/349, and focused plus compiled-consumer evidence passes in Debug and ReleaseSafe.

• Implement private async-context call ABI #373 — async-context frame calls
• Implement DOMFormData private ABI and Blob entries #374 — DOMFormData private ABI and Blob entries

Current private-ABI evidence

At 172fea6, Home is 375/471 implemented (96 pending), Bun is 367/461 (94 pending), the Home consumer links 362/362, and the focused Bun DOMFormData fixture links 10/10. Debug and ReleaseSafe pass, including 25/25 relocation tests.

• Implement FetchHeaders private ABI and native adapters #375 — FetchHeaders private ABI and native adapters

• Implement VM-stable private CommonStrings projection #378 — VM-stable CommonStrings projection

Latest private-ABI checkpoint

At 9c51dee, Home is 376/471 implemented (95 pending), Bun is 368/461 (93 pending), and the Home fixture links 363/363. Debug and ReleaseSafe pass for the shared Home and exact Bun evidence.

• ABI: broadcast hot-reload readiness to every inspector connection #392 — process-wide hot-reload inspector broadcast
• ABI: implement per-VM CPU sampling profiles #404 — per-VM CPU sampling profiles
• ABI: implement readable-stream consumption and conversions #405 — readable-stream consumption and conversions

Checkpoint at 6427d1c: #392 is complete. Home is 409/471 private implemented (62 pending); Bun is 401/461 (60 pending). Exact multi-VM, detach/reentrancy, Debug, and ReleaseSafe evidence passes with zero leaks; benchmark scores are unchanged because this is compatibility work.

Checkpoint at 4275f7c: #404 is complete with exact fixing-main CI evidence. #405 implements all six pinned ReadableStream consumers and is awaiting only its exact main CI gate. Home is 439/471 private symbols implemented (32 pending); Bun is 430/461 (31 pending). Focused engine and external Home/Bun consumers pass in Debug, ReleaseSafe, and TSan; README benchmark scores are unchanged because this is compatibility work.

July 28, 2026 PR-249 terminal checkpoint

f6f8ef1b completes #143, #429, and #430. The pinned 339-file reference tree now records 259 executables as 253 promoted, 0 blocked, and 6 verifier-enforced terminal dispositions, plus five helpers outside the denominator. ReleaseSafe passes 246/246 serialized-required and 253/253 no-GIL-required promoted cases with zero failures or skips; all six terminal dispositions match in both modes. The release matrix reached 9/12 green at that checkpoint.

July 29, 2026 optimizer release checkpoint

9e51e1ff completes #146, #433, and #434. The sole declared optimizer backend is macOS AArch64; 24 seeded serialized/no-GIL differentials require real publication and exact guard deoptimization, normal and TSan focused gates pass 176/176, the full unit suite passes 1,452/1,452, and unsupported macOS/Linux x86-64 builds remain explicit fallback. The machine-readable optimizer inventory and dated raw JavaScriptCore artifact move the release matrix to 10/12 green. Remaining roadmap blockers are #446 automatic shared compaction evidence and #447 moving nursery.

[chrisbbreuer]

README tracking link landed on main in 8bf959db. This issue is now the removal gate for the documented unsupported-surface list.

[chrisbbreuer]

Roadmap decomposition is now linked in the issue body as #135–#147. The first implementation slice, #136, landed on main in 82b8e50a and 7bf1712f: public TypedArray/ArrayBuffer construction and inspection, true no-copy backing stores, and exactly-once failure/finalization lifetime handling. Full unit evidence: 783/783, zero skips/failures/leaks. #136 stays open for its #135 header and C compile-link gate.

[chrisbbreuer]

Inspector/debugger scope #139 is complete. Worker target child #156 closed through 1060784 with protocol parity, simultaneous independent targets, precise-GC root evidence, and deterministic teardown. The README no longer lists worker inspector parity as missing.

The umbrella now accurately remains open for #138, #140–#147: Objective-C/private ABI profiles, WebAssembly/reference hooks, moving/multi-age/parallel-minor GC, optimizing JIT, and the final compatibility/removal gate.

[chrisbbreuer]

Objective-C bridge parent #138 and children #157–#161 are complete through f29ca38: pinned 108/108 SDK inventory, semantic managed clearing, typed blocks and JSExport, same-VM cross-context identity, 18-row system-JSC parity (360c1ad3ccf51d6b), 200-cycle ASan/UBSan lifetime stress, deterministic allocation/registration rollback, and Apple leaks at 0 bytes. README/API commands and the What Is Not Implemented boundary are updated. The umbrella remains open for private/Bun/Home ABIs, WebAssembly/reference hooks, moving/multi-age GC, parallel mid-script minor collection, and optimizing JIT.

[chrisbbreuer]

Closed private-ABI child #253 on main through 657cbba8; parent checklists and latest evidence are updated.

[chrisbbreuer]

#255 is complete on main through 779f7eff (runtime 481f8ddc), with the roadmap body updated to 262/431 Home, 256/421 Bun, and 261/261 compiled fixture coverage. #254 is now explicitly linked as the remaining async-stack implementation slice. Current benchmark evidence is unchanged because these private embedding exports are outside its measured workloads.

[chrisbbreuer]

#254 is complete on main through 0ccdad67 (runtime 0c5e5441). Roadmap evidence is now Home 263/431, Bun 257/421, compiled fixture 262/262, and zero unclassified declarations; the current benchmark remains unchanged because this diagnostic ABI is not measured.

[chrisbbreuer]

Opened #256 for the next bounded private-ABI slice: validated MAP_PRIVATE shared-memfd import into exact ArrayBuffer/Uint8Array values with no-copy slice semantics and exactly-once full-region unmapping. Opaque native JSC::ArrayBuffer handles remain deliberately separate until their producer/lifetime contract is specified.

[chrisbbreuer]

Completed #256 on main through ae61fd67 (runtime e0164ae9). Evidence: focused ownership/GC matrix green; compiled consumer 263/263; Home 264/431 with 167 pending; Bun 258/421 with 163 pending; both audits zero-unclassified; Bun-selected tags green. README/docs are current, while the 1,540-sample benchmark remains unchanged because this embedding-only path is outside the workload.

[chrisbbreuer]

Opened #257 for the three opaque native ArrayBuffer exports plus their real bindgen producer. The pinned converter transfers RefPtr<JSC::ArrayBuffer>::leakRef() as an adopted +1, so completion requires an independent backing-store handle that can outlive its JS wrapper/VM—not a raw cell pointer or realm-retaining test adapter.

[chrisbbreuer]

Opened #258 for the next executable private-ABI cluster: exact GetterSetter/CustomGetterSetter cells, their four null predicates, generated type checks, and non-indexed property traversal that returns descriptor cells without invoking ordinary getters.

[chrisbbreuer]

WebAssembly profile foundation #262 is complete on main through af10c01c. The checked-in registry pins 12 proposal revisions across 4 profiles; dependency closure and registry/runtime/gate drift are CI-enforced; disabled and enabled-but-unimplemented features reject deterministically. Focused WebAssembly evidence is 126/126 passing. Continuing with the Core 2.0 baseline in #263.

[chrisbbreuer]

Completed Core 2.0 numeric slice #269 on main through 56273afc: all 5 sign-extension and 8 nontrapping conversion instructions decode, validate, instantiate, and execute behind explicit realm feature switches. Default-realm rejection and public JavaScript API execution are covered. Focused WebAssembly evidence is now 133/133 passing; the July 17 benchmark matrix remains current because these paths are outside its workloads. Continuing with structural Core 2.0 issue #263.