@scriptc/compiler 0.2.10 → 0.3.1

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

@@ -14,12 +14,11 @@ import { lowerGenMethodCall } from "./lower-generators.js";
 import { lowerClassSymbolMethodCall } from "./symbol-methods.js";
 import { errorToStringCall } from "./error-methods.js";
 import { lowerClassPrototypeAssign, lowerClassPrototypeDescriptors } from "./class-prototypes.js";
-import { BYTES_ELEMENT_NAME, BIGINT_T, BOOL, CAUGHT, DYN, F64, JSVAL, NULL_T, STRING, SYMBOL_T, UNDEFINED_T, VOID, arrayOf, canBoxFuncIntoDyn, canConvertToDyn, canDynCheckTo, funcOf, isDynTypedRefType, isUnitType, shapeHasAccessorSlots, typeEquals, } from "../../ir/ir.js";
+import { BYTES_ELEMENT_NAME, BIGINT_T, BOOL, CAUGHT, DYN, F64, NULL_T, STRING, SYMBOL_T, UNDEFINED_T, VOID, arrayOf, canBoxFuncIntoDyn, canConvertToDyn, canDynCheckTo, funcOf, isDynTypedRefType, isUnitType, shapeHasAccessorSlots, typeEquals, } from "../../ir/ir.js";
 import { isJsSourceFile, locOf, requireSpecOf } from "../program.js";
 import { isGenericCallableMemberType, typeKey } from "../type-mapper.js";
-import { PoisonError, dynFallbackType, importCallHandleType, jsFuncNameOf, newFnCtx, staticImportNamespaceType, } from "./lowerer.js";
+import { dynFallbackType, jsFuncNameOf, newFnCtx, staticImportNamespaceType } from "./lowerer.js";
 import { NARROW_FIRST, STRING_INDEX_METHODS, STR_METHODS, stdlibGlobalNameOf } from "./surfaces.js";
-import { requiresDynamicDiag } from "../../diagnostics/diagnostic.js";
 import { dynStringReceiver } from "./containers/dynamic-receivers.js";
 import { lowerArrayConstructor, lowerArrayFromCall, lowerArrayOfCall, } from "./containers/array-construction.js";
 import { lowerDynArrayFilterCall, lowerDynArrayFlatMapCall } from "./containers/array-callbacks.js";
@@ -47,6 +46,7 @@ import { EMITTER_API_MEMBERS, exactClassOfReceiver, exactInstanceClassOf, findGe
 import { classCallbackCall, isClassCallback } from "./class-callbacks.js";
 import { emitterRooted, lowerEmitterMethodCall } from "./lower-event-emitter.js";
 import { lowerConsoleInspectArg, lowerFormatCall } from "./lower-inspect.js";
+import { lowerConsoleInstanceCall } from "./lower-console.js";
 import { STREAM_API_MEMBERS, lowerStreamMethodCall, lowerStreamStaticCall, streamSidesOf, } from "./lower-stream.js";
 import { ambientNsRootOf, ambientUndefReadType, ambientUndefVarRootOf, ambientUndefinedFnSymbolOf, contextualUndefReadType, fenceEarlyAliasUse, fenceEarlyNsMemberRef, nsMemberIdentOf, nsUndefRead, } from "./lower-namespaces.js";
 import { expandoMemberRead } from "./lower-expando.js";
@@ -57,28 +57,10 @@ import { lowerClassDataDescriptor, lowerClassDescriptorRead } from "./class-desc
 import { classStaticDataFor } from "./class-static-data.js";
 import { lowerUrlFactory } from "./lower-url.js";
 import { nullishValueUnitOf } from "./binding-analysis.js";
-import { spreadNeedsRuntimeArity, completeFuncValueArgs, lowerSpreadArgsCall, omittedArgFor, completeArgs, } from "./call-arguments.js";
+import { spreadNeedsRuntimeArity, completeFuncValueArgs, lowerSpreadArgsCall, completeArgs, } from "./call-arguments.js";
 import { isThisParameter } from "./call-signatures.js";
 import { checkedArmExtraction } from "./coercions/unions.js";
 import { requireObjLitGenericReceiver, objLitGenericFnNodeOf, objLitGenericFnInfoOf, genericCallInstance, } from "./generic-functions.js";
-/** An island call result the .d.ts DECLARES as a primitive exits eagerly
- * to that static type — the member-read rule's call sibling (see the
- * getProp lowering in lower-exprs.ts): primitives copy by value, every
- * static consumer works on the result, and a lying declaration throws the
- * catchable TypeError. Chain-handled forms stay jsval (the optChain's
- * unit path is the engine's undefined). */
-export function islandPrimitiveExit(lowerer, call, result) {
-    if (call.questionDotToken)
-        return result;
-    if (ts.isPropertyAccessExpression(call.expression) && call.expression.questionDotToken)
-        return result;
-    const declared = lowerer.mapTypeOf(lowerer.typeOf(call));
-    if (declared &&
-        (declared.kind === "f64" || declared.kind === "bool" || declared.kind === "string")) {
-        return { kind: "jsExit", value: result, type: declared, loc: result.loc };
-    }
-    return result;
-}
 export function lowerCall(lowerer, expr) {
     const loc = locOf(expr);
     // Object's checker return type is `any`. Claim known object inputs
@@ -280,12 +262,6 @@ export function lowerCall(lowerer, expr) {
         }
         const args = expr.arguments.map((a) => {
             const lowered = lowerer.lowerExpr(a);
-            if (lowered.type.kind === "jsval") {
-                // Node prints objects with util.inspect formatting, which
-                // String() cannot match — silent divergence is banned. Templates
-                // are ToString (Node-exact), casts are validated: both honest.
-                lowerer.unsupported("SC1090", a, `${surface} of 'any' values (wrap it: ${surface}(\`\${v}\`), or validate with 'as <type>' first)`);
-            }
             // Checked-dynamic values carry their own shape, so the runtime
             // renders them exactly like Node's console formatter renders a
             // non-format argument: strings VERBATIM, everything else through
@@ -347,6 +323,9 @@ export function lowerCall(lowerer, expr) {
             loc,
         });
     }
+    const consoleInstanceCall = lowerConsoleInstanceCall(lowerer, expr, loc);
+    if (consoleInstanceCall)
+        return consoleInstanceCall;
     if (ts.isPropertyAccessExpression(expr.expression) &&
         TIMER_MODULE_MEMBERS.has(expr.expression.name.text) &&
         lowerer.stdlibGlobalMember(expr.expression, "globalThis") === expr.expression.name.text) {
@@ -580,20 +559,6 @@ export function lowerCall(lowerer, expr) {
         if (name === "String")
             return lowerer.ensureString(arg, argNode);
     }
-    // __island_eval: the internal island testing hook (eval in the embedded
-    // engine, String(result) back). Provenance-checked like setTimeout.
-    // Only meaningful when the engine is linked: without --dynamic it is a
-    // clean requires-dynamic diagnostic, never an ICE or a link error.
-    if (ts.isIdentifier(expr.expression) &&
-        expr.expression.text === "__island_eval" &&
-        lowerer.isStdlibSymbol(lowerer.resolveValueSymbol(expr.expression) ?? undefined)) {
-        if (!lowerer.dynamic) {
-            lowerer.pushDiag(requiresDynamicDiag("'__island_eval'", loc));
-            throw new PoisonError();
-        }
-        const code = lowerer.lowerExprExpecting(expr.arguments[0], STRING);
-        return { kind: "libCall", fn: "island.eval", args: [code], type: STRING, loc };
-    }
     // Computed calls preserve their evaluated receiver just like dotted
     // calls, including when the property is keyed by a native symbol.
     if (ts.isElementAccessExpression(expr.expression) &&
@@ -640,129 +605,6 @@ export function lowerCall(lowerer, expr) {
             };
         }
     }
-    // Island calls. A property-access callee whose receiver is an 'any'
-    // value is an engine method call (this = receiver, JS-exact); any other
-    // 'any'-typed callee is an engine function call. Arguments marshal in;
-    // results stay island values.
-    // A questionDotToken here is always chain-handled (the gate at the top
-    // of lowerCall routed unhandled ones to the chain lowering), so
-    // `x?.y(...)` re-dispatches into this same method-call form with the
-    // receiver reading back as the chain's bound handle.
-    if (ts.isPropertyAccessExpression(expr.expression) &&
-        lowerer.isIslandExpr(expr.expression.expression)) {
-        // Typed fetch/Web Streams handles map to island values under
-        // --dynamic, but their inventory still owns which methods exist.
-        // Reject unsupported rows before the universal jsval method path.
-        lowerer.fenceStaticResponseMember(expr.expression, "call");
-        lowerer.fenceStaticHeadersMember(expr.expression, "call");
-        lowerer.fenceStaticReadableStreamMember(expr.expression, "call");
-        const receiver = lowerer.lowerExpr(expr.expression.expression);
-        // A checker-`any` receiver whose VALUE lives in the checked-dynamic tree (a
-        // checked-dynamic local behind the any-typed spelling — the JS
-        // WeakSet placeholder, rest-args arrays): the checked-dynamic
-        // method machinery owns it — receiver-kind dispatch, stored-member
-        // calls, honest fences — never an engine op over a dyn value.
-        if (receiver.type.kind === "dyn") {
-            const served = lowerDynReceiverMethodCall(lowerer, expr, expr.expression);
-            if (served)
-                return served;
-            lowerer.unsupported("SC1100", expr, `'.${expr.expression.name.text}()' calls through 'unknown'-valued receivers in dynamically-executed positions`);
-        }
-        const args = expr.arguments.map((a) => lowerer.jsvalIn(lowerer.lowerExpr(a), a));
-        const result = {
-            kind: "jsOp",
-            op: "callMethod",
-            name: expr.expression.name.text,
-            args: [receiver, ...args],
-            type: JSVAL,
-            loc,
-        };
-        return islandPrimitiveExit(lowerer, expr, result);
-    }
-    if (lowerer.isIslandExpr(expr.expression)) {
-        // `o.m(...)` where o LOWERS checked-dynamic and the checker types
-        // `o.m` 'any' (a member read behind an 'object'/'unknown'-typed
-        // bag): METHOD-CALL semantics — receiver-kind dispatch (dynInvoke),
-        // so `this` binds and a WRAPPED island receiver runs the ENGINE's
-        // own method (the routed-ops lane). A stored-member dynCall would
-        // call engine prototype methods receiverless — the this-less
-        // `list.slice()` ToObject TypeError. Spread arguments keep the
-        // stored-member path below (the runtime-arity lane owns them).
-        if (ts.isPropertyAccessExpression(expr.expression) &&
-            !expr.expression.questionDotToken &&
-            !expr.questionDotToken &&
-            !expr.arguments.some((a) => ts.isSpreadElement(a))) {
-            const recvProbe = tryLowerExpression(lowerer, expr.expression.expression);
-            if (recvProbe?.type.kind === "dyn") {
-                const args = expr.arguments.map((a) => lowerer.lowerExprExpecting(a, DYN));
-                return {
-                    kind: "dynInvoke",
-                    recv: recvProbe,
-                    method: expr.expression.name.text,
-                    calleeName: expr.expression.getText(),
-                    args,
-                    type: DYN,
-                    loc,
-                };
-            }
-        }
-        const callee = lowerer.lowerExpr(expr.expression);
-        // A checker-`any` callee that LOWERED checked-dynamic (a dyn member
-        // chain's stored function): the checked-dynamic tree's own call — dynCall reads and
-        // calls the stored member with Node's is-not-a-function TypeError
-        // on refusal.
-        if (callee.type.kind === "dyn") {
-            const args = expr.arguments.map((a) => lowerer.lowerExprExpecting(a, DYN));
-            const calleeName = ts.isPropertyAccessExpression(expr.expression)
-                ? expr.expression.getText()
-                : ts.isIdentifier(expr.expression)
-                    ? expr.expression.text
-                    : "value";
-            return { kind: "dynCall", callee, calleeName, args, type: DYN, loc };
-        }
-        // `fn(...args)` — a TRAILING spread into an island call: the
-        // engine's own apply (`fn.apply(undefined, argsArray)`); leading
-        // plain arguments prepend through `[l1, l2].concat(argsArray)`
-        // (concat flattens the array argument one level — exactly the
-        // spread). Other spread shapes keep the syntax fence.
-        if (expr.arguments.length > 0 &&
-            ts.isSpreadElement(expr.arguments[expr.arguments.length - 1]) &&
-            expr.arguments.slice(0, -1).every((a) => !ts.isSpreadElement(a))) {
-            const spread = expr.arguments[expr.arguments.length - 1];
-            const spreadV = lowerer.jsvalIn(lowerer.lowerExpr(spread.expression), spread.expression);
-            const leading = expr.arguments
-                .slice(0, -1)
-                .map((a) => lowerer.jsvalIn(lowerer.lowerExpr(a), a));
-            const argsArr = leading.length === 0
-                ? spreadV
-                : {
-                    kind: "jsOp",
-                    op: "callMethod",
-                    name: "concat",
-                    args: [{ kind: "jsOp", op: "arrLit", args: leading, type: JSVAL, loc }, spreadV],
-                    type: JSVAL,
-                    loc,
-                };
-            const result = {
-                kind: "jsOp",
-                op: "callMethod",
-                name: "apply",
-                args: [callee, { kind: "jsOp", op: "undefLit", args: [], type: JSVAL, loc }, argsArr],
-                type: JSVAL,
-                loc,
-            };
-            return islandPrimitiveExit(lowerer, expr, result);
-        }
-        const args = expr.arguments.map((a) => lowerer.jsvalIn(lowerer.lowerExpr(a), a));
-        const result = {
-            kind: "jsOp",
-            op: "callFn",
-            args: [callee, ...args],
-            type: JSVAL,
-            loc,
-        };
-        return islandPrimitiveExit(lowerer, expr, result);
-    }
     // Builtin-module functions (fs, path, os, ...): named imports whose
     // binding resolves to a supported builtin specifier lower to `libCall`.
     // A user local shadowing an import has a different symbol and never
@@ -851,9 +693,8 @@ export function lowerCall(lowerer, expr) {
         }
         // STATIC parseInt/parseFloat/isNaN/isFinite (num.parseInt /
         // num.parseFloat / num.isNaN / number.isFinite — scr_string.c,
-        // scr_lib.c; ECMA-exact, Node is the oracle). Provenance like the
-        // island globals: a user function shadowing the name has a
-        // different, non-stdlib symbol. parseInt's omitted radix completes
+        // scr_lib.c; ECMA-exact, Node is the oracle). Declaration provenance
+        // excludes shadowed names. parseInt's omitted radix completes
         // to 0 — the spec's "undefined" (base 10 with the 0x hex escape);
         // parseFloat lowers the STRING form only (Node would ToString other
         // values — no static story); isNaN/isFinite's arguments are
@@ -935,8 +776,7 @@ export function lowerCall(lowerer, expr) {
             if (v.type.kind === "dyn") {
                 data = v;
             }
-            else if (v.kind === "unitLit" ||
-                (v.type.kind !== "jsval" && lowerer.dynConvertible(v.type))) {
+            else if (v.kind === "unitLit" || lowerer.dynConvertible(v.type)) {
                 data = { kind: "dynFrom", value: v, type: DYN, loc };
             }
             else {
@@ -950,11 +790,10 @@ export function lowerCall(lowerer, expr) {
                 loc,
             };
         }
-        // Island-backed globals (parseFloat, isFinite): the engine's own
         // global function executes — callFn(globalGet(name)) — and the
         // result exits to the declared static type. A user function
         // shadowing the name has a different, non-stdlib symbol.
-        const islFn = lowerer.islandGlobalFnOf(expr.expression);
+        const islFn = lowerer.stdlibGlobalFnOf(expr.expression);
         if (islFn && expr.arguments.length !== islFn.args.length) {
             const name = expr.expression.text;
             lowerer.noLowering(`${name} with ${expr.arguments.length} argument${expr.arguments.length === 1 ? "" : "s"}`, expr);
@@ -962,31 +801,14 @@ export function lowerCall(lowerer, expr) {
         if (islFn && expr.arguments.length === islFn.args.length) {
             // The static forms above already took the exactly-typed argument
             // (a string for parseFloat, a number for isFinite): name the
-            // argument type that sent this call to the engine, so the message
-            // states the condition rather than reading as if the global itself
-            // were unsupported.
-            const argText = lowerer.dynamic ? "" : loweredArgumentText(lowerer, expr.arguments[0]);
+            // argument type that refused the call, so the message states the
+            // condition rather than reading as if the global itself were
+            // unsupported.
+            const argText = loweredArgumentText(lowerer, expr.arguments[0]);
             const exact = expr.expression.text === "isFinite" ? "number" : "string";
-            lowerer.requireDynamicApi(`'${expr.expression.text}' with a '${argText}' argument (only a ${exact} argument compiles statically)`, expr, exact === "string"
-                ? "convert the argument explicitly first (for example String(x), or narrow the union), or build with --dynamic to run the coercing call in the embedded engine (adds ~620KB to the binary)"
-                : "narrow the argument to a number first (isFinite over a number compiles statically), or build with --dynamic to run the coercing call in the embedded engine (adds ~620KB to the binary)");
-            const callee = {
-                kind: "jsOp",
-                op: "globalGet",
-                name: expr.expression.text,
-                args: [],
-                type: JSVAL,
-                loc,
-            };
-            const args = expr.arguments.map((a) => lowerer.jsvalIn(lowerer.lowerExpr(a), a));
-            const result = {
-                kind: "jsOp",
-                op: "callFn",
-                args: [callee, ...args],
-                type: JSVAL,
-                loc,
-            };
-            return { kind: "jsExit", value: result, type: islFn.ret, loc };
+            lowerer.refuseUnsupportedApi(`'${expr.expression.text}' with a '${argText}' argument`, expr, exact === "string"
+                ? "only a string argument compiles statically: convert the argument explicitly first (for example String(x), or narrow the union)"
+                : "only a number argument compiles statically: narrow the argument to a number first");
         }
     }
     // A TYPE-GUARD call on a catch binding (`isErrnoException(err)` —
@@ -1254,8 +1076,6 @@ export function lowerCall(lowerer, expr) {
             lowerPromiseAllTupleCall(lowerer, expr, expr.expression) ??
             lowerer.lowerPromiseStaticCall(expr, expr.expression) ??
             lowerPromiseRejectCall(lowerer, expr, expr.expression) ??
-            // Before the island path: regex-argument replace/replaceAll/split
-            // lower STATICALLY; only the string-pattern overloads are island.
             lowerRegexMethodCallWithOptionalArg(lowerer, expr, expr.expression) ??
             lowerUrlStaticCall(lowerer, expr, expr.expression) ??
             lowerer.lowerUrlMethodCall(expr, expr.expression) ??
@@ -1304,7 +1124,6 @@ export function lowerCall(lowerer, expr) {
             lowerStringPrototypeCall(lowerer, expr, expr.expression) ??
             lowerStringMethodCallWithOptionalArgs(lowerer, expr, expr.expression) ??
             // Typed-array/Buffer receivers and the Buffer statics — before the
-            // island path (bytes never cross the boundary).
             lowerer.lowerBytesMethodCall(expr, expr.expression) ??
             lowerBytesStaticCall(lowerer, expr, expr.expression) ??
             lowerBufferStaticCallWithNarrowedArg(lowerer, expr, expr.expression) ??
@@ -1312,7 +1131,6 @@ export function lowerCall(lowerer, expr) {
             // stdlib chokepoint claims the member).
             lowerStreamStaticCall(lowerer, expr, expr.expression) ??
             // Primitive toString calls, including numeric radices, use the
-            // native formatters before the island method path.
             lowerNumberToStringCall(lowerer, expr, expr.expression) ??
             // Union receivers whose every arm has a text — the ngrok
             // `(chunk: Buffer | string) => chunk.toString()` idiom.
@@ -1321,31 +1139,23 @@ export function lowerCall(lowerer, expr) {
             // override-free program classes — "[object Object]", folded.
             lowerDefaultToStringCall(lowerer, expr, expr.expression) ??
             // The remaining primitive prototype statics — toExponential(),
-            // both toFixed() forms, hasOwnProperty over literal keys. Before
-            // the island path. Optional-chain spellings first enter the chain
-            // machinery above, then re-enter here with a narrowed chainRecv.
+            // both toFixed() forms, hasOwnProperty over literal keys.
             lowerPrimitiveProtoCall(lowerer, expr, expr.expression.expression, expr.expression.name.text, lowerer.checker.getSymbolAtLocation(expr.expression.name)) ??
             // hasOwnProperty on a program class CONSTRUCTOR — own statics are
             // compile-time-known, so a literal key folds to a constant.
             lowerClassHasOwnPropertyCall(lowerer, expr, expr.expression) ??
             lowerObjectOwnMethodCall(lowerer, expr, expr.expression) ??
-            // Response constructor-object operations are unsupported in both
-            // tiers. Keep their SC2020 inventory contract ahead of the island
-            // and generic-call fallbacks (Response.json otherwise reports the
-            // generic SC1090 fence).
+            // Refuse Response constructor operations before generic-call
+            // fallbacks can report an unrelated SC1090 diagnostic.
             lowerer.fenceUnsupportedFetchConstructorMember(expr.expression) ??
             // Static fetch responses are checked-dynamic handles, but the
             // adopted undici declaration exposes a wider API than that handle.
-            // Fence unimplemented members before either the island or generic
-            // dyn receiver path can compile them into a runtime missing-method
-            // failure. Dynamic-only rows pass through these checks unchanged.
+            // Refuse unsupported members before generic checked-value dispatch.
             lowerer.fenceStaticResponseMember(expr.expression, "call") ??
             lowerer.fenceStaticHeadersMember(expr.expression, "call") ??
             lowerer.fenceStaticReadableStreamMember(expr.expression, "call") ??
-            lowerer.lowerIslandMethodCall(expr, expr.expression) ??
+            lowerer.lowerStdlibMethodCall(expr, expr.expression) ??
             // Dyn receivers (JSON.parse-derived `unknown`/`any` values) —
-            // validated-extract, then the static machinery. After the island
-            // path (jsval receivers belong there), before the fences.
             lowerDynReceiverMethodCall(lowerer, expr, expr.expression) ??
             // Narrowing filters (inferred predicates, filter(Boolean)) claim
             // their calls before the generic array HOF path types the result
@@ -1472,9 +1282,6 @@ export function lowerCall(lowerer, expr) {
         const symbolMethod = lowerClassSymbolMethodCall(lowerer, expr);
         if (symbolMethod)
             return symbolMethod;
-        const headersIterator = lowerer.lowerDynamicHeadersIteratorCall(expr, expr.expression);
-        if (headersIterator)
-            return headersIterator;
         lowerer.fenceUnsupportedFetchConstructorMember(expr.expression);
         lowerer.fenceStaticResponseMember(expr.expression, "call");
         lowerer.fenceStaticHeadersMember(expr.expression, "call");
@@ -1663,34 +1470,6 @@ export function lowerCall(lowerer, expr) {
         if (spreadServed)
             return spreadServed;
     }
-    // An ISLAND-REST func value called directly (`f(1, 2)` where f is the
-    // --dynamic `(...args) =>` lambda): the type SPELLS its trailing
-    // engine-array param — complete the call exactly like completeArgs'
-    // island pack (fixed slots positionally, missing ones with the
-    // engine's undefined, the surplus marshaled into one fresh engine
-    // array). JS arity, no runtime machinery.
-    if (callee.type.rest === true &&
-        callee.type.restAbi === "jsval" &&
-        callee.type.params.length >= 1 &&
-        callee.type.params[callee.type.params.length - 1].kind === "jsval" &&
-        !expr.arguments.some((a) => ts.isSpreadElement(a))) {
-        const fixed = callee.type.params.slice(0, -1);
-        const args = fixed.map((p, i) => {
-            const a = expr.arguments[i];
-            if (a)
-                return lowerer.lowerExprExpecting(a, p);
-            const absent = omittedArgFor(lowerer, p, loc);
-            if (!absent) {
-                lowerer.unsupported("SC1090", expr, "calls omitting a non-optional parameter of the callee's type");
-            }
-            return absent;
-        });
-        const restArgs = expr.arguments
-            .slice(fixed.length)
-            .map((a) => lowerer.lowerExprExpecting(a, JSVAL));
-        args.push({ kind: "jsOp", op: "arrLit", args: restArgs, type: JSVAL, loc });
-        return { kind: "callValue", callee, args, type: callee.type.ret, loc };
-    }
     // A JS call with MORE arguments than the callee's lowered signature
     // (`cb(1, 'x')` where the mustCall wrapper's inferred type declared
     // fewer params — tsc's JS world doesn't police arity): ride the
@@ -2204,8 +1983,7 @@ const ARRAY_BORROW_METHODS = new Set([
     "some",
 ]);
 function lowerArrayPrototypeBorrowCall(lowerer, call, access) {
-    if (lowerer.dynamic ||
-        !isJsSourceFile(call.getSourceFile()) ||
+    if (!isJsSourceFile(call.getSourceFile()) ||
         call.questionDotToken ||
         access.questionDotToken ||
         access.name.text !== "call" ||
@@ -2239,9 +2017,7 @@ function lowerArrayPrototypeBorrowCall(lowerer, call, access) {
     };
 }
 function lowerObjectOwnPrototypeCall(lowerer, call, access) {
-    if (lowerer.dynamic ||
-        access.name.text !== "call" ||
-        !ts.isPropertyAccessExpression(access.expression))
+    if (access.name.text !== "call" || !ts.isPropertyAccessExpression(access.expression))
         return null;
     const method = access.expression;
     const enumerable = method.name.text === "propertyIsEnumerable";
@@ -2258,8 +2034,7 @@ function lowerObjectOwnPrototypeCall(lowerer, call, access) {
 }
 function lowerObjectOwnMethodCall(lowerer, call, access) {
     const method = access.name.text;
-    if (lowerer.dynamic ||
-        call.questionDotToken ||
+    if (call.questionDotToken ||
         access.questionDotToken ||
         (method !== "hasOwnProperty" && method !== "propertyIsEnumerable") ||
         call.arguments.some(ts.isSpreadElement))
@@ -2477,9 +2252,7 @@ function lowerObjectOwnCall(lowerer, call, receiverNode, keyNode, extraNodes, me
     return { kind: "seqExpr", stmts, result, type: BOOL, loc };
 }
 function lowerObjectPrototypeCall(lowerer, call, access) {
-    if (lowerer.dynamic ||
-        access.name.text !== "call" ||
-        !ts.isPropertyAccessExpression(access.expression))
+    if (access.name.text !== "call" || !ts.isPropertyAccessExpression(access.expression))
         return null;
     const method = access.expression;
     const prototype = method.expression;
@@ -3578,12 +3351,11 @@ function lowerArrayIsArrayCall(lowerer, call, access) {
         // (`Array.isArray(tlds)` on `string | readonly string[]` — the
         // narrowing test tsc's control flow then builds on); several array
         // arms OR their tag tests, and zero arms fold to false — both only
-        // over side-effect-free reads (the operand re-evaluates/drops, the
-        // `in`-operator fold discipline). dyn/caught/jsval arms have no
-        // static tag answer and keep the narrow-first fence.
+        // over side-effect-free reads. Opaque arms have no static tag answer
+        // and keep the narrow-first fence.
         const unionId = arg.type.unionId;
         const def = lowerer.unions.get(unionId);
-        const opaque = !def || def.arms.some((a) => a.kind === "dyn" || a.kind === "caught" || a.kind === "jsval");
+        const opaque = !def || def.arms.some((a) => a.kind === "dyn" || a.kind === "caught");
         const arrayTags = lowerer.arrayValueTags(arg.type.unionId);
         const freeRead = arg.kind === "varRef" || arg.kind === "recordGet" || arg.kind === "fieldGet";
         if (!opaque && arrayTags.length === 1) {
@@ -3615,7 +3387,7 @@ function lowerArrayIsArrayCall(lowerer, call, access) {
         }
         lowerer.unsupported("SC1090", argNode, `Array.isArray on '${lowerer.fmt(arg.type)}' values (narrow first: check a discriminant field, or compare with '!== undefined'/'!== null' for unit arms)`);
     }
-    if (arg.type.kind === "jsval" || arg.type.kind === "caught")
+    if (arg.type.kind === "caught")
         return null;
     if (arg.kind === "varRef" || arg.kind === "recordGet" || arg.kind === "fieldGet") {
         return { kind: "boolLit", value: lowerer.isArrayValueType(arg.type), type: BOOL, loc };
@@ -4127,6 +3899,21 @@ function implicitReceiverOverloadReturn(lowerer, expr) {
  * with no honest bridge keep coerceInto's exactness fences. Calls that
  * resolved to the implementation itself (non-overloaded callees) pass
  * through untouched. */
+/** A body-less abstract method that is its name's only declaration is the
+ * virtual slot itself, not an overload signature: its lowered return is the
+ * family ABI every override shares, so the call keeps that result instead
+ * of narrowing it to the declared type. */
+function isSoleAbstractMethod(decl) {
+    if (!ts.isMethodDeclaration(decl))
+        return false;
+    if (!ts.getModifiers(decl)?.some((m) => m.kind === ts.SyntaxKind.AbstractKeyword))
+        return false;
+    const owner = decl.parent;
+    if (!ts.isClassDeclaration(owner) && !ts.isClassExpression(owner))
+        return false;
+    const name = decl.name.getText();
+    return !owner.members.some((member) => member !== decl && ts.isMethodDeclaration(member) && member.name.getText() === name);
+}
 function reconcileOverloadReturn(lowerer, expr, call) {
     const rsig = lowerer.checker.getResolvedSignature(expr);
     const rdecl = rsig ? lowerer.checker.signatureDeclaration(rsig) : undefined;
@@ -4142,7 +3929,8 @@ function reconcileOverloadReturn(lowerer, expr, call) {
     const resolvedOverload = rsig &&
         rdecl &&
         (ts.isFunctionDeclaration(rdecl) || ts.isMethodDeclaration(rdecl)) &&
-        !rdecl.body
+        !rdecl.body &&
+        !isSoleAbstractMethod(rdecl)
         ? lowerer.mapTypeOf(lowerer.checker.getReturnTypeOfSignature(rsig))
         : null;
     const rt = resolvedOverload ?? implicitReceiverOverloadReturn(lowerer, expr);
@@ -4152,24 +3940,13 @@ function reconcileOverloadReturn(lowerer, expr, call) {
     // follows maybeNarrow's stance — a unit arm has no payload to extract.
     if (!rt || rt.kind === "void" || isUnitType(rt) || typeEquals(rt, call.type))
         return call;
-    // An ISLAND-valued implementation return (`any` under --dynamic): the
     // resolved overload's return type is a claim tsc never checked against
     // the body — extracting it HERE would throw the boundary TypeError
     // where Node just lets the value flow (functionOverloads35: the
     // implementation returns its object argument under a number-returning
     // overload signature; Node exits clean). The checker-trust trap keeps
     // governing edges the checker actually vouches for; this edge it never
-    // did. The handle stays the value's only story: bindings store it
-    // (uncheckedOverloadHandleCall's rule at the declaration sites), and
-    // uses dispatch to engine ops like any island value.
-    if (call.type.kind === "jsval")
-        return call;
-    // The CHECKED-DYNAMIC twin of the island rule: an `any`-returning
-    // implementation under a typed overload signature is the same
-    // never-vouched-for edge (functionOverloads35's shape without
-    // --dynamic) — extracting the resolved type HERE would throw the
-    // boundary TypeError where Node lets the value flow. Uses stay
-    // checked per read like every any-origin value.
+    // did. The checked value stays in bindings and is validated per use.
     if (call.type.kind === "dyn")
         return call;
     if (call.type.kind === "union" && rt.kind !== "union") {
@@ -4224,24 +4001,6 @@ function templateEscapesValid(raw) {
     }
     return true;
 }
-/** Tagged templates `tag\`a${x}b\`` — ES's call: tag(strings, ...values).
- * The strings object is a per-SITE lazily initialized hidden array global,
- * so the spec's identity contract holds — the same site evaluated twice
- * hands the tag the SAME array; two sites never share. TemplateStringsArray
- * maps to string[] (type-mapper.ts), so the array rides the ordinary
- * slot-directed coercion into whatever the tag's first parameter wants
- * — string[] exactly, an `any` slot through the dyn boundary, a rest
- * pack's first element. Checked tags receive frozen cooked and raw
- * arrays with the standard nonenumerable `.raw` descriptor. Typed direct
- * tags retain the string-array representation.
- *
- * Tag forms: a top-level declared function (the direct-call fast path —
- * overload sets reconcile through the resolved signature exactly like
- * plain calls), an island value under --dynamic (engine method/function
- * call with the engine's cooked/raw template object), and
- * a checked-dynamic value (the dynCall boundary — a non-function tag
- * throws Node's catchable TypeError). Everything else — generic tags,
- * method tags, function-value bindings — fences by name. */
 export function lowerTaggedTemplate(lowerer, expr) {
     const loc = locOf(expr);
     const pieces = ts.isNoSubstitutionTemplateLiteral(expr.template)
@@ -4256,51 +4015,6 @@ export function lowerTaggedTemplate(lowerer, expr) {
     const values = ts.isNoSubstitutionTemplateLiteral(expr.template)
         ? []
         : expr.template.templateSpans.map((s) => s.expression);
-    // Island tags (--dynamic): the engine call forms, mirroring lowerCall's
-    // island paths — a property-access tag is a method call (this = the
-    // receiver, JS-exact), any other island tag a function call. The
-    // strings argument builds ENGINE-NATIVE with its `.raw` property (the
-    // tplStrings op): a JSON marshal would drop `.raw`, and tags dispatch
-    // on it (the outdent idiom treats a raw-less argument as its OPTIONS
-    // form and answers a function). A fresh array per evaluation — tags
-    // caching by strings identity re-compute per call (SEMANTICS.md).
-    const islandStrings = () => ({
-        kind: "jsOp",
-        op: "tplStrings",
-        args: [
-            ...pieces.map((p) => ({
-                kind: "jsMarshal",
-                value: { kind: "strLit", value: p.text, type: STRING, loc },
-                type: JSVAL,
-                loc,
-            })),
-            ...pieces.map((p) => ({
-                kind: "jsMarshal",
-                value: { kind: "strLit", value: templateRawTextOf(p), type: STRING, loc },
-                type: JSVAL,
-                loc,
-            })),
-        ],
-        type: JSVAL,
-        loc,
-    });
-    if (ts.isPropertyAccessExpression(expr.tag) && lowerer.isIslandExpr(expr.tag.expression)) {
-        const receiver = lowerer.lowerExpr(expr.tag.expression);
-        const args = [islandStrings(), ...values.map((a) => lowerer.jsvalIn(lowerer.lowerExpr(a), a))];
-        return {
-            kind: "jsOp",
-            op: "callMethod",
-            name: expr.tag.name.text,
-            args: [receiver, ...args],
-            type: JSVAL,
-            loc,
-        };
-    }
-    if (lowerer.isIslandExpr(expr.tag)) {
-        const callee = lowerer.lowerExpr(expr.tag);
-        const args = [islandStrings(), ...values.map((a) => lowerer.jsvalIn(lowerer.lowerExpr(a), a))];
-        return { kind: "jsOp", op: "callFn", args: [callee, ...args], type: JSVAL, loc };
-    }
     // Direct call of a top-level declared function — the plain-call fast
     // path with the strings array as the leading completed argument.
     if (ts.isIdentifier(expr.tag) && !lowerer.isSelfReference(expr.tag)) {
@@ -4494,20 +4208,14 @@ function loweredTemplateStrings(lowerer, expr, cooked, loc, raw) {
  * wrapper's await re-throws it), and a handler throw rejects the
  * result — the spec's onFulfilled rules by construction. Null for
  * non-promise receivers and other members. */
-/** The storage type behind a promise-valued expression whose CHECKER type
- * has no mapping — the dynamic-import receiver rule (--dynamic): a direct
- * `import("...")` call is the island promise itself; an identifier bound
- * to a promise-of-jsval local or module global answers the binding's
- * type. Null everywhere else. */
-function islandPromiseStorageTypeOf(lowerer, e) {
-    const direct = lowerer.dynamic ? importCallHandleType(e) : staticImportNamespaceType(lowerer, e);
+function modulePromiseStorageTypeOf(lowerer, e) {
+    const direct = staticImportNamespaceType(lowerer, e);
     if (direct?.kind === "promise")
         return direct;
     if (!ts.isIdentifier(e))
         return null;
     const local = lowerer.resolveLocal(e);
-    if (local?.type.kind === "promise" &&
-        (local.type.inner.kind === "jsval" || local.type.inner.kind === "moduleNs"))
+    if (local?.type.kind === "promise" && local.type.inner.kind === "moduleNs")
         return local.type;
     if (local)
         return null;
@@ -4515,27 +4223,10 @@ function islandPromiseStorageTypeOf(lowerer, e) {
     if (sym && sym.flags & ts.SymbolFlags.Alias)
         sym = lowerer.checker.getAliasedSymbol(sym);
     const g = sym ? lowerer.globalsBySymbol.get(sym) : undefined;
-    if (g?.type.kind === "promise" &&
-        (g.type.inner.kind === "jsval" || g.type.inner.kind === "moduleNs"))
+    if (g?.type.kind === "promise" && g.type.inner.kind === "moduleNs")
         return g.type;
     return null;
 }
-/** Marks an INLINE then-handler's unannotated identifier parameters for
- * the island-handle (jsval) binding type — paramShape's early-out. Only
- * the inline arrow/function forms qualify: a handler VALUE keeps its own
- * declared signature (and the settled-type equality check below). */
-function markJsvalHandlerParams(lowerer, handler) {
-    let e = handler;
-    while (ts.isParenthesizedExpression(e))
-        e = e.expression;
-    if (!ts.isArrowFunction(e) && !ts.isFunctionExpression(e))
-        return;
-    for (const p of e.parameters) {
-        if (ts.isIdentifier(p.name) && p.type === undefined && !p.dotDotDotToken && !p.initializer) {
-            lowerer.jsvalParamOverrides.add(p);
-        }
-    }
-}
 function markModuleNsHandlerParams(lowerer, handler, type) {
     let e = handler;
     while (ts.isParenthesizedExpression(e))
@@ -4557,13 +4248,10 @@ export function lowerPromiseMethodCall(lowerer, call, access) {
     let recvT = lowerer.mapTypeOf(lowerer.typeOf(access.expression)) ??
         dynFallbackType(lowerer, access.expression, lowerer.typeOf(access.expression));
     // A dynamic-import promise under an unmappable checker type
-    // (`Promise<typeof import("./m")>` — module-namespace types have no
-    // static mapping): the BINDING holds the island promise
-    // (importCallHandleType / the island-HANDLE var rules), so the storage
-    // type is the receiver's truth. Direct `import("./m").then(...)`
-    // spells the same promise with no binding at all.
+    // (`Promise<typeof import("./m")>`) uses the module promise's native
+    // storage type. Direct `import("./m").then(...)` needs no binding.
     if (!recvT)
-        recvT = islandPromiseStorageTypeOf(lowerer, access.expression);
+        recvT = modulePromiseStorageTypeOf(lowerer, access.expression);
     if (recvT?.kind !== "promise")
         return null;
     if (!lowerer.isStdlibMember(access))
@@ -4597,20 +4285,6 @@ export function lowerPromiseMethodCall(lowerer, call, access) {
     }
     // The receiver evaluates FIRST, in the enclosing function, like JS.
     let receiver = lowerer.lowerExpr(access.expression);
-    // A PACKAGE-returned promise lowers as an island value (jsval): the
-    // promise lives in the engine, so bridge it — a static promise the
-    // engine promise settles (fulfillment = the retained handle or void,
-    // rejection = the bridged reason) — and desugar over the BRIDGE
-    // exactly like a native receiver. This is the classic CLI entry line,
-    // `program.parseAsync(process.argv).catch(handler)`.
-    if (receiver.type.kind === "jsval") {
-        receiver = {
-            kind: "jsBridgePromise",
-            value: receiver,
-            type: { kind: "promise", inner: recvT.inner.kind === "void" ? VOID : JSVAL },
-            loc,
-        };
-    }
     if (receiver.type.kind === "dyn" && lowerer.dynConvertible(recvT))
         receiver = lowerer.coerceInto(access.expression, receiver, recvT);
     if (receiver.type.kind !== "promise") {
@@ -4618,9 +4292,8 @@ export function lowerPromiseMethodCall(lowerer, call, access) {
         // a lowering gap, named rather than ICEd on.
         lowerer.unsupported("SC1090", call, `'.${member}' on this receiver`);
     }
-    // The wrapper types follow the RECEIVER's promise type (the bridge's
-    // promise-of-jsval for package receivers, the mapped type otherwise);
-    // typed uses of the settled value exit through coerceInto below.
+    // Wrapper types follow the receiver's promise type; typed uses of the
+    // settled value convert through coerceInto below.
     const promT = receiver.type;
     const inner = promT.inner;
     if (passthrough) {
@@ -4685,8 +4358,6 @@ export function lowerPromiseMethodCall(lowerer, call, access) {
                 lowerer.noLowering("then with these handlers", call, "the result must be a representable promise");
             }
             const R = resultT.inner;
-            if (!fulfilledAbsent && inner.kind === "jsval")
-                markJsvalHandlerParams(lowerer, fulfilledNode);
             if (!fulfilledAbsent && inner.kind === "moduleNs")
                 markModuleNsHandlerParams(lowerer, fulfilledNode, inner);
             const boxHandler = (node, allowDirect) => {
@@ -4744,17 +4415,46 @@ export function lowerPromiseMethodCall(lowerer, call, access) {
                     ? [{ kind: "varDecl", localId: vLocal.id, init: awaitE, loc }]
                     : [{ kind: "exprStmt", expr: awaitE, loc }];
                 const resultOf = (value, returnsPromise = false) => {
-                    const settled = value.type.kind === "promise"
-                        ? { kind: "awaitExpr", value, type: value.type.inner, loc }
-                        : returnsPromise
-                            ? { kind: "libCall", fn: "async.awaitDyn", args: [value], type: DYN, loc }
-                            : value;
+                    if (value.type.kind === "promise")
+                        return [lowerer.adoptingReturn(value, R, (e) => lowerer.coerceInto(call, e, R))];
+                    if (returnsPromise) {
+                        // A boxed handler's promise result adopts too: the then job's
+                        // turn after the call, then the await of the returned value.
+                        const hLocal = lowerer.declareHiddenLocal("h", DYN);
+                        const settledDyn = {
+                            kind: "libCall",
+                            fn: "async.awaitDyn",
+                            args: [{ kind: "varRef", localId: hLocal.id, type: DYN, loc }],
+                            type: DYN,
+                            loc,
+                        };
+                        return [
+                            { kind: "varDecl", localId: hLocal.id, init: value, loc },
+                            {
+                                kind: "exprStmt",
+                                expr: { kind: "libCall", fn: "async.hop", args: [], type: VOID, loc },
+                                loc,
+                            },
+                            ...(R.kind === "void"
+                                ? [
+                                    { kind: "exprStmt", expr: settledDyn, loc },
+                                    { kind: "return", value: null, loc },
+                                ]
+                                : [
+                                    {
+                                        kind: "return",
+                                        value: lowerer.coerceInto(call, settledDyn, R),
+                                        loc,
+                                    },
+                                ]),
+                        ];
+                    }
                     return R.kind === "void"
                         ? [
-                            { kind: "exprStmt", expr: settled, loc },
+                            { kind: "exprStmt", expr: value, loc },
                             { kind: "return", value: null, loc },
                         ]
-                        : [{ kind: "return", value: lowerer.coerceInto(call, settled, R), loc }];
+                        : [{ kind: "return", value: lowerer.coerceInto(call, value, R), loc }];
                 };
                 const rejectedCall = rLocal
                     ? {
@@ -4864,12 +4564,8 @@ export function lowerPromiseMethodCall(lowerer, call, access) {
                 lowerer.fnStack.pop();
             }
         }
-        // The settled value is an island HANDLE: an inline handler's
-        // unannotated parameter binds it as jsval, whatever the checker's
         // contextual type spelled (a module-namespace type has no mapping —
         // the handle is the value's only story, isIslandExpr's local rule).
-        if (inner.kind === "jsval")
-            markJsvalHandlerParams(lowerer, call.arguments[0]);
         if (inner.kind === "moduleNs")
             markModuleNsHandlerParams(lowerer, call.arguments[0], inner);
         let cb = lowerer.lowerExpr(call.arguments[0]);
@@ -5030,29 +4726,14 @@ export function lowerPromiseMethodCall(lowerer, call, access) {
                 loc,
             };
             // The handler's result: promise returns flatten exactly like
-            // `return p` in any async body (awaitExpr re-throws rejections —
-            // the spec's thenable adoption); everything else coerces into R.
-            if (R.kind === "void") {
-                if (handlerCall.type.kind === "promise") {
-                    body.push({
-                        kind: "exprStmt",
-                        expr: { kind: "awaitExpr", value: handlerCall, type: handlerCall.type.inner, loc },
-                        loc,
-                    });
-                }
-                else {
-                    body.push({ kind: "exprStmt", expr: handlerCall, loc });
-                }
-                body.push({ kind: "return", value: null, loc });
+            // `return p` in any async body (the spec's thenable adoption);
+            // everything else coerces into R.
+            if (handlerCall.type.kind === "promise" && R.kind !== "promise") {
+                body.push(lowerer.adoptingReturn(handlerCall, R, (e) => lowerer.coerceInto(call, e, R)));
             }
-            else if (handlerCall.type.kind === "promise" && R.kind !== "promise") {
-                const awaited = {
-                    kind: "awaitExpr",
-                    value: handlerCall,
-                    type: handlerCall.type.inner,
-                    loc,
-                };
-                body.push({ kind: "return", value: lowerer.coerceInto(call, awaited, R), loc });
+            else if (R.kind === "void") {
+                body.push({ kind: "exprStmt", expr: handlerCall, loc });
+                body.push({ kind: "return", value: null, loc });
             }
             else {
                 body.push({ kind: "return", value: lowerer.coerceInto(call, handlerCall, R), loc });
@@ -5389,18 +5070,6 @@ export function lowerPromiseMethodCall(lowerer, call, access) {
             // with the dyn undefined.
             catchBody.push({ kind: "return", value: dynUndefinedExpr(loc), loc });
         }
-        else if (R.kind === "jsval") {
-            // A package-typed result (Promise<Command> — the parseAsync().catch
-            // entry line): falling off the handler's end resolves with
-            // undefined, which on the island side is the engine's own
-            // undefined. Also what makes a never-returning handler (ending in
-            // process.exit) satisfy the always-returns analysis.
-            catchBody.push({
-                kind: "return",
-                value: { kind: "jsOp", op: "globalGet", name: "undefined", args: [], type: JSVAL, loc },
-                loc,
-            });
-        }
         const ctx = lowerer.ctx;
         const lifted = {
             name: fnName,
@@ -5498,7 +5167,7 @@ export function lowerFilterNarrowCall(lowerer, call, access) {
         // ToBoolean must be answerable per element (dyn/caught arms are not).
         if (elem.kind === "union")
             lowerer.requireTruthyUnion(elem.unionId, argNode);
-        if (elem.kind === "dyn" || elem.kind === "jsval" || elem.kind === "void" || isUnitType(elem)) {
+        if (elem.kind === "dyn" || elem.kind === "void" || isUnitType(elem)) {
             lowerer.badType(argNode, lowerer.typeOf(argNode));
         }
         const receiver = lowerer.lowerExpr(access.expression);
@@ -6056,8 +5725,7 @@ function lowerObjectStaticCall(lowerer, call, access) {
         member === "getOwnPropertySymbols" ||
         member === "getOwnPropertyDescriptors") &&
         call.arguments.length === 1 &&
-        !call.arguments.some(ts.isSpreadElement) &&
-        !lowerer.dynamic) {
+        !call.arguments.some(ts.isSpreadElement)) {
         let object = lowerer.lowerExpr(call.arguments[0]);
         if (object.type.kind === "string" ||
             object.type.kind === "f64" ||
@@ -6079,8 +5747,7 @@ function lowerObjectStaticCall(lowerer, call, access) {
     }
     if ((member === "getPrototypeOf" || member === "setPrototypeOf") &&
         call.arguments.length === (member === "getPrototypeOf" ? 1 : 2) &&
-        !call.arguments.some(ts.isSpreadElement) &&
-        !lowerer.dynamic) {
+        !call.arguments.some(ts.isSpreadElement)) {
         let object = lowerer.lowerExpr(call.arguments[0]);
         if (object.type.kind === "func") {
             const fnName = jsFuncNameOf(call.arguments[0], lowerer);
@@ -6160,7 +5827,6 @@ function lowerObjectStaticCall(lowerer, call, access) {
     // identity. Statically DISJOINT kind pairs answer the constant false
     // with the operands still evaluated (tsc admits any pair — Object.is
     // is (any, any) — and JS evaluates the arguments either way).
-    // dyn/jsval operands keep strict equality's stance: validate first.
     if (member === "is") {
         if (call.arguments.length !== 2 || call.arguments.some((a) => ts.isSpreadElement(a))) {
             lowerer.noLowering(`Object.is with ${call.arguments.length} arguments`, call, "exactly two arguments are the lowered form (JS treats a missing one as undefined — pass it explicitly)");
@@ -6184,7 +5850,7 @@ function lowerObjectStaticCall(lowerer, call, access) {
         const unitTest = lowerer.lowerUnitComparison(left, right, false, loc);
         if (unitTest)
             return unitTest;
-        if (lk === "dyn" || rk === "dyn" || lk === "jsval" || rk === "jsval") {
+        if (lk === "dyn" || rk === "dyn") {
             return {
                 kind: "libCall",
                 fn: "dyn.sameValue",
@@ -6271,8 +5937,7 @@ function lowerObjectStaticCall(lowerer, call, access) {
         lowerer.noLowering(`Object.is over '${lowerer.fmt(left.type)}' and '${lowerer.fmt(right.type)}' operands`, call, "the operands must share one comparable kind (numbers, strings, booleans, units, one union shape, or one reference type)");
     }
     // Native checked objects retain a live prototype and can install an
-    // own-property descriptor table during creation. Engine-held values
-    // use the engine's Object.create path below.
+    // own-property descriptor table during creation.
     if (member === "create") {
         if (call.arguments.some((a) => ts.isSpreadElement(a))) {
             lowerer.noLowering("Object.create with spread arguments", call);
@@ -6285,50 +5950,6 @@ function lowerObjectStaticCall(lowerer, call, access) {
         while (ts.isParenthesizedExpression(protoNode))
             protoNode = protoNode.expression;
         const nullProto = protoNode.kind === ts.SyntaxKind.NullKeyword;
-        if (lowerer.dynamic) {
-            if (call.arguments.length === 2)
-                lowerer.noLowering("Object.create with properties under --dynamic", call);
-            // The checker types the result `any` — an ENGINE value under
-            // --dynamic — and the engine's own Object.create answers with
-            // REAL prototype semantics: reads delegate LIVE, writes shadow,
-            // and inspect renders Node's exact shapes ("[Object: null
-            // prototype]" included). null and engine-held (jsval) prototypes
-            // route; checked-dynamic (dyn) prototypes keep the named fence —
-            // their marshal into the engine is a DEEP COPY, so a later
-            // prototype mutation would be invisible through the created
-            // object where Node delegates live.
-            const objectGlobal = () => ({
-                kind: "jsOp",
-                op: "globalGet",
-                name: "Object",
-                args: [],
-                type: JSVAL,
-                loc,
-            });
-            if (nullProto) {
-                const nullIn = { kind: "jsOp", op: "nullLit", args: [], type: JSVAL, loc };
-                return {
-                    kind: "jsOp",
-                    op: "callMethod",
-                    name: "create",
-                    args: [objectGlobal(), nullIn],
-                    type: JSVAL,
-                    loc,
-                };
-            }
-            const proto = lowerer.lowerExpr(protoNode);
-            if (proto.type.kind === "jsval") {
-                return {
-                    kind: "jsOp",
-                    op: "callMethod",
-                    name: "create",
-                    args: [objectGlobal(), proto],
-                    type: JSVAL,
-                    loc,
-                };
-            }
-            lowerer.noLowering(`Object.create over '${lowerer.fmt(proto.type)}' prototypes`, call, "prototype reads delegate LIVE in Node (mutating the prototype shows through the created object), which the boundary's deep copy cannot honor — only null and engine-held ('any') prototypes lower");
-        }
         if (nullProto && call.arguments.length === 1) {
             return { kind: "libCall", fn: "dyn.objCreateNullProto", args: [], type: DYN, loc };
         }
@@ -6979,7 +6600,6 @@ function lowerObjectStaticCall(lowerer, call, access) {
     }
     // unknown[] uses the checked-dynamic array representation. Enumerate
     // a live view of the record so values retain their identities and the
-    // result never pretends to be a native vector or an island array.
     const enumerationType = lowerer.mapTypeOf(lowerer.typeOf(call));
     if ((member === "values" || member === "entries") &&
         (enumerationType?.kind === "dyn" ||
@@ -7683,7 +7303,6 @@ function lowerObjLitGenericMethodCall(lowerer, call, access) {
         const provablyNot = thisT !== null &&
             thisT.kind !== "searchParams" &&
             thisT.kind !== "dyn" &&
-            thisT.kind !== "jsval" &&
             (!thisArg ||
                 ts.isIdentifier(thisArg) ||
                 ts.isLiteralExpression(thisArg) ||
@@ -8396,8 +8015,8 @@ function loweredArgumentText(lowerer, arg) {
 }
 /** The static global number parsers (parseInt/parseFloat/isNaN/isFinite),
  * shared by the globals and their Number.* aliases. `call` blames arity
- * fences; null when the argument shape needs the engine (the caller keeps
- * its island path or SC2012 fence). */
+ * fences; null when the argument shape has no static form (the caller
+ * reports the SC2012 refusal). */
 export function lowerStaticNumberGlobal(lowerer, name, call, args, loc) {
     if (name === "parseInt" || name === "isNaN") {
         const maxArgs = name === "parseInt" ? 2 : 1;
@@ -8498,10 +8117,9 @@ export function lowerStaticNumberGlobal(lowerer, name, call, args, loc) {
     // parseInt's siblings (num.parseFloat is ECMA 19.2.4's decimal-
     // literal prefix parse in scr_string.c; a number-typed isFinite IS
     // Number.isFinite — the global's ToNumber coercion is the identity
-    // there, ms's `isFinite(val)` guard). Other argument types fall
-    // through to today's island path (--dynamic) or its SC2012 fence:
-    // the ToNumber/ToString coercions on arbitrary values stay engine
-    // territory. The probe never emits — lowering is IR construction.
+    // there, ms's `isFinite(val)` guard). Other argument types retain
+    // their native coercion checks or the SC2012 refusal. The probe never
+    // emits — lowering is IR construction.
     if ((name === "parseFloat" || name === "isFinite") && args.length === 1) {
         if (name === "parseFloat") {
             const optional = optionalCallValue(lowerer, args[0]);