@scriptc/compiler 0.2.10 → 0.3.1

package/dist/frontend/lowering/{lower-island.js → lower-stdlib.js}

@@ -1,225 +1,20 @@
 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 { lowerToNumberArgument } from "./lower-exprs.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, STRING, VOID, canConvertToDyn, isUnitType, } from "../../ir/ir.js";
+import { STDLIB_SURFACE, STATIC_MATH_FNS, STATIC_MATH_PROPS, stdlibGlobalNameOf, } from "./surfaces.js";
+import { unsupportedNativeApiDiag, unsupportedPackageValueDiag, } from "../../diagnostics/diagnostic.js";
+import { esmNamedImportLinkCrash, isCjsJsFile, locOf, npmPackageNameOf } from "../program.js";
 import { foldedStringKeyOf, lowerDynObjectLiteral } from "./expressions/object-literals.js";
-import { isSafeToRepeat } from "./expressions/evaluation-safety.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). */
-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.
-    if (!lowerer.dynamic)
-        return false;
-    const mapped = lowerer.mapTypeOf(lowerer.typeOf(node));
-    if (mapped?.kind === "jsval")
-        return true;
-    if (mapped?.kind !== "promise" && ts.isIdentifier(node)) {
-        const local = lowerer.peekLocal(node);
-        if (local?.type.kind === "jsval")
-            return true;
-        // File-scope handle bindings (a module global slotted jsval by the
-        // island-pattern or unchecked-overload rules) take the same rule as
-        // locals: the handle is the value's only story.
-        if (!local && lowerer.globalOf(node)?.type.kind === "jsval")
-            return true;
-    }
-    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. */
-/** 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
- * invoked — building the value compiles; only a call through the
- * island stops the run. Null (caller rethrows) outside the JS deferral
- * gate: TypeScript sources, probe mode, ICEs. */
-export function islandFuncValueFence(lowerer, diagsBefore, node) {
-    if (!isJsSourceFile(node.getSourceFile()))
-        return null;
-    const fence = lowerer.deferToRuntimeFence(diagsBefore, node, {
-        kind: "closure",
-        name: () => `%fn${lowerer.lambdaCounter++}_islfence`,
-        returnType: VOID,
-        type: { kind: "func", params: [], ret: VOID },
-    });
-    if (!fence)
-        return null;
-    return {
-        kind: "jsMarshal",
-        value: fence,
-        type: JSVAL,
-        loc: fence.loc,
-    };
-}
-export function jsvalIn(lowerer, e, node) {
-    if (e.type.kind === "jsval")
-        return e;
-    // Bare unit literals (`undefined` / `null` in an 'any' slot): the
-    // 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,
-        };
-    }
-    if (e.type.kind === "dyn") {
-        // A CHECKED-DYNAMIC value entering the island: the dyn tree
-        // deep-copies into engine values — exactly coerceToExpected's
-        // jsval-IN rule (data kinds only; a dyn carrying a boxed
-        // function/handle throws the catchable TypeError at runtime).
-        return { kind: "jsMarshal", value: e, type: JSVAL, loc: e.loc };
-    }
-    // Closures cross INTO the island as host functions — THE package
-    // callback pattern (`.action((a, b) => ...)`). Unannotated params stay
-    // 'any' (contextual typing against package signatures) and pass through
-    // as handles; TYPED params convert at call time through the validated-
-    // exit machinery (strict primitives, JSON round-trip composites,
-    // `T | undefined` taking the undefined arm for an absent argument), so
-    // a conversion failure throws back into the island as a TypeError.
-    // Anything outside both shapes gets the specific fix, not the generic
-    // boundary recitation.
-    if (e.type.kind === "func" &&
-        !canMarshalTypedFuncIntoIsland(e.type, (id) => lowerer.shapes.get(id), (id) => lowerer.unions.get(id))) {
-        const diagsBefore = lowerer.diags.length;
-        try {
-            lowerer.unsupported("SC1090", node, `functions with this signature crossing into dynamically-executed code ` +
-                `(a callback passed to a package/'any' API may take 'any' parameters — ` +
-                `leave them unannotated so contextual typing keeps them 'any' — or parameters ` +
-                `convertible at the boundary (number, string, boolean, JSON-safe ` +
-                `records/arrays/unions, 'T | undefined'), and return 'any', void, number, ` +
-                `string, boolean, a JSON-safe composite, or a Promise of the primitive kinds${e.type.kind === "func" && e.type.params.length > MAX_ISLAND_CALLBACK_ARITY
-                    ? `; at most ${MAX_ISLAND_CALLBACK_ARITY} parameters`
-                    : ""})`);
-        }
-        catch (err) {
-            // JS sources defer the crossing like a statement fence, one level
-            // deeper: the slot receives a host closure that THROWS the
-            // diagnostic when INVOKED (the withPlugins aggregation shape —
-            // wrappers built at module init around functions the smoke path
-            // never calls). TypeScript and probe mode keep the poison.
-            if (!(err instanceof PoisonError))
-                throw err;
-            const fence = islandFuncValueFence(lowerer, diagsBefore, node);
-            if (fence)
-                return fence;
-            throw err;
-        }
-    }
-    // A STATIC promise crossing INTO the island: a real engine thenable
-    // settled when the scriptc promise settles (the async-callback return
-    // bridge, scr_jsval_from_promise) — the loadBuiltinPlugins cache
-    // shape and the island Promise.all arm's static entries. Only
-    // fulfillments in the bridge's payload domain cross; the rest keep
-    // the boundary fence below with the promise type named.
-    if (e.type.kind === "promise" && islandPromisePayloadTag(e.type.inner) !== null) {
-        return { kind: "jsMarshal", value: e, type: JSVAL, loc: e.loc };
-    }
-    if (e.type.kind !== "func" && !lowerer.boundarySafe(e.type)) {
-        // A RegExp crossing INTO the island (`z.string().regex(/^a+$/)` —
-        // the validation-pattern argument): the engine compiles its own
-        // from source+flags. A fresh engine RegExp per marshal — identity
-        // and lastIndex state do not cross (SEMANTICS.md). Only literal
-        // and pure-read spellings lower (the rebuild reads the operand
-        // twice); computed regex values keep the boundary fence.
-        if (e.type.kind === "regex") {
-            const re = islandRegexpOf(e);
-            if (re)
-                return re;
-        }
-        // jsval-BEARING composites (an `any[]` value, a record holding one)
-        // have no JSON marshal but an honest per-field/per-element island
-        // construction — the same lift the implicit coercion path uses.
-        if (lowerer.jsvalLiftable(e.type))
-            return lowerer.jsvalLiftExpr(e, e.loc);
-        lowerer.unsupported("SC1090", node, boundaryIntoIslandMsg(lowerer.fmt(e.type)));
-    }
-    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. */
-export function islandRegexpOf(e) {
-    if (e.type.kind !== "regex")
-        return null;
-    const loc = e.loc;
-    let src;
-    let flags;
-    if (e.kind === "regexLit") {
-        src = { kind: "strLit", value: e.pattern, type: STRING, loc };
-        flags = { kind: "strLit", value: e.flags, type: STRING, loc };
-    }
-    else if (isSafeToRepeat(e)) {
-        src = { kind: "regexIntrinsic", method: "source", receiver: e, args: [], type: STRING, loc };
-        flags = { kind: "regexIntrinsic", method: "flags", receiver: e, args: [], type: STRING, loc };
-    }
-    else {
-        return null;
-    }
-    const ctor = {
-        kind: "jsOp",
-        op: "globalGet",
-        name: "RegExp",
-        args: [],
-        type: JSVAL,
-        loc,
-    };
-    return {
-        kind: "jsOp",
-        op: "construct",
-        args: [
-            ctor,
-            { kind: "jsMarshal", value: src, type: JSVAL, loc },
-            { kind: "jsMarshal", value: flags, type: JSVAL, loc },
-        ],
-        type: JSVAL,
-        loc,
-    };
-}
-/** 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"). */
-export function requireDynamicApi(lowerer, feature, node, hint) {
-    if (lowerer.dynamic)
-        return;
-    lowerer.pushDiag(requiresDynamicApiDiag(feature, locOf(node), hint));
+export function refuseUnsupportedApi(lowerer, feature, node, hint) {
+    lowerer.pushDiag(unsupportedNativeApiDiag(feature, locOf(node), hint));
     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. */
-export function islandGlobalFnOf(lowerer, ident) {
-    const entry = own(ISLAND_SURFACE.globals, ident.text);
+export function stdlibGlobalFnOf(lowerer, ident) {
+    const entry = own(STDLIB_SURFACE.globals, ident.text);
     if (!entry)
         return null;
     const symbol = lowerer.resolveValueSymbol(ident);
@@ -242,10 +37,9 @@ function requestInitLiteralKey(lowerer, prop) {
         return foldedStringKeyOf(lowerer, name.expression);
     return null;
 }
-/** Fence declared RequestInit members outside the selected compiler tier.
- * Computed runtime keys and non-literal objects are validated again by the
- * static runtime; source-visible members that neither tier preserves are
- * rejected before the dynamic bridge can silently discard them. */
+/** Unwrap assertions and parentheses when checking RequestInit values.
+ * Computed runtime keys and non-literal objects are also validated by the
+ * native runtime. */
 function requestInitValueExpr(expr) {
     let current = expr;
     while (ts.isParenthesizedExpression(current) ||
@@ -519,7 +313,7 @@ function fenceRequestInitObject(lowerer, init, seen) {
     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) => {
-        if (lowerer.dynamic ? row.status !== "unsupported" : row.status === "static")
+        if (row.status === "static")
             return;
         if (value !== null) {
             const type = lowerer.typeOf(requestInitValueExpr(value));
@@ -531,7 +325,7 @@ function fenceRequestInitObject(lowerer, init, seen) {
         const sym = contextualArms
             .map((arm) => lowerer.checker.getPropertyOfType(arm, row.member))
             .find((member) => member !== undefined);
-        lowerer.noLowering(`RequestInit option '${row.member}'${lowerer.dynamic ? "" : " in a static build"}`, blame, row.reason ??
+        lowerer.noLowering(`RequestInit option '${row.member}'${" in a static build"}`, blame, row.reason ??
             "the native static RequestInit surface is method, headers, body, duplex, redirect, and signal", sym);
     };
     // Object spread is last-write-wins. Walk from the end and trace only the
@@ -624,28 +418,6 @@ function fenceRequestInitValueInner(lowerer, value, seen) {
 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. */
 export function lowerFetchCall(lowerer, call) {
     const callee = call.expression;
     if (!ts.isIdentifier(callee) || callee.text !== "fetch")
@@ -661,7 +433,7 @@ export function lowerFetchCall(lowerer, call) {
     const initNode = call.arguments[1];
     if (initNode !== undefined)
         fenceRequestInitValue(lowerer, initNode);
-    if (!lowerer.dynamic) {
+    {
         const inputNode = call.arguments[0];
         const input = lowerer.lowerExpr(inputNode);
         let init;
@@ -726,33 +498,12 @@ 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,
-    };
-    // 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
-    // values marshal individually, so an AbortSignal HANDLE passes
-    // 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 raw = { kind: "jsOp", op: "callFn", args: [fetchFn, ...args], type: JSVAL, loc };
-    return { kind: "jsBridgePromise", value: raw, type: { kind: "promise", inner: JSVAL }, loc };
 }
 /** Static Response.json(): consume the native Response's readable body
  * stream and parse its UTF-8 payload into the ordinary checked-dynamic
  * JSON tree. Syntax and stream failures reject at await like the web API. */
 export function lowerStaticResponseCall(lowerer, call) {
-    if (lowerer.dynamic ||
-        call.questionDotToken ||
+    if (call.questionDotToken ||
         (!ts.isPropertyAccessExpression(call.expression) &&
             !ts.isElementAccessExpression(call.expression))) {
         return null;
@@ -909,7 +660,7 @@ function fetchInventoryReason(owner, member, placement) {
     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
+ * methods. The inventory marks the former unsupported; fence
  * them explicitly so the generic call fallback cannot report SC1090 for
  * Response.json while the other statics report SC2020. */
 export function fenceUnsupportedFetchConstructorMember(lowerer, access) {
@@ -921,7 +672,7 @@ export function fenceUnsupportedFetchConstructorMember(lowerer, access) {
     const member = members.find((candidate) => fetchInventoryStatus("Response", candidate, "static") === "unsupported");
     if (member === undefined)
         return null;
-    lowerer.noLowering(`Response.${member}`, access, "Response static constructor-object operations have no compiler lowering in either tier");
+    lowerer.noLowering(`Response.${member}`, access, "Response static constructor-object operations have no compiler lowering");
 }
 function hasLiveWebMutableArm(lowerer, type) {
     if (type.kind === "record" || type.kind === "array" || type.kind === "bytes") {
@@ -975,18 +726,15 @@ export function fenceStaticResponseMember(lowerer, access, use) {
     if (members === null)
         return null;
     const status = (member) => fetchInventoryStatus("Response", member, member.startsWith("[Symbol.") ? "prototype-symbol" : "prototype");
-    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);
-    if (!lowerer.dynamic && members.every(supported))
+    if (members.every(supported))
         return null;
-    const member = members.find((candidate) => lowerer.dynamic ? status(candidate) === "unsupported" : !supported(candidate));
+    const member = members.find((candidate) => !supported(candidate));
     if (status(member) === "unsupported") {
         lowerer.noLowering(`Response.${member}`, access, fetchInventoryReason("Response", member, "prototype") ??
-            "this Response operation has no compiler lowering in either tier", sym);
+            "this Response operation has no compiler lowering", sym);
     }
-    lowerer.noLowering(`Response.${member} in a static build`, access, "the native static Response surface is status/ok/statusText/url/redirected/headers/body/bodyUsed plus json(), text(), bytes(), and arrayBuffer(); use --dynamic for the wider Web API", sym);
+    lowerer.noLowering(`Response.${member} in a static build`, access, "the native static Response surface is status/ok/statusText/url/redirected/headers/body/bodyUsed plus json(), text(), bytes(), and arrayBuffer(); other forms are unsupported", sym);
 }
 /** Response Headers are native checked-dynamic handles. Keep their exact
  * supported method slice aligned with the compatibility census so newly
@@ -1001,30 +749,20 @@ export function fenceStaticHeadersMember(lowerer, access, use) {
     if (members === null)
         return null;
     const status = (member) => fetchInventoryStatus("Headers", member, member.startsWith("[Symbol.") ? "prototype-symbol" : "prototype");
-    if (lowerer.dynamic && members.every((member) => status(member) !== "unsupported")) {
+    if (use === "call" && members.every((member) => STATIC_HEADERS_CALLS.has(member))) {
         return null;
     }
-    if (!lowerer.dynamic &&
-        use === "call" &&
-        members.every((member) => STATIC_HEADERS_CALLS.has(member))) {
-        return null;
-    }
-    const member = members.find((candidate) => lowerer.dynamic
-        ? status(candidate) === "unsupported"
-        : use !== "call" || !STATIC_HEADERS_CALLS.has(candidate));
+    const member = members.find((candidate) => use !== "call" || !STATIC_HEADERS_CALLS.has(candidate));
     if (status(member) === "unsupported") {
-        lowerer.noLowering(`Headers.${member}`, access, "symbol-keyed Headers iteration has no compiler lowering in either tier; call entries() with --dynamic instead", sym);
+        lowerer.noLowering(`Headers.${member}`, access, "symbol-keyed Headers iteration is unsupported; use forEach()", sym);
     }
-    lowerer.noLowering(`Headers.${member} in a static build`, access, "the native static Headers surface is append/delete/get/getSetCookie/has/set/forEach; use keys()/values()/entries() or symbol-keyed iteration with --dynamic, while construction remains unsupported", sym);
+    lowerer.noLowering(`Headers.${member} in a static build`, access, "the native static Headers surface is append/delete/get/getSetCookie/has/set/forEach; keys()/values()/entries(), symbol-keyed iteration, and construction remain unsupported", sym);
 }
 /** The native AbortController handle dispatches `abort()` directly and
  * exposes `.signal` as data, but it has no first-class function value for
  * the prototype method. Fence method extraction before the checked-dynamic
- * keyed-read fallback can silently answer `undefined`. Dynamic builds use
- * the engine's real AbortController object and retain ordinary method reads. */
+ * keyed-read fallback can silently answer `undefined`. */
 export function fenceStaticAbortControllerMemberRead(lowerer, access) {
-    if (lowerer.dynamic)
-        return null;
     const symbol = isStdlibFetchInterface(lowerer, access.expression, "AbortController");
     if (!symbol)
         return null;
@@ -1047,7 +785,7 @@ function isStdlibFetchInterface(lowerer, node, owner) {
  * through. Null means this is not the standard-library ReadableStream or
  * its element cannot be represented statically. */
 export function staticReadableStreamElementType(lowerer, node) {
-    if (lowerer.dynamic || !isStdlibFetchInterface(lowerer, node, "ReadableStream")) {
+    if (!isStdlibFetchInterface(lowerer, node, "ReadableStream")) {
         return null;
     }
     const type = lowerer.checker.getBaseTypeOfLiteralType(lowerer.typeOf(node));
@@ -1107,24 +845,17 @@ function fenceFetchObjectMembers(lowerer, ownerNode, members) {
                 entry.placement === "prototype-symbol"));
         if (!row || row.status === "out-of-scope")
             continue;
-        if (lowerer.dynamic && row.status !== "unsupported")
-            continue;
         // Static data properties retain the ordinary checked-dynamic keyed-read
         // lowering. Only a method extraction loses the receiver that its direct
         // call bridge would preserve; non-static rows keep their inventory fence.
         const operation = NODE24_FETCH_COMPAT_PROFILE.operations.find((candidate) => candidate.id === row.id);
-        if (!lowerer.dynamic && row.status === "static" && operation?.kind === "property") {
+        if (row.status === "static" && operation?.kind === "property") {
             continue;
         }
-        lowerer.noLowering(`${owner}.${member}${lowerer.dynamic ? "" : " through object destructuring in a static build"}`, node, row.reason ??
+        lowerer.noLowering(`${owner}.${member}${" through object destructuring in a static build"}`, node, row.reason ??
             "the direct lowered read/call form has a compiler bridge, but extracting this member as a value does not", symbol);
     }
 }
-/** Object binding syntax reads members without constructing property-access
- * nodes, so the ordinary Response/Headers/ReadableStream chokepoints never
- * see it. Attribute those reads to the same inventory rows before generic
- * dyn/jsval destructuring either reports SC1031 or admits an unsupported
- * member in the dynamic tier. */
 export function fenceFetchObjectBinding(lowerer, pattern) {
     fenceFetchObjectMembers(lowerer, pattern, pattern.elements.flatMap((element) => {
         if (element.dotDotDotToken)
@@ -1144,12 +875,8 @@ export function fenceFetchObjectAssignment(lowerer, target, source) {
 }
 /** Iteration syntax invokes Headers[Symbol.iterator] without constructing
  * an element-access node, so the member chokepoint above never sees it.
- * Keep engine-free builds on the same SC2020 profile row for for-of,
- * array spread, and array destructuring. The dynamic tier uses the
- * engine's iterator protocol and is intentionally allowed. */
+ * Use the same SC2020 profile row for for-of, array spread, and array destructuring. */
 export function fenceStaticHeadersIteration(lowerer, node) {
-    if (lowerer.dynamic)
-        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) &&
@@ -1161,101 +888,7 @@ export function fenceStaticHeadersIteration(lowerer, node) {
     const sym = isStdlibFetchInterface(lowerer, value, "Headers");
     if (!sym)
         return;
-    lowerer.noLowering("Headers.[Symbol.iterator] in a static build", node, "Headers iteration requires --dynamic; append/delete/get/getSetCookie/has/set/forEach remain engine-free", sym);
-}
-/** Dynamic element-spelled Headers iteration. Symbol.iterator uses the
- * engine's GetIterator operation. A finite union of keys()/values()/entries()
- * dispatches through fixed-name engine calls after evaluating the receiver
- * and key once, preserving the method receiver and JavaScript evaluation
- * order without trying to represent the union of method values. */
-export function lowerDynamicHeadersIteratorCall(lowerer, call, access) {
-    if (!lowerer.dynamic ||
-        call.questionDotToken ||
-        access.questionDotToken ||
-        call.arguments.length !== 0 ||
-        !isStdlibFetchInterface(lowerer, access.expression, "Headers")) {
-        return null;
-    }
-    const members = fetchElementMemberNames(lowerer, access.argumentExpression);
-    if (members === null)
-        return null;
-    const symbolIterator = members.length === 1 && members[0] === "[Symbol.iterator]";
-    if (!symbolIterator &&
-        !members.every((member) => member === "keys" || member === "values" || member === "entries")) {
-        return null;
-    }
-    const receiver = lowerer.lowerExpr(access.expression);
-    if (receiver.type.kind !== "jsval")
-        return null;
-    const loc = locOf(call);
-    if (!symbolIterator) {
-        const key = lowerer.lowerExpr(access.argumentExpression);
-        if (key.type.kind !== "string")
-            return null;
-        const recvLocal = lowerer.declareHiddenLocal("%headers", JSVAL);
-        const keyLocal = lowerer.declareHiddenLocal("%headersKey", STRING);
-        const recvRef = {
-            kind: "varRef",
-            localId: recvLocal.id,
-            type: JSVAL,
-            loc,
-        };
-        const keyRef = {
-            kind: "varRef",
-            localId: keyLocal.id,
-            type: STRING,
-            loc,
-        };
-        const invoke = (member) => ({
-            kind: "jsOp",
-            op: "callMethod",
-            name: member,
-            args: [recvRef],
-            type: JSVAL,
-            loc,
-        });
-        // Same-kind literal unions erase to STRING in IR, so a lying assertion
-        // can carry a runtime key outside `members`. Validate every arm instead
-        // of treating the last member as an unconditional default: substituting
-        // another method is silent corruption. The trust-but-verify fallback is
-        // the catchable TypeError used by the compiler's other erased casts.
-        let result = nodeThrowExpr(1, "", `${access.getText()} is not a function`, JSVAL, loc);
-        for (let i = members.length - 1; i >= 0; i--) {
-            const member = members[i];
-            result = {
-                kind: "ternary",
-                cond: {
-                    kind: "strEq",
-                    negated: false,
-                    left: keyRef,
-                    right: { kind: "strLit", value: member, type: STRING, loc },
-                    type: BOOL,
-                    loc,
-                },
-                then: invoke(member),
-                else_: result,
-                type: JSVAL,
-                loc,
-            };
-        }
-        return {
-            kind: "seqExpr",
-            stmts: [
-                { kind: "varDecl", localId: recvLocal.id, init: receiver, loc },
-                { kind: "varDecl", localId: keyLocal.id, init: key, loc },
-            ],
-            result,
-            type: JSVAL,
-            loc,
-        };
-    }
-    return {
-        kind: "jsOp",
-        op: "iterNew",
-        args: [receiver],
-        type: JSVAL,
-        loc,
-    };
+    lowerer.noLowering("Headers.[Symbol.iterator] in a static build", node, "Headers iteration is unsupported; use append/delete/get/getSetCookie/has/set/forEach", sym);
 }
 /** Bracket-spelled calls on a profiled fetch/Web-stream handle. A call such
  * as `headers["get"](name)` is still a method reference in JavaScript: the
@@ -1283,26 +916,21 @@ 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")));
-    if (rows.some((row) => row === undefined ||
-        row.status === "out-of-scope" ||
-        (lowerer.dynamic ? row.status === "unsupported" : row.status !== "static"))) {
+    if (rows.some((row) => row === undefined || row.status === "out-of-scope" || row.status !== "static")) {
         return null;
     }
     const receiver = lowerer.lowerExpr(access.expression);
-    if (receiver.type.kind !== (lowerer.dynamic ? "jsval" : "dyn"))
+    if (receiver.type.kind !== "dyn")
         return null;
     const key = lowerer.lowerExpr(access.argumentExpression);
     if (key.type.kind !== "string")
         return null;
     const loc = locOf(call);
-    const receiverLocal = lowerer.declareHiddenLocal("%fetchReceiver", lowerer.dynamic ? JSVAL : DYN);
+    const receiverLocal = lowerer.declareHiddenLocal("%fetchReceiver", DYN);
     const keyLocal = lowerer.declareHiddenLocal("%fetchMember", STRING);
-    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)
-            ? lowerLiveWebValue(lowerer, argument)
-            : lowerer.lowerExprExpecting(argument, DYN));
+    const argumentValues = call.arguments.map((argument, index) => fetchMethodArgumentIsLive(resolved.owner, members, index)
+        ? lowerLiveWebValue(lowerer, argument)
+        : lowerer.lowerExprExpecting(argument, DYN));
     const argumentLocals = argumentValues.map((argument) => lowerer.declareHiddenLocal("%fetchMethodArg", argument.type));
     const receiverRef = {
         kind: "varRef",
@@ -1316,46 +944,24 @@ export function lowerFetchElementMethodCall(lowerer, call) {
         type: STRING,
         loc,
     };
-    const calleeRef = calleeLocal === null
-        ? null
-        : {
-            kind: "varRef",
-            localId: calleeLocal.id,
-            type: JSVAL,
-            loc,
-        };
-    const memberReadStmt = calleeLocal === null
-        ? {
-            kind: "exprStmt",
-            expr: {
-                kind: "dynKeyGet",
-                value: receiverRef,
-                key: keyRef,
-                type: DYN,
-                loc,
-            },
-            loc,
-        }
-        : {
-            kind: "varDecl",
-            localId: calleeLocal.id,
-            init: {
-                kind: "jsOp",
-                op: "getIdx",
-                args: [receiverRef, { kind: "jsMarshal", value: keyRef, type: JSVAL, loc }],
-                type: JSVAL,
-                loc,
-            },
+    const memberReadStmt = {
+        kind: "exprStmt",
+        expr: {
+            kind: "dynKeyGet",
+            value: receiverRef,
+            key: keyRef,
+            type: DYN,
             loc,
-        };
+        },
+        loc,
+    };
     const argumentRefs = argumentLocals.map((argument) => ({
         kind: "varRef",
         localId: argument.id,
         type: argument.type,
         loc,
     }));
-    const staticResponsePromise = !lowerer.dynamic &&
-        resolved.owner === "Response" &&
+    const staticResponsePromise = resolved.owner === "Response" &&
         call.arguments.length === 0 &&
         members.every((member) => member === "text" || member === "bytes")
         ? (() => {
@@ -1370,35 +976,27 @@ export function lowerFetchElementMethodCall(lowerer, call) {
             return inner ? { kind: "promise", inner } : null;
         })()
         : null;
-    const invoke = (member) => lowerer.dynamic
+    const invoke = (member) => staticResponsePromise !== null
         ? {
-            kind: "jsOp",
-            op: "callFnThis",
-            args: [calleeRef, receiverRef, ...argumentRefs],
-            type: JSVAL,
+            kind: "libCall",
+            fn: member === "text" ? "fetch.responseText" : "fetch.responseBytes",
+            args: [receiverRef],
+            type: staticResponsePromise,
             loc,
         }
-        : staticResponsePromise !== null
-            ? {
-                kind: "libCall",
-                fn: member === "text" ? "fetch.responseText" : "fetch.responseBytes",
-                args: [receiverRef],
-                type: staticResponsePromise,
-                loc,
-            }
-            : {
-                kind: "dynInvoke",
-                recv: receiverRef,
-                method: member,
-                calleeName: access.getText(),
-                args: argumentRefs,
-                type: DYN,
-                loc,
-            };
+        : {
+            kind: "dynInvoke",
+            recv: receiverRef,
+            method: member,
+            calleeName: access.getText(),
+            args: argumentRefs,
+            type: DYN,
+            loc,
+        };
     // Literal-string unions share the STRING carrier. A cast can therefore
     // smuggle a different runtime key into this call; validate all arms and
     // fail loudly rather than dispatching every mismatch to the last member.
-    const invocationType = staticResponsePromise ?? (lowerer.dynamic ? JSVAL : DYN);
+    const invocationType = staticResponsePromise ?? DYN;
     let result = nodeThrowExpr(1, "", `${access.getText()} is not a function`, invocationType, loc);
     for (let index = members.length - 1; index >= 0; index--) {
         const member = members[index];
@@ -1418,11 +1016,6 @@ export function lowerFetchElementMethodCall(lowerer, call) {
             loc,
         };
     }
-    const declared = lowerer.dynamic ? lowerer.mapTypeOf(lowerer.typeOf(call)) : null;
-    if (declared &&
-        (declared.kind === "f64" || declared.kind === "bool" || declared.kind === "string")) {
-        result = { kind: "jsExit", value: result, type: declared, loc };
-    }
     return {
         kind: "seqExpr",
         stmts: [
@@ -1441,36 +1034,6 @@ export function lowerFetchElementMethodCall(lowerer, call) {
         loc,
     };
 }
-/** `[...headers]` in the dynamic tier: Array.from runs inside the engine
- * over the real Headers iterator, then the resulting pair array exits
- * through the checker's declared array type. For Headers this is the
- * spread algorithm's exact iterable snapshot. */
-export function lowerDynamicHeadersSpread(lowerer, node, type) {
-    if (!lowerer.dynamic || !isStdlibFetchInterface(lowerer, requestInitValueExpr(node), "Headers")) {
-        return null;
-    }
-    const receiver = lowerer.lowerExpr(node);
-    if (receiver.type.kind !== "jsval")
-        return null;
-    const loc = locOf(node);
-    const arrayCtor = {
-        kind: "jsOp",
-        op: "globalGet",
-        name: "Array",
-        args: [],
-        type: JSVAL,
-        loc,
-    };
-    const snapshot = {
-        kind: "jsOp",
-        op: "callMethod",
-        name: "from",
-        args: [arrayCtor, receiver],
-        type: JSVAL,
-        loc,
-    };
-    return { kind: "jsExit", value: snapshot, type, loc };
-}
 /** The fallback ambient declaration intentionally exposes only the native
  * stream slice, but @types/node adopts the complete WHATWG ReadableStream
  * interface. Fence that wider surface before its checked-dynamic handle can
@@ -1483,19 +1046,16 @@ export function fenceStaticReadableStreamMember(lowerer, access, use) {
     if (members === null)
         return null;
     const status = (member) => fetchInventoryStatus("ReadableStream", member, member.startsWith("[Symbol.") ? "prototype-symbol" : "prototype");
-    if (lowerer.dynamic && members.every((member) => status(member) !== "unsupported")) {
-        return null;
-    }
     const supported = (member) => use === "call"
         ? STATIC_READABLE_STREAM_CALLS.has(member)
         : STATIC_READABLE_STREAM_READS.has(member);
-    if (!lowerer.dynamic && members.every(supported))
+    if (members.every(supported))
         return null;
-    const member = members.find((candidate) => lowerer.dynamic ? status(candidate) === "unsupported" : !supported(candidate));
+    const member = members.find((candidate) => !supported(candidate));
     if (status(member) === "unsupported") {
-        lowerer.noLowering(`ReadableStream.${member}`, access, fetchInventoryReason("ReadableStream", member, member.startsWith("[Symbol.") ? "prototype-symbol" : "prototype") ?? "this ReadableStream operation has no compiler lowering in either tier", sym);
+        lowerer.noLowering(`ReadableStream.${member}`, access, fetchInventoryReason("ReadableStream", member, member.startsWith("[Symbol.") ? "prototype-symbol" : "prototype") ?? "this ReadableStream operation has no compiler lowering", sym);
     }
-    lowerer.noLowering(`ReadableStream.${member} in a static build`, access, "the native static ReadableStream surface is locked plus cancel() and getReader(); values()/[Symbol.asyncIterator]() compile when consumed directly by for await, while stored iterator handles require --dynamic", sym);
+    lowerer.noLowering(`ReadableStream.${member} in a static build`, access, "the native static ReadableStream surface is locked plus cancel() and getReader(); values()/[Symbol.asyncIterator]() compile when consumed directly by for await, while stored iterator handles remain unsupported", sym);
 }
 /** Static AbortSignal constructors and ReadableStream.from(). These
  * ambient globals have no first-class constructor-object representation;
@@ -1537,8 +1097,7 @@ function staticCallWithSurplusArgs(lowerer, call, first, result) {
     return result(staticFirstArgWithSurplusArgs(lowerer, call, first));
 }
 export function lowerStaticFetchCompanionCall(lowerer, call) {
-    if (lowerer.dynamic ||
-        call.questionDotToken ||
+    if (call.questionDotToken ||
         !ts.isPropertyAccessExpression(call.expression) ||
         call.expression.questionDotToken ||
         !ts.isIdentifier(call.expression.expression)) {
@@ -1656,8 +1215,7 @@ export function lowerStaticFetchCompanionCall(lowerer, call) {
  * are ignored by the runtime operation. */
 export function lowerStaticAbortControllerCall(lowerer, call) {
     const access = call.expression;
-    if (lowerer.dynamic ||
-        call.questionDotToken ||
+    if (call.questionDotToken ||
         call.arguments.some((argument) => ts.isSpreadElement(argument)) ||
         (!ts.isPropertyAccessExpression(access) && !ts.isElementAccessExpression(access)) ||
         access.questionDotToken ||
@@ -1695,8 +1253,7 @@ export function lowerStaticAbortControllerCall(lowerer, call) {
  * object identity for the reader/source callbacks that observe them. */
 export function lowerStaticReadableStreamControllerCall(lowerer, call) {
     const access = call.expression;
-    if (lowerer.dynamic ||
-        call.questionDotToken ||
+    if (call.questionDotToken ||
         call.arguments.length > 1 ||
         (!ts.isPropertyAccessExpression(access) && !ts.isElementAccessExpression(access)) ||
         access.questionDotToken) {
@@ -1735,8 +1292,7 @@ export function lowerStaticReadableStreamControllerCall(lowerer, call) {
  * live typed-reference capsule instead of the general dyn boundary's copy. */
 export function lowerStaticReadableStreamCancelCall(lowerer, call) {
     const access = call.expression;
-    if (lowerer.dynamic ||
-        call.questionDotToken ||
+    if (call.questionDotToken ||
         call.arguments.length > 1 ||
         call.arguments.some((argument) => ts.isSpreadElement(argument)) ||
         (!ts.isPropertyAccessExpression(access) && !ts.isElementAccessExpression(access)) ||
@@ -1771,8 +1327,7 @@ export function lowerStaticReadableStreamCancelCall(lowerer, call) {
  * chunks so repeated crossings still denote one EventListener object. */
 export function lowerStaticAbortSignalListenerCall(lowerer, call) {
     const access = call.expression;
-    if (lowerer.dynamic ||
-        call.questionDotToken ||
+    if (call.questionDotToken ||
         call.arguments.length < 2 ||
         call.arguments.some((arg) => ts.isSpreadElement(arg)) ||
         (!ts.isPropertyAccessExpression(access) && !ts.isElementAccessExpression(access)) ||
@@ -1806,10 +1361,6 @@ export function lowerStaticAbortSignalListenerCall(lowerer, call) {
         loc,
     }));
 }
-/** `new AbortController()`. Static builds create a native controller handle
- * over the same signal state consumed by fetch; dynamic builds construct the
- * 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") {
         return null;
@@ -1821,26 +1372,6 @@ export function lowerAbortControllerNew(lowerer, expr) {
     if (args.some((argument) => ts.isSpreadElement(argument)))
         return null;
     const loc = locOf(expr);
-    if (lowerer.dynamic) {
-        const ctor = {
-            kind: "jsOp",
-            op: "globalGet",
-            name: "AbortController",
-            args: [],
-            type: JSVAL,
-            loc,
-        };
-        return {
-            kind: "jsOp",
-            op: "construct",
-            args: [
-                ctor,
-                ...args.map((argument) => lowerer.jsvalIn(lowerer.lowerExpr(argument), argument)),
-            ],
-            type: JSVAL,
-            loc,
-        };
-    }
     const result = {
         kind: "libCall",
         fn: "fetch.abortControllerNew",
@@ -1862,9 +1393,6 @@ export function lowerAbortControllerNew(lowerer, expr) {
         loc,
     };
 }
-/** `new ReadableStream(source?)`. Static builds box the source record into
- * 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") {
         return null;
@@ -1876,28 +1404,6 @@ export function lowerStaticReadableStreamNew(lowerer, expr) {
     if (args.length > 1)
         return null;
     const loc = locOf(expr);
-    if (lowerer.dynamic) {
-        const ctor = {
-            kind: "jsOp",
-            op: "globalGet",
-            name: "ReadableStream",
-            args: [],
-            type: JSVAL,
-            loc,
-        };
-        const source = args[0] === undefined
-            ? null
-            : ts.isObjectLiteralExpression(args[0])
-                ? lowerIslandObjectLiteral(lowerer, args[0])
-                : lowerer.jsvalIn(lowerer.lowerExpr(args[0]), args[0]);
-        return {
-            kind: "jsOp",
-            op: "construct",
-            args: source === null ? [ctor] : [ctor, source],
-            type: JSVAL,
-            loc,
-        };
-    }
     const source = args.length === 0
         ? dynUndefinedExpr(loc)
         : ts.isObjectLiteralExpression(args[0])
@@ -1920,17 +1426,6 @@ export function lowerFetchWebNew(lowerer, expr) {
     if (args.some(ts.isSpreadElement))
         return null;
     const loc = locOf(expr);
-    if (lowerer.dynamic)
-        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,
-        };
     if (name === "Request" && args[1])
         fenceRequestInitValue(lowerer, args[1]);
     const lowered = args.map((arg) => ts.isObjectLiteralExpression(arg)
@@ -1946,10 +1441,6 @@ export function lowerFetchWebNew(lowerer, expr) {
         loc,
     };
 }
-/** `new Response(body?, init?)`. Dynamic builds construct the island's
- * Web Response directly. Static builds hand a checked-dynamic BodyInit and
- * ResponseInit snapshot to the native fetch runtime, which returns the same
- * opaque Response handle as fetch(). */
 export function lowerResponseNew(lowerer, expr) {
     if (stdlibGlobalNameOf(lowerer, expr.expression) !== "Response")
         return null;
@@ -1957,26 +1448,6 @@ export function lowerResponseNew(lowerer, expr) {
     if (args.some(ts.isSpreadElement))
         return null;
     const loc = locOf(expr);
-    if (lowerer.dynamic) {
-        const ctor = {
-            kind: "jsOp",
-            op: "globalGet",
-            name: "Response",
-            args: [],
-            type: JSVAL,
-            loc,
-        };
-        const lowered = args.map((arg) => ts.isObjectLiteralExpression(arg)
-            ? lowerIslandObjectLiteral(lowerer, arg)
-            : lowerer.jsvalIn(lowerer.lowerExpr(arg), arg));
-        return {
-            kind: "jsOp",
-            op: "construct",
-            args: [ctor, ...lowered],
-            type: JSVAL,
-            loc,
-        };
-    }
     const toDyn = (node, value, what) => {
         if (node === undefined)
             return dynUndefinedExpr(loc);
@@ -2099,8 +1570,7 @@ export function lowerResponseNew(lowerer, expr) {
  * widening keeps the compiler's ordinary copy-based width semantics. */
 export function lowerStaticReadableStreamReaderCall(lowerer, call) {
     const access = call.expression;
-    if (lowerer.dynamic ||
-        call.questionDotToken ||
+    if (call.questionDotToken ||
         call.arguments.length !== 0 ||
         (!ts.isPropertyAccessExpression(access) && !ts.isElementAccessExpression(access)) ||
         access.questionDotToken) {
@@ -2130,142 +1600,27 @@ export function lowerStaticReadableStreamReaderCall(lowerer, call) {
         loc: locOf(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(...)`. */
 export function lowerDynamicImportCall(lowerer, call) {
     if (call.expression.kind !== ts.SyntaxKind.ImportKeyword)
         return null;
-    const loc = locOf(call);
     const arg = call.arguments[0];
     if (arg === undefined || !ts.isStringLiteralLike(arg)) {
-        lowerer.unsupported("SC1090", call, "dynamic import() of computed specifiers (the module graph embeds at " +
+        lowerer.unsupported("SC1090", call, "dynamic import() of computed specifiers (the module graph resolves at " +
             "build time — the specifier must be a string literal)");
     }
     if (call.arguments.length !== 1) {
         lowerer.unsupported("SC1090", call, "dynamic import() with import attributes");
     }
     const res = lowerer.dynImports.get(`${call.getSourceFile().fileName}\u0000${arg.text}`);
-    if (!lowerer.dynamic) {
-        if (res?.kind === "program-module") {
-            return lowerOwnStaticModuleImport(lowerer, call, arg);
-        }
-        if (res?.kind === "static-builtin") {
-            return lowerStaticNamespaceImport(lowerer, call, {
-                kind: "moduleNs",
-                moduleId: `builtin:${res.module}`,
-            });
-        }
-        lowerer.requireDynamicApi("'import()'", call);
-        throw new PoisonError();
-    }
-    lowerer.requireDynamicApi("'import()'", call);
-    if (!res) {
-        // Collection walks every file before bodies lower, so a missing
-        // entry is a lowerer bug, not user error.
-        throw new InternalCompilerError(`lowerer bug: unresolved dynamic import '${arg.text}'`);
-    }
+    if (res === undefined)
+        lowerer.refuseUnsupportedApi("'import()'", call);
     if (res.kind === "program-module") {
-        return lowerOwnDynamicModuleImport(lowerer, call, arg);
-    }
-    if (res.kind !== "module") {
-        throw new PoisonError(); // resolution failed — collection reported it
-    }
-    const raw = {
-        kind: "libCall",
-        fn: "island.importDyn",
-        args: [{ kind: "strLit", value: res.key, type: STRING, loc }],
-        type: JSVAL,
-        loc,
-    };
-    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. */
-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) : []) {
-        if (ts.isSourceFile(d) && !d.isDeclarationFile) {
-            dep = d;
-            break;
-        }
+        return lowerOwnStaticModuleImport(lowerer, call, arg);
     }
-    if (dep !== null && (dep.fileName.endsWith(".cts") || isCjsJsFile(dep, lowerer.program))) {
-        lowerer.unsupported("SC1090", call, `dynamic import of the program's own CommonJS module '${arg.text}' ` +
-            "(its namespace comes from module.exports through Node's CJS lexer, " +
-            "which has no compiled story — require it, or import it statically)");
-    }
-    const builder = dep !== null ? dynNsBuilderOf(lowerer, dep, loc) : null;
-    if (builder === null) {
-        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 builderAsync = dep !== null && lowerer.asyncInitFiles.has(dep);
-    const builderFn = {
-        kind: "func",
-        params: [],
-        ret: builderAsync ? { kind: "promise", inner: JSVAL } : JSVAL,
-    };
-    const marshaled = {
-        kind: "jsMarshal",
-        value: { kind: "closure", fnName: builder, captures: [], type: builderFn, loc },
-        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 };
+    return lowerStaticNamespaceImport(lowerer, call, {
+        kind: "moduleNs",
+        moduleId: `builtin:${res.module}`,
+    });
 }
 /** The checker-resolved program source behind one literal import(). */
 function programImportTarget(lowerer, arg) {
@@ -2410,408 +1765,25 @@ function appendStaticModuleInit(lowerer, dep, body, loc) {
         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). */
-function dynNsBuilderOf(lowerer, dep, loc) {
-    const cached = lowerer.dynNsBuilders.get(dep);
-    if (cached !== undefined)
-        return cached;
-    const initName = lowerer.initNameOf.get(dep);
-    if (initName === undefined)
-        return null;
-    const rawTag = lowerer.fileTag.get(dep) ?? "";
-    const name = `%dynns.${rawTag === "" ? "e." : rawTag.replace(/^%/, "")}`;
-    lowerer.dynNsBuilders.set(dep, name);
-    const isAsync = lowerer.asyncInitFiles.has(dep);
-    const fnCtx = newFnCtx(true, null, null, JSVAL);
-    fnCtx.isAsync = isAsync;
-    lowerer.fnStack.push(fnCtx);
-    try {
-        const body = [];
-        const linkCrash = esmNamedImportLinkCrash(lowerer.program, dep);
-        if (linkCrash !== null) {
-            // A dynamic import links its graph when the returned promise is
-            // settled. Throw from the synthesized namespace builder, which runs
-            // inside the Promise reaction, so no module init executes before the
-            // link failure and the bridge turns it into the import rejection.
-            body.push({
-                kind: "throw",
-                value: {
-                    kind: "libCall",
-                    fn: "error.new",
-                    args: [{ kind: "strLit", value: linkCrash.message, type: STRING, loc }],
-                    type: { kind: "object", className: linkCrash.className },
-                    loc,
-                },
-                loc,
-            });
-        }
-        // A synchronous entry has no run-once guard, so its historical
-        // self-import path must not call %init again. An ASYNC entry does
-        // have the stronger evaluation-promise cache: awaiting that cached
-        // promise is essential for top-level `await import("./self")`,
-        // which deadlocks (and ultimately exits 13) in Node rather than
-        // exposing a half-evaluated namespace.
-        if (linkCrash === null && (dep !== lowerer.entry || isAsync)) {
-            const call = {
-                kind: "call",
-                callee: initName,
-                args: [],
-                type: isAsync ? { kind: "promise", inner: VOID } : VOID,
-                loc,
-            };
-            const cyclePromiseId = lowerer.asyncCyclePromiseOf.get(dep);
-            if (isAsync && cyclePromiseId !== undefined) {
-                // Starting the REQUESTED member matters for dynamically-only
-                // cycles: build-time discovery may have encountered another
-                // member first, but Node roots evaluation at the first module
-                // actually imported at runtime. The spawn wrapper publishes
-                // that outermost promise in the SCC's shared slot after eager
-                // recursive spawning returns. Discard the member promise here
-                // and await the shared root before exposing any namespace.
-                body.push({ kind: "exprStmt", expr: call, loc });
-                const promiseT = { kind: "promise", inner: VOID };
-                body.push({
-                    kind: "exprStmt",
-                    expr: {
-                        kind: "awaitExpr",
-                        value: { kind: "varRef", localId: cyclePromiseId, type: promiseT, loc },
-                        type: VOID,
-                        loc,
-                    },
-                    loc,
-                });
-            }
-            else {
-                body.push({
-                    kind: "exprStmt",
-                    expr: isAsync ? { kind: "awaitExpr", value: call, type: VOID, loc } : call,
-                    loc,
-                });
-            }
-        }
-        // Node sorts module-namespace keys (code-unit order); tsc erases
-        // type-only exports, so only VALUE exports appear.
-        const entries = [];
-        const modSym = lowerer.checker.getSymbolAtLocation(dep);
-        modSym?.getExports().forEach((sym, key) => {
-            const n = String(key);
-            if (!n.startsWith("__") && n !== "export=")
-                entries.push([n, sym]);
-        });
-        entries.sort((a, b) => (a[0] < b[0] ? -1 : a[0] > b[0] ? 1 : 0));
-        const args = [];
-        for (const [exportName, sym] of entries) {
-            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);
-        }
-        body.push({
-            kind: "return",
-            value: { kind: "jsOp", op: "objLit", args, type: JSVAL, loc },
-            loc,
-        });
-        const ctx = lowerer.ctx;
-        lowerer.liftedFns.push({
-            name,
-            params: [],
-            returnType: JSVAL,
-            locals: ctx.locals,
-            captures: ctx.captures ?? [],
-            body,
-            ...(isAsync ? { async: true } : {}),
-            loc,
-        });
-    }
-    finally {
-        lowerer.fnStack.pop();
-    }
-    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). */
-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;
-    if (sym.flags & ts.SymbolFlags.Alias) {
-        // `export type { x }` / `export { type x }`: erased at runtime.
-        for (const d of lowerer.checker.declarationsOf(sym)) {
-            if (ts.isExportSpecifier(d)) {
-                const exportDecl = d.parent?.parent;
-                if (d.isTypeOnly || (ts.isExportDeclaration(exportDecl) && exportDecl.isTypeOnly))
-                    return null;
-            }
-            if (ts.isImportSpecifier(d)) {
-                const clause = d.parent?.parent;
-                if (d.isTypeOnly ||
-                    (ts.isImportClause(clause) && clause.phaseModifier === ts.SyntaxKind.TypeKeyword))
-                    return null;
-            }
-        }
-        resolved = lowerer.checker.getAliasedSymbol(sym);
-    }
-    if (!(resolved.flags & ts.SymbolFlags.Value))
-        return null; // pure type surface
-    const g = lowerer.globalsBySymbol.get(resolved);
-    if (g) {
-        const ref = { kind: "varRef", localId: g.id, type: g.type, 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,
-            };
-        }
-        if (ref.type.kind === "func") {
-            return canMarshalTypedFuncIntoIsland(ref.type, (id) => lowerer.shapes.get(id), (id) => lowerer.unions.get(id))
-                ? { kind: "jsMarshal", value: ref, type: JSVAL, loc }
-                : trap(`a function value of type '${lowerer.fmt(ref.type)}'`);
-        }
-        if (lowerer.boundarySafe(ref.type))
-            return { kind: "jsMarshal", value: ref, type: JSVAL, loc };
-        if (lowerer.jsvalLiftable(ref.type))
-            return lowerer.jsvalLiftExpr(ref, 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")));
-    if (sig && decl0) {
-        if (!sig.params.every((p) => p.mode === "required")) {
-            return trap("a function with optional, default, or rest parameters");
-        }
-        const funcType = {
-            kind: "func",
-            params: sig.params.map((p) => p.type),
-            ret: sig.returnType,
-        };
-        if (!canMarshalTypedFuncIntoIsland(funcType, (id) => lowerer.shapes.get(id), (id) => lowerer.unions.get(id))) {
-            return trap(`a function of type '${lowerer.fmt(funcType)}'`);
-        }
-        lowerer.noteEdge(sig.name);
-        return {
-            kind: "jsMarshal",
-            value: { kind: "closure", fnName: sig.name, captures: [], type: funcType, loc },
-            type: JSVAL,
-            loc,
-        };
-    }
-    if (lowerer.genericFnsBySymbol.has(resolved))
-        return trap("a generic function");
-    const flags = resolved.flags;
-    if (flags & ts.SymbolFlags.Class)
-        return trap("a class");
-    if (flags & ts.SymbolFlags.Enum)
-        return trap("an enum object");
-    if (flags & ts.SymbolFlags.ValueModule || flags & ts.SymbolFlags.NamespaceModule) {
-        return trap("a namespace object");
-    }
-    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. */
-function islandTrapFnValue(lowerer, message, loc) {
-    void lowerer;
-    const code = `throw new TypeError(${JSON.stringify(message)})`;
-    return {
-        kind: "jsOp",
-        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,
-            },
-        ],
-        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. */
-function lowerIslandObjectLiteral(lowerer, expr) {
-    const loc = locOf(expr);
-    let args = [];
-    let acc = null;
-    const flushFields = () => {
-        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 };
-        args = [];
-    };
-    for (const prop of expr.properties) {
-        if (ts.isSpreadAssignment(prop)) {
-            flushFields();
-            const spread = ts.isObjectLiteralExpression(prop.expression)
-                ? lowerIslandObjectLiteral(lowerer, prop.expression)
-                : lowerer.jsvalIn(lowerer.lowerExpr(prop.expression), prop.expression);
-            acc ??= { kind: "jsOp", op: "objLit", args: [], type: JSVAL, loc };
-            acc = { kind: "jsOp", op: "objSpread", args: [acc, spread], type: JSVAL, loc: locOf(prop) };
-            continue;
-        }
-        if (!ts.isPropertyAssignment(prop) &&
-            !ts.isShorthandPropertyAssignment(prop) &&
-            !ts.isMethodDeclaration(prop)) {
-            lowerer.unsupported("SC1090", prop, "this property form in an island-built object literal (use a spelled or pure const-folded key with a value or method)");
-        }
-        const propertyName = requestInitLiteralKey(lowerer, prop);
-        if (propertyName === null) {
-            lowerer.unsupported("SC1090", prop, "this property key in an island-built object literal (use a spelled or pure const-folded key)");
-        }
-        const nameLoc = locOf(prop.name);
-        args.push({
-            kind: "jsMarshal",
-            value: { kind: "strLit", value: propertyName, type: STRING, loc: nameLoc },
-            type: JSVAL,
-            loc: nameLoc,
-        });
-        const valueNode = ts.isPropertyAssignment(prop)
-            ? prop.initializer
-            : ts.isShorthandPropertyAssignment(prop)
-                ? prop.name
-                : prop;
-        if (ts.isObjectLiteralExpression(valueNode)) {
-            args.push(lowerIslandObjectLiteral(lowerer, valueNode));
-        }
-        else if (ts.isArrayLiteralExpression(valueNode) &&
-            !valueNode.elements.some(ts.isSpreadElement)) {
-            const elems = valueNode.elements.map((el) => lowerer.jsvalIn(lowerer.lowerExpr(el), el));
-            args.push({ kind: "jsOp", op: "arrLit", args: elems, type: JSVAL, loc: locOf(valueNode) });
-        }
-        else {
-            const value = ts.isMethodDeclaration(valueNode)
-                ? (lowerer.rejectThisInObjectMethod(valueNode.body ?? valueNode),
-                    lowerer.lowerLambda(valueNode))
-                : lowerer.lowerExpr(valueNode);
-            args.push(lowerer.jsvalIn(value, valueNode));
-        }
-    }
-    flushFields();
-    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. */
-export function lowerIslandMethodCall(lowerer, call, access) {
+export function lowerStdlibMethodCall(lowerer, call, access) {
     if (lowerer.chainBlocked(access, call))
         return null;
     const name = access.name.text;
     const loc = locOf(call);
-    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,
-        };
-        return { kind: "jsExit", value: result, type: entry.ret, loc };
-    };
-    // `AbortSignal.timeout(ms)` / `.abort(reason?)` / `.any(signals)` —
-    // the fetch-cancellation ambient: the engine's own AbortSignal mints
-    // the signal, which stays a HANDLE (its checker type, AbortSignal,
-    // maps to jsval — see ISLAND_AMBIENT_TYPES) so it can ride a
-    // RequestInit literal into fetch without a JSON detour. The prelude
-    // implements all three statics.
+    // Supported native AbortSignal statics are handled before this generic
+    // method path. Refuse forms that reach this point without a lowering.
     {
         const sigMember = lowerer.stdlibGlobalMember(access, "AbortSignal");
         if ((sigMember === "timeout" || sigMember === "abort" || sigMember === "any") &&
             call.arguments.every((argument) => !ts.isSpreadElement(argument))) {
-            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,
-            };
-            return {
-                kind: "jsOp",
-                op: "callMethod",
-                name: sigMember,
-                args: [signalGlobal, ...args],
-                type: JSVAL,
-                loc,
-            };
+            lowerer.refuseUnsupportedApi(`'AbortSignal.${sigMember}'`, call);
         }
     }
     if (lowerer.stdlibGlobalMember(access, "ReadableStream") === "from" &&
         call.arguments.every((argument) => !ts.isSpreadElement(argument))) {
-        lowerer.requireDynamicApi("'ReadableStream.from'", call);
-        const streamGlobal = {
-            kind: "jsOp",
-            op: "globalGet",
-            name: "ReadableStream",
-            args: [],
-            type: JSVAL,
-            loc,
-        };
-        return {
-            kind: "jsOp",
-            op: "callMethod",
-            name: "from",
-            args: [
-                streamGlobal,
-                ...call.arguments.map((argument) => lowerer.jsvalIn(lowerer.lowerExpr(argument), argument)),
-            ],
-            type: JSVAL,
-            loc,
-        };
+        lowerer.refuseUnsupportedApi("'ReadableStream.from'", call);
     }
     const isMath = lowerer.stdlibGlobalMember(access, "Math") !== null;
-    // Static numeric Math calls precede the island path. The scalar methods
     // use their declared arity; min/max and hypot accept their variadic forms.
     const staticMath = isMath ? own(STATIC_MATH_FNS, name) : undefined;
     // A missing element (a hole bound by a loop, a local or field holding a
@@ -2857,9 +1829,7 @@ export function lowerIslandMethodCall(lowerer, call, access) {
         }
     }
     // `Math.max(...xs)` / `Math.min(...xs)` over a number[]: a STATIC
-    // runtime fold (JS-exact: NaN poisons, ±0 order by the JS rules, the
-    // empty array yields ∓Infinity like the zero-arg calls) — no island
-    // involved, so it works without --dynamic too. Only the exact
+    // runtime fold (NaN poisons and ±0 follows JS ordering). This
     // one-spread form lowers; mixed spread/positional argument lists keep
     // the nest-calls fence.
     if (isMath &&
@@ -2887,26 +1857,22 @@ export function lowerIslandMethodCall(lowerer, call, access) {
             loc,
         };
     }
-    const mathFn = isMath ? own(ISLAND_SURFACE.math.fns, name) : undefined;
+    const mathFn = isMath ? own(STDLIB_SURFACE.math.fns, name) : undefined;
     if (mathFn && call.arguments.length === mathFn.args.length) {
-        lowerer.requireDynamicApi(`'Math.${name}'`, call);
-        return finish({ kind: "jsOp", op: "globalGet", name: "Math", args: [], type: JSVAL, loc }, mathFn);
+        lowerer.refuseUnsupportedApi(`'Math.${name}'`, call);
     }
     const kind = lowerer.mapTypeOf(lowerer.typeOf(access.expression))?.kind;
     const entry = kind === "f64"
-        ? own(ISLAND_SURFACE.number, name)
+        ? own(STDLIB_SURFACE.number, name)
         : kind === "string"
-            ? own(ISLAND_SURFACE.string, name)
+            ? own(STDLIB_SURFACE.string, name)
             : undefined;
     if (!entry || call.arguments.length !== entry.args.length)
         return null;
     if (!lowerer.isStdlibMember(access))
         return null;
-    lowerer.requireDynamicApi(`'.${name}()' on ${kind === "f64" ? "numbers" : "strings"}`, call);
-    return finish(lowerer.jsvalIn(lowerer.lowerExpr(access.expression), access.expression), entry);
+    lowerer.refuseUnsupportedApi(`'.${name}()' on ${kind === "f64" ? "numbers" : "strings"}`, call);
 }
-/** Math constants and fixed-arity numeric functions have native value forms.
- * Remaining properties retain the island/fence path. */
 export function lowerMathProperty(lowerer, expr) {
     const member = lowerer.stdlibGlobalMember(expr, "Math");
     if (member === null)
@@ -2933,37 +1899,16 @@ export function lowerMathProperty(lowerer, expr) {
             valueParams: params.map((type) => ({ mode: "required", type })),
         }, `Math.${member}`, loc);
     }
-    const propType = own(ISLAND_SURFACE.math.props, member);
+    const propType = own(STDLIB_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,
-        };
-        return { kind: "jsExit", value: read, type: propType, loc };
+        lowerer.refuseUnsupportedApi(`'Math.${member}'`, expr);
     }
-    if (own(ISLAND_SURFACE.math.fns, member) !== undefined ||
+    if (own(STDLIB_SURFACE.math.fns, member) !== undefined ||
         own(STATIC_MATH_FNS, member) !== undefined) {
         lowerer.unsupported("SC1090", expr, `Math methods as values (call '${member}' directly)`);
     }
     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. */
 export function npmPackageOf(lowerer, type) {
     const pkg = lowerer.npmPackageOfSymbol(type.getAliasSymbol() ?? type.getSymbol());
     if (pkg)
@@ -2977,20 +1922,12 @@ 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. */
 export function npmMemberFence(lowerer, access) {
-    if (lowerer.dynamic)
-        return;
     const pkg = lowerer.npmPackageOf(lowerer.typeOf(access.expression)) ??
         lowerer.npmPackageOfSymbol(lowerer.checker.getSymbolAtLocation(access.name));
     if (!pkg)
         return;
-    lowerer.pushDiag(requiresDynamicPackageDiag(pkg, locOf(access)));
+    lowerer.pushDiag(unsupportedPackageValueDiag(pkg, locOf(access)));
     throw new PoisonError();
 }
 /** The npm package a SYMBOL is declared by, or null. The symbol half of
@@ -3004,4 +1941,4 @@ export function npmPackageOfSymbol(lowerer, sym) {
         return null;
     return npmPackageNameOf(decls[0].getSourceFile().fileName);
 }
-//# sourceMappingURL=lower-island.js.map
+//# sourceMappingURL=lower-stdlib.js.map