[cramforce]

Stacked on #3123 (test/island-stress-lifecycle, merged in at f96f851); the diff against that branch is this PR. It includes one commit by the agent working on top of it (e496a03, the V8 Error of a native error is freed once the program and the island drop the error). The regenerated island value matrix is commit 12870c1.

Three ways promises and errors went wrong when they crossed between native code and a Node island, found by #3123's stress suite and decided there (pi-decisions, island promises = A, native errors in island code = A), plus one found since (members of an island Promise subclass).

What changes

An island promise that only island code handles is no longer reported as unhandled, and awaiting one takes Node's number of turns. try { await lib.all([lib.failing(), lib.other()]) } catch { … } printed the caught error and then Unhandled promise rejection, exit 1. The program's mirror of an island promise subscribed to the V8 promise when it crossed, so every island promise the program had seen had a native reaction, and the runtime reported the mirror. Now the mirror subscribes when native code first reacts to it, settles inside V8's reaction job, and runs the native reactions in that job (no microtask of their own). A typed conversion of a mirror (const p: Promise<number> = lib.f()) waits with it. V8 decides whether an island promise is unhandled: one island code handles is not reported, one nobody handles ends the program through Node's report as before.

A native error keeps its identity, class and fields through island frames. After lib.run(() => { throw original }), e === original was false, e instanceof ValidationError false and e.status undefined, and island code that caught a native error saw none of its fields, cause or errors. A native error now crosses by reference: one V8 Error per native error (an export; SCR_NV_ERROR carries the export id, bridge ABI 12), which is the native error again when it crosses back. Island code reads its own enumerable fields (copied onto the V8 Error at each crossing, where Object.keys, JSON.stringify and util.inspect look) and everything else (cause, an AggregateError's errors) through the export. The message, name, stack and code the V8 Error holds are brought up to date at each crossing too, so island code that keeps a native error sees what native code changed on it. A native AggregateError is V8's AggregateError.

An island object with a then method is a thenable to every resolution. #3123 fixed await. Promise.resolve(v), a combinator's entry, an async function's return v, an executor's resolve(v) and a reaction's result still answered the object. The Node island build of scr_async_dyn.c reads then in V8 and the runtime's own thenable job calls it; await uses the same job now (one mechanism instead of V8's adoption for one form). That also answers the review thread on #3123 at scr_node_island_handle.c:1224 (then read twice during adoption): the resolution reads then once and calls what it read, pinned by node-island-crossing-then-read-once (a getter that answers a function on the first read only: Node and the program both print the function of the first read 1). An executor that resolved its promise with an island thenable has resolved it: its later resolve, reject or throw changes nothing.

Members an island class adds to Promise reach the island object. class Request<T> extends Promise<T> { url; describe() } (an SDK's request promise) crossed as a plain promise: a read typed any answered undefined, a typed read threw, a method call threw. Reads, writes and calls through the package's declared types, and dynamic reads and in, now go to the island object; then, catch and finally stay the program's promise.

Where the code is

Island-only: scr_node_island_handle.c, scr_node_island_export.c, scr_node_island.c, the bridge, and #ifdef SCR_NODE_ISLANDS blocks in scr_async.c, scr_json.c and scr_async_dyn.c. scr_async_dyn.c gets Node island builds beside its existing ones (the pack matrix test covers the selection); every other program keeps the objects it had. ScrPromise keeps its size: the lazy flag takes padding, and a pending lazy view keeps its source in the payload words. The compiler changes are the bridge ABI pin, one library function (nodeIsland.promiseResolve) and four lines in the existing island-thenable pass, which only runs for programs with islands.

Not in this PR (each with a repro, in the fleet's follow-up list)

• Several native reactions on one island promise run at the first one's position: p.then(n1); lib.then(p, i2); p.then(n3) runs n1, n3, i2 (Node: n1, i2, n3). One native reaction, or native reactions with no island reaction between them, keep Node's order.
• Island code writing a field of a native error does not reach the native error.
• Methods and constructor of a program error class are not visible to island code (typeof e.retryable is undefined); fields, cause, errors, instanceof are right. This is the remaining difference in the stress programs r02 and d02.
• A dynamic method call or write on a member of an island Promise subclass in untyped code is the TypeError it was.
• In a program without islands, a thenable held in a dynamic value is still not adopted by Promise.resolve, an executor's resolve, an async return or a reaction's result in JavaScript source (on main; not island-specific).

Proof

Linux x64 Sandboxes (Intel Xeon 2.90 GHz), Node 24.22.1, a libnode pack built from this branch's bridge (ABI 12). Head def1687, base f96f851.

• Full round on the head (zero-cost gate with --gate-corpus=all, lanes, native bootstraps): gate PASS, 5,242 programs identical, 142 both-fail (the Node island programs, which the gate builds without a pack on both sides), 0 differing rows, 0 runtime-only rows; bench geomean +0.36% [95% CI -0.57%, +1.10%], self-compile -0.76% [-1.75%, +0.97%], fixtures -0.25% [-1.44%, +0.95%]. Lanes: plain 22,110 passed, 0 failed; sanitized 18,875 passed, 0 failed (90 jobs), including the plain and the sanitized native bootstrap lanes.
• Stress driver (Node islands: fix error properties, process.argv, thenable awaits and work after 'exit'; pin lifecycle behaviour with 40 corpus programs #3123's differential driver: each program compiled once, run under Node and natively, 3 runs per side plain and 2 sanitized). Of Node islands: fix error properties, process.argv, thenable awaits and work after 'exit'; pin lifecycle behaviour with 40 corpus programs #3123's 76 programs, 43 matched on its head and 46 match here (b03-await-ticks, r03-await-island-thenable, r11-await-island-promise-tick), and no program that matched stopped matching. The other repros of these bugs are down to the remainders listed above: b06-combinators no longer ends in an unhandled rejection and differs in one line (instanceof AggregateError of an island error, on Node islands: fix error properties, process.argv, thenable awaits and work after 'exit'; pin lifecycle behaviour with 40 corpus programs #3123's list); r02-native-error-through-island differs in one line and d02-native-throws in six of 70 (methods and constructor of a program error class). With the programs written for this PR, 62 of 95 match, plain and sanitized.
• New corpus programs. 14 tests/corpus/node-island-crossing-* (JavaScript and TypeScript, three with a typed island package): await order across the boundary at each level; combinators run by each side over promises of both sides; rejections handled by one side only; an unhandled island rejection (three exit-1 programs); error identity, class, fields, cause, errors, stack and later changes after one and two round trips in both directions; every thenable form with a then that resolves, rejects, throws, resolves then throws, has a throwing getter, never settles or is not callable, and an executor's first resolution; then read once; the Promise subclass members; a lock taken from an island package and released in finally. All node-island corpus programs pass differential.test.ts and llvm-differential.test.ts, plain and SCRIPTC_SAN=1 (276 cases per flavor). The sanitized lane is the leak audit: it caught a typed view of an island promise that is never awaited keeping the mirror, fixed in 97be309.
• Island value matrix (main's Pin how values cross a Node island boundary, and fix seven observations that differed from Node #3161), regenerated in 12870c1 and reviewed cell by cell: 57 pinned differences are gone and 26 cells list fewer; the 32 new cells are all in sections that used to end in exit before they were reached, and are named refusals, island-write cells that already existed for the other direction, or the native tier's own answers. Four cells change kind, n2i2n/U.clone: unsupported -> wrong in the untyped error kinds: structuredClone of a native error after a round trip is now the native tier's own answer for an Error, which the control rows pin as wrong with no island. No cell went from a match to a difference.
• The self-build. A first version of the pass change replaced an IR node in place through a Record<string, unknown> view. The gate did not see it; the native bootstrap lanes did, as time limits: in the compiler compiled by itself every IR node type became a dynamic record, the LLVM input doubled (2.06 GB against 1.03 GB) and the bootstrap's seed build took 1,926 s against the base's 767 s (one 32 vCPU machine, each build alone). def1687 uses the typed IR rewrite instead: 751 s, 1.03 GB, the base's profile match (81.9% against 82.0%).
• pnpm lint, pnpm format:check, pnpm test:ts7 --baselines-only: clean. pnpm manifest leaves surface-manifest.json unchanged.

🤖 Generated with Claude Code

[vercel]

The latest updates on your projects. Learn more about Vercel for GitHub.

Project	Deployment	Actions	Updated
scriptc	Ready	Preview, v0	Nov 7, 2026 2:52pm UTC

[cramforce]

Superseded by #3377 (landing train islands-1), which carries this branch's commits merged with the other island boundary changes and current main, validated as one tree. Review of this change continues there; if #3377 does not land, this can be reopened.

🤖 Generated with Claude Code