@scriptc/compiler 0.0.11 → 0.0.13

package/dist/frontend/lowering/lower-builtins.js

@@ -15,6 +15,7 @@ import { invalidJsonModuleDiag, requiresDynamicImportDiag } from "../../diagnost
 import { builtinModuleFnOf, FS_READDIR_DOCUMENTED_OPTIONS, FS_WATCH_DOCUMENTED_OPTIONS, FS_WRITE_FILE_DOCUMENTED_OPTIONS, QS_PARSE_DOCUMENTED_OPTIONS, QS_STRINGIFY_DOCUMENTED_OPTIONS, READLINE_DOCUMENTED_OPTIONS, builtinConstLit, fenceOrDropOptionKey, isChildSurfaceMember, } from "./surfaces.js";
 import { conditionalSpreadOf, lowerDynObjectLiteral } from "./lower-exprs.js";
 import { HTTP2_CONSTANTS } from "./http2-constants.js";
+import { CRYPTO_CIPHERS, CRYPTO_CONSTANTS, CRYPTO_CURVES, CRYPTO_HASHES } from "./crypto-tables.js";
 import { timerStyleCallback } from "./lower-calls.js";
 import { registerHttpClientFnBinding } from "./lower-server.js";
 import { BOOL, BYTES_U8, CHILD_T, CHILDSTREAM_T, DYN, F64, FSWATCHER_T, PROCSTREAM_T, JSVAL, NULL_T, SEARCH_PARAMS_T, SPAWNRES_T, STRING, UNDEFINED_T, VOID, arrayOf, canBoxFuncIntoDyn, canConvertToDyn, funcOf, isUnitType, typeEquals, typeKey } from "../../ir/nodes.js";
@@ -376,38 +377,60 @@ export function lowerCreateRequireCall(L, call, loc) {
         loc,
     };
 }
-/** True when `node` denotes the http2.constants OBJECT — any of its
-   * spellings: `http2.constants` through a namespace/require binding, a
-   * destructured or member-bound `constants` alias from the http2 module,
-   * or `require("http2").constants` inline. The object itself never
-   * materializes; each member read bakes as its literal. */
-export function isHttp2ConstantsExpr(L, node) {
+/** The builtin modules whose `constants` object bakes as literals at
+   * every access site (the fs.constants precedent, scaled up): http2's
+   * full Node v24 table, and crypto's OpenSSL-constant table. The object
+   * itself never materializes at runtime. */
+const BUILTIN_CONSTANTS_TABLES = {
+    http2: {
+        table: HTTP2_CONSTANTS,
+        hint: "the table bakes Node v24's 240 members as literals — this name is not one of them",
+    },
+    crypto: {
+        table: CRYPTO_CONSTANTS,
+        hint: "the table bakes Node v24's crypto.constants members as literals — this name is not one of them",
+    },
+};
+/** The module whose baked-constants OBJECT `node` denotes, or null — any
+   * of the spellings: `http2.constants`/`crypto.constants` through a
+   * namespace/require binding, a destructured or member-bound `constants`
+   * alias from the module, or `require("http2").constants` inline. The
+   * object itself never materializes; each member read bakes as its
+   * literal. */
+export function builtinConstantsModuleOf(L, node) {
+    let module = null;
     if (ts.isPropertyAccessExpression(node) && !node.questionDotToken) {
         if (node.name.text !== "constants")
-            return false;
+            return null;
         const bi = L.builtinMemberOf(node);
-        if (bi && bi.module === "http2")
-            return true;
-        const spec = requireSpecOf(node.expression);
-        return spec !== null && canonicalBuiltinModule(spec) === "http2";
+        if (bi)
+            module = bi.module;
+        else {
+            const spec = requireSpecOf(node.expression);
+            module = spec !== null ? canonicalBuiltinModule(spec) : null;
+        }
     }
-    if (ts.isIdentifier(node)) {
+    else if (ts.isIdentifier(node)) {
         const bi = builtinImportOf(L, node);
-        return bi !== null && bi.module === "http2" && bi.member === "constants";
+        if (bi !== null && bi.member === "constants")
+            module = bi.module;
     }
-    return false;
+    return module !== null && own(BUILTIN_CONSTANTS_TABLES, module) !== undefined ? module : null;
 }
-/** `constants.NGHTTP2_CANCEL` (any http2.constants spelling) → the baked
-   * literal; unknown members fence by name. Null when the receiver is not
-   * the constants object (the property chain keeps trying). */
-export function lowerHttp2ConstantsProperty(L, expr) {
+/** `constants.NGHTTP2_CANCEL` / `constants.SSL_OP_NO_TICKET` (any baked-
+   * constants spelling) → the literal; unknown members fence by name.
+   * Null when the receiver is not a baked constants object (the property
+   * chain keeps trying). */
+export function lowerBuiltinConstantsProperty(L, expr) {
     if (expr.questionDotToken)
         return null;
-    if (!isHttp2ConstantsExpr(L, expr.expression))
+    const module = builtinConstantsModuleOf(L, expr.expression);
+    if (module === null)
         return null;
-    const value = own(HTTP2_CONSTANTS, expr.name.text);
+    const entry = BUILTIN_CONSTANTS_TABLES[module];
+    const value = own(entry.table, expr.name.text);
     if (value === undefined) {
-        L.noLowering(`http2.constants.${expr.name.text}`, expr, "the table bakes Node v24's 240 members as literals — this name is not one of them");
+        L.noLowering(`${module}.constants.${expr.name.text}`, expr, entry.hint);
     }
     return builtinConstLit(value, locOf(expr));
 }
@@ -487,27 +510,30 @@ function perfNowFnValueOf(L) {
     }
     return name;
 }
-/** True for `const { NGHTTP2_CANCEL, ... } = http2.constants` — a plain
-   * object destructure (identifier elements, renames allowed, no rest/
-   * defaults/nesting) over the constants object whose every name is in
-   * the table. The declaration is alias plumbing with no storage
-   * (lowerVarDecl and collectGlobals both skip it); each USE reads its
-   * baked literal (http2ConstantBindingOf). */
-export function http2ConstantsDestructureDecl(L, nameNode, init) {
+/** True for `const { NGHTTP2_CANCEL, ... } = http2.constants` (and the
+   * crypto.constants twin) — a plain object destructure (identifier
+   * elements, renames allowed, no rest/defaults/nesting) over a baked
+   * constants object whose every name is in its table. The declaration is
+   * alias plumbing with no storage (lowerVarDecl and collectGlobals both
+   * skip it); each USE reads its baked literal
+   * (builtinConstantBindingOf). */
+export function builtinConstantsDestructureDecl(L, nameNode, init) {
     if (!ts.isObjectBindingPattern(nameNode) || !init)
         return false;
-    if (!isHttp2ConstantsExpr(L, init))
+    const module = builtinConstantsModuleOf(L, init);
+    if (module === null)
         return false;
+    const table = BUILTIN_CONSTANTS_TABLES[module].table;
     return nameNode.elements.every((el) => !el.dotDotDotToken &&
         el.initializer === undefined &&
         el.name !== undefined &&
         ts.isIdentifier(el.name) &&
         (el.propertyName === undefined || ts.isIdentifier(el.propertyName)) &&
-        own(HTTP2_CONSTANTS, (el.propertyName ?? el.name).text) !== undefined);
+        own(table, (el.propertyName ?? el.name).text) !== undefined);
 }
-/** Resolves an identifier bound by an http2ConstantsDestructureDecl to its
-   * baked literal value. Null for every other binding. */
-export function http2ConstantBindingOf(L, ident) {
+/** Resolves an identifier bound by a builtinConstantsDestructureDecl to
+   * its baked literal value. Null for every other binding. */
+export function builtinConstantBindingOf(L, ident) {
     const symbol = L.checker.getSymbolAtLocation(ident);
     const decl = symbol ? L.checker.declarationsOf(symbol)[0] : undefined;
     if (!decl || !ts.isBindingElement(decl) || decl.dotDotDotToken || decl.initializer)
@@ -517,14 +543,15 @@ export function http2ConstantBindingOf(L, ident) {
     const varDecl = decl.parent.parent;
     if (!ts.isVariableDeclaration(varDecl) || varDecl.initializer === undefined)
         return null;
-    if (!isHttp2ConstantsExpr(L, varDecl.initializer))
+    const module = builtinConstantsModuleOf(L, varDecl.initializer);
+    if (module === null)
         return null;
     const key = decl.propertyName && ts.isIdentifier(decl.propertyName)
         ? decl.propertyName.text
         : decl.name !== undefined && ts.isIdentifier(decl.name) ? decl.name.text : null;
     if (key === null)
         return null;
-    const value = own(HTTP2_CONSTANTS, key);
+    const value = own(BUILTIN_CONSTANTS_TABLES[module].table, key);
     if (value === undefined)
         return null;
     return builtinConstLit(value, locOf(ident));
@@ -587,7 +614,7 @@ function optionMember(p) {
  * utimes family runs on its time arguments: finite numbers pass
  * (negatives answer now/1000, Node's shape), numeric STRINGS coerce
  * through ToNumber's loose-equality gate, everything else throws
- * Node's exact ERR_INVALID_ARG_TYPE. The argument crosses as a DOM
+ * Node's exact ERR_INVALID_ARG_TYPE. The argument crosses as a dyn
  * value so the runtime renders the Received tail. Null when this is
  * not that call (the table fence stays for other shapes). */
 export function lowerFsToUnixTimestampCall(L, expr, bi, loc) {
@@ -605,7 +632,7 @@ export function lowerFsToUnixTimestampCall(L, expr, bi, loc) {
 /** The fs validation-ladder spoke (checked-dynamic lane, JS sources
  * only — TypeScript keeps its compile fences): implemented-namespace
  * calls whose misuse Node rejects with typed errors lower to fs.*Chk
- * libCalls that replicate the validation ladder over DOM values and
+ * libCalls that replicate the validation ladder over dyn values and
  * throw Node's exact ERR_INVALID_ARG_TYPE / ERR_INVALID_ARG_VALUE /
  * ERR_OUT_OF_RANGE — the honest tail (the real operation where one
  * exists, the compiler-rendered SC2020 fence otherwise) runs only
@@ -619,7 +646,7 @@ export function lowerFsLadderCall(L, expr, bi, loc) {
     const args = expr.arguments;
     if (args.some(ts.isSpreadElement))
         return null;
-    // Every ladder argument crosses as a DOM value; an argument that
+    // Every ladder argument crosses as a dyn value; an argument that
     // cannot leaves the historical fence in place.
     const dynArg = (node) => {
         if (!node)
@@ -657,7 +684,7 @@ export function lowerFsLadderCall(L, expr, bi, loc) {
             // false THROUGH it, and the answer is asynchronous.
             // A provably-non-file `new URL('<literal>')` path (the suite's
             // https://foo probe): Node answers false through the callback
-            // synchronously — the DOM has no URL kind, so the path slot
+            // synchronously — the checked-dynamic tree has no URL kind, so the path slot
             // carries the unvalidatable token instead (construction of a
             // parseable literal is effect-free; file: URLs keep the fence —
             // they would need the real path conversion).
@@ -779,7 +806,7 @@ export function lowerBuiltinModuleCall(L, expr, bi, fn, loc) {
     }
     // node:querystring — parse/stringify are entirely special-cased (the
     // sep/eq/options completions, parse's call-site-shaped dictionary
-    // result, stringify's DOM-crossing object argument); decode/encode
+    // result, stringify's dyn-crossing object argument); decode/encode
     // are Node's own aliases of the pair (`const decode = parse` in the
     // module source) and take the same lowerings. escape/unescape ride
     // the generic table tail below.
@@ -817,7 +844,7 @@ export function lowerBuiltinModuleCall(L, expr, bi, fn, loc) {
         }
     }
     // node:diagnostics_channel — the module-level pub/sub surface. The
-    // subscriber arguments box into the DOM (dyn) so JS harness wrappers
+    // subscriber arguments box into the checked-dynamic tree (dyn) so JS harness wrappers
     // (test/common's mustCall — a rest-args function value) and typed
     // closures both cross; publish and the Channel methods lower in
     // lowerDcChannelMethodCall over the f64 channel handle.
@@ -2484,7 +2511,7 @@ function isReadlineTyped(L, node) {
 function dcChannelNameArg(L, node) {
     return L.lowerExprExpecting(node, STRING);
 }
-/** A diagnostics_channel subscriber as a DOM value: dyn callables pass
+/** A diagnostics_channel subscriber as a dyn value: dyn callables pass
  * through (test/common's mustCall wrapper — an untyped JS function
  * value), boxable typed closures ride dynFrom. Identity is preserved
  * either way, so unsubscribe(fn) finds the subscribe(fn) entry. */
@@ -2506,14 +2533,14 @@ function dcSubscriberArg(L, node) {
         canBoxFuncIntoDyn(cb.type, (id) => L.shapes.get(id), (id) => L.unions.get(id))) {
         return { kind: "dynFrom", value: cb, type: DYN, loc: locOf(node) };
     }
-    L.unsupported("SC1090", node, `channel subscribers of type '${L.fmt(cb.type)}' (subscribers cross as DOM functions — parameters must be dyn-representable)`);
+    L.unsupported("SC1090", node, `channel subscribers of type '${L.fmt(cb.type)}' (subscribers cross as dyn functions — parameters must be dyn-representable)`);
 }
-/** A published message as a DOM value: dyn passes through, everything
+/** A published message as a dyn value: dyn passes through, everything
  * in the dynFrom domain (JSON-safe data, bytes, %Error, boxable
  * functions, handle kinds) boxes; the rest fences with the domain named. */
 function dcMessageArg(L, node) {
     // An explicit `undefined` argument (tracePromise(fn, ctx, undefined,
-    // ...args) — Node's own no-this spelling) is the undefined DOM value,
+    // ...args) — Node's own no-this spelling) is the undefined dyn value,
     // exactly what an omitted slot defaults to.
     if (ts.isIdentifier(node) && node.text === "undefined") {
         return dynUndefinedExpr(locOf(node));
@@ -2524,7 +2551,7 @@ function dcMessageArg(L, node) {
     if (canConvertToDyn(msg.type, (id) => L.shapes.get(id), (id) => L.unions.get(id))) {
         return { kind: "dynFrom", value: msg, type: DYN, loc: locOf(node) };
     }
-    L.unsupported("SC1090", node, `publishing '${L.fmt(msg.type)}' messages (messages cross as DOM values — JSON-safe data, Uint8Array, errors, and functions)`);
+    L.unsupported("SC1090", node, `publishing '${L.fmt(msg.type)}' messages (messages cross as dyn values — JSON-safe data, Uint8Array, errors, and functions)`);
 }
 /** True when `node`'s checker type is diagnostics_channel's Channel
  * (stdlib provenance plus the ambient module, the readline.Interface
@@ -2565,7 +2592,7 @@ export function lowerDcChannelMethodCall(L, call, access) {
     // bindStore(store[, transform]) / unbindStore(store) / runStores(data,
     // fn[, thisArg[, ...args]]): the AsyncLocalStorage integration — the
     // store argument is the ALS f64 handle; the transform crosses as a
-    // DOM function (absent = identity, the undefined DOM value); runStores
+    // dyn function (absent = identity, the undefined dyn value); runStores
     // enters the bound stores, publishes inside them, and forwards
     // this/arguments to fn exactly like the trace calls.
     if ((name === "bindStore" || name === "unbindStore") &&
@@ -2608,7 +2635,7 @@ function isAlsTyped(L, node) {
 }
 /** Method calls on AsyncLocalStorage receivers: run(store, fn, ...args),
  * exit(fn, ...args), getStore(), enterWith(store), disable() — over the
- * f64 store handle (als.* libCalls; values cross as DOM values). Null
+ * f64 store handle (als.* libCalls; values cross as dyn values). Null
  * for non-ALS receivers. */
 export function lowerAlsMethodCall(L, call, access) {
     if (call.questionDotToken || access.questionDotToken)
@@ -2678,8 +2705,8 @@ function isDcTracingChannelTyped(L, node) {
         L.isStdlibFile(d.getSourceFile()));
 }
 const DC_TRACE_EVENTS = ["start", "end", "asyncStart", "asyncEnd", "error"];
-/** A TracingChannel handlers object as a DOM value: dyn passes through;
- * an INLINE object literal of plain event-name properties builds the DOM
+/** A TracingChannel handlers object as a dyn value: dyn passes through;
+ * an INLINE object literal of plain event-name properties builds the checked-dynamic tree
  * object member-by-member (each value through the message conversion —
  * closures box by identity, so unsubscribe still matches), covering the
  * `{ start: () => {} }` spelling whose record type (function members)
@@ -2708,7 +2735,7 @@ function dcHandlersArg(L, node) {
     }
     return dcMessageArg(L, node);
 }
-/** A trace-call argument list's tail as ONE DOM array (dynArrLit over
+/** A trace-call argument list's tail as ONE dyn array (dynArrLit over
  * per-element conversions). Spread arguments fence — the built array
  * must mirror the call site's argument vector exactly. */
 function dcTraceArgsArr(L, args, loc) {
@@ -2721,9 +2748,9 @@ function dcTraceArgsArr(L, args, loc) {
     return { kind: "dynArrLit", elems, type: DYN, loc };
 }
 /** Method calls on TracingChannel receivers: subscribe/unsubscribe over
- * a DOM handlers object, traceSync/traceCallback through the runtime's
+ * a dyn handlers object, traceSync/traceCallback through the runtime's
  * publish choreography (dc.tcTraceSync/dc.tcTraceCallback — fn, context,
- * thisArg, and the argument vector all cross as DOM values; context
+ * thisArg, and the argument vector all cross as dyn values; context
  * defaults to a fresh `{}` and thisArg to undefined, Node's defaults),
  * and tracePromise through the reaction-fiber choreography
  * (dc.tcTracePromise — the result is the reaction promise, typed
@@ -2994,7 +3021,7 @@ export function strdecHelper(L, op, shapeId, loc) {
 }
 /** `JSON.parse(text)` / `JSON.stringify(value)`.
    * - parse → a may-throw `libCall` producing a dyn value (the runtime JSON
-   *   DOM); malformed input throws a catchable SyntaxError-shaped string.
+   *   dyn); malformed input throws a catchable SyntaxError-shaped string.
    *   The divergence override types the one-argument form `unknown`; the
    *   lib's reviver form typechecks (returning `any`) and is fenced here.
    * - stringify → the type-DIRECTED `jsonStringify` node: the lib
@@ -3048,8 +3075,8 @@ export function lowerJsonMethodCall(L, call, access) {
         }
         // A dyn ROOT (`JSON.stringify(u)` over unknown / `{}` / `Object` /
         // `object` slots, the JSON.parse round-trip) serializes with the
-        // runtime's DOM walker instead of a type-directed serializer — the
-        // DOM is JSON-representable by construction (non-JSON values fenced
+        // runtime's dyn walker instead of a type-directed serializer — the
+        // dyn is JSON-representable by construction (non-JSON values fenced
         // at their conversion INTO the slot). Two edges, both documented:
         // a root the stringify drops (runtime undefined) produces the TEXT
         // "undefined" where Node produces the undefined VALUE (tsc's own lib
@@ -3268,6 +3295,41 @@ function lowerHashDigestChain(L, call, access) {
     }
     L.noLowering(`Hash.update of '${dataIr ? L.fmt(dataIr) : L.checker.typeToString(L.typeOf(dataNode))}' values`, dataNode, "string and Buffer/Uint8Array inputs are the lowered update forms");
 }
+/** The node:crypto introspection statics — build-time constants of the
+   * compiled runtime, baked at the call site (the http2.constants stance
+   * extended to calls): getFips() answers 0 (no FIPS provider can ever
+   * load into a compiled binary — Node's own answer for a non-FIPS
+   * build), and getCiphers()/getHashes()/getCurves() answer Node v24's
+   * name lists as fresh string[] literals. The lists are INTROSPECTION
+   * data (Node's contract is "names the provider recognizes"); the
+   * operations behind the names keep their per-member fences — a program
+   * that probes the list and then constructs a cipher fences at the
+   * construction site, never here. Null for other members (the dispatch
+   * keeps trying). */
+export function lowerCryptoModuleCall(L, expr, bi, loc) {
+    if (bi.module !== "crypto")
+        return null;
+    const LISTS = {
+        getCiphers: CRYPTO_CIPHERS,
+        getHashes: CRYPTO_HASHES,
+        getCurves: CRYPTO_CURVES,
+    };
+    const list = own(LISTS, bi.member);
+    if (bi.member !== "getFips" && list === undefined)
+        return null;
+    if (expr.arguments.length !== 0) {
+        L.noLowering(`crypto.${bi.member} with ${expr.arguments.length} arguments`, expr);
+    }
+    if (bi.member === "getFips") {
+        return { kind: "numLit", value: 0, type: F64, loc };
+    }
+    return {
+        kind: "arrayLit",
+        elems: list.map((s) => ({ kind: "strLit", value: s, type: STRING, loc })),
+        type: arrayOf(STRING),
+        loc,
+    };
+}
 /** Method calls on URL-typed receivers: `u.toString()` is Node's href
    * serialization (the href getter's libCall). Everything else the lib
    * declares fences member-qualified. Null for non-URL receivers. */
@@ -3390,7 +3452,7 @@ export function lowerSearchParamsMethodCall(L, call, access) {
     // One name/value slot, WHATWG USVString rules: statically-string
     // arguments lower directly; a symbol can never convert (V8's
     // TypeError, statically decided); everything else crosses into the
-    // DOM and coerces at runtime with the object protocol (a user
+    // dyn and coerces at runtime with the object protocol (a user
     // toString/valueOf runs and its throw propagates).
     const strArg = (i) => {
         const node = args[i];
@@ -3402,7 +3464,7 @@ export function lowerSearchParamsMethodCall(L, call, access) {
         }
         let v;
         if (ts.isObjectLiteralExpression(node)) {
-            // Object literals take the DOM literal path directly (method
+            // Object literals take the dyn literal path directly (method
             // members box as dyn functions — the typed record fence never
             // applies to the coercion probes).
             v = lowerDynObjectLiteral(L, node);
@@ -3415,7 +3477,7 @@ export function lowerSearchParamsMethodCall(L, call, access) {
                 v = { kind: "dynFrom", value: raw, type: DYN, loc: raw.loc };
             }
             else if (raw.type.kind === "record") {
-                // A RECORD-represented value that cannot cross into the DOM (a
+                // A RECORD-represented value that cannot cross into the checked-dynamic tree (a
                 // func-carrying shape — the throwing-toString probes): run
                 // ToPrimitive's string hint STATICALLY. A zero-parameter
                 // toString func member is called (its throw propagates); a
@@ -3430,7 +3492,7 @@ export function lowerSearchParamsMethodCall(L, call, access) {
                     tsMember.type.kind === "func" &&
                     tsMember.type.params.length === 0 &&
                     L.dynConvertible(tsMember.type)) {
-                    // Box just the toString member into a fresh DOM carrier and
+                    // Box just the toString member into a fresh dyn carrier and
                     // run the protocol at runtime — the boxed call propagates its
                     // throw, string answers convert, and a bare (void) return is
                     // ToString(undefined), all through one path.
@@ -3446,11 +3508,11 @@ export function lowerSearchParamsMethodCall(L, call, access) {
                     };
                 }
                 else {
-                    L.noLowering(`URLSearchParams.${name} with a '${L.fmt(raw.type)}' argument`, node, "string arguments are the lowered shape (other values coerce through the DOM — narrow unions first)");
+                    L.noLowering(`URLSearchParams.${name} with a '${L.fmt(raw.type)}' argument`, node, "string arguments are the lowered shape (other values coerce through the checked-dynamic tree — narrow unions first)");
                 }
             }
             else {
-                L.noLowering(`URLSearchParams.${name} with a '${L.fmt(raw.type)}' argument`, node, "string arguments are the lowered shape (other values coerce through the DOM — narrow unions first)");
+                L.noLowering(`URLSearchParams.${name} with a '${L.fmt(raw.type)}' argument`, node, "string arguments are the lowered shape (other values coerce through the checked-dynamic tree — narrow unions first)");
             }
         }
         return { kind: "libCall", fn: "dyn.toStringCoerce", args: [v], type: STRING, loc };
@@ -4552,7 +4614,7 @@ export function lowerQuerystringParseCall(L, call, loc) {
     return { kind: "libCall", fn: "qs.parse", args: [str, sep, eq, maxKeys], type: result, loc };
 }
 /** querystring.stringify / querystring.encode: the object crosses as a
- * DOM value (dynFrom — JSON-safe records and, in JS sources, dyn values
+ * dyn value (dynFrom — JSON-safe records and, in JS sources, dyn values
  * directly) and Node's encodeStringified rules run in the runtime
  * (scr_qs_stringify), so arrays expand to repeated keys and
  * null/undefined values are empty. The default encoder is the one
@@ -4844,19 +4906,29 @@ export function lowerProcessMethodCall(L, call, access) {
         // (test-event-emitter-special-event-names.js's process.on).
         const SIGNALS = { SIGINT: 2, SIGTERM: 15 };
         const signo = event !== null ? own(SIGNALS, event) : undefined;
-        // 'unhandledRejection': the listener crosses as a DOM function and
+        // 'unhandledRejection': the listener crosses as a dyn function and
         // the loop-end report dispatches it (reason, promise) per
         // never-observed rejection instead of printing and exiting 1
         // (scr_async.c; the end-of-turn timing is a SEMANTICS.md
-        // divergence). `once`/`off` forms have no removal story yet.
-        if (event === "unhandledRejection" && member === "on") {
+        // divergence). `once` auto-removes after one delivery and
+        // `off`/`removeListener` remove by closure identity — the warning
+        // registry's story. 'rejectionHandled' is the sibling registry:
+        // under the loop-exhaustion model its ONE firing window is a
+        // handler attached during an unhandledRejection listener (earlier
+        // handling never enters the report at all — the same documented
+        // divergence), dispatched synchronously with the promise.
+        if (event === "unhandledRejection" || event === "rejectionHandled") {
             if (!ts.isExpressionStatement(call.parent)) {
                 L.unsupported("SC1090", call, "chaining process listener registration (the result is void here — register each listener as its own statement)");
             }
             const cb = dcSubscriberArg(L, call.arguments[1]);
-            return { kind: "libCall", fn: "process.onUnhandledRejection", args: [cb], type: VOID, loc };
+            const onceArg = { kind: "boolLit", value: member === "once", type: BOOL, loc };
+            const fn = event === "unhandledRejection"
+                ? (isOff ? "process.offUnhandledRejection" : "process.onUnhandledRejection")
+                : (isOff ? "process.offRejectionHandled" : "process.onRejectionHandled");
+            return { kind: "libCall", fn, args: isOff ? [cb] : [cb, onceArg], type: VOID, loc };
         }
-        // 'warning': the listener crosses as a DOM function; emitWarning
+        // 'warning': the listener crosses as a dyn function; emitWarning
         // and the runtime deprecation sites dispatch synchronously
         // (SEMANTICS.md). off/removeListener remove by closure identity.
         if (event === "warning" && (member === "on" || isOff)) {
@@ -4873,7 +4945,7 @@ export function lowerProcessMethodCall(L, call, access) {
             };
         }
         if (signo === undefined && event !== "exit") {
-            L.noLowering(`process.${member}(${event === null ? "non-literal event" : `"${event}"`}, ...)`, call.arguments[0], '"SIGINT", "SIGTERM", "exit", "warning", and "unhandledRejection" (on) are the supported process events (as literals)');
+            L.noLowering(`process.${member}(${event === null ? "non-literal event" : `"${event}"`}, ...)`, call.arguments[0], '"SIGINT", "SIGTERM", "exit", "warning", "unhandledRejection", and "rejectionHandled" are the supported process events (as literals)');
         }
         if (!ts.isExpressionStatement(call.parent)) {
             L.unsupported("SC1090", call, "chaining process listener registration (the result is void here — register each listener as its own statement)");
@@ -4931,7 +5003,7 @@ export function lowerProcessMethodCall(L, call, access) {
         }
         return { kind: "libCall", fn: "process.onExit", args: [cb, onceArg], type: VOID, loc };
     }
-    // process.emitWarning(...): the argument vector crosses as ONE DOM
+    // process.emitWarning(...): the argument vector crosses as ONE dyn
     // array and the runtime applies Node's full grammar (string or Error
     // warning; type/ctor/options second; code/ctor third — wrong kinds
     // throw ERR_INVALID_ARG_TYPE). A single SPREAD of a checked-dynamic
@@ -5596,9 +5668,70 @@ export function lowerPromiseStaticCall(L, call, access) {
                 };
                 return { kind: "intrinsic", name: "promise.all", args: [entriesArr], type: resultT, loc };
             }
+            // MIXED entries where some entry is already an ISLAND value (the
+            // withPlugins shape: Promise.all([loadBuiltinPlugins(),
+            // loadPlugins(plugins)]) with an 'any'-typed loader): the
+            // ENGINE's own Promise.all runs — island entries pass through,
+            // STATIC promises cross as real engine thenables (the reverse
+            // bridge, payload-domain gated), plain values marshal per the
+            // boundary — and the combined result stays an island value
+            // (awaiting it rides the island→static promise bridge; element
+            // reads are the routed keyed ops). All-static tuples keep the
+            // typed fence hint below. --dynamic only by construction: jsval
+            // entries exist only there.
+            if (elems.some((e) => e.type.kind === "jsval")) {
+                const diagsBefore = L.diags.length;
+                try {
+                    const marshaled = argNode.elements.map((el, i) => L.jsvalIn(elems[i], el));
+                    return {
+                        kind: "jsOp",
+                        op: "callMethod",
+                        name: "all",
+                        args: [
+                            { kind: "jsOp", op: "globalGet", name: "Promise", args: [], type: JSVAL, loc },
+                            { kind: "jsOp", op: "arrLit", args: marshaled, type: JSVAL, loc },
+                        ],
+                        type: JSVAL,
+                        loc,
+                    };
+                }
+                catch (err) {
+                    // An entry outside every crossing domain: drop the boundary
+                    // diagnostics and let the shape fence below name the fix.
+                    if (!(err instanceof PoisonError))
+                        throw err;
+                    L.diags.splice(diagsBefore);
+                }
+            }
             L.noLowering("Promise.all over this argument shape", argNode, "the entries must share ONE promise type — Promise.all([p, q]) lowers when p and q are the same Promise<T>");
         }
         const entries = L.lowerExpr(argNode);
+        // A NON-literal island argument (`Promise.all(plugins.map((p) =>
+        // loadPlugin(p)))` — the loadPlugins shape, where the checker
+        // spells `any[]`): the ENGINE's own Promise.all runs over the
+        // marshaled array (an 'any' value passes through; an `any[]` value
+        // lifts per element by reference), the result staying an island
+        // value the static side awaits through the island→static bridge.
+        if (entries.type.kind === "jsval" ||
+            (entries.type.kind === "array" && entries.type.elem.kind === "jsval")) {
+            const diagsBefore = L.diags.length;
+            try {
+                const arg = L.jsvalIn(entries, argNode);
+                return {
+                    kind: "jsOp",
+                    op: "callMethod",
+                    name: "all",
+                    args: [{ kind: "jsOp", op: "globalGet", name: "Promise", args: [], type: JSVAL, loc }, arg],
+                    type: JSVAL,
+                    loc,
+                };
+            }
+            catch (err) {
+                if (!(err instanceof PoisonError))
+                    throw err;
+                L.diags.splice(diagsBefore);
+            }
+        }
         if (entries.type.kind !== "array" || entries.type.elem.kind !== "promise") {
             // The heterogeneous-literal case: the checker's tuple overload
             // types the literal as a TUPLE of promises (a tuple-flagged record