@scriptc/compiler 0.2.3 → 0.2.5

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

@@ -1,27 +1,28 @@
+import { dynUndefinedExpr, nodeThrowExpr } from "../../ir/build.js";
 import { InternalCompilerError } from "../../errors.js";
 /* Island-boundary lowering: jsval marshaling into the island (jsvalIn and
  * its boundary fences), island-expression detection, the island method-call
  * surface (Math and number/string methods under --dynamic), and the npm
  * package boundary fences for node_modules-declared symbols. */
 import * as ts from "../ts7/adapter.js";
-import { arrayOf, BOOL, BYTES_U8, DYN, F64, JSVAL, MAX_ISLAND_CALLBACK_ARITY, STRING, VOID, canConvertToDyn, canMarshalTypedFuncIntoIsland, islandPromisePayloadTag, isUnitType } from "../../ir/ir.js";
-import { ISLAND_SURFACE, STATIC_MATH_FNS, STATIC_MATH_PROPS, boundaryIntoIslandMsg, stdlibGlobalNameOf } from "./surfaces.js";
-import { requiresDynamicApiDiag, requiresDynamicPackageDiag } from "../../diagnostics/diagnostic.js";
-import { esmNamedImportLinkCrash, isCjsJsFile, isJsSourceFile, locOf, npmPackageNameOf } from "../program.js";
+import { arrayOf, BOOL, BYTES_U8, DYN, F64, JSVAL, MAX_ISLAND_CALLBACK_ARITY, STRING, VOID, canConvertToDyn, canMarshalTypedFuncIntoIsland, islandPromisePayloadTag, isUnitType, } from "../../ir/ir.js";
+import { ISLAND_SURFACE, STATIC_MATH_FNS, STATIC_MATH_PROPS, boundaryIntoIslandMsg, stdlibGlobalNameOf, } from "./surfaces.js";
+import { requiresDynamicApiDiag, requiresDynamicPackageDiag, } from "../../diagnostics/diagnostic.js";
+import { esmNamedImportLinkCrash, isCjsJsFile, isJsSourceFile, locOf, npmPackageNameOf, } from "../program.js";
 import { foldedStringKeyOf, lowerDynObjectLiteral } from "./expressions/object-literals.js";
 import { isSafeToRepeat } from "./expressions/evaluation-safety.js";
-import { PoisonError, dynUndefinedExpr, newFnCtx, nodeThrowExpr, own } from "./lowerer.js";
+import { PoisonError, newFnCtx, own } from "./lowerer.js";
 import { NODE24_FETCH_COMPAT_PROFILE, STATIC_HEADERS_CALLS, STATIC_READABLE_STREAM_CALLS, STATIC_READABLE_STREAM_READS, STATIC_RESPONSE_CALLS, STATIC_RESPONSE_READS, } from "../../compat/fetch-profile.js";
 /** True iff the checker's type for this node maps to jsval ('any') —
-   * the island test in front of every engine-op lowering (receivers,
-   * callees, assignment targets). ALSO true for an identifier bound to an
-   * island-HANDLE local whose declared type says otherwise (`const {
-   * readFileSync } = await import("fs")` — the binding's declared
-   * function/Buffer type never held the value; the handle is the value's
-   * only story), so its uses dispatch to engine ops instead of
-   * re-reporting the declared type. The one exclusion is promise-mapped
-   * declared types: a package promise held as a handle keeps its existing
-   * checker-driven dispatch (the await/.catch bridge lowerings own it). */
+ * the island test in front of every engine-op lowering (receivers,
+ * callees, assignment targets). ALSO true for an identifier bound to an
+ * island-HANDLE local whose declared type says otherwise (`const {
+ * readFileSync } = await import("fs")` — the binding's declared
+ * function/Buffer type never held the value; the handle is the value's
+ * only story), so its uses dispatch to engine ops instead of
+ * re-reporting the declared type. The one exclusion is promise-mapped
+ * declared types: a package promise held as a handle keeps its existing
+ * checker-driven dispatch (the await/.catch bridge lowerings own it). */
 export function isIslandExpr(lowerer, node) {
     // Static builds cannot contain island handles. Avoid mapping entire
     // receiver/callee types (and their checker RPCs) just to prove that.
@@ -43,10 +44,10 @@ export function isIslandExpr(lowerer, node) {
     return false;
 }
 /** Marshal a static value into the island (--dynamic): primitives by
-   * value, JSON-safe composites as a deep copy (the documented aliasing
-   * divergence). Values with no island representation — closures, class
-   * instances, promises, un-validated 'unknown' — are rejected with the
-   * boundary message. */
+ * value, JSON-safe composites as a deep copy (the documented aliasing
+ * divergence). Values with no island representation — closures, class
+ * instances, promises, un-validated 'unknown' — are rejected with the
+ * boundary message. */
 /** The call-time deferral of a FUNC-value island crossing in a JS
  * source: captures the just-recorded diagnostic into the runtime-fence
  * ledger and answers a marshaled host closure that THROWS it when
@@ -78,7 +79,13 @@ export function jsvalIn(lowerer, e, node) {
     // engine's own units — unit-typed expressions are literals (units have
     // no other producers), so dropping the operand loses nothing.
     if (isUnitType(e.type)) {
-        return { kind: "jsOp", op: e.type.kind === "undefinedT" ? "undefLit" : "nullLit", args: [], type: JSVAL, loc: e.loc };
+        return {
+            kind: "jsOp",
+            op: e.type.kind === "undefinedT" ? "undefLit" : "nullLit",
+            args: [],
+            type: JSVAL,
+            loc: e.loc,
+        };
     }
     if (e.type.kind === "dyn") {
         // A CHECKED-DYNAMIC value entering the island: the dyn tree
@@ -154,11 +161,11 @@ export function jsvalIn(lowerer, e, node) {
     return { kind: "jsMarshal", value: e, type: JSVAL, loc: e.loc };
 }
 /** A static RegExp value as a fresh ENGINE RegExp — `new RegExp(source,
-   * flags)` in the island, the pattern TEXT crossing (both worlds compile
-   * the ES-spec grammar). Literals rebuild from their own pattern/flags;
-   * pure reads (a regex-typed binding) read the source/flags intrinsics —
-   * the rebuild emits the operand twice, so effectful producers return
-   * null into the caller's boundary fence. */
+ * flags)` in the island, the pattern TEXT crossing (both worlds compile
+ * the ES-spec grammar). Literals rebuild from their own pattern/flags;
+ * pure reads (a regex-typed binding) read the source/flags intrinsics —
+ * the rebuild emits the operand twice, so effectful producers return
+ * null into the caller's boundary fence. */
 export function islandRegexpOf(e) {
     if (e.type.kind !== "regex")
         return null;
@@ -176,7 +183,14 @@ export function islandRegexpOf(e) {
     else {
         return null;
     }
-    const ctor = { kind: "jsOp", op: "globalGet", name: "RegExp", args: [], type: JSVAL, loc };
+    const ctor = {
+        kind: "jsOp",
+        op: "globalGet",
+        name: "RegExp",
+        args: [],
+        type: JSVAL,
+        loc,
+    };
     return {
         kind: "jsOp",
         op: "construct",
@@ -190,9 +204,9 @@ export function islandRegexpOf(e) {
     };
 }
 /** The gate on every ISLAND_SURFACE lowering: under --dynamic the caller
-   * proceeds to engine ops; without it the use site is a per-site SC2012
-   * (poison-recovered, so every site in the program reports — and the
-   * coverage report groups them under "runs with --dynamic"). */
+ * proceeds to engine ops; without it the use site is a per-site SC2012
+ * (poison-recovered, so every site in the program reports — and the
+ * coverage report groups them under "runs with --dynamic"). */
 export function requireDynamicApi(lowerer, feature, node) {
     if (lowerer.dynamic)
         return;
@@ -200,9 +214,9 @@ export function requireDynamicApi(lowerer, feature, node) {
     throw new PoisonError();
 }
 /** Resolves an identifier to an island-backed ambient GLOBAL function
-   * (parseFloat, isFinite). Provenance, not name: the
-   * symbol's declaration must live in the ambient file, so a user function
-   * named `parseFloat` never matches. */
+ * (parseFloat, isFinite). Provenance, not name: the
+ * symbol's declaration must live in the ambient file, so a user function
+ * named `parseFloat` never matches. */
 export function islandGlobalFnOf(lowerer, ident) {
     const entry = own(ISLAND_SURFACE.globals, ident.text);
     if (!entry)
@@ -262,8 +276,7 @@ function requestInitPropMutatedSymbols(lowerer) {
     const symbols = new Set();
     const noteBase = (target) => {
         let base = requestInitValueExpr(target);
-        while (ts.isPropertyAccessExpression(base) ||
-            ts.isElementAccessExpression(base)) {
+        while (ts.isPropertyAccessExpression(base) || ts.isElementAccessExpression(base)) {
             base = requestInitValueExpr(base.expression);
         }
         if (!ts.isIdentifier(base))
@@ -284,16 +297,13 @@ function requestInitPropMutatedSymbols(lowerer) {
             if (ts.isBinaryExpression(node) &&
                 node.operatorToken.kind >= ts.SyntaxKind.FirstAssignment &&
                 node.operatorToken.kind <= ts.SyntaxKind.LastAssignment &&
-                (ts.isPropertyAccessExpression(node.left) ||
-                    ts.isElementAccessExpression(node.left))) {
+                (ts.isPropertyAccessExpression(node.left) || ts.isElementAccessExpression(node.left))) {
                 noteBase(node.left);
             }
-            else if ((ts.isPrefixUnaryExpression(node) ||
-                ts.isPostfixUnaryExpression(node)) &&
+            else if ((ts.isPrefixUnaryExpression(node) || ts.isPostfixUnaryExpression(node)) &&
                 (node.operator === ts.SyntaxKind.PlusPlusToken ||
                     node.operator === ts.SyntaxKind.MinusMinusToken) &&
-                (ts.isPropertyAccessExpression(node.operand) ||
-                    ts.isElementAccessExpression(node.operand))) {
+                (ts.isPropertyAccessExpression(node.operand) || ts.isElementAccessExpression(node.operand))) {
                 noteBase(node.operand);
             }
             else if (ts.isDeleteExpression(node)) {
@@ -315,8 +325,8 @@ function requestInitConstBacked(lowerer, value, seen) {
         if (selected !== null) {
             return requestInitConstBacked(lowerer, selected ? expr.whenTrue : expr.whenFalse, new Set(seen));
         }
-        return requestInitConstBacked(lowerer, expr.whenTrue, new Set(seen)) &&
-            requestInitConstBacked(lowerer, expr.whenFalse, new Set(seen));
+        return (requestInitConstBacked(lowerer, expr.whenTrue, new Set(seen)) &&
+            requestInitConstBacked(lowerer, expr.whenFalse, new Set(seen)));
     }
     if (!ts.isIdentifier(expr))
         return false;
@@ -326,11 +336,14 @@ function requestInitConstBacked(lowerer, value, seen) {
     if (requestInitPropMutatedSymbols(lowerer).has(symbol))
         return false;
     seen.add(symbol);
-    const declarations = lowerer.checker.declarationsOf(symbol).filter((declaration) => ts.isVariableDeclaration(declaration) &&
+    const declarations = lowerer.checker
+        .declarationsOf(symbol)
+        .filter((declaration) => ts.isVariableDeclaration(declaration) &&
         declaration.initializer !== undefined &&
         ts.isVariableDeclarationList(declaration.parent) &&
         (declaration.parent.flags & ts.NodeFlags.Const) !== 0);
-    return declarations.length > 0 && declarations.every((declaration) => requestInitConstBacked(lowerer, declaration.initializer, new Set(seen)));
+    return (declarations.length > 0 &&
+        declarations.every((declaration) => requestInitConstBacked(lowerer, declaration.initializer, new Set(seen))));
 }
 /** Visit the values selected by one key or index on a const-backed object or
  * array. Property symbols can come from annotations rather than the literal
@@ -355,8 +368,7 @@ function visitRequestInitConstSelectedValues(lowerer, value, selector, seen, vis
             if (ts.isPropertyAssignment(property)) {
                 visit(property.initializer);
             }
-            else if (ts.isShorthandPropertyAssignment(property) &&
-                ts.isIdentifier(property.name)) {
+            else if (ts.isShorthandPropertyAssignment(property) && ts.isIdentifier(property.name)) {
                 visit(property.name);
             }
             return true;
@@ -365,9 +377,7 @@ function visitRequestInitConstSelectedValues(lowerer, value, selector, seen, vis
     }
     if (selector.kind === "index" && ts.isArrayLiteralExpression(expr)) {
         const element = expr.elements[selector.index];
-        if (element === undefined ||
-            ts.isOmittedExpression(element) ||
-            ts.isSpreadElement(element)) {
+        if (element === undefined || ts.isOmittedExpression(element) || ts.isSpreadElement(element)) {
             return false;
         }
         visit(element);
@@ -493,15 +503,18 @@ function fenceRequestInitProperty(lowerer, access, seen) {
         if (ts.isPropertyAssignment(declaration)) {
             fenceRequestInitValueInner(lowerer, declaration.initializer, seen);
         }
-        else if (ts.isShorthandPropertyAssignment(declaration) &&
-            ts.isIdentifier(declaration.name)) {
+        else if (ts.isShorthandPropertyAssignment(declaration) && ts.isIdentifier(declaration.name)) {
             fenceRequestInitValueInner(lowerer, declaration.name, seen);
         }
     }
 }
 function fenceRequestInitObject(lowerer, init, seen) {
     const contextual = lowerer.checker.getContextualType(init);
-    const contextualArms = contextual?.isUnionType() ? ts.constituentTypes(contextual) : contextual ? [contextual] : [];
+    const contextualArms = contextual?.isUnionType()
+        ? ts.constituentTypes(contextual)
+        : contextual
+            ? [contextual]
+            : [];
     const rows = NODE24_FETCH_COMPAT_PROFILE.inventory.entries.filter((entry) => entry.owner === "RequestInit" && entry.placement === "dictionary");
     const shadowed = new Set();
     const fence = (row, value, blame) => {
@@ -611,27 +624,27 @@ function fenceRequestInitValue(lowerer, value) {
     fenceRequestInitValueInner(lowerer, value, new Set());
 }
 /** USER-code `fetch(url)` / `fetch(url, init)` — the ambient global
-   * (provenance, not the name: a user's own `fetch` never matches).
-   *
-   * The static tier owns URL requests directly: scr_fetch_static runs
-   * over the native net/http/tls stack, consumes a checked-dynamic
-   * RequestInit object, and returns a promise of an opaque native
-   * Response handle. AbortSignal and readable Web Streams are native
-   * checked-dynamic handles too, so cancellation and streaming bodies
-   * stay engine-free.
-   *
-   * The engine's own fetch executes (the same one embedded npm code calls —
-   * scr_fetch.c over the native net/tls stack): the url marshals in (strings; template
-   * results), an init OBJECT LITERAL builds natively in the island through
-   * the existing 'any'-contextual literal path (RequestInit maps to jsval,
-   * so field values marshal individually and an AbortSignal handle passes
-   * straight through), and the engine's promise bridges to a static
-   * `promise of jsval` (jsBridgePromise) — `await fetch(...)` parks the
-   * fiber like any await and resumes with the Response HANDLE. Member
-   * reads/calls on the handle are engine ops; typed extraction happens at
-   * the user's narrowing sites through the validated-exit machinery.
-   * Null for anything that isn't THE ambient fetch, so lowerCall keeps
-   * trying. */
+ * (provenance, not the name: a user's own `fetch` never matches).
+ *
+ * The static tier owns URL requests directly: scr_fetch_static runs
+ * over the native net/http/tls stack, consumes a checked-dynamic
+ * RequestInit object, and returns a promise of an opaque native
+ * Response handle. AbortSignal and readable Web Streams are native
+ * checked-dynamic handles too, so cancellation and streaming bodies
+ * stay engine-free.
+ *
+ * The engine's own fetch executes (the same one embedded npm code calls —
+ * scr_fetch.c over the native net/tls stack): the url marshals in (strings; template
+ * results), an init OBJECT LITERAL builds natively in the island through
+ * the existing 'any'-contextual literal path (RequestInit maps to jsval,
+ * so field values marshal individually and an AbortSignal handle passes
+ * straight through), and the engine's promise bridges to a static
+ * `promise of jsval` (jsBridgePromise) — `await fetch(...)` parks the
+ * fiber like any await and resumes with the Response HANDLE. Member
+ * reads/calls on the handle are engine ops; typed extraction happens at
+ * the user's narrowing sites through the validated-exit machinery.
+ * Null for anything that isn't THE ambient fetch, so lowerCall keeps
+ * trying. */
 export function lowerFetchCall(lowerer, call) {
     const callee = call.expression;
     if (!ts.isIdentifier(callee) || callee.text !== "fetch")
@@ -700,7 +713,9 @@ export function lowerFetchCall(lowerer, call) {
                 type: STRING,
                 loc: locOf(inputNode),
             }
-            : input.type.kind === "dyn" ? inputRef : lowerer.coerceInto(inputNode, inputRef, STRING);
+            : input.type.kind === "dyn"
+                ? inputRef
+                : lowerer.coerceInto(inputNode, inputRef, STRING);
         const answer = {
             kind: "libCall",
             fn: input.type.kind === "dyn" ? "fetch.input" : "fetch.start",
@@ -710,7 +725,14 @@ export function lowerFetchCall(lowerer, call) {
         };
         return { kind: "seqExpr", stmts, result: answer, type: answer.type, loc };
     }
-    const fetchFn = { kind: "jsOp", op: "globalGet", name: "fetch", args: [], type: JSVAL, loc };
+    const fetchFn = {
+        kind: "jsOp",
+        op: "globalGet",
+        name: "fetch",
+        args: [],
+        type: JSVAL,
+        loc,
+    };
     // Init OBJECT LITERALS build natively in the island (the general
     // 'any'-contextual literal path can't claim them: the optional param's
     // contextual type is `RequestInit | undefined`, a union) — field
@@ -718,7 +740,9 @@ export function lowerFetchCall(lowerer, call) {
     // through and dashed header keys ("content-type") are plain engine
     // property names. Non-literal inits marshal as a whole (JSON-safe
     // records; a signal field inside one fences with the boundary rule).
-    const args = call.arguments.map((a) => ts.isObjectLiteralExpression(a) ? lowerIslandObjectLiteral(lowerer, a) : lowerer.jsvalIn(lowerer.lowerExpr(a), a));
+    const args = call.arguments.map((a) => ts.isObjectLiteralExpression(a)
+        ? lowerIslandObjectLiteral(lowerer, a)
+        : lowerer.jsvalIn(lowerer.lowerExpr(a), a));
     const raw = { kind: "jsOp", op: "callFn", args: [fetchFn, ...args], type: JSVAL, loc };
     return { kind: "jsBridgePromise", value: raw, type: { kind: "promise", inner: JSVAL }, loc };
 }
@@ -735,10 +759,7 @@ export function lowerStaticResponseCall(lowerer, call) {
     const access = call.expression;
     const member = staticResponseMemberName(lowerer, access);
     if (access.questionDotToken ||
-        (member !== "json" &&
-            member !== "text" &&
-            member !== "bytes" &&
-            member !== "arrayBuffer") ||
+        (member !== "json" && member !== "text" && member !== "bytes" && member !== "arrayBuffer") ||
         call.arguments.length !== 0) {
         return null;
     }
@@ -881,14 +902,10 @@ function fetchAccessMemberNames(lowerer, access) {
         : fetchElementMemberNames(lowerer, access.argumentExpression);
 }
 function fetchInventoryStatus(owner, member, placement) {
-    return NODE24_FETCH_COMPAT_PROFILE.inventory.entries.find((entry) => entry.owner === owner &&
-        entry.member === member &&
-        entry.placement === placement)?.status ?? null;
+    return (NODE24_FETCH_COMPAT_PROFILE.inventory.entries.find((entry) => entry.owner === owner && entry.member === member && entry.placement === placement)?.status ?? null);
 }
 function fetchInventoryReason(owner, member, placement) {
-    return NODE24_FETCH_COMPAT_PROFILE.inventory.entries.find((entry) => entry.owner === owner &&
-        entry.member === member &&
-        entry.placement === placement)?.reason;
+    return NODE24_FETCH_COMPAT_PROFILE.inventory.entries.find((entry) => entry.owner === owner && entry.member === member && entry.placement === placement)?.reason;
 }
 /** Constructor-object operations are distinct from Response instance
  * methods. The inventory marks the former unsupported in both tiers; fence
@@ -906,14 +923,13 @@ export function fenceUnsupportedFetchConstructorMember(lowerer, access) {
     lowerer.noLowering(`Response.${member}`, access, "Response static constructor-object operations have no compiler lowering in either tier");
 }
 function hasLiveWebMutableArm(lowerer, type) {
-    if (type.kind === "record" ||
-        type.kind === "array" ||
-        type.kind === "bytes") {
+    if (type.kind === "record" || type.kind === "array" || type.kind === "bytes") {
         return true;
     }
     if (type.kind !== "union")
         return false;
-    return lowerer.unions.get(type.unionId)?.arms.some((arm) => hasLiveWebMutableArm(lowerer, arm)) ?? false;
+    return (lowerer.unions.get(type.unionId)?.arms.some((arm) => hasLiveWebMutableArm(lowerer, arm)) ??
+        false);
 }
 /** Box mutable data for Web API slots that expose the exact JavaScript
  * value again. Ordinary dynFrom remains the documented copy boundary;
@@ -938,8 +954,7 @@ function fetchMethodArgumentIsLive(owner, members, index) {
     return ((index === 0 &&
         ((owner === "ReadableStreamDefaultController" &&
             members.some((member) => member === "enqueue" || member === "error")) ||
-            ((owner === "ReadableStream" ||
-                owner === "ReadableStreamDefaultReader") &&
+            ((owner === "ReadableStream" || owner === "ReadableStreamDefaultReader") &&
                 members.includes("cancel")) ||
             (owner === "AbortController" && members.includes("abort")))) ||
         (index === 1 &&
@@ -962,9 +977,7 @@ export function fenceStaticResponseMember(lowerer, access, use) {
     if (lowerer.dynamic && members.every((member) => status(member) !== "unsupported")) {
         return null;
     }
-    const supported = (member) => use === "call"
-        ? STATIC_RESPONSE_CALLS.has(member)
-        : STATIC_RESPONSE_READS.has(member);
+    const supported = (member) => use === "call" ? STATIC_RESPONSE_CALLS.has(member) : STATIC_RESPONSE_READS.has(member);
     if (!lowerer.dynamic && members.every(supported))
         return null;
     const member = members.find((candidate) => lowerer.dynamic ? status(candidate) === "unsupported" : !supported(candidate));
@@ -990,7 +1003,9 @@ export function fenceStaticHeadersMember(lowerer, access, use) {
     if (lowerer.dynamic && members.every((member) => status(member) !== "unsupported")) {
         return null;
     }
-    if (!lowerer.dynamic && use === "call" && members.every((member) => STATIC_HEADERS_CALLS.has(member))) {
+    if (!lowerer.dynamic &&
+        use === "call" &&
+        members.every((member) => STATIC_HEADERS_CALLS.has(member))) {
         return null;
     }
     const member = members.find((candidate) => lowerer.dynamic
@@ -1136,7 +1151,9 @@ export function fenceStaticHeadersIteration(lowerer, node) {
         return;
     // The initializer is the value being iterated. Asking for the binding
     // pattern's synthesized tuple type can panic in TypeScript serialization.
-    const source = ts.isArrayBindingPattern(node) && ts.isVariableDeclaration(node.parent) && node.parent.initializer
+    const source = ts.isArrayBindingPattern(node) &&
+        ts.isVariableDeclaration(node.parent) &&
+        node.parent.initializer
         ? node.parent.initializer
         : node;
     const value = ts.isExpression(source) ? requestInitValueExpr(source) : source;
@@ -1264,8 +1281,7 @@ export function lowerFetchElementMethodCall(lowerer, call) {
     }
     const rows = members.map((member) => NODE24_FETCH_COMPAT_PROFILE.inventory.entries.find((entry) => entry.owner === resolved.owner &&
         entry.member === member &&
-        (entry.placement === "prototype" ||
-            entry.placement === "prototype-inherited")));
+        (entry.placement === "prototype" || entry.placement === "prototype-inherited")));
     if (rows.some((row) => row === undefined ||
         row.status === "out-of-scope" ||
         (lowerer.dynamic ? row.status === "unsupported" : row.status !== "static"))) {
@@ -1280,9 +1296,7 @@ export function lowerFetchElementMethodCall(lowerer, call) {
     const loc = locOf(call);
     const receiverLocal = lowerer.declareHiddenLocal("%fetchReceiver", lowerer.dynamic ? JSVAL : DYN);
     const keyLocal = lowerer.declareHiddenLocal("%fetchMember", STRING);
-    const calleeLocal = lowerer.dynamic
-        ? lowerer.declareHiddenLocal("%fetchMethod", JSVAL)
-        : null;
+    const calleeLocal = lowerer.dynamic ? lowerer.declareHiddenLocal("%fetchMethod", JSVAL) : null;
     const argumentValues = call.arguments.map((argument, index) => lowerer.dynamic
         ? lowerer.jsvalIn(lowerer.lowerExpr(argument), argument)
         : fetchMethodArgumentIsLive(resolved.owner, members, index)
@@ -1327,10 +1341,7 @@ export function lowerFetchElementMethodCall(lowerer, call) {
             init: {
                 kind: "jsOp",
                 op: "getIdx",
-                args: [
-                    receiverRef,
-                    { kind: "jsMarshal", value: keyRef, type: JSVAL, loc },
-                ],
+                args: [receiverRef, { kind: "jsMarshal", value: keyRef, type: JSVAL, loc }],
                 type: JSVAL,
                 loc,
             },
@@ -1408,9 +1419,7 @@ export function lowerFetchElementMethodCall(lowerer, call) {
     }
     const declared = lowerer.dynamic ? lowerer.mapTypeOf(lowerer.typeOf(call)) : null;
     if (declared &&
-        (declared.kind === "f64" ||
-            declared.kind === "bool" ||
-            declared.kind === "string")) {
+        (declared.kind === "f64" || declared.kind === "bool" || declared.kind === "string")) {
         result = { kind: "jsExit", value: result, type: declared, loc };
     }
     return {
@@ -1502,9 +1511,7 @@ function staticFirstArgWithSurplusArgs(lowerer, call, first) {
         type: first.type,
         loc,
     };
-    const stmts = [
-        { kind: "varDecl", localId: firstLocal.id, init: first, loc },
-    ];
+    const stmts = [{ kind: "varDecl", localId: firstLocal.id, init: first, loc }];
     for (const argument of call.arguments.slice(1)) {
         if (ts.isSpreadElement(argument)) {
             lowerer.noLowering("spread surplus arguments on the static fetch companion APIs", argument, "pass surplus arguments without spread syntax");
@@ -1651,8 +1658,7 @@ export function lowerStaticAbortControllerCall(lowerer, call) {
     if (lowerer.dynamic ||
         call.questionDotToken ||
         call.arguments.some((argument) => ts.isSpreadElement(argument)) ||
-        (!ts.isPropertyAccessExpression(access) &&
-            !ts.isElementAccessExpression(access)) ||
+        (!ts.isPropertyAccessExpression(access) && !ts.isElementAccessExpression(access)) ||
         access.questionDotToken ||
         staticResponseMemberName(lowerer, access) !== "abort") {
         return null;
@@ -1660,8 +1666,9 @@ export function lowerStaticAbortControllerCall(lowerer, call) {
     const receiverTs = lowerer.checker.getBaseTypeOfLiteralType(lowerer.typeOf(access.expression));
     const symbol = receiverTs.getAliasSymbol() ?? receiverTs.getSymbol();
     if (symbol?.name !== "AbortController" ||
-        !lowerer.checker.declarationsOf(symbol).some((d) => ts.isInterfaceDeclaration(d) &&
-            lowerer.isStdlibFile(d.getSourceFile()))) {
+        !lowerer.checker
+            .declarationsOf(symbol)
+            .some((d) => ts.isInterfaceDeclaration(d) && lowerer.isStdlibFile(d.getSourceFile()))) {
         return null;
     }
     const receiver = lowerer.lowerExpr(access.expression);
@@ -1690,8 +1697,7 @@ export function lowerStaticReadableStreamControllerCall(lowerer, call) {
     if (lowerer.dynamic ||
         call.questionDotToken ||
         call.arguments.length > 1 ||
-        (!ts.isPropertyAccessExpression(access) &&
-            !ts.isElementAccessExpression(access)) ||
+        (!ts.isPropertyAccessExpression(access) && !ts.isElementAccessExpression(access)) ||
         access.questionDotToken) {
         return null;
     }
@@ -1701,8 +1707,9 @@ export function lowerStaticReadableStreamControllerCall(lowerer, call) {
     const receiverTs = lowerer.checker.getBaseTypeOfLiteralType(lowerer.typeOf(access.expression));
     const symbol = receiverTs.getAliasSymbol() ?? receiverTs.getSymbol();
     if (symbol?.name !== "ReadableStreamDefaultController" ||
-        !lowerer.checker.declarationsOf(symbol).some((d) => ts.isInterfaceDeclaration(d) &&
-            lowerer.isStdlibFile(d.getSourceFile()))) {
+        !lowerer.checker
+            .declarationsOf(symbol)
+            .some((d) => ts.isInterfaceDeclaration(d) && lowerer.isStdlibFile(d.getSourceFile()))) {
         return null;
     }
     const recv = lowerer.lowerExpr(access.expression);
@@ -1710,9 +1717,7 @@ export function lowerStaticReadableStreamControllerCall(lowerer, call) {
         return null;
     const loc = locOf(call);
     const args = [
-        call.arguments[0]
-            ? lowerLiveWebValue(lowerer, call.arguments[0])
-            : dynUndefinedExpr(loc),
+        call.arguments[0] ? lowerLiveWebValue(lowerer, call.arguments[0]) : dynUndefinedExpr(loc),
     ];
     return lowerStaticFixedFetchMethodCall(lowerer, call, access, member, recv, args, (receiver, argumentRefs) => ({
         kind: "dynInvoke",
@@ -1733,15 +1738,13 @@ export function lowerStaticReadableStreamCancelCall(lowerer, call) {
         call.questionDotToken ||
         call.arguments.length > 1 ||
         call.arguments.some((argument) => ts.isSpreadElement(argument)) ||
-        (!ts.isPropertyAccessExpression(access) &&
-            !ts.isElementAccessExpression(access)) ||
+        (!ts.isPropertyAccessExpression(access) && !ts.isElementAccessExpression(access)) ||
         access.questionDotToken ||
         staticResponseMemberName(lowerer, access) !== "cancel") {
         return null;
     }
     const resolved = fetchInterfaceInventoryOwner(lowerer, access.expression);
-    if (resolved?.owner !== "ReadableStream" &&
-        resolved?.owner !== "ReadableStreamDefaultReader") {
+    if (resolved?.owner !== "ReadableStream" && resolved?.owner !== "ReadableStreamDefaultReader") {
         return null;
     }
     const receiver = lowerer.lowerExpr(access.expression);
@@ -1749,9 +1752,7 @@ export function lowerStaticReadableStreamCancelCall(lowerer, call) {
         return null;
     const loc = locOf(call);
     const args = [
-        call.arguments[0]
-            ? lowerLiveWebValue(lowerer, call.arguments[0])
-            : dynUndefinedExpr(loc),
+        call.arguments[0] ? lowerLiveWebValue(lowerer, call.arguments[0]) : dynUndefinedExpr(loc),
     ];
     return lowerStaticFixedFetchMethodCall(lowerer, call, access, "cancel", receiver, args, (receiverRef, argumentRefs) => ({
         kind: "dynInvoke",
@@ -1773,8 +1774,7 @@ export function lowerStaticAbortSignalListenerCall(lowerer, call) {
         call.questionDotToken ||
         call.arguments.length < 2 ||
         call.arguments.some((arg) => ts.isSpreadElement(arg)) ||
-        (!ts.isPropertyAccessExpression(access) &&
-            !ts.isElementAccessExpression(access)) ||
+        (!ts.isPropertyAccessExpression(access) && !ts.isElementAccessExpression(access)) ||
         access.questionDotToken) {
         return null;
     }
@@ -1785,17 +1785,16 @@ export function lowerStaticAbortSignalListenerCall(lowerer, call) {
     const receiverTs = lowerer.checker.getBaseTypeOfLiteralType(lowerer.typeOf(access.expression));
     const symbol = receiverTs.getAliasSymbol() ?? receiverTs.getSymbol();
     if (symbol?.name !== "AbortSignal" ||
-        !lowerer.checker.declarationsOf(symbol).some((d) => ts.isInterfaceDeclaration(d) &&
-            lowerer.isStdlibFile(d.getSourceFile()))) {
+        !lowerer.checker
+            .declarationsOf(symbol)
+            .some((d) => ts.isInterfaceDeclaration(d) && lowerer.isStdlibFile(d.getSourceFile()))) {
         return null;
     }
     const recv = lowerer.lowerExpr(access.expression);
     if (recv.type.kind !== "dyn")
         return null;
     const loc = locOf(call);
-    const args = call.arguments.map((arg, index) => index === 1
-        ? lowerLiveWebValue(lowerer, arg)
-        : lowerer.lowerExprExpecting(arg, DYN));
+    const args = call.arguments.map((arg, index) => index === 1 ? lowerLiveWebValue(lowerer, arg) : lowerer.lowerExprExpecting(arg, DYN));
     return lowerStaticFixedFetchMethodCall(lowerer, call, access, member, recv, args, (receiver, argumentRefs) => ({
         kind: "dynInvoke",
         recv: receiver,
@@ -1811,8 +1810,7 @@ export function lowerStaticAbortSignalListenerCall(lowerer, call) {
  * island Web object. JavaScript accepts surplus constructor arguments, so
  * both tiers evaluate them even though AbortController ignores their values. */
 export function lowerAbortControllerNew(lowerer, expr) {
-    if (!ts.isIdentifier(expr.expression) ||
-        expr.expression.text !== "AbortController") {
+    if (!ts.isIdentifier(expr.expression) || expr.expression.text !== "AbortController") {
         return null;
     }
     const symbol = lowerer.resolveValueSymbol(expr.expression);
@@ -1834,7 +1832,10 @@ export function lowerAbortControllerNew(lowerer, expr) {
         return {
             kind: "jsOp",
             op: "construct",
-            args: [ctor, ...args.map((argument) => lowerer.jsvalIn(lowerer.lowerExpr(argument), argument))],
+            args: [
+                ctor,
+                ...args.map((argument) => lowerer.jsvalIn(lowerer.lowerExpr(argument), argument)),
+            ],
             type: JSVAL,
             loc,
         };
@@ -1864,8 +1865,7 @@ export function lowerAbortControllerNew(lowerer, expr) {
  * the checked-dynamic tree; dynamic builds construct the island's Web
  * stream directly so the returned handle composes with dynamic fetch. */
 export function lowerStaticReadableStreamNew(lowerer, expr) {
-    if (!ts.isIdentifier(expr.expression) ||
-        expr.expression.text !== "ReadableStream") {
+    if (!ts.isIdentifier(expr.expression) || expr.expression.text !== "ReadableStream") {
         return null;
     }
     const symbol = lowerer.resolveValueSymbol(expr.expression);
@@ -1920,17 +1920,30 @@ export function lowerFetchWebNew(lowerer, expr) {
         return null;
     const loc = locOf(expr);
     if (lowerer.dynamic)
-        return { kind: "jsOp", op: "construct", args: [
+        return {
+            kind: "jsOp",
+            op: "construct",
+            args: [
                 { kind: "jsOp", op: "globalGet", name, args: [], type: JSVAL, loc },
                 ...args.map((arg) => lowerer.jsvalIn(lowerer.lowerExpr(arg), arg)),
-            ], type: JSVAL, loc };
+            ],
+            type: JSVAL,
+            loc,
+        };
     if (name === "Request" && args[1])
         fenceRequestInitValue(lowerer, args[1]);
     const lowered = args.map((arg) => ts.isObjectLiteralExpression(arg)
-        ? lowerDynObjectLiteral(lowerer, arg) : lowerLiveWebValue(lowerer, arg));
-    return { kind: "libCall", fn: name === "Request" ? "fetch.requestNew" : "fetch.headersNew",
-        args: name === "Request" ? [lowered[0] ?? dynUndefinedExpr(loc), lowered[1] ?? dynUndefinedExpr(loc)]
-            : [lowered[0] ?? dynUndefinedExpr(loc)], type: DYN, loc };
+        ? lowerDynObjectLiteral(lowerer, arg)
+        : lowerLiveWebValue(lowerer, arg));
+    return {
+        kind: "libCall",
+        fn: name === "Request" ? "fetch.requestNew" : "fetch.headersNew",
+        args: name === "Request"
+            ? [lowered[0] ?? dynUndefinedExpr(loc), lowered[1] ?? dynUndefinedExpr(loc)]
+            : [lowered[0] ?? dynUndefinedExpr(loc)],
+        type: DYN,
+        loc,
+    };
 }
 /** `new Response(body?, init?)`. Dynamic builds construct the island's
  * Web Response directly. Static builds hand a checked-dynamic BodyInit and
@@ -2003,8 +2016,7 @@ export function lowerResponseNew(lowerer, expr) {
             }
         }
         if (value.kind === "unitLit" || lowerer.dynConvertible(value.type)) {
-            if (what === "an init value" &&
-                hasLiveWebMutableArm(lowerer, value.type)) {
+            if (what === "an init value" && hasLiveWebMutableArm(lowerer, value.type)) {
                 return {
                     kind: "dynFrom",
                     value,
@@ -2074,10 +2086,7 @@ export function lowerResponseNew(lowerer, expr) {
     const result = {
         kind: "libCall",
         fn: "fetch.responseNew",
-        args: [
-            toDyn(bodyNode, bodyRef, "a body"),
-            toDyn(initNode, initRef, "an init value"),
-        ],
+        args: [toDyn(bodyNode, bodyRef, "a body"), toDyn(initNode, initRef, "an init value")],
         type: DYN,
         loc,
     };
@@ -2092,8 +2101,7 @@ export function lowerStaticReadableStreamReaderCall(lowerer, call) {
     if (lowerer.dynamic ||
         call.questionDotToken ||
         call.arguments.length !== 0 ||
-        (!ts.isPropertyAccessExpression(access) &&
-            !ts.isElementAccessExpression(access)) ||
+        (!ts.isPropertyAccessExpression(access) && !ts.isElementAccessExpression(access)) ||
         access.questionDotToken) {
         return null;
     }
@@ -2103,13 +2111,13 @@ export function lowerStaticReadableStreamReaderCall(lowerer, call) {
     const receiverTs = lowerer.typeOf(access.expression);
     const symbol = receiverTs.getSymbol();
     if (symbol?.name !== "ReadableStreamDefaultReader" ||
-        !lowerer.checker.declarationsOf(symbol).some((d) => ts.isInterfaceDeclaration(d) &&
-            lowerer.isStdlibFile(d.getSourceFile()))) {
+        !lowerer.checker
+            .declarationsOf(symbol)
+            .some((d) => ts.isInterfaceDeclaration(d) && lowerer.isStdlibFile(d.getSourceFile()))) {
         return null;
     }
     const type = lowerer.mapTypeOf(lowerer.typeOf(call));
-    if (type?.kind !== "promise" ||
-        type.inner.kind !== "record") {
+    if (type?.kind !== "promise" || type.inner.kind !== "record") {
         return null;
     }
     const receiver = lowerer.lowerExprExpecting(access.expression, DYN);
@@ -2122,21 +2130,21 @@ export function lowerStaticReadableStreamReaderCall(lowerer, call) {
     }));
 }
 /** Literal `import(spec)` at a user site. Static builds compile program
-   * modules and supported Node builtins to a native Promise<moduleNs>;
-   * dynamic builds retain the island-backed package/module path below.
-   * Under --dynamic the call lowers to island.importDyn(key): the engine
-   * loads the module (embedded npm graph, a shipped local .js/.mjs the
-   * build embedded, or a builtin shim — collectDynamicImports resolved and
-   * embedded the specifier at collection time) and answers an ENGINE
-   * promise of the namespace object, bridged to a static
-   * `Promise<jsval>` (jsBridgePromise, the fetch precedent) — so `await
-   * import(x)` parks the fiber and resumes with the namespace HANDLE, and
-   * a load/evaluation failure crosses as a catchable rejection, exactly
-   * where Node puts it. Specifiers must be string literals: the module
-   * graph is a BUILD-time artifact — a runtime-computed name has nothing
-   * to embed, and the fence says so. Static builds accept compiled program
-   * modules and supported builtins; other execution homes report SC2012.
-   * Null for anything that isn't `import(...)`. */
+ * modules and supported Node builtins to a native Promise<moduleNs>;
+ * dynamic builds retain the island-backed package/module path below.
+ * Under --dynamic the call lowers to island.importDyn(key): the engine
+ * loads the module (embedded npm graph, a shipped local .js/.mjs the
+ * build embedded, or a builtin shim — collectDynamicImports resolved and
+ * embedded the specifier at collection time) and answers an ENGINE
+ * promise of the namespace object, bridged to a static
+ * `Promise<jsval>` (jsBridgePromise, the fetch precedent) — so `await
+ * import(x)` parks the fiber and resumes with the namespace HANDLE, and
+ * a load/evaluation failure crosses as a catchable rejection, exactly
+ * where Node puts it. Specifiers must be string literals: the module
+ * graph is a BUILD-time artifact — a runtime-computed name has nothing
+ * to embed, and the fence says so. Static builds accept compiled program
+ * modules and supported builtins; other execution homes report SC2012.
+ * Null for anything that isn't `import(...)`. */
 export function lowerDynamicImportCall(lowerer, call) {
     if (call.expression.kind !== ts.SyntaxKind.ImportKeyword)
         return null;
@@ -2185,26 +2193,26 @@ export function lowerDynamicImportCall(lowerer, call) {
     return { kind: "jsBridgePromise", value: raw, type: { kind: "promise", inner: JSVAL }, loc };
 }
 /** Dynamic `import()` of one of the program's OWN modules: the compiled
-   * module's exports, marshaled into the engine as a namespace object.
-   * The site lowers to `Promise.resolve().then(<builder>)` in the engine —
-   * the builder is a synthesized compiled function (dynNsBuilderOf) that
-   * runs on the engine MICROTASK, calls the target module's run-once %init
-   * (Node's evaluation point for a module first reached through import():
-   * after the importer's synchronous code, before the .then handlers), and
-   * returns the exports object. Node differences (numbered divergences,
-   * pinned in island.test.ts): the namespace is a SNAPSHOT taken when the
-   * import resolves (Node's is live), a plain engine object (no Module
-   * toStringTag, keys still sorted like Node's, each import minting a
-   * fresh object where Node caches one), and exports with no island
-   * representation (classes, generic functions, un-marshalable
-   * signatures) cross as trap functions that throw a pointed TypeError
-   * when USED — the namespace still builds, exactly like Node still
-   * resolves it. */
+ * module's exports, marshaled into the engine as a namespace object.
+ * The site lowers to `Promise.resolve().then(<builder>)` in the engine —
+ * the builder is a synthesized compiled function (dynNsBuilderOf) that
+ * runs on the engine MICROTASK, calls the target module's run-once %init
+ * (Node's evaluation point for a module first reached through import():
+ * after the importer's synchronous code, before the .then handlers), and
+ * returns the exports object. Node differences (numbered divergences,
+ * pinned in island.test.ts): the namespace is a SNAPSHOT taken when the
+ * import resolves (Node's is live), a plain engine object (no Module
+ * toStringTag, keys still sorted like Node's, each import minting a
+ * fresh object where Node caches one), and exports with no island
+ * representation (classes, generic functions, un-marshalable
+ * signatures) cross as trap functions that throw a pointed TypeError
+ * when USED — the namespace still builds, exactly like Node still
+ * resolves it. */
 function lowerOwnDynamicModuleImport(lowerer, call, arg) {
     const loc = locOf(call);
     let dep = null;
     const modSym = lowerer.checker.getSymbolAtLocation(arg);
-    for (const d of (modSym ? lowerer.checker.declarationsOf(modSym) : [])) {
+    for (const d of modSym ? lowerer.checker.declarationsOf(modSym) : []) {
         if (ts.isSourceFile(d) && !d.isDeclarationFile) {
             dep = d;
             break;
@@ -2220,8 +2228,22 @@ function lowerOwnDynamicModuleImport(lowerer, call, arg) {
         lowerer.unsupported("SC1090", call, `dynamic import of the program's own module '${arg.text}' ` +
             "(this module is not part of the compiled module graph — import it statically)");
     }
-    const promiseCtor = { kind: "jsOp", op: "globalGet", name: "Promise", args: [], type: JSVAL, loc };
-    const resolved = { kind: "jsOp", op: "callMethod", name: "resolve", args: [promiseCtor], type: JSVAL, loc };
+    const promiseCtor = {
+        kind: "jsOp",
+        op: "globalGet",
+        name: "Promise",
+        args: [],
+        type: JSVAL,
+        loc,
+    };
+    const resolved = {
+        kind: "jsOp",
+        op: "callMethod",
+        name: "resolve",
+        args: [promiseCtor],
+        type: JSVAL,
+        loc,
+    };
     const builderAsync = dep !== null && lowerer.asyncInitFiles.has(dep);
     const builderFn = {
         kind: "func",
@@ -2234,23 +2256,30 @@ function lowerOwnDynamicModuleImport(lowerer, call, arg) {
         type: JSVAL,
         loc,
     };
-    const chained = { kind: "jsOp", op: "callMethod", name: "then", args: [resolved, marshaled], type: JSVAL, loc };
+    const chained = {
+        kind: "jsOp",
+        op: "callMethod",
+        name: "then",
+        args: [resolved, marshaled],
+        type: JSVAL,
+        loc,
+    };
     return { kind: "jsBridgePromise", value: chained, type: { kind: "promise", inner: JSVAL }, loc };
 }
 /** The checker-resolved program source behind one literal import(). */
 function programImportTarget(lowerer, arg) {
     const modSym = lowerer.checker.getSymbolAtLocation(arg);
-    for (const d of (modSym ? lowerer.checker.declarationsOf(modSym) : [])) {
+    for (const d of modSym ? lowerer.checker.declarationsOf(modSym) : []) {
         if (ts.isSourceFile(d) && !d.isDeclarationFile)
             return d;
     }
     return null;
 }
 /** Static literal import of one compiled ESM module. The async helper's
-   * first operation is an await of an already-settled promise: evaluation
-   * therefore starts on a microtask, after the importer's synchronous
-   * tail, matching import(). Its result is the module's singleton nominal
-   * namespace token; member reads resolve separately to live exports. */
+ * first operation is an await of an already-settled promise: evaluation
+ * therefore starts on a microtask, after the importer's synchronous
+ * tail, matching import(). Its result is the module's singleton nominal
+ * namespace token; member reads resolve separately to live exports. */
 function lowerOwnStaticModuleImport(lowerer, call, arg) {
     const dep = programImportTarget(lowerer, arg);
     if (dep !== null && (dep.fileName.endsWith(".cts") || isCjsJsFile(dep, lowerer.program))) {
@@ -2264,7 +2293,7 @@ function lowerOwnStaticModuleImport(lowerer, call, arg) {
     }
     const ns = {
         kind: "moduleNs",
-        moduleId: `file:${dep === null ? "" : lowerer.moduleNamespaceIdOfType(lowerer.typeOf(call))?.replace(/^file:/, "") ?? dep.fileName}`,
+        moduleId: `file:${dep === null ? "" : (lowerer.moduleNamespaceIdOfType(lowerer.typeOf(call))?.replace(/^file:/, "") ?? dep.fileName)}`,
     };
     // The call's type is Promise<typeof import(...)>; prefer the mapper's
     // canonical normalized id when available.
@@ -2273,8 +2302,8 @@ function lowerOwnStaticModuleImport(lowerer, call, arg) {
     return lowerStaticNamespaceImport(lowerer, call, inner, dep);
 }
 /** Builds a fresh native promise for a static module namespace. Source
-   * modules run/await their guarded initializer after the mandatory hop;
-   * builtins only take the hop and resolve their immortal token. */
+ * modules run/await their guarded initializer after the mandatory hop;
+ * builtins only take the hop and resolve their immortal token. */
 function lowerStaticNamespaceImport(lowerer, call, ns, dep = null) {
     const loc = locOf(call);
     const resultT = { kind: "promise", inner: ns };
@@ -2328,7 +2357,7 @@ function lowerStaticNamespaceImport(lowerer, call, ns, dep = null) {
     };
 }
 /** Appends Node's lazy source-module link/evaluation work to a static
-   * import helper. This is the native twin of dynNsBuilderOf's prelude. */
+ * import helper. This is the native twin of dynNsBuilderOf's prelude. */
 function appendStaticModuleInit(lowerer, dep, body, loc) {
     const linkCrash = esmNamedImportLinkCrash(lowerer.program, dep);
     if (linkCrash !== null) {
@@ -2381,12 +2410,12 @@ function appendStaticModuleInit(lowerer, dep, body, loc) {
     });
 }
 /** The namespace-BUILDER function for one program module, synthesized on
-   * first demand and shared by every import() of that module (deterministic
-   * name per file tag, so the discovery and emit passes agree). Body: the
-   * module's guarded %init (skipped for the entry — it is running or ran),
-   * then `return { <sorted exports> }` as an engine object. Null when the
-   * module never joined the compiled graph (no %init exists — an empty
-   * preflight order or a cycle the extension refused). */
+ * first demand and shared by every import() of that module (deterministic
+ * name per file tag, so the discovery and emit passes agree). Body: the
+ * module's guarded %init (skipped for the entry — it is running or ran),
+ * then `return { <sorted exports> }` as an engine object. Null when the
+ * module never joined the compiled graph (no %init exists — an empty
+ * preflight order or a cycle the extension refused). */
 function dynNsBuilderOf(lowerer, dep, loc) {
     const cached = lowerer.dynNsBuilders.get(dep);
     if (cached !== undefined)
@@ -2460,9 +2489,7 @@ function dynNsBuilderOf(lowerer, dep, loc) {
             else {
                 body.push({
                     kind: "exprStmt",
-                    expr: isAsync
-                        ? { kind: "awaitExpr", value: call, type: VOID, loc }
-                        : call,
+                    expr: isAsync ? { kind: "awaitExpr", value: call, type: VOID, loc } : call,
                     loc,
                 });
             }
@@ -2482,9 +2509,18 @@ function dynNsBuilderOf(lowerer, dep, loc) {
             const value = exportJsvalValue(lowerer, exportName, sym, loc);
             if (value === null)
                 continue;
-            args.push({ kind: "jsMarshal", value: { kind: "strLit", value: exportName, type: STRING, loc }, type: JSVAL, loc }, value);
+            args.push({
+                kind: "jsMarshal",
+                value: { kind: "strLit", value: exportName, type: STRING, loc },
+                type: JSVAL,
+                loc,
+            }, value);
         }
-        body.push({ kind: "return", value: { kind: "jsOp", op: "objLit", args, type: JSVAL, loc }, loc });
+        body.push({
+            kind: "return",
+            value: { kind: "jsOp", op: "objLit", args, type: JSVAL, loc },
+            loc,
+        });
         const ctx = lowerer.ctx;
         lowerer.liftedFns.push({
             name,
@@ -2503,13 +2539,13 @@ function dynNsBuilderOf(lowerer, dep, loc) {
     return name;
 }
 /** One export's island value for the namespace object — the jsvalIn
-   * marshal set (primitives and JSON-safe composites by deep copy, units as
-   * the engine's own, marshalable closures as host functions, jsval-bearing
-   * composites through the per-field lift), with every UN-marshalable
-   * export crossing as a trap function that throws a pointed TypeError when
-   * called or constructed — the namespace still builds (Node resolves it;
-   * only the USE has no compiled story). Null for exports that do not exist
-   * at runtime (type-only). */
+ * marshal set (primitives and JSON-safe composites by deep copy, units as
+ * the engine's own, marshalable closures as host functions, jsval-bearing
+ * composites through the per-field lift), with every UN-marshalable
+ * export crossing as a trap function that throws a pointed TypeError when
+ * called or constructed — the namespace still builds (Node resolves it;
+ * only the USE has no compiled story). Null for exports that do not exist
+ * at runtime (type-only). */
 function exportJsvalValue(lowerer, name, sym, loc) {
     const trap = (what) => islandTrapFnValue(lowerer, `the '${name}' export is ${what} of the compiled program, which cannot cross into dynamically-executed code yet`, loc);
     let resolved = sym;
@@ -2523,7 +2559,8 @@ function exportJsvalValue(lowerer, name, sym, loc) {
             }
             if (ts.isImportSpecifier(d)) {
                 const clause = d.parent?.parent;
-                if (d.isTypeOnly || (ts.isImportClause(clause) && clause.phaseModifier === ts.SyntaxKind.TypeKeyword))
+                if (d.isTypeOnly ||
+                    (ts.isImportClause(clause) && clause.phaseModifier === ts.SyntaxKind.TypeKeyword))
                     return null;
             }
         }
@@ -2537,7 +2574,13 @@ function exportJsvalValue(lowerer, name, sym, loc) {
         if (ref.type.kind === "jsval")
             return ref;
         if (isUnitType(ref.type)) {
-            return { kind: "jsOp", op: ref.type.kind === "undefinedT" ? "undefLit" : "nullLit", args: [], type: JSVAL, loc };
+            return {
+                kind: "jsOp",
+                op: ref.type.kind === "undefinedT" ? "undefLit" : "nullLit",
+                args: [],
+                type: JSVAL,
+                loc,
+            };
         }
         if (ref.type.kind === "func") {
             return canMarshalTypedFuncIntoIsland(ref.type, (id) => lowerer.shapes.get(id), (id) => lowerer.unions.get(id))
@@ -2551,7 +2594,11 @@ function exportJsvalValue(lowerer, name, sym, loc) {
         return trap(`a value of type '${lowerer.fmt(ref.type)}'`);
     }
     const sig = lowerer.fnSigsBySymbol.get(resolved);
-    const decl0 = lowerer.checker.declarationsOf(resolved).find((d) => ts.isFunctionDeclaration(d) && (ts.isSourceFile(d.parent) || (d.parent !== undefined && lowerer.nsBlocks.get(d.parent) === "flattened")));
+    const decl0 = lowerer.checker
+        .declarationsOf(resolved)
+        .find((d) => ts.isFunctionDeclaration(d) &&
+        (ts.isSourceFile(d.parent) ||
+            (d.parent !== undefined && lowerer.nsBlocks.get(d.parent) === "flattened")));
     if (sig && decl0) {
         if (!sig.params.every((p) => p.mode === "required")) {
             return trap("a function with optional, default, or rest parameters");
@@ -2585,10 +2632,10 @@ function exportJsvalValue(lowerer, name, sym, loc) {
     return trap("a binding");
 }
 /** An engine value whose any USE throws: `new Function("<throw>")` — a
-   * real engine function, so the namespace member reads back fine (Node's
-   * namespace holds the value too), property probes answer like a
-   * function's, and calling or `new`-ing it runs the body, which throws
-   * the pointed TypeError. */
+ * real engine function, so the namespace member reads back fine (Node's
+ * namespace holds the value too), property probes answer like a
+ * function's, and calling or `new`-ing it runs the body, which throws
+ * the pointed TypeError. */
 function islandTrapFnValue(lowerer, message, loc) {
     void lowerer;
     const code = `throw new TypeError(${JSON.stringify(message)})`;
@@ -2597,22 +2644,27 @@ function islandTrapFnValue(lowerer, message, loc) {
         op: "construct",
         args: [
             { kind: "jsOp", op: "globalGet", name: "Function", args: [], type: JSVAL, loc },
-            { kind: "jsMarshal", value: { kind: "strLit", value: code, type: STRING, loc }, type: JSVAL, loc },
+            {
+                kind: "jsMarshal",
+                value: { kind: "strLit", value: code, type: STRING, loc },
+                type: JSVAL,
+                loc,
+            },
         ],
         type: JSVAL,
         loc,
     };
 }
 /** An object literal built NATIVELY in the island — one engine object,
-   * each field marshaled individually (nested object/array literals
-   * recurse, island handles pass straight through, everything else takes
-   * the JSON-safe copy-marshal). The same jsOp the 'any'-contextual
-   * literal path emits, callable from lowerings that KNOW the literal is
-   * island-bound (fetch's init) even when the contextual type is a union
-   * the generic path declines. Spelled and pure const-folded computed keys
-   * are admitted; engine property names have no identifier restriction. Plain
-   * spreads copy through the engine's CopyDataProperties operation in
-   * source order, including nested RequestInit/header dictionaries. */
+ * each field marshaled individually (nested object/array literals
+ * recurse, island handles pass straight through, everything else takes
+ * the JSON-safe copy-marshal). The same jsOp the 'any'-contextual
+ * literal path emits, callable from lowerings that KNOW the literal is
+ * island-bound (fetch's init) even when the contextual type is a union
+ * the generic path declines. Spelled and pure const-folded computed keys
+ * are admitted; engine property names have no identifier restriction. Plain
+ * spreads copy through the engine's CopyDataProperties operation in
+ * source order, including nested RequestInit/header dictionaries. */
 function lowerIslandObjectLiteral(lowerer, expr) {
     const loc = locOf(expr);
     let args = [];
@@ -2621,9 +2673,10 @@ function lowerIslandObjectLiteral(lowerer, expr) {
         if (args.length === 0)
             return;
         const chunk = { kind: "jsOp", op: "objLit", args, type: JSVAL, loc };
-        acc = acc === null
-            ? chunk
-            : { kind: "jsOp", op: "objSpread", args: [acc, chunk], type: JSVAL, loc };
+        acc =
+            acc === null
+                ? chunk
+                : { kind: "jsOp", op: "objSpread", args: [acc, chunk], type: JSVAL, loc };
         args = [];
     };
     for (const prop of expr.properties) {
@@ -2649,7 +2702,8 @@ function lowerIslandObjectLiteral(lowerer, expr) {
         args.push({
             kind: "jsMarshal",
             value: { kind: "strLit", value: propertyName, type: STRING, loc: nameLoc },
-            type: JSVAL, loc: nameLoc,
+            type: JSVAL,
+            loc: nameLoc,
         });
         const valueNode = ts.isPropertyAssignment(prop)
             ? prop.initializer
@@ -2666,7 +2720,8 @@ function lowerIslandObjectLiteral(lowerer, expr) {
         }
         else {
             const value = ts.isMethodDeclaration(valueNode)
-                ? (lowerer.rejectThisInObjectMethod(valueNode.body ?? valueNode), lowerer.lowerLambda(valueNode))
+                ? (lowerer.rejectThisInObjectMethod(valueNode.body ?? valueNode),
+                    lowerer.lowerLambda(valueNode))
                 : lowerer.lowerExpr(valueNode);
             args.push(lowerer.jsvalIn(value, valueNode));
         }
@@ -2675,15 +2730,15 @@ function lowerIslandObjectLiteral(lowerer, expr) {
     return acc ?? { kind: "jsOp", op: "objLit", args: [], type: JSVAL, loc };
 }
 /** Method calls on the island-backed ambient surface: `Math.<fn>(...)`
-   * (the engine's own Math object executes) and the number/string methods
-   * the static runtime doesn't implement (`x.toPrecision(2)`,
-   * `s.replace("a", "b")`, ...). Each site is self-contained — the receiver
-   * and arguments marshal in, the engine executes with JS-exact semantics,
-   * and the result exits (validated) to the DECLARED static return type,
-   * so no jsval leaks into the program's types. tsc has already checked
-   * receiver, arity, and argument types against ambient/scriptc.d.ts; an
-   * ambient member missing from ISLAND_SURFACE returns null into the
-   * existing generic rejections. */
+ * (the engine's own Math object executes) and the number/string methods
+ * the static runtime doesn't implement (`x.toPrecision(2)`,
+ * `s.replace("a", "b")`, ...). Each site is self-contained — the receiver
+ * and arguments marshal in, the engine executes with JS-exact semantics,
+ * and the result exits (validated) to the DECLARED static return type,
+ * so no jsval leaks into the program's types. tsc has already checked
+ * receiver, arity, and argument types against ambient/scriptc.d.ts; an
+ * ambient member missing from ISLAND_SURFACE returns null into the
+ * existing generic rejections. */
 export function lowerIslandMethodCall(lowerer, call, access) {
     if (lowerer.chainBlocked(access, call))
         return null;
@@ -2692,7 +2747,12 @@ export function lowerIslandMethodCall(lowerer, call, access) {
     const finish = (receiver, entry) => {
         const args = call.arguments.map((a) => lowerer.jsvalIn(lowerer.lowerExpr(a), a));
         const result = {
-            kind: "jsOp", op: "callMethod", name, args: [receiver, ...args], type: JSVAL, loc,
+            kind: "jsOp",
+            op: "callMethod",
+            name,
+            args: [receiver, ...args],
+            type: JSVAL,
+            loc,
         };
         return { kind: "jsExit", value: result, type: entry.ret, loc };
     };
@@ -2709,11 +2769,20 @@ export function lowerIslandMethodCall(lowerer, call, access) {
             lowerer.requireDynamicApi(`'AbortSignal.${sigMember}'`, call);
             const args = call.arguments.map((a) => lowerer.jsvalIn(lowerer.lowerExpr(a), a));
             const signalGlobal = {
-                kind: "jsOp", op: "globalGet", name: "AbortSignal", args: [], type: JSVAL, loc,
+                kind: "jsOp",
+                op: "globalGet",
+                name: "AbortSignal",
+                args: [],
+                type: JSVAL,
+                loc,
             };
             return {
-                kind: "jsOp", op: "callMethod", name: sigMember,
-                args: [signalGlobal, ...args], type: JSVAL, loc,
+                kind: "jsOp",
+                op: "callMethod",
+                name: sigMember,
+                args: [signalGlobal, ...args],
+                type: JSVAL,
+                loc,
             };
         }
     }
@@ -2748,12 +2817,17 @@ export function lowerIslandMethodCall(lowerer, call, access) {
         const elems = call.arguments.map((a) => ts.isSpreadElement(a)
             ? lowerer.lowerExprExpecting(a.expression, arrayOf(F64))
             : lowerer.lowerExprExpecting(a, F64));
-        const spreads = call.arguments.flatMap((a, i) => ts.isSpreadElement(a) ? [i] : []);
-        const packed = { kind: "arrayLit", elems, ...(spreads.length > 0 ? { spreads } : {}), type: arrayOf(F64), loc };
+        const spreads = call.arguments.flatMap((a, i) => (ts.isSpreadElement(a) ? [i] : []));
+        const packed = {
+            kind: "arrayLit",
+            elems,
+            ...(spreads.length > 0 ? { spreads } : {}),
+            type: arrayOf(F64),
+            loc,
+        };
         return { kind: "libCall", fn: staticMath.fn, args: [packed], type: F64, loc };
     }
-    if (staticMath &&
-        call.arguments.every((a) => !ts.isSpreadElement(a))) {
+    if (staticMath && call.arguments.every((a) => !ts.isSpreadElement(a))) {
         // Math.max/Math.min at ANY plain arity — Node's are variadic. The
         // spec's reduction is a left fold of the same NaN-poisoning
         // ±0-ordered scalar compare the two-arg form lowers to, so n
@@ -2843,20 +2917,38 @@ export function lowerMathProperty(lowerer, expr) {
     if (native && (member === "min" || member === "max" || member === "hypot"))
         return lowerer.lowerNativeCallableValue({
             fn: member === "min" ? "math.minArr" : member === "max" ? "math.maxArr" : "math.hypotArr",
-            params: [arrayOf(F64)], result: F64, valueParams: [{ mode: "rest", type: F64 }],
+            params: [arrayOf(F64)],
+            result: F64,
+            valueParams: [{ mode: "rest", type: F64 }],
         }, `Math.${member}`, loc);
     if (native && member !== "min" && member !== "max" && member !== "hypot") {
         const params = Array.from({ length: native.arity }, () => F64);
         return lowerer.lowerNativeCallableValue({
-            fn: native.fn, params, result: F64,
+            fn: native.fn,
+            params,
+            result: F64,
             valueParams: params.map((type) => ({ mode: "required", type })),
         }, `Math.${member}`, loc);
     }
     const propType = own(ISLAND_SURFACE.math.props, member);
     if (propType !== undefined) {
         lowerer.requireDynamicApi(`'Math.${member}'`, expr);
-        const math = { kind: "jsOp", op: "globalGet", name: "Math", args: [], type: JSVAL, loc };
-        const read = { kind: "jsOp", op: "getProp", name: member, args: [math], type: JSVAL, loc };
+        const math = {
+            kind: "jsOp",
+            op: "globalGet",
+            name: "Math",
+            args: [],
+            type: JSVAL,
+            loc,
+        };
+        const read = {
+            kind: "jsOp",
+            op: "getProp",
+            name: member,
+            args: [math],
+            type: JSVAL,
+            loc,
+        };
         return { kind: "jsExit", value: read, type: propType, loc };
     }
     if (own(ISLAND_SURFACE.math.fns, member) !== undefined ||
@@ -2866,9 +2958,9 @@ export function lowerMathProperty(lowerer, expr) {
     return null; // declared-but-untabled members fall through generically
 }
 /** The npm package a type is declared by ("commander", "@scope/pkg"),
-   * or null when the type isn't package-declared. Union parts are searched
-   * too: `string | Command` fails mapping as a whole, but the blame (and
-   * the --dynamic attribution) belongs to the package-declared part. */
+ * or null when the type isn't package-declared. Union parts are searched
+ * too: `string | Command` fails mapping as a whole, but the blame (and
+ * the --dynamic attribution) belongs to the package-declared part. */
 export function npmPackageOf(lowerer, type) {
     const pkg = lowerer.npmPackageOfSymbol(type.getAliasSymbol() ?? type.getSymbol());
     if (pkg)
@@ -2883,11 +2975,11 @@ export function npmPackageOf(lowerer, type) {
     return null;
 }
 /** The npm chokepoint for member reads and method calls in a STATIC
-   * build: a receiver whose type (or member whose symbol) a package's
-   * .d.ts declares means the operation runs in the embedded engine —
-   * attribute the site to the package instead of the generic property/
-   * method rejection. No-op under --dynamic (the island paths claimed
-   * these) and for non-package receivers, so callers' fallbacks apply. */
+ * build: a receiver whose type (or member whose symbol) a package's
+ * .d.ts declares means the operation runs in the embedded engine —
+ * attribute the site to the package instead of the generic property/
+ * method rejection. No-op under --dynamic (the island paths claimed
+ * these) and for non-package receivers, so callers' fallbacks apply. */
 export function npmMemberFence(lowerer, access) {
     if (lowerer.dynamic)
         return;
@@ -2899,8 +2991,8 @@ export function npmMemberFence(lowerer, access) {
     throw new PoisonError();
 }
 /** The npm package a SYMBOL is declared by, or null. The symbol half of
-   * npmPackageOf, also asked directly for import-alias bindings (whose
-   * aliased symbol is the package's export). */
+ * npmPackageOf, also asked directly for import-alias bindings (whose
+ * aliased symbol is the package's export). */
 export function npmPackageOfSymbol(lowerer, sym) {
     const decls = sym ? lowerer.checker.declarationsOf(sym) : undefined;
     if (!decls || decls.length === 0)