ABI: implement the pinned Home private-JSC profile

Parent: #140 Public Home embedding compatibility remains separate under #162.

The private compatibility target is Home 7ed99c02e50034f869d0db6d487115bb44332fe4. Its generated inventory pins every declaration, provider, layout, calling convention, and semantic contract; mismatched revisions and drift fail explicitly.

Acceptance

• Pin the exact Home revision and private binding source set.
• Inventory every required private symbol, layout, calling convention, and semantic assumption.
• Implement the complete declared profile behind the private shim boundary.
• Reject unknown or mismatched profile revisions.
• Add generated verification and independently compiled consumer fixtures.
• Reach zero missing and zero unclassified entries.

Terminal evidence

• Home profile: 447/447 implemented, zero pending/unclassified.
• Complete private runtime fixture: 392/392 in Debug, ReleaseSafe, and TSan.
• Consumer/provider final-link audit covers Home-owned definitions without duplicate zig-js exports.
• Final implementation children #411, #412, #417, #422, and #424 are closed.
• Exact main commit e3fdc52385204c75fe6ae5c64d48dae6e5ede418: 43/43 Actions jobs passed.

#253 complete: Home 260/431 with 171 pending; compiled consumer 259/259; zero unclassified.

#255 adds both Home-profile contiguous-vector exports and focused runtime evidence. Progress is now 262/431 implemented, 169 pending, with the compiled fixture at 261/261 and zero unclassified declarations. #254 is linked as open work.

#254 adds the Home-profile async stack export and runtime metadata. Home is now 263/431 implemented with 168 pending; the compiled fixture is 262/262 and the Home audit remains zero-unclassified.

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.

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.

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.

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.

Opened #295 for the next bounded private-ABI slice: the two pinned SystemError__* error-construction exports (SystemError.zig, pending in both inventories). Taking this track in parallel with the in-flight WebAssembly work, which stays with the other agent.

#295 complete: both pinned SystemError__* bridges are on main through 8874cb1e (docs 26003992). Home is now 278/431 implemented with 153 pending; the compiled consumer is 280/280 and both audits remain zero-unclassified. The pre-existing gc.test slab-layout failure noted in the issue evidence belongs to the in-flight GC/WASM work on main, not this slice.

#301 complete: the pinned JSC__JSGlobalObject__bunVM owning-VM query is on main through 731e218f (docs 95bc0ceb). Home is now 279/431 implemented with 152 pending; the compiled consumer is 281/281 and both audits remain zero-unclassified.

Claiming next slice (non-wasm track): VM execution-control exports — JSC__VM__getAPILock / holdAPILock / releaseAPILock / setExecutionTimeLimit / clearExecutionTimeLimit / hasExecutionTimeLimit (VM.zig, pending in both inventories). Child issue: #302.

Deferred from this cluster with rationale (will note in the inventory docs on landing):

• JSC__VM__create / JSC__VM__deinit / JSC__VM__deferGC — create/deferGC have no definition anywhere in Bun's C++/Zig tree (consumer-side externs only; deferGC needs GC deferral machinery), and Bun's deinit is an empty function — a bare-VM-without-global model doesn't map onto zig-js context groups without deeper design work.
• Zig__GlobalObject__create / createForTestIsolation / destructOnExit — full WebCore global construction (console client, worker env, napi-env adoption, gcProtect roots); engine-feature depth, not an ABI slice.

#302 landed and closed: VM execution-control exports (6 symbols).

• Commits: 7f6cbf17 feat(abi) + e1b0755f docs(abi), pushed to main
• Fixture: 287/287 symbols linked; runtime matrix passed — including a real 30 ms watchdog interruption of while (true) {} attributed via termination_requested, and a cross-thread API-lock exclusion proof
• Inventories: Home 285/431 implemented (146 pending), Bun 277/421 (144 pending) — exactly six status flips each; zero unclassified
• Audits: bun-private-abi-audit, c-api-audit (117/117, 293 private profile exports), test-home-public-abi (50/50), test-c-api, -Dtest-filter=c_api (148/148) all green
• Full zig build test: validated baseline-vs-candidate on clean-HEAD worktrees pinned to the same base — 1120/1121 both runs, identical single pre-existing gc-slab failure from the in-flight wasm/gc track, zero new failures

Design notes: API lock = recursive per-CContextGroup mutex (JSLock owner-thread recursion); time limit = lazily spawned host-watchdog thread per group using the documented Context.requestTermination() contract, joined in group destroy; timeout mapping mirrors JSC::Watchdog (+inf/noTimeLimit, NaN armed-never-fires, saturation); documented platform delta — zig-js treats watchdog termination as terminal for the context. Remaining deferrals from this cluster (JSC__VM__create/deinit/deferGC, Zig__GlobalObject__create*/destructOnExit) recorded in the claim comment above.

Claiming next slice: JSGlobalObject__setTimeZone (JSGlobalObject.zig, pending in both inventories) — process-wide default-timezone override with real Intl/Temporal default-zone consumers. Child issue: #303.

Also noting for the record: Zig__GlobalObject__getModuleRegistryMap / resetModuleRegistryMap are dead code upstream (bindings return nullptr/false with "no callers" — ZigGlobalObject.cpp:834-846); they'll be deferred rather than landed as behavior-free symbols.

#303 landed and closed: process default-timezone override (1 symbol, both inventories).

• Commits: f2bc3d9f feat(abi) + d1abe65a docs(abi), pushed to main
• Fixture: 288/288 symbols linked; runtime matrix passed — UTC baseline, null tolerance, unknown-zone rejection without state disturbance, canonical acceptance, explicit-option precedence, process-wide visibility from a foreign VM (WTF parity), lowercase normalization, alias canonicalization (America/Atka → America/Adak), empty-string reset
• Inventories: Home 286/431 implemented (145 pending), Bun 278/421 (143 pending); zero unclassified
• Audits: bun-private-abi-audit, c-api-audit (117/117, 294 private profile exports), test-home-public-abi (50/50), test-c-api, -Dtest-filter=c_api (148/148) all green
• Full zig build test: baseline-vs-candidate on clean worktrees pinned to 7be5f42d — 1134/1135 both runs, identical single pre-existing gc-slab failure, zero new failures; temporal/intl filters green

Implementation: process-wide override in src/interpreter.zig (setTimeZoneOverride/timeZoneOverride/validCanonicalTimeZoneName sharing the Intl pipeline's case normalization + alias + canonical-IANA check), consumed by the Intl.DateTimeFormat default zone and Temporal.Now default zone/timeZoneId(); export in src/c_api.zig. Documented boundary: Date local-time methods stay UTC-coincident by engine design; pinned date-cache reset is vacuous (no cache).

Claiming the next slice: VM trap notifications → child issue #304.

• JSC__VM__notifyNeedWatchdogCheck (VM.zig:142) — implement: VM-wide trap flag consumed at the interpreter's step checkpoint, re-checking the armed #302 execution deadline on the executing thread.
• JSC__VM__notifyNeedDebuggerBreak (VM.zig:148) — implement: requests an inspector pause (reason "pause") at the next statement boundary on every realm of the VM with an enabled debugger session; inert without one, matching JSC.
• JSC__VM__notifyNeedShellTimeoutCheck (VM.zig:154) — rejected: jsc-shell --timeout-specific trap, no possible zig-js consumer (same category as SourceProvider__deref). Recorded in #304 and will be reflected in the next body sync.

#304 closed — VM trap notifications are implemented and on main.

• JSC__VM__notifyNeedWatchdogCheck (VM.zig:142): VM-wide trap bit consumed at the interpreter's 1024-step checkpoint, re-checking the armed #302 deadline on the executing thread; elapsed → worker terminated. Redundant with the host watchdog thread by design, exactly like JSC's trap bit and Watchdog timer.
• JSC__VM__notifyNeedDebuggerBreak (VM.zig:148): requests a reason-"pause" break at the next statement boundary on every realm with an enabled debugger session (same path as CDP Debugger.pause); inert without one. CInspectorState.pause_requested is now atomic end-to-end for cross-thread notifies.
• JSC__VM__notifyNeedShellTimeoutCheck (VM.zig:154): stays rejected (jsc-shell --timeout machinery, no zig-js consumer).

Evidence: 66836af0 + 0940549a; fixture 290/290; audits 288/143 Home, 280/141 Bun, c-api 117/117 (+296 private exports); full-suite worktree A/B on pinned 1c368e84 → zero new failures. Tracker bodies synced.

Pending-symbol triage note (no code change):

• Bun__runDeferredWork (JSCScheduler.zig:20) — rejected. The task pointer is a consumer-C++-owned heap object (JSCTaskScheduler.cpp wraps each DeferredWorkTimer job and hands it to Bun__queueJSCDeferredWorkTaskConcurrently); nothing in the pinned profile lets zig-js construct or receive one, so a zig-js implementation could never be invoked. The underlying FinalizationRegistry-cleanup delivery already exists engine-side via the context-owned finalization_cleanup_jobs queue, so no consumer behavior is lost. Same rejection category as SourceProvider__deref and Zig__GlobalObject__getModuleRegistryMap.
• web_worker.zig cluster (6: WebWorker__dispatchError/dispatchExit/dispatchOnline/fireEarlyMessages/teardownJSCVM, Bun__ScriptExecutionContext__removeFromContextsMapByIdentifier) — deferred with the WebCore cluster: these are Bun's WebCore Worker event-dispatch entry points (ErrorEvent/EventTarget surface), not plain JSC value shims; will be scoped with the WebWorker/EventTarget feature area rather than as one-off shims.

Claiming the next slice: URLSearchParams ABI boundary (URLSearchParams__create / __fromJS / __toString) → child issue #307. Thin plumbing over the engine's existing URLSearchParams builtin (form-urlencoded parse/serialize, \x00usp pairs slot); no WHATWG URL parser work pulled in — URL.zig/DOMURL.zig stay deferred.

#307 (URLSearchParams create/fromJS/toString boundary) is complete and closed with evidence. Thin ABI plumbing over the engine's existing URLSearchParams builtin — no new URL machinery: create decodes through the exact new URLSearchParams(string) parse (one leading ? stripped, +/percent codec), fromJS is the WebCoreCast equivalent mapped to the canonical cell handle via the \x00usp pairs slot, toString serializes like the JS method with owner-realm recovery. Home now 291/431 implemented (140 pending); compiled consumer 294/294. On main through 437e6467. WHATWG URL parser cluster (URL__*/DOMURL__*) stays deferred.

Triage update after #307 (URLSearchParams boundary) and a re-scope of the deferred clusters:

• URL cluster (URL__* ×20, DOMURL__* ×4, BunString__toURL/toJSDOMURL) — now considered tractable. The original deferral assumed no WHATWG parser existed in zig-js. The engine in fact ships a real URL builtin: urlParse with base resolution, relative-reference resolution, path/query/fragment state machine, UrlParts records, and the live URLSearchParams query linkage. URL__fromString/getHref/etc. can therefore be thin ABI plumbing over existing engine semantics — the same pattern that made #307 small. This is the next slice candidate, likely split into sub-slices (core parse/href boundary first).
• AbortSignal cluster (×14) — upgraded from deferred to scopeable. The engine has AbortSignal/AbortController builtins; the Bun surface (create/aborted/abortReason/addListener/pending-activity) needs scoping against Bun's AbortSignal.cpp semantics before committing.
• TextCodec cluster (×6) — deferral re-confirmed. Bun vendors the complete WebCore codec stack (EncodingTables, TextCodecCJK, TextCodecSingleByte, TextCodecReplacement, TextCodecUserDefined, TextEncodingRegistry); the zig-js TextDecoder builtin covers a fraction of that encoding set, so this is an encoding-library port, not ABI plumbing.
• All other deferred clusters unchanged (FetchHeaders, DOMFormData, HTTPServerAgent, readableStreamTo*, profilers, JSSecrets, Bake/plugins/napi/hot-reloader, VM create/deinit/deferGC, web_worker, CachedBytecode, serializeJSValue, JSC__createStructure, ZigString external trio, callCustomInspectFunction, SourceProvider__deref, Bun__runDeferredWork rejected).

Claiming #308 — URL cluster sub-slice 1: native parsed-URL record (URL__fromString/deinit) plus the 11 component getters, as thin plumbing over the engine's existing urlParse/urlSerialize (allocator-first refactor of the parse layer, zero behavior change). Follow-ups scoped in the issue: JS-value helpers (fromJS/getHref*/file-URL), then DOMURL/BunString__toURL.

#308 (URL native record and component getters) is complete and closed with evidence — first URL-cluster sub-slice, confirming the upgraded tractability assessment from the triage note. The WHATWG parse layer was refactored to allocator-first with zero behavior change (one parser now shared by the JS URL builtin, fetch paths, and the ABI exports); WTF::URL* maps to a magic-validated native heap record since URL__fromString carries no global; the 11 getters follow Bun/WTF semantics where they deliberately diverge from the JS getters (protocol without colon, search keeping ? for present-but-empty queries, host/hostname inversion, port maxInt(u32)). Home now 304/431 (127 pending); compiled consumer 307/307. On main through 062ef265. Next sub-slice: the JS-value helpers (URL__fromJS, URL__getHrefFromJS/getHref/getHrefJoin, URL__getFileURLString, URL__pathFromFileURL).

Claiming #309 — URL cluster sub-slice 2: the six JS-value/static string helpers (URL__fromJS, URL__getHrefFromJS, URL__getHref, URL__getHrefJoin, URL__getFileURLString, URL__pathFromFileURL) on top of #308's native record and allocator-first parse layer.

#309 closed — URL JS-value and static string helpers (second URL-cluster sub-slice) on main through bcf9b0fd (runtime 5ca8373c).

Six exports: URL__fromJS/URL__getHrefFromJS (same-VM ToString coercion, throwing coercion publishes the exception → null/Dead, foreign VM → TypeError, empty/invalid → null/Dead cleanly), URL__getHref (no-base re-serialization), URL__getHrefJoin (existing base-resolution path), URL__getFileURLString (file:// + per-segment path-set encoding, slashes kept, dot segments unresolved), URL__pathFromFileURL (percent-decoded path, + literal). Engine delta: urlPercentEncode made pub + one new pub urlPercentDecode.

Fixture 307 → 313/313; Home 310/431 (121 pending), Bun 303/421 (118 pending); c-api audit 319 private exports; worktree A/B at e9869bc4 zero new failures. Full evidence on #309. Remaining URL-cluster: BunString__toURL/toJSDOMURL + DOMURL__* (JS DOMURL object creation) and URL__originLength.

#312 closed — URL__originLength (third URL-cluster sub-slice) on main through a44593a7 (runtime a95eb6fd).

Latin-1 slice widened to WTF-8, no-base parse, pathStart mirroring urlSerialize's prefix emission exactly (scheme + authority + /. sentinel); empty/invalid/null → 0. Fixture 313 → 314/314 (fixed offsets, JS-derived href.length - pathname.length parity for non-special/sentinel cases, origin.length parity for https). Home 311/431 (120 pending), Bun 304/421 (117 pending); c-api audit 320 private exports; worktree A/B at bcf9b0fd zero new failures (validated in an isolated worktree — the shared checkout carries unrelated uncommitted wasm work that does not compile).

Note: CI run 29676155824 on bcf9b0fd went broadly red (wasm-simd-smoke, unit/tsan shards) — attribution posted on #300; the breadth points at the SIMD native-vector lowering, not the ABI track. Only the DOMURL object-creation group remains in the URL cluster.

#313 closed — DOMURL object boundary (final URL-cluster sub-slice) on main through 7aeb2193 (runtime 7b7cad40). Six exports: BunString__toJSDOMURL/BunString__toURL (URL-interface object creation, TypeError + empty handle on invalid input), WebCore__DOMURL__cast_ (VM-scoped downcast borrowing the live object), href_/pathname_ (interned borrowed views), fileSystemPath (context-free, error codes 1/2/3). Fixture 314 → 320/320; Home 317/431 (114 pending), Bun 308/421 (113 pending); c-api audit 326 private exports; worktree A/B at a44593a7 zero new failures. Full evidence on #313. The URL cluster is now complete.

Home private ABI progress: #323 landed in a40ec46, bringing the pinned inventory to 319 implemented / 112 pending at that commit. The exact owned serialization layout, round trip, flags, exception paths, OOM, GC stability, and idempotent release are covered. Full CI: https://github.com/zig-utils/zig-js/actions/runs/29698929044.

Next Home private-ABI child: #324 tracks the three external ZigString ownership/finalization exports deferred by #199, with exact GC/teardown callback and compiled-consumer gates.

Home private ABI progress: #322 landed in f095db7; inventory is now 320 implemented / 111 pending. Focused custom-inspect runtime and the 324-symbol compiled consumer cover receiver, arguments, recursion, colors, throws, cross-VM rejection, pending state, and GC roots. Full CI: https://github.com/zig-utils/zig-js/actions/runs/29700271582.

74b0fe3f implements the three external ZigString entries tracked by #324. The regenerated pinned Home inventory is now 323 implemented private / 108 pending; home-private-abi-audit and the 327/327 compile-link-runtime fixture pass. Acceptance matrix: https://github.com/zig-utils/zig-js/actions/runs/29702181895.

Private-profile progress update: #327 is implemented on main through eed1a550 with six TextCodec exports, pure-Zig deterministic fallback decoders, SHA-256-pinned generated tables, and independent consumer coverage. Home is now 329/431 private symbols implemented (102 pending); Bun core is 320/421 (101 pending); the Home fixture is 333/333. Descendant acceptance is running at https://github.com/zig-utils/zig-js/actions/runs/29703497726.

Home profile progress: accepted run 29703497726 and closed the completed inspect/TextCodec/ownership/GC issues. #329 is now implementing the 14 shared AbortSignal declarations; its refreshed target is 343/431 implemented and 88 pending after acceptance.

#331 corrected the scanner boundary in e4ee7c7: explicit C-link declarations are now inventoried instead of silently excluded. The exact Home denominator is 471 private symbols: 344 implemented and 127 pending. Repeated consumer imports retain alternate declaration provenance; public-C overlaps and libc imports remain separately classified.

Accepted follow-up update: #329 (native AbortSignal boundary) and #331 (explicit C-link declaration inventory) are complete on main, with the full descendant matrix green at https://github.com/zig-utils/zig-js/actions/runs/29706564614. The Home inventory remains 344/471 implemented (127 pending); these issues strengthened ownership and audit coverage without inflating symbol counts.

#367 is complete at 21561474: Bun__JSValue__protect/unprotect now provide counted precise-GC roots with exact primitive/unmatched no-op behavior. Current Home status is 346/471 private implemented, 125 pending, zero unclassified; the compiled consumer passes 333/333 in Debug and ReleaseSafe.

Home progress after #368 (4be4789d / 01cfa77b): 352/471 private symbols implemented, 119 pending, zero unclassified; the independently compiled Home fixture now reports 339/339 linked and passes Debug/ReleaseSafe.

#369 landed in 07a3e398: Home is now 356/471 private symbols implemented, 115 pending, zero unclassified. Its independently compiled consumer links 343/343 and passes in Debug and ReleaseSafe.

#370 landed in 01b3aef3: Home is now 359/471 private symbols implemented, 112 pending, zero unclassified. Its consumer links 346/346 and passes in Debug and ReleaseSafe.

#371 is complete at 930f177b: Home is now 361/471 implemented with 110 pending; its compiled consumer links 348/348 and passes in Debug and ReleaseSafe.

#372 is complete at 3e96dde2: Home is 362/471 implemented with 109 pending; its consumer links 349/349 and passes Debug/ReleaseSafe.

Home private ABI update from #373 / df79596: AsyncContextFrame__withAsyncContextIfNeeded, Bun__JSValue__isAsyncContextFrame, and Bun__JSValue__call are implemented. Inventory: 365/471 implemented, 106 pending. The Home compiled fixture is now 352/352 and passed in Debug and ReleaseSafe.

Home profile progress: #374 landed on main in 172fea6. DOMFormData adds ten implemented private entries, moving the pinned inventory to 375/471 implemented and 96 pending with zero unclassified. The Home compile-link-runtime fixture now links 362/362 and passes in Debug and ReleaseSafe, including a forced full-GC checkpoint before FormData callback projection.

Home profile progress: #378 landed in 9c51dee. CommonStrings adds one implemented symbol, moving the pinned profile to 376/471 implemented and 95 pending with zero unclassified entries. The Home fixture links 363/363 and passes in Debug and ReleaseSafe.

FetchHeaders checkpoint: #376 is complete in 975386e2 + b4a9f717. The Home inventory is now 397/471 implemented with the private fixture at 384/384 in both Debug and ReleaseSafe isolated runs. The remaining four external adapter symbols stay tracked by #377; the concurrent fixture memfd flake is #379.

PicoHeaders checkpoint: #380 is complete in 91c91b3f + 42bcd356. Home is now 398/471 implemented (73 pending), with the exact private fixture at 385/385 in Debug and ReleaseSafe. FetchHeaders has three remaining opaque UWS/H3 exports under #381.

UWS/H3 request checkpoint: #382 is complete in a9e909b4 + 727a1651. Home is now 400/471 implemented (71 pending), with 387/387 exact fixture symbols in Debug and ReleaseSafe. Only FetchHeaders response writer #383 remains.

FetchHeaders #375 is complete. Home is now 401/471 implemented (70 pending), with the exact fixture at 388/388 in Debug and ReleaseSafe.

#390 advances the pinned Home profile to 404/471 implemented with 67 pending and zero unclassified; the shared Home consumer links 388/388 in Debug and ReleaseSafe.

#391 closes the standalone VM lifecycle/GC-deferral slice. Home is now 408/471 implemented with 63 pending and zero unclassified; the 388-symbol consumer passes in Debug and ReleaseSafe.

The pending BunDebugger__willHotReload entry is now tracked by shared implementation child #392.

The pending Bun__ErrorCode__determineSpecificType entry is now tracked by shared child #393.

Linked #394 under #393 for the exact inspector fallback used by the Home private profile.

#393 core advances the pinned Home private profile to 410/471 implemented (61 pending) in 18527d73; Debug/ReleaseSafe consumer evidence passes. #394 remains linked for the falsy-constructor inspector fallback.

Profile update: #393 and #394 are complete through 522e19c. The Home private ABI remains 410/471 implemented with 61 explicitly pending; received-value diagnostics now have compiled consumer, source-contract, Debug, and ReleaseSafe evidence.

#396 implements eight shared Home imports and refreshes the exact inventory from 410 to 418 implemented private symbols, leaving 53/471 pending. The Home profile library compiles/links/runs the external inspector-agent consumer in Debug and ReleaseSafe. CI evidence is pending in run 29766523096.

#398 moves five shared HTTPServer inspector imports to implemented. Home is now 423/471 implemented, 48 pending with exact contract/source hashes and the shared external consumer passing Debug and ReleaseSafe. Fixing main CI: https://github.com/zig-utils/zig-js/actions/runs/29769670857

#400 moves Bun__onSignalForJS to implemented. Home is now 424/471 implemented, 47 pending; exact contract plus Debug/ReleaseSafe external consumer evidence pass.

#396, #398, and #400 are closed on green bounded CI. The currently published Home profile is 424/471 (47 pending); #401 is implemented and locally verified to move it to 425/471 (46 pending), pending its isolated push.

Published Home profile checkpoint 737bd957: 427/471 private symbols implemented, 44 pending. #401 contributes the Home-only execution-context retirement boundary; #402 contributes two shared exact module-registry shims.

New tracked child #404 owns the remaining CPU sampling-profiler ABI cluster: per-VM lifecycle, safe cooperative stack sampling, Chrome/Markdown serialization, Home/Bun output ownership, OOM, and sanitizer evidence. This keeps the three profiler symbols out of the broad pending bucket without treating link-only stubs as progress.

The three CPU profiler exports are implemented by #404 on main through 9ab79698. Home inventory is now 433/471 (38 pending); Debug, ReleaseSafe, and TSan cross-profile fixtures are green locally.

Next Home pending cluster is tracked in #405: six readable-stream conversion exports and their required stream state machine.

#404 is complete. Per-VM CPU sampling profiles landed through 9ab796987fe04331761e620b2e928b9534330a4f; the exact fixing-main private-abi-boundary job passed its Debug, ReleaseSafe, and TSan evidence. The pinned counts remain Home 433/471 and Bun 424/461 at that checkpoint; #405 is the next active private-ABI slice.

#405 is implemented on main through 4275f7c2: all six pinned ReadableStream consumers now share realm-local stream/reader/controller machinery, exact Home/Bun contracts, and compiled Debug/ReleaseSafe/TSan fixtures. Inventories are now Home 439/471 (32 pending) and Bun 430/461 (31 pending). #405 remains open only for its exact fixing-main CI gate.

Created #406 for the next coherent boundary: real WebAssembly.compileStreaming/instantiateStreaming plus the pinned JSC__Wasm__StreamingCompiler__addBytes opaque feed. It explicitly preserves the frozen WG1 baseline while validating modern coverage through the existing WG3 and upstream-main profiles.

The declared exact profile is complete with zero pending/unclassified entries, and exact main e3fdc52385204c75fe6ae5c64d48dae6e5ede418 passed all 43 jobs in run 29806223245.