@scriptc/compiler 0.0.10 → 0.0.12

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

@@ -2,10 +2,16 @@
  * crypto, child_process spawn/spawnSync and child/stats/spawn-result
  * methods), JSON.parse/stringify, process properties/methods and
  * process.env access, and console.log detection. */
+import { readFileSync } from "node:fs";
 import { builtinModules } from "node:module";
+import { dirname, resolve } from "node:path";
 import * as ts from "../ts7/adapter.js";
-import { dynUndefinedExpr, ladderFenceExpr, nodeThrowExpr, own } from "./lowerer.js";
+import { PoisonError, dynUndefinedExpr, ladderFenceExpr, nodeThrowExpr, own } from "./lowerer.js";
 import { canonicalBuiltinModule, isJsSourceFile, locOf, requireSpecOf } from "../program.js";
+import { isRelativeSpecifier } from "../shared.js";
+import { probeNodeRequireRefusal } from "../npm.js";
+import { isNpmStaticPackage } from "../npm-static.js";
+import { invalidJsonModuleDiag, requiresDynamicImportDiag } from "../../diagnostics/diagnostic.js";
 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";
@@ -132,9 +138,17 @@ export function builtinMemberRequireDecl(nameNode, init) {
 export function builtinNamespaceDestructureModuleOf(L, decl) {
     if (decl.name === undefined || !ts.isObjectBindingPattern(decl.name) || decl.initializer === undefined)
         return null;
-    if (!ts.isIdentifier(decl.initializer))
-        return null;
-    const module = L.builtinNamespaceModuleOf(decl.initializer);
+    // `const { join } = require("node:path")` through a createRequire
+    // binding: the call IS the namespace — same table keying.
+    let module = null;
+    const init = stripTypeCasts(decl.initializer);
+    if (ts.isCallExpression(init)) {
+        const cr = createRequireSpecOf(L, init);
+        module = cr !== null && cr.spec !== null ? canonicalBuiltinModule(cr.spec) : null;
+    }
+    else if (ts.isIdentifier(init)) {
+        module = L.builtinNamespaceModuleOf(init);
+    }
     if (module === null)
         return null;
     for (const el of decl.name.elements) {
@@ -145,6 +159,223 @@ export function builtinNamespaceDestructureModuleOf(L, decl) {
     }
     return module;
 }
+/* ── node:module — createRequire's static erasure ─────────────────────
+ * The config/version-reading pattern real CLIs ship:
+ *   import { createRequire } from "node:module";
+ *   const require = createRequire(import.meta.url);
+ *   const pkg = require("../package.json");
+ * A compiled program's module graph is fixed at build time, so the
+ * indirection ERASES where the required specifier is a static string
+ * literal naming something the compiler already handles: a builtin (the
+ * binding is a namespace import in const clothing), a relative .json
+ * document (the file bakes and parses like JSON.parse of its text), or
+ * an installed npm package (the island's require-condition entry under
+ * --dynamic). Dynamic specifiers and other targets fence by name. */
+/** Strips the type-only wrappers the require pattern rides in typed
+   * code (`require("node:os") as typeof import("node:os")` — the
+   * fallback declarations answer `unknown`, so the cast IS the idiom),
+   * plus parens, legacy assertions, and non-null suffixes. */
+export function stripTypeCasts(e) {
+    let cur = e;
+    while (ts.isParenthesizedExpression(cur) || ts.isAsExpression(cur) ||
+        ts.isTypeAssertion(cur) || ts.isNonNullExpression(cur)) {
+        cur = cur.expression;
+    }
+    return cur;
+}
+/** The `createRequire(<base>)` call over the node:module import binding
+   * with a supported base — import.meta.url, import.meta.filename, or
+   * __filename, every spelling of "this file" — or null. The base never
+   * LOWERS (import.meta has no value representation): it only names the
+   * file whose directory anchors the returned require's relative
+   * resolution, and every supported spelling names the call's own file. */
+export function createRequireBaseCallOf(L, expr) {
+    const e = stripTypeCasts(expr);
+    if (!ts.isCallExpression(e) || e.questionDotToken)
+        return null;
+    if (!ts.isIdentifier(e.expression))
+        return null;
+    const bi = builtinImportOf(L, e.expression);
+    if (!bi || bi.module !== "module" || bi.member !== "createRequire")
+        return null;
+    if (e.arguments.length !== 1)
+        return null;
+    const base = stripTypeCasts(e.arguments[0]);
+    if (ts.isIdentifier(base) && base.text === "__filename")
+        return e;
+    if (ts.isPropertyAccessExpression(base) &&
+        !base.questionDotToken &&
+        ts.isMetaProperty(base.expression) &&
+        base.expression.keywordToken === ts.SyntaxKind.ImportKeyword &&
+        (base.name.text === "url" || base.name.text === "filename")) {
+        return e;
+    }
+    return null;
+}
+/** True for `const require = createRequire(import.meta.url)` — the
+   * binding is compile-time plumbing (each call through it resolves per
+   * site) with no storage and no code; both declaration walks skip by
+   * this test. A reassignable (let/var) binding never matches — callers
+   * gate on constness like the other alias decls. */
+export function createRequireBindingDecl(L, nameNode, init) {
+    if (!ts.isIdentifier(nameNode) || init === undefined)
+        return false;
+    return createRequireBaseCallOf(L, init) !== null;
+}
+/** The declaring source file when `callee` denotes a createRequire-made
+   * require: a CONST binding over createRequire(import.meta.url) (the
+   * binding's own file anchors resolution) or the inline
+   * `createRequire(import.meta.url)(...)` spelling (the call's file).
+   * Null off the pattern, so call chains keep trying. */
+export function createRequireCalleeFileOf(L, callee) {
+    const e = stripTypeCasts(callee);
+    if (ts.isCallExpression(e)) {
+        return createRequireBaseCallOf(L, e) !== null ? e.getSourceFile() : null;
+    }
+    if (!ts.isIdentifier(e))
+        return null;
+    const symbol = L.checker.getSymbolAtLocation(e);
+    const decl = symbol ? L.checker.declarationsOf(symbol)[0] : undefined;
+    if (!decl || !ts.isVariableDeclaration(decl) || decl.initializer === undefined)
+        return null;
+    if (!ts.isVariableDeclarationList(decl.parent) || (decl.parent.flags & ts.NodeFlags.Const) === 0)
+        return null;
+    return createRequireBaseCallOf(L, decl.initializer) !== null ? decl.getSourceFile() : null;
+}
+/** The static require of `R("spec")` through a createRequire binding:
+   * the literal specifier plus the file anchoring relative resolution.
+   * Null when the callee is not a createRequire-made require; a matching
+   * callee with a non-literal (or missing) specifier answers spec null,
+   * so the call lowering fences by name instead of falling through to
+   * the generic call paths. */
+export function createRequireSpecOf(L, call) {
+    if (call.questionDotToken)
+        return null;
+    const baseFile = createRequireCalleeFileOf(L, call.expression);
+    if (baseFile === null)
+        return null;
+    if (call.arguments.length !== 1)
+        return { spec: null, baseFile };
+    const a = call.arguments[0];
+    return { spec: ts.isStringLiteralLike(a) ? a.text : null, baseFile };
+}
+/** True for `const fs = require("node:fs")` through a createRequire
+   * binding — a builtin namespace import in const clothing: alias
+   * plumbing with no storage (uses resolve through
+   * builtinNamespaceModuleOf's createRequire arm); both declaration
+   * walks skip by this test. */
+export function createRequireNamespaceDecl(L, nameNode, init) {
+    if (!ts.isIdentifier(nameNode) || init === undefined)
+        return false;
+    const call = stripTypeCasts(init);
+    if (!ts.isCallExpression(call))
+        return false;
+    const cr = createRequireSpecOf(L, call);
+    return cr !== null && cr.spec !== null && canonicalBuiltinModule(cr.spec) !== null;
+}
+/** `require("spec")` through a createRequire binding — the erasure per
+   * target. Builtins are reached here only OUTSIDE the const-namespace-
+   * binding shape (that declaration erases; member uses resolve through
+   * the namespace tables) and fence toward it. A relative .json document
+   * bakes: the file's text validates as JSON at compile time and the
+   * call lowers to json.parse over the baked literal — JSON.parse's
+   * checked-dynamic `unknown` stance, and exactly Node's value (require
+   * of JSON IS JSON.parse of the file; the per-call re-parse forgoes
+   * Node's module-cache identity, unobservable without mutation). A bare
+   * specifier NOTHING installed resolves compiles to Node's catchable
+   * MODULE_NOT_FOUND throw (the optional-dependency try/require
+   * pattern); an installed package loads through the island's
+   * require-condition entry under --dynamic (collectCreateRequires
+   * embedded it) and reports the requires-dynamic diagnostic in a static
+   * build. Null when the callee is not a createRequire require. */
+export function lowerCreateRequireCall(L, call, loc) {
+    const cr = createRequireSpecOf(L, call);
+    if (cr === null)
+        return null;
+    if (cr.spec === null) {
+        L.noLowering("createRequire's require with this argument shape", call, "the compiled module graph is fixed at build time — the one lowered form is require(\"<static string literal>\")");
+    }
+    const spec = cr.spec;
+    if (canonicalBuiltinModule(spec) !== null) {
+        L.unsupported("SC1090", call, `module namespace objects as values (bind it first: const m = require("${spec}"), then access members through the binding)`);
+    }
+    if (spec.startsWith("#")) {
+        L.noLowering(`createRequire's require of the '${spec}' project import`, call, "imports-field specifiers have no require lowering yet — import the target statically");
+    }
+    if (isRelativeSpecifier(spec) || spec.startsWith("/")) {
+        if (!spec.endsWith(".json")) {
+            L.noLowering(`createRequire's require of '${spec}'`, call, "relative requires lower for .json documents only — a program module is a static import");
+        }
+        const abs = spec.startsWith("/")
+            ? spec
+            : resolve(dirname(cr.baseFile.fileName), spec);
+        let text = null;
+        try {
+            text = readFileSync(abs, "utf8");
+        }
+        catch {
+            /* the fence below speaks */
+        }
+        if (text === null) {
+            L.noLowering(`createRequire's require of '${spec}' (no file at ${abs})`, call, "the required document resolves at build time — check the path against the requiring file");
+        }
+        try {
+            JSON.parse(text);
+        }
+        catch (e) {
+            L.pushDiag(invalidJsonModuleDiag(abs, e instanceof Error ? e.message : String(e), loc));
+            throw new PoisonError();
+        }
+        return {
+            kind: "libCall",
+            fn: "json.parse",
+            args: [{ kind: "strLit", value: text, type: STRING, loc }],
+            type: DYN,
+            loc,
+        };
+    }
+    // Bare package specifiers. --npm-static opt-ins are program modules —
+    // their exports bind through static imports, not a require value.
+    const pkgName = spec.startsWith("@")
+        ? spec.split("/").slice(0, 2).join("/")
+        : spec.split("/")[0];
+    if (isNpmStaticPackage(pkgName)) {
+        L.noLowering(`createRequire's require of the --npm-static package '${pkgName}'`, call, "the opted-in package compiles as program modules — import it statically");
+    }
+    const refusal = probeNodeRequireRefusal(cr.baseFile.fileName, spec);
+    if (refusal !== null) {
+        // Node's require-site MODULE_NOT_FOUND, catchable — the compiled
+        // expression IS that throw (the typed dummy is abandoned by the
+        // pending check's unwind).
+        return nodeThrowExpr(0, "MODULE_NOT_FOUND", refusal.message, DYN, loc);
+    }
+    if (!L.dynamic) {
+        L.pushDiag(requiresDynamicImportDiag(pkgName, loc));
+        throw new PoisonError();
+    }
+    const res = L.createRequireImports.get(`${cr.baseFile.fileName}\u0000${spec}`);
+    if (res === undefined) {
+        // Collection never saw the site (a shape this walk and that walk
+        // disagree on) — fence rather than mis-embed.
+        L.noLowering(`createRequire's require of '${spec}'`, call, undefined);
+    }
+    if (res === "")
+        throw new PoisonError(); // reported at collection
+    // A CJS facade's default IS module.exports (Node's require answer);
+    // an ESM-resolved entry answers its namespace (Node's require(esm)).
+    const exportName = res.format === "esm" ? "*" : "default";
+    return {
+        kind: "libCall",
+        fn: "island.import",
+        args: [
+            { kind: "strLit", value: res.entryKey, type: STRING, loc },
+            { kind: "strLit", value: exportName, type: STRING, loc },
+            { kind: "strLit", value: spec, type: STRING, loc },
+        ],
+        type: JSVAL,
+        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,
@@ -356,7 +587,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) {
@@ -374,7 +605,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
@@ -388,7 +619,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)
@@ -426,7 +657,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).
@@ -548,7 +779,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.
@@ -586,7 +817,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.
@@ -2253,7 +2484,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. */
@@ -2275,14 +2506,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));
@@ -2293,7 +2524,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
@@ -2334,7 +2565,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") &&
@@ -2377,7 +2608,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)
@@ -2447,8 +2678,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)
@@ -2477,7 +2708,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) {
@@ -2490,9 +2721,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
@@ -2763,7 +2994,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
@@ -2817,8 +3048,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
@@ -3159,7 +3390,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];
@@ -3171,7 +3402,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);
@@ -3184,7 +3415,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
@@ -3199,7 +3430,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.
@@ -3215,11 +3446,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 };
@@ -4321,7 +4552,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
@@ -4613,7 +4844,7 @@ 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
@@ -4625,7 +4856,7 @@ export function lowerProcessMethodCall(L, call, access) {
             const cb = dcSubscriberArg(L, call.arguments[1]);
             return { kind: "libCall", fn: "process.onUnhandledRejection", args: [cb], 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)) {
@@ -4700,7 +4931,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
@@ -5365,9 +5596,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