@scriptc/compiler 0.2.10 → 0.3.1

package/dist/frontend/lowering/lowerer.js

@@ -14,9 +14,8 @@ import { widthLiftPlan, unitOnlyElem, recordWidthPlan, describeRecordWidthBlocke
 import { widthCoerce, applyWidthLift, unionRecordWidthHelper, recordWidthHelper, tupleArrayWidthHelper, emptyArrayLiftHelper, arrayWidthHelper, objRecordWidthHelper, recordClassWidthHelper, classStaticsProjection, } from "./coercions/structural.js";
 import { funcReturnWidthAdapter, coercibleValue, cleanFuncAdaptable, funcCoerceAdapter, spawnResFnAdapterPlan, spawnResFnAdapter, } from "./coercions/function-adapters.js";
 import { unionRetagMappable, narrowedRetagHelper, strandedUnitTrap, strandedCoercionTrap, recordUnionWrapHelper, unionRetagHelper, narrowedArmHelper, checkedNarrowCall, checkedNarrowOperand, deferredReadHelper, } from "./coercions/unions.js";
-import { jsvalLiftable, jsvalLiftExpr, unionToJsvalHelper, recordToJsvalHelper, arrayToJsvalHelper, arrayToJsvalArrayHelper, } from "./coercions/island.js";
 import { lowerUtilTypeValue, pathModuleValue, utilTypesModuleValue, } from "./lower-builtin-values.js";
-import { everyExprChild, everyStmtChild, transformStmtList } from "../../ir/traverse.js";
+import { devirtualizeVirtualCalls } from "./devirtualize.js";
 import { RuntimeOptionalProvenance } from "./runtime-optional-provenance.js";
 import { presentAtUse, reassignedBindings } from "./runtime-optional-guards.js";
 import { NarrowingStability } from "./narrowing-stability.js";
@@ -57,12 +56,12 @@ import { tsgoPath } from "../dts-paths.js";
 import * as ts from "../ts7/adapter.js";
 import { literalValues } from "../literal-values.js";
 import { discriminantOwners, literalUnionArm } from "../union-discriminants.js";
-import { anyOpRequiresDynamicDiag, blockedBindingUseDiag, checkerPanicDiag, componentTypeDiag, isCheckerPanic, genericSignatureTypeDiag, indexSignatureTypeDiag, intersectionTypeDiag, noLoweringDiag, overloadedSignatureTypeDiag, recordShapeMismatchDiag, requiresDynamicApiDiag, requiresDynamicPackageDiag, requiresDynamicTypeDiag, unionMismatchDiag, UNSUPPORTED, unsupportedDiag, unsupportedTypeDiag, } from "../../diagnostics/diagnostic.js";
-import { arrayOf, BOOL, canAdaptDynFuncTo, canDynCheckTo, canConvertToDyn, canCrossIslandBoundary, canExitIslandToType, canMarshalTypedFuncIntoIsland, DYN, DYN_HANDLE_KINDS, F64, isDynTypedRefType, isJsonSafeType, isJsonStringifySafeType, isPrimitiveCollectionKey, isSupportedMapKey, isSupportedMapValue, isUndefinedArmedUnion, isUnitType, JSVAL, NULL_T, RUNTIME_ERROR_CLASSES, STRING, typeEquals, UNDEFINED_T, VOID, } from "../../ir/ir.js";
+import { unsupportedAnyOperationDiag, blockedBindingUseDiag, checkerPanicDiag, componentTypeDiag, isCheckerPanic, genericSignatureTypeDiag, indexSignatureTypeDiag, intersectionTypeDiag, noLoweringDiag, overloadedSignatureTypeDiag, recordShapeMismatchDiag, unsupportedNativeApiDiag, unsupportedPackageValueDiag, unionMismatchDiag, UNSUPPORTED, unsupportedDiag, unsupportedTypeDiag, } from "../../diagnostics/diagnostic.js";
+import { arrayOf, BOOL, canAdaptDynFuncTo, canDynCheckTo, canConvertToDyn, DYN, DYN_HANDLE_KINDS, F64, isDynTypedRefType, isJsonSafeType, isJsonStringifySafeType, isPrimitiveCollectionKey, isSupportedMapKey, isSupportedMapValue, isUndefinedArmedUnion, isUnitType, NULL_T, RUNTIME_ERROR_CLASSES, STRING, typeEquals, UNDEFINED_T, VOID, } from "../../ir/ir.js";
 import { provenanceActive } from "../provenance-registry.js";
 import { ambientDtsPath, canonicalBuiltinModule, cjsExportAssignmentOf, cjsExportDiscardReason, fallbackDtsPath, isCjsExportTableLiteral, isCjsJsFile, isJsSourceFile, isNodeEsmFile, isNodeTypesPath, locOf, orderedImportsOf, overridesDtsPath, npmStaticDepSf7, requireSpecOf, resolveImport, workspacePackageOfPath, } from "../program.js";
-import { containsRecord, containsUnion, describeComponentBlocker, describeRecordMemberBlocker, formatIrType, ISLAND_AMBIENT_TYPES, isUnitOnlyTsType, isWorkerHandleType, jsOpenObjectType, mapType, ShapeRegistry, typeKey, UnionRegistry, withUndefinedArm as withUndefinedArmCanonical, } from "../type-mapper.js";
-import { boundaryIntoIslandMsg, boundaryOutOfIslandMsg, builtinConstLit, builtinModuleConstOf, builtinModulesArrayLit, builtinFenceHintOf, builtinModuleFnOf, stdlibMemberFence, isStdlibMember, isStdlibSymbol, isStdlibGlobal, stdlibGlobalNameOf, stdlibGlobalMember, nodeTypesOnlySymbol, } from "./surfaces.js";
+import { containsRecord, containsUnion, describeComponentBlocker, describeRecordMemberBlocker, formatIrType, FETCH_AMBIENT_TYPES, isUnitOnlyTsType, isWorkerHandleType, jsOpenObjectType, mapType, ShapeRegistry, typeKey, UnionRegistry, withUndefinedArm as withUndefinedArmCanonical, } from "../type-mapper.js";
+import { builtinConstLit, builtinModuleConstOf, builtinModulesArrayLit, builtinFenceHintOf, builtinModuleFnOf, stdlibMemberFence, isStdlibMember, isStdlibSymbol, isStdlibGlobal, stdlibGlobalNameOf, stdlibGlobalMember, nodeTypesOnlySymbol, } from "./surfaces.js";
 import { splitFiles, collectProgram, collectNpmImports, collectJsonImports, moduleArtifacts, collectGlobals, declSymbolOf, defaultExportSymbolOf, lowerFileInit, lowerDefaultExport, buildMain, appendDynamicImportModules, appendForkModules, appendWorkerModules, } from "./lower-modules.js";
 import { prepareCjsModuleGraph } from "./lower-node-module.js";
 import { registerBuiltinErrorClasses, registerBuiltinEmitterClass, registerBuiltinStreamClasses, builtinErrorInfoOf, builtinEmitterInfoOf, builtinStreamInfoOf, analyzeClassDecoration, classIteratorDrainCall, classIteratorNextCall, classIteratorOf, classIteratorOpenCall, classIteratorRestDrainCall, classMemberNameOf, classValueRef, collectClassShape, exactClassOfReceiver, collectClassShapeInner, ctorAbiEquals, findMethodOn, findStaticOn, genericClassInstanceType, isSubclassOf, inHierarchy, overrideBelow, staticShadowBelow, upcastTo, lowerClassMembers, lowerClassCtor, lowerClassExpression, lowerClassExpressionInfo, lowerClassMethodMember, lowerClassValueProperty, lowerStaticMethod, throwingSetterFn, fieldInitStmts, lowerStaticFieldInits, lowerStaticFieldRead, lowerDerivedCtorBody, superCallStmt, lowerSuperMethodCall, superThisRef, lowerSuperAccessorRead, lowerSuperAccessorWrite, inheritsBuiltinErrorCtor, inheritsBuiltinEmitterCtor, errorConstructorArgs, lowerNew, accessorCall, } from "./lower-classes.js";
@@ -78,12 +77,13 @@ import { lowerCall, lowerPromiseMethodCall, lowerFilterNarrowCall } from "./lowe
 import { lowerFfiCall, validateFfiImports } from "./native-ffi.js";
 import { isTopLevelFnSymbol, lowerNestedFunctionDecl, lowerLambda, lowerFunction, } from "./lower-functions.js";
 import { lowerArrayMethodCall } from "./containers/array-methods.js";
+import { fuseArrayPipelines } from "./containers/array-pipelines.js";
 import { lowerMapMethodCall, lowerMapForEachCall, lowerSetMethodCall, lowerSetForEachCall, } from "./containers/collection-methods.js";
 import { lowerEnvToPairsHelper } from "./containers/indexed-objects.js";
 import { lowerBufferStaticCall, lowerBytesMethodCall, lowerBytesNew } from "./containers/bytes.js";
 import { lowerRegexMethodCall, lowerStringMethodCall } from "./containers/string-and-regexp.js";
 import { lowerEmitOverrideSpec, } from "./lower-event-emitter.js";
-import { builtinImportOf, createRequireBindingDecl, createRequireNamespaceDecl, createRequireProgramModuleOf, createRequireSpecOf, fencedBuiltinImportOf, } from "./builtins/module-bindings.js";
+import { builtinImportOf, createRequireProgramModuleOf, createRequireSpecOf, fencedBuiltinImportOf, } from "./builtins/module-bindings.js";
 import { stripTypeCasts } from "./builtins/arguments.js";
 import { lowerBuiltinModuleCall } from "./builtins/module-calls.js";
 import { lowerTimersPromisesSetInterval, lowerTimeoutMethodCall } from "./builtins/timers.js";
@@ -105,12 +105,13 @@ import { lowerDiagnosticsChannelMethodCall, lowerDiagnosticsChannelProperty, low
 import { lowerErrorCodeProperty } from "./builtins/errors.js";
 import { lowerProcessProperty, lowerProcessMethodCall, lowerProcessOptionalMethodCall, lowerProcessStreamProperty, } from "./builtins/process.js";
 import { isConsoleLog, consoleCallMember } from "./builtins/console.js";
+import { lowerConsoleNew } from "./lower-console.js";
 import { lowerNumberStaticCall, lowerNumberStaticProperty } from "./builtins/numbers.js";
 import { lowerDateCall } from "./builtins/dates.js";
 import { lowerFsConstantsProperty, lowerBuiltinConstantsProperty, builtinConstantBindingOf, builtinConstantsDestructureDecl, } from "./builtins/constants.js";
 import { lowerStringStaticCall, lowerStringLastIndexOfCall } from "./builtins/strings.js";
 import { lowerPromiseStaticCall } from "./builtins/promises.js";
-import { fenceFetchObjectAssignment, fenceFetchObjectBinding, fenceStaticAbortControllerMemberRead, fenceStaticHeadersIteration, fenceStaticHeadersMember, fenceStaticReadableStreamMember, fenceStaticResponseMember, fenceUnsupportedFetchConstructorMember, isIslandExpr, islandFuncValueFence, islandRegexpOf, jsvalIn, requireDynamicApi, islandGlobalFnOf, lowerAbortControllerNew, lowerDynamicHeadersIteratorCall, lowerDynamicHeadersSpread, lowerDynamicImportCall, lowerFetchCall, lowerFetchElementMethodCall, lowerResponseNew, lowerFetchWebNew, lowerStaticFetchCompanionCall, lowerStaticAbortControllerCall, lowerStaticAbortSignalListenerCall, lowerStaticReadableStreamCancelCall, lowerStaticReadableStreamControllerCall, lowerStaticReadableStreamNew, lowerStaticReadableStreamReaderCall, lowerStaticResponseCall, lowerIslandMethodCall, lowerMathProperty, npmPackageOf, npmMemberFence, npmPackageOfSymbol, } from "./lower-island.js";
+import { fenceFetchObjectAssignment, fenceFetchObjectBinding, fenceStaticAbortControllerMemberRead, fenceStaticHeadersIteration, fenceStaticHeadersMember, fenceStaticReadableStreamMember, fenceStaticResponseMember, fenceUnsupportedFetchConstructorMember, refuseUnsupportedApi, stdlibGlobalFnOf, lowerAbortControllerNew, lowerDynamicImportCall, lowerFetchCall, lowerFetchElementMethodCall, lowerResponseNew, lowerFetchWebNew, lowerStaticFetchCompanionCall, lowerStaticAbortControllerCall, lowerStaticAbortSignalListenerCall, lowerStaticReadableStreamCancelCall, lowerStaticReadableStreamControllerCall, lowerStaticReadableStreamNew, lowerStaticReadableStreamReaderCall, lowerStaticResponseCall, lowerStdlibMethodCall, lowerMathProperty, npmPackageOf, npmMemberFence, npmPackageOfSymbol, } from "./lower-stdlib.js";
 import { lowerHttpHeadersElement, lowerNetModuleCall, lowerServerMethodCall, lowerServerProperty, lowerTlsRootCertificates, } from "./lower-server.js";
 import { lowerDgramDnsModuleCall, lowerDgramMethodCall } from "./lower-dgram.js";
 import { lowerNodeTestModuleCall, lowerTestDirectCall, lowerTestMethodCall, lowerTestCtxProperty, } from "./lower-test.js";
@@ -118,7 +119,7 @@ import { lowerAssertModuleCall, lowerAssertDirectCall } from "./lower-assert.js"
 import { lowerUtilModuleCall } from "./lower-inspect.js";
 import { lowerSystemErrorMapValue } from "./lower-system-errors.js";
 import { lowerComptime, comptimeBakeable, rejectComptimeCaptures, comptimeValueToIr, } from "./lower-comptime.js";
-import { lowerStmts, hasJsTypeAnnotation, noteBlockedBindings, isBlockedBinding, lowerScopedBlock, predeclareForwardCapture, predeclareForwardFnDecl, predeclareForwardVar, lowerStmt, lowerVarStatement, lowerDestructuringDecl, lowerDestructuringAssignParts, lowerBindingPattern, lowerJsvalBindingPattern, checkBindingElement, bindPatternTarget, isParseArgsDynCheckerType, lowerVarDeclList, lowerVarDecl, lowerSwitch, lowerTry, lowerExprStatement, lowerForOf, lowerForStatement, } from "./lower-stmts.js";
+import { lowerStmts, hasJsTypeAnnotation, noteBlockedBindings, isBlockedBinding, lowerScopedBlock, predeclareForwardCapture, predeclareForwardFnDecl, predeclareForwardVar, lowerStmt, lowerVarStatement, lowerDestructuringDecl, lowerDestructuringAssignParts, lowerBindingPattern, checkBindingElement, bindPatternTarget, isParseArgsDynCheckerType, lowerVarDeclList, lowerVarDecl, lowerSwitch, lowerTry, lowerExprStatement, lowerForOf, lowerForStatement, } from "./lower-stmts.js";
 import { lowerExpr, maybeNarrow, lowerUnitComparison, lowerNullishCoalesce, lowerCondition, ensureBool, requireTruthyUnion, eqComparableUnion, lowerIntrinsicProperty, lowerArrayLiteral, lowerElementAccess, lowerElementWrite, lowerRecordKeyRead, ensureString, lowerTemplate, lowerAsExpression, lowerPrefixUnary, lowerBinary, lowerCaughtTypeofTest, caughtRead, caughtLocalOf, caughtToString, lowerInstanceOf, lowerRegexLiteral, lowerFieldRead, lowerUnionProperty, fieldTarget, fieldGetExpr, fieldSetStmt, lowerFieldCompound, uniqueSymbolKeyOf, } from "./lower-exprs.js";
 import { finishOptionalChain, isOptionalChainTail, lowerOptionalChain, } from "./expressions/optional-chains.js";
 import { foldedStringKeyOf, lowerDynObjectLiteral, lowerObjectLiteral, lowerShorthandValue, rejectThisInObjectMethod, } from "./expressions/object-literals.js";
@@ -139,35 +140,6 @@ export class PoisonError extends Error {
 export function own(table, key) {
     return Object.hasOwn(table, key) ? table[key] : undefined;
 }
-/** IrStmt discriminants — the island walk below must not descend into
- * NESTED statements (each is counted individually by its own lowerStmts
- * visit; descending would attribute a nested island statement to every
- * enclosing construct too). The top-level statement object itself is
- * always visited. */
-const IR_STMT_KINDS = new Set([
-    "varDecl",
-    "assign",
-    "exprStmt",
-    "if",
-    "while",
-    "doWhile",
-    "switch",
-    "arraySet",
-    "arraySetLength",
-    "arraySetUndefined",
-    "arrayDelete",
-    "forOf",
-    "return",
-    "fieldSet",
-    "recordSet",
-    "break",
-    "continue",
-    "block",
-    "tryCatch",
-    "throw",
-    "rethrow",
-    "runtimeFence",
-]);
 /** Every identifier a binding name binds: the identifier itself, or all
  * identifiers of a (possibly nested) destructuring pattern in source
  * order. */
@@ -184,28 +156,6 @@ export function boundIdentifiersOf(name) {
     }
     return out;
 }
-/** Inspect executable children directly, without boxing the statement tree
- * into checked-dynamic storage just to calculate coverage. */
-export function stmtUsesIsland(stmts) {
-    // Keep the accounting boundary at the source statement: nested statement
-    // lists are counted by their own lowerStmts invocation.
-    const nested = (stmt) => IR_STMT_KINDS.has(stmt.kind) || everyStmtChild(stmt, expr, nested);
-    const expr = (node) => {
-        if (node.kind === "jsOp" ||
-            node.kind === "jsExit" ||
-            node.kind === "jsBridgePromise" ||
-            (node.kind === "libCall" &&
-                (node.fn === "island.eval" ||
-                    node.fn === "island.import" ||
-                    node.fn === "island.importDyn" ||
-                    node.fn === "island.castFail")))
-            return false;
-        return everyExprChild(node, expr, nested);
-    };
-    if (Array.isArray(stmts))
-        return !stmts.every((stmt) => everyStmtChild(stmt, expr, nested));
-    return !everyStmtChild(stmts, expr, nested);
-}
 /** Statements a never-lowered body would have contributed to the coverage
  * totals: every element of a statement list (blocks, case clauses), plus
  * the single-statement bodies of control flow, nested functions included —
@@ -286,13 +236,12 @@ export function lowerToIr(program, entry, moduleOrder, options = {}) {
         process.stderr.write(`scriptc lowering ${JSON.stringify(event)}\n`);
         phaseLast = now;
     };
-    const dynamic = options.dynamic ?? false;
     const targetPlatform = options.targetPlatform ?? process.platform;
     const startupCrash = options.startupCrash ?? null;
     // Modules reachable only through literal import() of the program's own
     // files join the compiled graph here, ONCE, before any
     // pass constructs (nothing calls their %init at startup — the import()
-    // site's namespace builder does, on the engine microtask, Node's
+    // site's namespace builder does, on the native microtask, Node's
     // evaluation point for them). Inadmissible static cycles inside the
     // added subgraph are minted here and handed to reachable emit after this
     // extension of the shared array; no later pass re-walks the subgraph.
@@ -321,7 +270,7 @@ export function lowerToIr(program, entry, moduleOrder, options = {}) {
     const libraryCallbacks = options.libraryCallbacks ?? false;
     const externalTypes = options.externalTypes ?? new Map();
     const externalTypeSpecifiersByFile = options.externalTypeSpecifiersByFile ?? directExternalTypeSpecifiersByFile(externalTypes);
-    const validation = new Lowerer(program, entry, moduleOrder, dynamic, {
+    const validation = new Lowerer(program, entry, moduleOrder, {
         frontendServices: options.frontendServices,
         targetPlatform,
         startupCrash,
@@ -341,7 +290,7 @@ export function lowerToIr(program, entry, moduleOrder, options = {}) {
     // lowerer because validation is an immediate no-op there.
     const reachableEmit = ffiImports.length === 0
         ? validation
-        : new Lowerer(program, entry, moduleOrder, dynamic, {
+        : new Lowerer(program, entry, moduleOrder, {
             frontendServices: options.frontendServices,
             targetPlatform,
             startupCrash,
@@ -370,7 +319,7 @@ export function lowerToIr(program, entry, moduleOrder, options = {}) {
     // historical compiler. This is a rare compatibility fallback; programs
     // without such a settled fence retain checker-backed IR exactly once.
     if (reachableEmit.requiresHistoricalOrderRelower) {
-        const emit = new Lowerer(program, entry, moduleOrder, dynamic, {
+        const emit = new Lowerer(program, entry, moduleOrder, {
             frontendServices: options.frontendServices,
             reachable,
             targetPlatform,
@@ -432,7 +381,7 @@ export function lowerToIr(program, entry, moduleOrder, options = {}) {
         result = { ...result, contracts };
     if (options.coverage !== true)
         return result;
-    const remainder = new Lowerer(program, entry, moduleOrder, dynamic, {
+    const remainder = new Lowerer(program, entry, moduleOrder, {
         frontendServices: options.frontendServices,
         reachable,
         remainder: true,
@@ -459,40 +408,13 @@ export function lowerToIr(program, entry, moduleOrder, options = {}) {
         },
     };
 }
-/** The island-handle type a `import(...)` initializer gives a binding
- * whose DECLARED type has no static mapping (`Promise<typeof
- * import("./m")>` — module-namespace types don't map): the direct form
- * holds the static promise-of-handle, the awaited form holds the handle
- * itself. Null for every other initializer shape. */
-export function importCallHandleType(expr) {
-    if (!expr)
-        return null;
-    let e = expr;
-    let awaited = false;
-    for (;;) {
-        if (ts.isParenthesizedExpression(e)) {
-            e = e.expression;
-        }
-        else if (ts.isAwaitExpression(e)) {
-            awaited = true;
-            e = e.expression;
-        }
-        else {
-            break;
-        }
-    }
-    if (ts.isCallExpression(e) && e.expression.kind === ts.SyntaxKind.ImportKeyword) {
-        return awaited ? JSVAL : { kind: "promise", inner: JSVAL };
-    }
-    return null;
-}
 /** The native namespace type produced by a literal static import() of a
  * compiled program module or supported Node builtin. This syntax-level
  * fallback is used where the checker exposes an anonymous builtin-module
  * object type with no stable module symbol (locals/globals are still
  * represented nominally by the value they actually receive). */
 export function staticImportNamespaceType(lowerer, expr) {
-    if (!expr || lowerer.dynamic)
+    if (!expr)
         return null;
     let e = expr;
     let awaited = false;
@@ -531,48 +453,8 @@ export function staticImportNamespaceType(lowerer, expr) {
     const ns = { kind: "moduleNs", moduleId };
     return awaited ? ns : { kind: "promise", inner: ns };
 }
-/** True when `expr` is a call that resolved to an overload SIGNATURE of a
- * source-implemented function whose implementation returns an island value
- * (`any` under --dynamic): tsc never checks overload return types against
- * the body — only the implementation signature is checked — so the
- * overload's return is an unverifiable claim about an island value. The
- * binding stores the HANDLE instead of trap-extracting the claimed type
- * (reconcileOverloadReturn keeps the call jsval by the same rule), and
- * uses dispatch to engine ops — exactly the value Node's binding holds.
- * Ambient (.d.ts) declarations never reach this: they have no compiled
- * implementation, so their calls lower through the island/builtin paths
- * whose validated exits keep the checker-trust trap. */
-export function uncheckedOverloadHandleCall(lowerer, expr) {
-    if (!lowerer.dynamic || !expr)
-        return false;
-    let e = expr;
-    while (ts.isParenthesizedExpression(e))
-        e = e.expression;
-    // Tagged templates are calls too (tag(strings, ...values)) and resolve
-    // overload sets the same way — foo1`${1}` against a TemplateStringsArray
-    // overload of an any-returning implementation stores the handle.
-    if (!ts.isCallExpression(e) && !ts.isTaggedTemplateExpression(e))
-        return false;
-    const rsig = lowerer.checker.getResolvedSignature(e);
-    const rdecl = rsig ? lowerer.checker.signatureDeclaration(rsig) : undefined;
-    if (!rsig || !rdecl)
-        return false;
-    if (!(ts.isFunctionDeclaration(rdecl) || ts.isMethodDeclaration(rdecl)) || rdecl.body)
-        return false;
-    const name = rdecl.name;
-    const symbol = name ? lowerer.checker.getSymbolAtLocation(name) : undefined;
-    if (!symbol)
-        return false;
-    const impl = lowerer.checker
-        .declarationsOf(symbol)
-        .find((d) => (ts.isFunctionDeclaration(d) || ts.isMethodDeclaration(d)) &&
-        d.body !== undefined);
-    if (!impl)
-        return false;
-    const implSig = lowerer.checker.getSignatureFromDeclaration(impl);
-    if (!implSig)
-        return false;
-    return lowerer.mapTypeOf(lowerer.checker.getReturnTypeOfSignature(implSig))?.kind === "jsval";
+export function uncheckedOverloadHandleCall(_lowerer, _expr) {
+    return false;
 }
 /** The JavaScript declaration fallback for unmappable binding types (see
  * irTypeOf): `any` and every other inference residue is the checked-
@@ -628,29 +510,6 @@ export function ladderFenceExpr(lowerer, surface, node, hint) {
         loc,
     };
 }
-/** The checked-dynamic declaration fallback for unmappable binding types
- * (see irTypeOf), two gates over one story:
- *
- * JAVASCRIPT files: `any` and every other inference residue is the
- * checked-dynamic 'unknown' kind, and array types keep their array-ness
- * with the fallback applied to the ELEMENT (any[]/never[] evolving arrays
- * become unknown[], so length/push/index still lower).
- *
- * TYPESCRIPT files: genuine checker-`any` residue ONLY — a bare `any`
- * binding (`flags & Any`), or a single-call-signature function type whose
- * only unmappable pieces are `any` (`(value: any) => value is string` —
- * the arrow the binding holds lowers those params to dyn, so the binding
- * keeps its func-ness with the same per-piece fallback). The honest
- * static subset of `any` is a binding whose VALUES are dyn-representable:
- * the binding is 'unknown' storage with the boundary conversions
- * coerceToExpected already applies (dynFrom into the slot, validated
- * dynCheck out) and per-site SC2011 fences for the operations the checked-dynamic tree
- * cannot carry JS-exactly (the island still lifts those). Every OTHER
- * unmappable TS type keeps its own diagnostic — annotations exist there,
- * and the fence names the real blocker. `--dynamic` builds never reach
- * this fallback for `any` (mapType answers jsval first).
- *
- * Null for void (no value exists to represent). */
 export function dynFallbackType(lowerer, node, t) {
     if (t.flags & ts.TypeFlags.Void)
         return null;
@@ -806,10 +665,7 @@ function jsFallbackFunctionType(lowerer, node, t) {
         const optional = decl !== undefined &&
             ts.isParameter(decl) &&
             (decl.questionToken !== undefined || decl.initializer !== undefined);
-        if (optional &&
-            mapped.kind !== "dyn" &&
-            mapped.kind !== "jsval" &&
-            !lowerer.bareUndefinedArmedUnion(mapped)) {
+        if (optional && mapped.kind !== "dyn" && !lowerer.bareUndefinedArmedUnion(mapped)) {
             mapped = lowerer.withUndefinedArm(mapped);
         }
         return mapped;
@@ -988,7 +844,6 @@ export class Lowerer {
     program;
     entry;
     moduleOrder;
-    dynamic;
     frontendServices;
     checker;
     diags = [];
@@ -1514,7 +1369,7 @@ export class Lowerer {
     runtimeOptionalType(t) {
         if (t.kind === "union")
             return this.armTag(t.unionId, UNDEFINED_T) >= 0 ? t : (this.withUndefinedArmOf(t) ?? t);
-        if (t.kind === "void" || t.kind === "dyn" || t.kind === "jsval" || t.kind === "generator")
+        if (t.kind === "void" || t.kind === "dyn" || t.kind === "generator")
             return t;
         return this.withUndefinedArm(t);
     }
@@ -1618,6 +1473,9 @@ export class Lowerer {
     /** Synthetic array-HOF loop functions (map/filter/forEach desugar),
      * interned per method + element/callback-result type: key → fn name. */
     arrHofHelpers = new Map();
+    /** What each array-HOF helper computes, keyed by helper name: the chain
+     * fusion pass reads it to recognize pipelines of helper calls. */
+    arrHofInfo = new Map();
     /** Per-arm calls through union-typed class receivers, interned by the
      * receiver union, member, completed argument ABI, and result type. */
     unionCallHelpers = new Map();
@@ -1770,43 +1628,21 @@ export class Lowerer {
      * falls back through the shared node (collectGlobals registers both). */
     globalsByDeclNode = new Map();
     globalsList = [];
-    /** npm-import init statements (--dynamic), keyed by file AND import
-     * declaration: the island.import assignments/side-effect loads for that
-     * statement. lowerFileInit splices them into the importing file's %init
-     * header at the statement's position — Node evaluates each imported
-     * module (island packages included) where the import appears, so an
-     * `import "polyfill"` before an `import "./app.js"` runs the package
-     * top-level BEFORE app's init, not after. */
     npmInitActions = new Map();
     /** Per-file %init PRELUDE statements for JSON imports: bakeable DATA
      * assignments with no observable evaluation order of their own —
      * prepended by lowerFileInit so the bindings are live before any
      * top-level statement runs. */
     jsonInitActions = new Map();
-    /** The embedded npm runtime graph (collectNpmImports), attached to the
-     * emitted module. Null without npm imports or without --dynamic. */
-    npmEmbedded = null;
-    npmBuiltins = null;
-    npmLazyTraps = null;
     /** Dynamic `import("literal")` resolutions, keyed
      * `fileName\u0000specifier` (collectDynamicImports fills it during npm
      * collection; lowerDynamicImportCall reads it per site). */
     dynImports = new Map();
-    /** createRequire-require resolutions of BARE npm specifiers, keyed
-     * `fileName\u0000specifier` (collectCreateRequires fills it during npm
-     * collection under --dynamic — the require-condition entry key plus its
-     * embedded format; lowerCreateRequireCall reads it per site; "" marks a
-     * failed resolution already reported at collection). */
     createRequireImports = new Map();
     /** Module → the name of its synthesized namespace-BUILDER function
      * (lowerOwnModuleImport): every `import()` of the same program module
      * shares one builder. */
     dynNsBuilders = new Map();
-    /** Parameters forced to the island-handle type (jsval) regardless of
-     * their checker type: then-handler params whose settled value is an
-     * engine handle (a dynamic import's namespace object) — paramShape's
-     * early-out. */
-    jsvalParamOverrides = new Set();
     checkedCallbackParams = new Set();
     /** Inline Promise.then parameters whose contextual type is a builtin
      * module namespace anonymous object. The settled native token is the
@@ -1892,7 +1728,6 @@ export class Lowerer {
     stats = {
         statementsTotal: 0,
         statementsFailed: 0,
-        statementsIsland: 0,
         functionsSkipped: 0,
     };
     /** Reachability edge sink: every resolution of
@@ -1946,6 +1781,9 @@ export class Lowerer {
      * can contain any retained descendant, but importing its declaration
      * alone does not make every descendant constructible. */
     constructedClasses = null;
+    /** Set while a subclass constructor's super() call notes its base
+     * constructor edge: that edge does not instantiate the base exactly. */
+    superConstructorEdge = false;
     virtualEdges = new Map();
     classCanBeConstructed(info) {
         return (this.constructedClasses === null ||
@@ -2026,19 +1864,16 @@ export class Lowerer {
             return;
         let s = this.statsByFile.get(file);
         if (!s)
-            this.statsByFile.set(file, (s = { total: 0, failed: 0, island: 0 }));
+            this.statsByFile.set(file, (s = { total: 0, failed: 0 }));
         if (kind === "total")
             s.total += 1;
         else if (kind === "failed")
             s.failed += 1;
-        else
-            s.island += 1;
     }
-    constructor(program, entry, moduleOrder, dynamic, mode = {}) {
+    constructor(program, entry, moduleOrder, mode = {}) {
         this.program = program;
         this.entry = entry;
         this.moduleOrder = moduleOrder;
-        this.dynamic = dynamic;
         this.frontendServices = mode.frontendServices;
         this.reachable = mode.reachable ?? null;
         this.remainder = mode.remainder ?? false;
@@ -2121,7 +1956,6 @@ export class Lowerer {
             isStdlibFile: this.isStdlibFile,
             isNpmFile: this.isNpmFile,
             isExternalTypeFile: (sf) => this.externalTypeSpecifiersByFile.has(tsgoPath(resolve(sf.fileName))),
-            dynamic: this.dynamic,
             typeMemo: this.typeMemo,
             canMemoizeType: () => this.typeParamBindings === null &&
                 this.typeParamTsBindings === null &&
@@ -3135,7 +2969,6 @@ export class Lowerer {
         const signatureBySymbol = new Map();
         const methodFamilies = new Map();
         const familyBySymbol = new Map();
-        const optionalMethodFamilies = new Set();
         for (const [symbol, sig] of this.fnSigsBySymbol)
             signatureBySymbol.set(symbol, { params: sig.params, returnType: sig.returnType, top: sig });
         for (const decl of fnDecls) {
@@ -3310,7 +3143,6 @@ export class Lowerer {
             if (!element ||
                 element.kind === "void" ||
                 element.kind === "dyn" ||
-                element.kind === "jsval" ||
                 element.kind === "generator")
                 return null;
             return e;
@@ -3344,12 +3176,12 @@ export class Lowerer {
                 return false;
             const object = init.arguments[0];
             const objectType = object ? this.mapTypeOf(this.typeOf(object)) : null;
-            return objectType?.kind === "dyn" || objectType?.kind === "jsval";
+            return objectType?.kind === "dyn";
         };
         const addUndefined = (t) => {
             if (t.kind === "union")
                 return this.armTag(t.unionId, UNDEFINED_T) >= 0 ? t : (this.withUndefinedArmOf(t) ?? t);
-            if (t.kind === "void" || t.kind === "dyn" || t.kind === "jsval" || t.kind === "generator")
+            if (t.kind === "void" || t.kind === "dyn" || t.kind === "generator")
                 return t;
             return this.withUndefinedArm(t);
         };
@@ -3427,6 +3259,11 @@ export class Lowerer {
                 const symbol = symbolOf(e.name);
                 if (symbol && optionalSymbols.has(symbol))
                     return true;
+                // A getter read is a call of its body.
+                if (symbol &&
+                    (symbol.flags & ts.SymbolFlags.GetAccessor) !== 0 &&
+                    optionalReturns.has(symbol))
+                    return true;
             }
             if (ts.isCallExpression(e) && ts.isIdentifier(e.expression)) {
                 const symbol = callableSymbolOf(e.expression);
@@ -3501,6 +3338,27 @@ export class Lowerer {
                 return null;
             return { kind: "union", unionId: this.unions.intern([F64, STRING]) };
         };
+        /** The union of primitive result types, or null when any is missing or
+         * not a number, string or boolean (or a union of them). */
+        const joinPrimitiveTypes = (types) => {
+            const arms = new Map();
+            for (const type of types) {
+                if (!type)
+                    return null;
+                const parts = type.kind === "union" ? this.unions.get(type.unionId)?.arms : [type];
+                if (!parts)
+                    return null;
+                for (const arm of parts) {
+                    if (arm.kind !== "f64" && arm.kind !== "string" && arm.kind !== "bool")
+                        return null;
+                    arms.set(typeKey(arm), arm);
+                }
+            }
+            const sorted = [...arms.entries()].sort(([a], [b]) => (a < b ? -1 : 1)).map(([, t]) => t);
+            if (sorted.length === 1)
+                return sorted[0];
+            return { kind: "union", unionId: this.unions.intern(sorted) };
+        };
         const noteField = (decl, name) => {
             if (!ts.isIdentifier(decl.name))
                 return false;
@@ -3591,10 +3449,7 @@ export class Lowerer {
                         // checker. The array's element ABI describes every value a
                         // position may hold after that call, so bind from that type.
                         const mapped = sourceType.elem;
-                        if (mapped &&
-                            mapped.kind !== "void" &&
-                            mapped.kind !== "dyn" &&
-                            mapped.kind !== "jsval") {
+                        if (mapped && mapped.kind !== "void" && mapped.kind !== "dyn") {
                             const widened = mapped.kind === "union"
                                 ? this.withUndefinedArmOf(mapped)
                                 : this.withUndefinedArm(mapped);
@@ -3961,7 +3816,7 @@ export class Lowerer {
             if (mapped?.kind === "promise")
                 mapped = mapped.inner;
             const anyElements = mapped?.kind === "array"
-                ? mapped.elem.kind === "dyn" || mapped.elem.kind === "jsval"
+                ? mapped.elem.kind === "dyn"
                 : mapped === null &&
                     this.checker.isArrayType(checkerType) &&
                     !this.checker.isTupleType(checkerType) &&
@@ -4141,7 +3996,6 @@ export class Lowerer {
                     mapped.kind === "record" ||
                     mapped.kind === "object" ||
                     mapped.kind === "dyn" ||
-                    mapped.kind === "jsval" ||
                     mapped.kind === "union");
             },
             restKeys: (call) => {
@@ -4512,9 +4366,6 @@ export class Lowerer {
                             if (arg &&
                                 (this.typeOf(arg).flags & (ts.TypeFlags.Undefined | ts.TypeFlags.Void)) === 0)
                                 continue;
-                            const family = familyBySymbol.get(symbol);
-                            if (family)
-                                optionalMethodFamilies.add(family);
                             for (const target of familyBySymbol.get(symbol) ?? [symbol]) {
                                 const shape = signatureBySymbol.get(target)?.params[i];
                                 if (!shape || shape.mode !== "required")
@@ -4539,10 +4390,7 @@ export class Lowerer {
                             }
                         }
                     }
-                    const restAt = sig.params.findIndex((shape) => shape.mode === "rest" ||
-                        shape.mode === "dynRest" ||
-                        shape.mode === "islandRest" ||
-                        shape.mode === "arguments");
+                    const restAt = sig.params.findIndex((shape) => shape.mode === "rest" || shape.mode === "dynRest" || shape.mode === "arguments");
                     node.arguments.forEach((arg, argumentIndex) => {
                         const i = restAt >= 0 && argumentIndex >= restAt ? restAt : argumentIndex;
                         const shape = sig.params[i];
@@ -4634,8 +4482,6 @@ export class Lowerer {
                         // Promote every implementation and its parameter bindings so
                         // downstream calls and returns see the same optional value.
                         const family = familyBySymbol.get(symbol);
-                        if (family)
-                            optionalMethodFamilies.add(family);
                         for (const target of family ?? [symbol]) {
                             const parameterShape = signatureBySymbol.get(target)?.params[i];
                             if (!parameterShape)
@@ -4762,18 +4608,35 @@ export class Lowerer {
                     changed = true;
                 }
             }
-            // Every implementation of a virtual slot must retain the same ABI,
-            // including when just one body forwards an omitted parameter.
-            for (const family of optionalMethodFamilies) {
-                if (!family.some((symbol) => optionalReturns.has(symbol)))
+            // Every implementation of a virtual slot must retain the same ABI:
+            // when one body can return undefined at runtime (an unchecked element
+            // read, a forwarded omitted parameter), the abstract or base
+            // declaration and every override return the widened type too.
+            for (const family of methodFamilies.values()) {
+                if (family.length < 2)
                     continue;
-                for (const symbol of family) {
+                const optional = family.some((symbol) => optionalReturns.has(symbol));
+                for (const symbol of optional ? family : []) {
                     if (!optionalReturns.has(symbol)) {
                         optionalReturns.add(symbol);
                         provenance?.note("return", functionDeclBySymbol.get(symbol), undefined, "(override family)");
                         changed = true;
                     }
                 }
+                // A primitive-widened result (`names[i] + 1` is NaN for a missing
+                // string) likewise becomes the slot's result for every member.
+                if (!family.some((symbol) => arithmeticReturns.has(symbol)))
+                    continue;
+                const joined = joinPrimitiveTypes(family.map((symbol) => arithmeticReturns.get(symbol) ?? signatureBySymbol.get(symbol)?.returnType));
+                if (!joined)
+                    continue;
+                for (const symbol of family) {
+                    const previous = arithmeticReturns.get(symbol);
+                    if (previous && typeEquals(previous, joined))
+                        continue;
+                    arithmeticReturns.set(symbol, joined);
+                    changed = true;
+                }
             }
         }
         // NaN-coded slots convert optional values on entry instead of holding
@@ -5038,8 +4901,7 @@ export class Lowerer {
             }
         }
         // Each file's top-level statements form its run-once init function.
-        // %main calls only the ENTRY's init: each init's hoisted import header
-        // runs its dependencies (npm island loads at their import positions),
+        // %main calls only the entry's init. Hoisted imports call their inits;
         // inline require statements call theirs mid-body, and the guards make
         // revisits cache hits — Node's evaluation order over the WHOLE graph
         // falls out of the nesting. The coverage remainder skips them — they
@@ -5111,7 +4973,7 @@ export class Lowerer {
                     !this.remainder &&
                         classDispatch.process(this, [...functions, ...this.liftedFns, ...this.implicitFns]);
             }
-            classDispatch.finalize();
+            classDispatch.finalize(this);
         }
         // Lambdas lifted while lowering any of the above (plus synthetic
         // array-HOF loop functions, which ride the same list), and the
@@ -5135,8 +4997,6 @@ export class Lowerer {
                 stats: this.stats,
                 ...(this.statsByFile.size > 0 ? { statsByFile: this.statsByFile } : {}),
                 ...(this.provenanceElided.length > 0 ? { provenanceElided: this.provenanceElided } : {}),
-                ...(this.npmBuiltins ? { npmBuiltins: this.npmBuiltins } : {}),
-                ...(this.npmLazyTraps ? { npmLazyTraps: this.npmLazyTraps } : {}),
             };
         }
         return this.finishModule(functions);
@@ -5144,6 +5004,8 @@ export class Lowerer {
     /** Final retention, pruning, and module assembly shared by ordinary emit
      * and the retained reachability worklist. */
     finishModule(functions) {
+        if (this.diags.length === 0)
+            fuseArrayPipelines(this, functions);
         finalizeClassMethodValues(this, functions);
         trackClassFieldCreation(this, functions);
         // Globals typed by a class that never REGISTERED (a JS class whose
@@ -5236,14 +5098,13 @@ export class Lowerer {
         const module = this.diags.length > 0
             ? null
             : {
-                irVersion: 15,
+                irVersion: 16,
                 sourceFile: this.entry.fileName,
                 functions,
                 classes: artifacts.classes,
                 records: artifacts.records,
                 unions: artifacts.unions,
                 globals: this.globalsList,
-                ...(this.npmEmbedded ? { embedded: this.npmEmbedded } : {}),
                 entry: ENTRY_NAME,
                 ...(this.usesWorkers ? { workers: true } : {}),
                 ...(isNodeEsmFile(this.entry, this.program) ? {} : { commonJsEntry: true }),
@@ -5260,8 +5121,6 @@ export class Lowerer {
             stats: this.stats,
             ...(this.statsByFile.size > 0 ? { statsByFile: this.statsByFile } : {}),
             ...(this.provenanceElided.length > 0 ? { provenanceElided: this.provenanceElided } : {}),
-            ...(this.npmBuiltins ? { npmBuiltins: this.npmBuiltins } : {}),
-            ...(this.npmLazyTraps ? { npmLazyTraps: this.npmLazyTraps } : {}),
         };
     }
     /** True when `t` (recursively) names a class instance type with no
@@ -5531,11 +5390,17 @@ export class Lowerer {
         };
         const reachable = new Set();
         this.constructedClasses = new Set();
+        // Every constructor edge except super() may create an instance of
+        // exactly that class (`new C`, class values, library roots, dynamic
+        // construction, ...).
+        const instantiated = new Set();
         const queue = [];
         const loweredUnits = new Map();
         const initFunctions = [];
         const instanceFunctions = [];
         this.onEdge = (name) => {
+            if (!this.superConstructorEdge && name.endsWith(".constructor"))
+                instantiated.add(name.slice(1, -".constructor".length));
             if (reachable.has(name))
                 return;
             reachable.add(name);
@@ -5723,7 +5588,7 @@ export class Lowerer {
             this.restoreGenericInstanceOrder(instLowered);
             this.restoreGenericClassInstanceOrder(clsInstLowered);
         }
-        classDispatch.finalize();
+        classDispatch.finalize(this);
         const orderedUnits = [...loweredUnits]
             .sort(([left], [right]) => units.get(left).order - units.get(right).order)
             .map(([, fn]) => fn);
@@ -5741,35 +5606,14 @@ export class Lowerer {
             ...this.liftedFns,
             ...this.implicitFns,
         ];
-        // The worklist can leave a virtual site with only its base method.
+        // The worklist can leave a virtual site with a single implementation.
         // Devirtualize after construction/override reachability has settled.
-        for (const fn of functions)
-            fn.body = transformStmtList(fn.body, {
-                stmt: (statement) => statement,
-                expr: (expression) => {
-                    if (expression.kind !== "virtualCall")
-                        return expression;
-                    const info = this.classes.get(expression.className);
-                    const method = info && this.findMethodOn(info, expression.method);
-                    if (!method ||
-                        method.sig.abstract ||
-                        [...this.classes.values()].some((candidate) => this.isSubclassOf(candidate.def.name, expression.className) &&
-                            candidate.def.name !== expression.className &&
-                            candidate.methods.has(expression.method) &&
-                            reachable.has(`%${candidate.def.name}.${expression.method}`)))
-                        return expression;
-                    return {
-                        kind: "call",
-                        callee: `%${method.declarer.def.name}.${expression.method}`,
-                        args: [
-                            this.upcastTo(expression.args[0], method.declarer.def.name),
-                            ...expression.args.slice(1),
-                        ],
-                        type: expression.type,
-                        loc: expression.loc,
-                    };
-                },
-            });
+        devirtualizeVirtualCalls(this, functions, {
+            reachable,
+            instantiated,
+            library: extraRoots !== undefined,
+            files: parts.map((fp) => fp.sf),
+        });
         this.reachableForArtifacts = reachable;
         return { reachable, result: this.finishModule(functions) };
     }
@@ -5779,6 +5623,17 @@ export class Lowerer {
         if (this.onEdge)
             this.onEdge(name);
     }
+    /** A subclass constructor's super() edge: the base constructor runs, but
+     * no instance of exactly the base class is created. */
+    noteSuperConstructorEdge(name) {
+        this.superConstructorEdge = true;
+        try {
+            this.noteEdge(name);
+        }
+        finally {
+            this.superConstructorEdge = false;
+        }
+    }
     /** Discovery hook for virtual dispatch: a virtualCall on `info`'s static
      * class reaches the nearest declaration at/above it plus every override
      * on a STRICT descendant (receivers of sibling branches can't flow into
@@ -5903,22 +5758,13 @@ export class Lowerer {
             ? `values from the '${specifier}' external host module (types supplied by --external-types, but no runtime implementation or scriptc lowering was provided)`
             : `the '${specifier}' external host module (types supplied by --external-types, but no runtime implementation or scriptc lowering was provided)`, `the declaration mapping is analysis-only: coverage continues through project code, while executing ${valueUse ? "this value" : "this module"} requires an embedder integration with explicit runtime semantics`);
     }
-    /** The dynamic-family fence for an OPERATION on an `any`-origin
-     * checked-dynamic value that only the engine can execute (operators,
-     * iteration, computed member names, ...). Carries SC2011 — the same
-     * code as the `any` type fence — so the coverage report groups it with
-     * the dynamic-capable family and the two-tier retry knows the island
-     * lifts the site. Use exactly when the blocking operand IS dyn-typed
-     * and its checker type is `any`-flavored; genuine `unknown` keeps the
-     * SC1100-family fences (tsc constrains what unknown can do, so those
-     * sites are checker-error territory, not engine territory). */
     anyOpFence(feature, node) {
-        this.pushDiag(anyOpRequiresDynamicDiag(feature, locOf(node)));
+        this.pushDiag(unsupportedAnyOperationDiag(feature, locOf(node)));
         throw new PoisonError();
     }
     /** True when this expression's CHECKER type is `any`-flavored — the
      * gate anyOpFence's call sites use to tell `any`-origin dyn values
-     * (the engine could run the operation) from genuine `unknown` ones. */
+     * with an unsupported operation from genuine `unknown` ones. */
     anyOrigin(node) {
         return (this.typeOf(node).flags & ts.TypeFlags.Any) !== 0;
     }
@@ -5940,11 +5786,10 @@ export class Lowerer {
         // SC2012 rather than the generic supported-types recitation. Native
         // fetch values map earlier to checked-dynamic handles and do not reach
         // here; constructor objects such as Headers still can.
-        if (!this.dynamic &&
-            typeSym &&
-            ISLAND_AMBIENT_TYPES.includes(typeSym.name) &&
+        if (typeSym &&
+            FETCH_AMBIENT_TYPES.includes(typeSym.name) &&
             this.isStdlibSymbol(typeSym)) {
-            this.pushDiag(requiresDynamicApiDiag(`a value of type '${typeSym.name}'`, locOf(node)));
+            this.pushDiag(unsupportedNativeApiDiag(`a value of type '${typeSym.name}'`, locOf(node)));
             throw new PoisonError();
         }
         // ENUM OBJECTS (`typeof e` — a numeric enum's type carries the
@@ -5983,30 +5828,14 @@ export class Lowerer {
                 this.pushDiag(noLoweringDiag(this.checker.typeToString(type), locOf(node)));
                 throw new PoisonError();
             }
-            // The MEASURED island probe, same mechanism as the general dynamic
-            // reroute below: an index-signature shape the dynamic mapping
-            // accepts (an `any`-valued signature absorbing into an island
-            // object, jsval-entangled members) reports the retry-eligible
-            // SC2011 choice instead of the static recitation.
-            if (!this.dynamic &&
-                !(widened.flags & ts.TypeFlags.Any) &&
-                mapType(widened, { ...this.typeCtx, dynamic: true }) !== null) {
-                this.pushDiag(requiresDynamicTypeDiag(this.checker.typeToString(type), locOf(node)));
-                throw new PoisonError();
-            }
             this.pushDiag(indexSignatureTypeDiag(this.checker.typeToString(type), locOf(node)));
             throw new PoisonError();
         }
-        // Package-declared types in a STATIC build: name the package, not the
-        // type — the per-package requires-dynamic diagnostic (and the coverage
-        // report's one-line-per-package attribution). Under --dynamic these
-        // types map to jsval, so reaching here means the type is genuinely
-        // unrepresentable (a jsval union arm, a jsval array element) — the
-        // generic type message tells that story better.
-        if (!this.dynamic) {
+        // Attribute an unsupported package type to its package.
+        {
             const pkg = this.npmPackageOf(widened);
             if (pkg) {
-                this.pushDiag(requiresDynamicPackageDiag(pkg, locOf(node)));
+                this.pushDiag(unsupportedPackageValueDiag(pkg, locOf(node)));
                 throw new PoisonError();
             }
         }
@@ -6023,24 +5852,6 @@ export class Lowerer {
                 throw new PoisonError();
             }
         }
-        // A type the DYNAMIC mapping accepts (`any[]`, records/functions with
-        // `any`-typed members, .d.ts-declared shapes whose values are island
-        // handles): the honest per-site story is the dynamic-family choice, not
-        // the supported-types recitation — proved by re-running mapType with
-        // `dynamic: true`, never guessed from the type text. Probing is safe
-        // here: a diagnostic means this build already failed, so anything the
-        // probe interns or registers on the way is never emitted. Checked LAST
-        // so every more specific story above (island ambients, index
-        // signatures, per-package attribution, generic signatures) keeps its
-        // own fence class. Bare `any` is excepted: unsupportedTypeDiag's own
-        // SC2011 arm tells that story with the stronger stay-static remedy
-        // ('unknown' + a checked cast).
-        if (!this.dynamic &&
-            !(widened.flags & ts.TypeFlags.Any) &&
-            mapType(widened, { ...this.typeCtx, dynamic: true }) !== null) {
-            this.pushDiag(requiresDynamicTypeDiag(this.checker.typeToString(type), locOf(node)));
-            throw new PoisonError();
-        }
         // STANDARD-LIBRARY nominal provenance, decided once: interface/class
         // declarations in the lib's own files (Date, ArrayBuffer, WeakMap, the
         // iterator/constructor interfaces). Such types report the SC2020 story
@@ -6147,12 +5958,6 @@ export class Lowerer {
     fenceFetchObjectAssignment(target, source) {
         return fenceFetchObjectAssignment(this, target, source);
     }
-    lowerDynamicHeadersIteratorCall(call, access) {
-        return lowerDynamicHeadersIteratorCall(this, call, access);
-    }
-    lowerDynamicHeadersSpread(node, type) {
-        return lowerDynamicHeadersSpread(this, node, type);
-    }
     fenceStaticReadableStreamMember(access, use) {
         return fenceStaticReadableStreamMember(this, access, use);
     }
@@ -6344,23 +6149,6 @@ export class Lowerer {
     bareUndefinedArmedUnion(t) {
         return isUndefinedArmedUnion(t, (id) => this.unions.get(id));
     }
-    /** canCrossIslandBoundary with this Lowerer's registries — THE test
-     * behind every marshal/exit decision (the implicit coercions, jsvalIn,
-     * the checked island-exit cast). Rejections that follow a false answer
-     * speak through boundaryIntoIslandMsg / boundaryOutOfIslandMsg. */
-    boundarySafe(t) {
-        return canCrossIslandBoundary(t, (id) => this.shapes.get(id), (id) => this.unions.get(id));
-    }
-    /** canExitIslandToType with this Lowerer's registries — the EXIT
-     * direction's slightly wider test (bare undefined-armed unions of
-     * JSON-safe data arms exit; the engine's undefined takes the undefined
-     * arm before the JSON round trip). */
-    boundaryExitSafe(t) {
-        return canExitIslandToType(t, (id) => this.shapes.get(id), (id) => this.unions.get(id));
-    }
-    isIslandExpr(node) {
-        return isIslandExpr(this, node);
-    }
     /** True when this node's CHECKER type is proven `any[]`/`unknown[]`,
      * directly or through the intersection tsc builds for a readonly tuple
      * union (`(Model | readonly [Model, Command]) & any[]`; TS7 distributes
@@ -6492,14 +6280,6 @@ export class Lowerer {
             }
             this.unsupported("SC1101", node);
         }
-        // jsval mismatches surviving coerceToExpected involve a type with no
-        // island representation (in) or no validated exit (out).
-        if (actual.kind === "jsval") {
-            this.unsupported("SC1090", node, boundaryOutOfIslandMsg(this.fmt(expected)));
-        }
-        if (expected.kind === "jsval") {
-            this.unsupported("SC1090", node, boundaryIntoIslandMsg(this.fmt(actual)));
-        }
         // Class-value mismatches: the pointed stories — a widening whose
         // constructor ABIs differ (construction through the slot would
         // dispatch a mismatched signature), or a structural flow between
@@ -6648,98 +6428,12 @@ export class Lowerer {
             if (adapted)
                 return adapted;
         }
-        // Island boundary, both directions. IN: any static value flowing into
         // an any-typed slot marshals implicitly (tsc allows the assignment;
         // the marshal is where its semantics live). OUT: an 'any' value
         // flowing into a typed slot compiles to a VALIDATED exit — like every
         // dyn→static edge, trust-but-verify: a lying `any` throws a catchable
         // TypeError instead of corrupting memory (SEMANTICS.md). Unmarshalable
         // and unextractable types fall through to requireExactShape's fences.
-        if (expected.kind === "jsval" && expr.type.kind !== "jsval") {
-            // Bare unit literals: the engine's own undefined/null (units have no
-            // other producers, so dropping the operand loses nothing).
-            if (isUnitType(expr.type)) {
-                return {
-                    kind: "jsOp",
-                    op: expr.type.kind === "undefinedT" ? "undefLit" : "nullLit",
-                    args: [],
-                    type: JSVAL,
-                    loc: expr.loc,
-                };
-            }
-            // A CHECKED-DYNAMIC (dyn/'unknown') value entering the island (the
-            // `isJson ? JSON.parse(text) : islandParser(text)` config ternary):
-            // the dyn tree deep-copies into engine values — data kinds only; a
-            // dyn carrying a boxed function/handle/promise throws the catchable
-            // TypeError at runtime (trust-but-verify, like every boundary).
-            if (expr.type.kind === "dyn") {
-                return { kind: "jsMarshal", value: expr, type: JSVAL, loc: expr.loc };
-            }
-            if (this.boundarySafe(expr.type)) {
-                return { kind: "jsMarshal", value: expr, type: JSVAL, loc: expr.loc };
-            }
-            // Closures cross as host functions when their signature marshals —
-            // the same shapes jsvalIn admits at call arguments (`const f: any =
-            // (x: number) => x * 3` is the declaration-slot spelling of the
-            // package-callback pattern).
-            if (expr.type.kind === "func" &&
-                canMarshalTypedFuncIntoIsland(expr.type, (id) => this.shapes.get(id), (id) => this.unions.get(id))) {
-                return { kind: "jsMarshal", value: expr, type: JSVAL, loc: expr.loc };
-            }
-            // jsval-BEARING composites (a record holding `any` fields, an array
-            // of such records) have no JSON marshal but an honest per-field
-            // island construction — see jsvalLiftExpr.
-            if (this.jsvalLiftable(expr.type)) {
-                return this.jsvalLiftExpr(expr, expr.loc);
-            }
-            // A RegExp flowing into an 'any' slot: the fresh-engine-RegExp
-            // rebuild (see jsvalIn's regex rule); computed regex values fall
-            // through to requireExactShape's fence.
-            if (expr.type.kind === "regex") {
-                const re = islandRegexpOf(expr);
-                if (re)
-                    return re;
-            }
-            return expr;
-        }
-        if (expr.type.kind === "jsval" && expected.kind !== "jsval") {
-            // The jsval→dyn crossing (the world unification's engine-handle
-            // kind): an 'any'-typed engine value flowing into an 'unknown'/
-            // 'object'/JS-residue slot wraps BY REFERENCE as the checked-dynamic tree's island
-            // kind — engine scalars normalize to native dyn kinds at wrap time,
-            // typeof/truthiness/String()/=== route to the engine, un-armed dyn
-            // walks fence loudly, and the value unwraps back identity-preserved
-            // (scr_jsval_from_dyn). Monotone under evolution/widening: a value
-            // wraps once at its first dyn edge and stays valid through every
-            // subsequent dyn slot; narrowing never changes representation.
-            // This wrap RETIRES the silent-wrong-answer fence-closure box for
-            // jsval members of dyn object literals (lowerDynObjectLiteral's
-            // coercion lands here first).
-            if (expected.kind === "dyn") {
-                return { kind: "dynFromJsval", value: expr, type: DYN, loc: expr.loc };
-            }
-            // An island value flowing into a PROMISE-typed slot (the inferred
-            // `loadPlugins` return — `Promise.all(...)` lowered engine-side
-            // against a Promise<any[]> inference): the island→static promise
-            // bridge — the engine promise settles a fresh static promise (void
-            // fulfillments drop, `any[]`-declared fulfillments exit
-            // Array.isArray-gated by reference at the settle, 'any' parks as an
-            // island handle). Only inner shapes the bridge can deliver take the
-            // arm; the rest keep the exit fence with the type named.
-            if (expected.kind === "promise" &&
-                (expected.inner.kind === "void" ||
-                    expected.inner.kind === "jsval" ||
-                    (expected.inner.kind === "array" && expected.inner.elem.kind === "jsval"))) {
-                return { kind: "jsBridgePromise", value: expr, type: expected, loc: expr.loc };
-            }
-            // The exit set: everything round-trippable, plus bare undefined-armed
-            // unions of JSON-safe data arms (the engine's undefined takes the
-            // undefined arm before the JSON detour) — canExitIslandToType.
-            if (this.boundaryExitSafe(expected)) {
-                return { kind: "jsExit", value: expr, type: expected, loc: expr.loc };
-            }
-            return expr;
-        }
         // A TYPED value flowing into an 'unknown' slot (`const u: unknown = 5`,
         // an unknown-typed param/return, a dyn-valued index slot): the
         // static→dyn conversion — dynFrom, a DEEP COPY (the jsMarshal aliasing
@@ -6822,8 +6516,7 @@ export class Lowerer {
         // A dyn ('unknown') ACTUAL flowing into a typed slot the checker
         // approved (an assertion function's narrowing, the error-any world's
         // forgiven chains): the VALIDATED extraction — dynCheck, the
-        // checked-cast machinery, applied automatically. Trust-but-verify,
-        // exactly the island exit's stance: a value that doesn't match the
+        // checked-cast machinery, applied automatically. A value outside the
         // slot's type throws a catchable TypeError instead of misreading the
         // payload. Only dynCheck's own domain (JSON-representable types,
         // undefined-armed unions of those, bytes<u8>, the %Error root)
@@ -7114,17 +6807,15 @@ export class Lowerer {
                 return this.applyWidthLift(lift, expr, expected, expr.loc);
             // Arms OUTSIDE widthLiftPlan's domain keep the historic per-arm
             // widthCoerce probe (first match): index-signature record arms (the
-            // overflow CAPTURE helper owns their reshapes) and `any[]` arms
-            // (the island-boundary per-element lift). Bounded to those arm
-            // shapes so the plan's ambiguity rule for record/array lifts is
-            // never undone by a first-match fallback.
+            // overflow CAPTURE helper owns their reshapes). Exclude shapes
+            // already owned by the plan so first-match fallback cannot undo
+            // its ambiguity rule for record/array lifts.
             {
                 const def = this.unions.get(expected.unionId);
                 if (def) {
                     for (let i = 0; i < def.arms.length; i++) {
                         const arm = def.arms[i];
-                        const boundaryArm = (arm.kind === "record" && this.shapes.get(arm.shapeId)?.indexValue !== undefined) ||
-                            (arm.kind === "array" && arm.elem.kind === "jsval");
+                        const boundaryArm = arm.kind === "record" && this.shapes.get(arm.shapeId)?.indexValue !== undefined;
                         if (!boundaryArm)
                             continue;
                         const w = this.widthCoerce(expr, arm);
@@ -7259,27 +6950,6 @@ export class Lowerer {
     deferredReadHelper(fromId, target, loc) {
         return deferredReadHelper(this, fromId, target, loc);
     }
-    jsvalLiftable(t, visiting = new Set()) {
-        return jsvalLiftable(this, t, visiting);
-    }
-    jsvalLiftExpr(e, loc) {
-        return jsvalLiftExpr(this, e, loc);
-    }
-    unionToJsvalHelper(unionId, loc) {
-        return unionToJsvalHelper(this, unionId, loc);
-    }
-    recordToJsvalHelper(shapeId, loc) {
-        return recordToJsvalHelper(this, shapeId, loc);
-    }
-    arrayToJsvalHelper(elem, loc) {
-        return arrayToJsvalHelper(this, elem, loc);
-    }
-    arrayToJsvalArrayHelper(fromElem, loc) {
-        return arrayToJsvalArrayHelper(this, fromElem, loc);
-    }
-    jsvalIn(e, node) {
-        return jsvalIn(this, e, node);
-    }
     /** THE coercion path for values flowing into a typed slot: union arms
      * wrap implicitly (coerceToExpected), then the exact-type fence runs
      * (SC2002 for record shapes, SC2003 for unions). Every slot-directed
@@ -7341,17 +7011,7 @@ export class Lowerer {
                 }
             }
         }
-        let e = this.dynamic &&
-            expr.type.kind === "dyn" &&
-            expected.kind === "array" &&
-            expected.elem.kind === "jsval"
-            ? {
-                kind: "jsExit",
-                value: this.jsvalIn(expr, node),
-                type: expected,
-                loc: expr.loc,
-            }
-            : this.coerceToExpected(expr, expected);
+        let e = this.coerceToExpected(expr, expected);
         // Keep storage intact when ordinary widening already accepts it. Only
         // a destination needing a more specific class layout uses the site's
         // refinement and checked extraction.
@@ -7375,24 +7035,6 @@ export class Lowerer {
             e.value.type.kind === "array") {
             e = { ...e, liveRef: true };
         }
-        // An 'any' value PROVABLY null/undefined (the unit literal itself, or
-        // a read of a binding nothing ever assigns a non-unit value) flowing
-        // implicitly into a primitive slot: the validated exit refuses units
-        // unconditionally, so every run would throw the boundary TypeError
-        // where Node proceeds silently. A failure certain at compile time is
-        // a fence, not a runtime surprise. Explicit casts keep their runtime
-        // checked-cast semantics (the cast lowering builds its own jsExit
-        // before this runs, so `e !== expr` skips them), and union/composite
-        // targets keep the runtime exit (an undefined-armed union ACCEPTS the
-        // engine's undefined; composite validation is dynCheck's business).
-        if (e !== expr &&
-            e.kind === "jsExit" &&
-            (e.type.kind === "f64" || e.type.kind === "string" || e.type.kind === "bool")) {
-            const unit = this.provenUnitAnyOf(node, e.value);
-            if (unit !== null) {
-                this.unsupported("SC1090", node, `an 'any' value that is always ${unit} flowing into a '${this.fmt(expected)}' slot (nothing in the program gives this value another shape, and the island boundary's validated exit refuses ${unit} — every run would throw a TypeError where Node proceeds silently)`, `give the binding a value other than ${unit} before this use, or keep the slot's type 'any'`);
-            }
-        }
         // A closure that just BOXED into dyn takes its best-effort JS name
         // from the source node (identifier reads, named function expressions,
         // NamedEvaluation through a variable initializer) — inspect prints
@@ -7428,34 +7070,12 @@ export class Lowerer {
                 }
             }
         }
-        // A JS FUNC value outside the island marshal set flowing into a
-        // jsval slot (`withPlugins(getSupportInfoWithoutPlugins, 0)` — a
-        // wrapper built at module init around a function the run may never
-        // call): the crossing defers to a call-time fence closure instead of
-        // stopping the statement — jsvalIn's deferral, the implicit-coercion
-        // spelling.
-        if (expected.kind === "jsval" && e.type.kind === "func" && !typeEquals(e.type, expected)) {
-            const diagsBefore = this.diags.length;
-            try {
-                this.requireExactShape(node, e.type, expected);
-            }
-            catch (err) {
-                if (!(err instanceof PoisonError))
-                    throw err;
-                const fence = islandFuncValueFence(this, diagsBefore, node);
-                if (fence)
-                    return fence;
-                throw err;
-            }
-            return e;
-        }
         this.requireExactShape(node, e.type, expected);
         return e;
     }
     /** The unit an 'any' expression PROVABLY holds on every run, or null
-     * when no proof exists. Two spellings prove: the lowered value IS the
-     * engine unit literal (`null as any`, an any-contextual `undefined`),
-     * or the node is an identifier whose every declaration is a plain,
+     * when no proof exists. The node must be an identifier whose every
+     * declaration is a plain,
      * non-ambient `var`/`let`/`const` declarator under a variable STATEMENT
      * (catch bindings, for-of/for-in cursors, parameters, and imports all
      * fail this shape test — each receives values from elsewhere), each
@@ -7466,13 +7086,7 @@ export class Lowerer {
      * bindings are read-only, so cross-file writes don't exist). A hoisted
      * `var` read before its unit-initialized statement holds undefined —
      * also a unit — so the mixed case reports both names. */
-    provenUnitAnyOf(node, value) {
-        if (value.kind === "jsOp" && value.args.length === 0) {
-            if (value.op === "undefLit")
-                return "undefined";
-            if (value.op === "nullLit")
-                return "null";
-        }
+    provenUnitAnyOf(node, _value) {
         let n = node;
         while (ts.isParenthesizedExpression(n))
             n = n.expression;
@@ -7580,7 +7194,6 @@ export class Lowerer {
                 const from = this.mapTypeOf(this.typeOf(asserted.expression));
                 const to = this.mapTypeOf(this.checker.getTypeFromTypeNode(asserted.type));
                 if (from?.kind === "dyn" ||
-                    from?.kind === "jsval" ||
                     (from?.kind === "record" && to?.kind === "record" && !typeEquals(from, to))) {
                     this.noLowering("collection key assertion requiring a structural copy or dynamic conversion", asserted, "use the original reference with the same type as the collection key");
                 }
@@ -7594,7 +7207,7 @@ export class Lowerer {
                 (from.kind === "object" &&
                     to.kind === "object" &&
                     this.isSubclassOf(from.className, to.className))));
-        if (!preservesIdentity || value.kind === "dynCheck" || value.kind === "jsExit") {
+        if (!preservesIdentity || value.kind === "dynCheck") {
             this.noLowering(`collection key conversion from '${this.fmt(value.type)}' to '${this.fmt(expected)}' requiring a structural copy or dynamic conversion`, node, "use the same reference type for the key and collection; copying a key would change its identity");
         }
         return this.coerceInto(node, value, expected);
@@ -7786,11 +7399,6 @@ export class Lowerer {
         if (value.kind === "unitLit") {
             return { kind: "dynFrom", value, type: DYN, loc: value.loc };
         }
-        // An ISLAND ('any') value: the by-reference jsval→dyn wrap — the same
-        // edge coerceToExpected converts (dyn slots accept engine values).
-        if (value.type.kind === "jsval") {
-            return { kind: "dynFromJsval", value, type: DYN, loc: value.loc };
-        }
         if (!this.dynConvertible(value.type)) {
             this.unsupported("SC1100", node, `storing '${this.fmt(value.type)}' values under an 'unknown'-valued index signature (only numbers, strings, booleans, and JSON-safe records/arrays/unions convert)`);
         }
@@ -7826,10 +7434,10 @@ export class Lowerer {
     }
     /** The value of a `return` statement. In an async function `return p`
      * where p is a promise flattens (JS: the returned promise's settlement
-     * becomes the async function's result), so it lowers exactly as
-     * `return await p` — the awaitExpr parks the fiber and re-throws
-     * rejections, which IS the flattening. Everything else flows into the
-     * function's return slot through the usual coercion path. */
+     * becomes the async function's result) through an adopting awaitExpr,
+     * which parks the fiber and re-throws rejections after the adoption's
+     * then-job turn. Everything else flows into the function's return slot
+     * through the usual coercion path. */
     /** The value of `return <expr>` against the context's declared return —
      * or NULL for a bare return: `return undefined`/`return null` in a
      * void-returning function (`{ bar() { return undefined } }`, inferred
@@ -7860,11 +7468,38 @@ export class Lowerer {
         if (expected.kind === "void" && e.kind === "unitLit")
             return null;
         if (this.ctx.isAsync && e.type.kind === "promise" && expected.kind !== "promise") {
-            const awaited = { kind: "awaitExpr", value: e, type: e.type.inner, loc: e.loc };
+            const awaited = this.returnedPromiseAwait(e);
             return this.coerceInto(node, awaited, expected);
         }
         return this.coerceInto(node, e, expected);
     }
+    /** Whether a promise returned here resolves the function's own promise
+     * by adoption (async functions; async generators await their return
+     * operand instead). */
+    adoptsReturnedPromise() {
+        return this.ctx.isAsync === true && !this.ctx.generator;
+    }
+    /** `return p` of a promise into a non-promise result `R` (a void result
+     * drops the settled value; widening keeps the adopting await the return's
+     * own value). */
+    adoptingReturn(e, R, coerce) {
+        const loc = e.loc;
+        if (R.kind !== "void")
+            return { kind: "return", value: coerce(this.returnedPromiseAwait(e)), loc };
+        const widened = e.type.kind === "promise" && e.type.inner.kind !== "void"
+            ? { kind: "promiseVoidWiden", value: e, type: { kind: "promise", inner: VOID }, loc }
+            : e;
+        return { kind: "return", value: this.returnedPromiseAwait(widened), loc };
+    }
+    /** The await a returned promise `e` lowers to: adopting in async
+     * functions (one then-job turn first, outside the function's handlers). */
+    returnedPromiseAwait(e) {
+        if (e.type.kind !== "promise")
+            throw new InternalCompilerError("returned-promise await of a non-promise");
+        if (!this.adoptsReturnedPromise())
+            return { kind: "awaitExpr", value: e, type: e.type.inner, loc: e.loc };
+        return { kind: "awaitExpr", value: e, type: e.type.inner, adopt: true, loc: e.loc };
+    }
     /** `return <expr>` lowered as a STATEMENT against the declared return.
      * Void-returning contexts get the JS drop: a contextually void-typed
      * function may return a value (`fv = function() { return 0; }` into a
@@ -7876,7 +7511,9 @@ export class Lowerer {
         if (expected.kind === "void") {
             let e = this.lowerExpr(node);
             if (this.ctx.isAsync && e.type.kind === "promise") {
-                e = { kind: "awaitExpr", value: e, type: e.type.inner, loc: e.loc };
+                if (this.adoptsReturnedPromise())
+                    return this.adoptingReturn(e, VOID, (x) => x);
+                e = this.returnedPromiseAwait(e);
             }
             if (e.kind === "unitLit")
                 return { kind: "return", value: null, loc };
@@ -7987,18 +7624,7 @@ export class Lowerer {
         }
         return { kind: "boolLit", value: true, type: BOOL, loc };
     }
-    /** The entry value of a binding JS initializes to `undefined` (an
-     * initializer-less declaration, a hoisted `var` before its statement):
-     * undefined-armed unions hold the interned undefined arm, and 'any'
-     * slots hold the ENGINE's undefined — tsc's definite-assignment
-     * analysis never guards `any` reads, so a jsval slot IS readable before
-     * any assignment and must never stay a C-level NULL (a validated exit
-     * or engine op on NULL is memory-unsafe, not a TypeError). Null for
-     * every other type: tsc rejects their pre-assignment reads. */
     unassignedSlotInit(type, loc) {
-        if (type.kind === "jsval") {
-            return { kind: "jsOp", op: "undefLit", args: [], type: JSVAL, loc };
-        }
         return this.wrappedUndefined(type, loc);
     }
     undefinedArgFor(type, loc, blame) {
@@ -8524,24 +8150,19 @@ export class Lowerer {
                     // identifier-param prologue's ternary), then destructure the
                     // picked value.
                     const abi = shape.type;
-                    if (abi.kind === "dyn" || abi.kind === "jsval") {
-                        // A DYNAMIC-TIER pattern source (`function f({} = a)` with
-                        // `a: any` — jsval for island values, dyn for the checked-
-                        // dynamic dyn): the slot holds its tier's undefined directly,
-                        // so the default test is the runtime undefined test — then
-                        // the pattern destructures the picked value.
+                    if (abi.kind === "dyn") {
+                        // The checked-value slot holds native undefined directly.
+                        // Test it at runtime, then destructure the selected value.
                         const dflt = defaultValue(decl.initializer, abi);
                         const src = this.declareHiddenLocal("%psrc", abi);
                         const inRef = () => ({ kind: "varRef", localId: slot.id, type: abi, loc });
-                        const isUndef = abi.kind === "jsval"
-                            ? {
-                                kind: "jsOp",
-                                op: "eq",
-                                args: [inRef(), { kind: "jsOp", op: "undefLit", args: [], type: JSVAL, loc }],
-                                type: BOOL,
-                                loc,
-                            }
-                            : { kind: "dynTest", test: "undefined", value: inRef(), type: BOOL, loc };
+                        const isUndef = {
+                            kind: "dynTest",
+                            test: "undefined",
+                            value: inRef(),
+                            type: BOOL,
+                            loc,
+                        };
                         prologue.push({
                             kind: "varDecl",
                             localId: src.id,
@@ -8641,24 +8262,20 @@ export class Lowerer {
             const name = decl.name.text;
             if (shape.mode === "omittable" && shape.bodyType && decl.initializer) {
                 const abi = shape.type;
-                if (abi.kind === "dyn" || abi.kind === "jsval") {
-                    // A DYNAMIC-TIER defaulted param (`function f(x = a)` with
-                    // `a: any` — jsval for island values, dyn for the checked-
-                    // dynamic dyn): the slot holds its tier's undefined directly —
-                    // the body local picks the default on the runtime test.
+                if (abi.kind === "dyn") {
+                    // The checked-value slot holds native undefined directly;
+                    // the body local selects the default with a runtime test.
                     const loc = locOf(decl);
                     const slot = this.declareHiddenLocal(name, abi);
                     params.push({ localId: slot.id, name, type: abi });
                     const inRef = () => ({ kind: "varRef", localId: slot.id, type: abi, loc });
-                    const isUndef = abi.kind === "jsval"
-                        ? {
-                            kind: "jsOp",
-                            op: "eq",
-                            args: [inRef(), { kind: "jsOp", op: "undefLit", args: [], type: JSVAL, loc }],
-                            type: BOOL,
-                            loc,
-                        }
-                        : { kind: "dynTest", test: "undefined", value: inRef(), type: BOOL, loc };
+                    const isUndef = {
+                        kind: "dynTest",
+                        test: "undefined",
+                        value: inRef(),
+                        type: BOOL,
+                        loc,
+                    };
                     const dflt = defaultValue(decl.initializer, abi);
                     const body = this.declareLocal(decl.name, name, abi, true);
                     prologue.push({
@@ -8841,13 +8458,6 @@ export class Lowerer {
     resolveThis() {
         return this.resolveKey(undefined);
     }
-    /** READ-ONLY twin of resolveLocal for PROBES (isIslandExpr): answers
-     * the nearest binding entry without boxing, threading, or predeclaring.
-     * resolveKey mutates capture state as a side effect, and a speculative
-     * island-ness query through a context that takes no captures (a plain
-     * declared function between the origin and the reference) was an ICE —
-     * the REAL lowering path still resolves (and diagnoses) the reference
-     * itself. */
     peekLocal(ident) {
         let symbol = this.checker.getSymbolAtLocation(ident);
         if (ident.parent &&
@@ -9015,79 +8625,6 @@ export class Lowerer {
             allowDynObject ||=
                 srcType.kind === "dyn" && isParseArgsDynCheckerType(this, this.typeOf(pattern));
         }
-        // An ISLAND source (`const { readFileSync } = await import("fs")` —
-        // a namespace handle, or any 'any'-typed object): each bound name is
-        // an engine property read, mirroring the island property-read rule —
-        // a member the .d.ts declares as a primitive exits eagerly to the
-        // static type; everything else (including members whose declared
-        // types have no static mapping, like @types/node's function types)
-        // stays a HANDLE, and its use sites dispatch to engine ops. Patterns
-        // the element-wise walk cannot spell — ARRAY patterns (the iterator
-        // protocol), empty patterns (the coercion checks), holes, rest,
-        // defaults — run the REAL pattern in a synthesized engine function
-        // instead (lowerJsvalBindingPattern).
-        const elementWise = srcType.kind === "jsval" &&
-            ts.isObjectBindingPattern(pattern) &&
-            pattern.elements.length > 0 &&
-            pattern.elements.every((el) => !el.dotDotDotToken &&
-                !el.initializer &&
-                el.name !== undefined &&
-                ts.isIdentifier(el.propertyName ?? el.name));
-        if (srcType.kind === "jsval" && !elementWise) {
-            if (lowerJsvalBindingPattern(this, pattern, srcRef, isLet, out))
-                return;
-            // No engine form (computed keys, untransportable defaults): fall
-            // through to the static fences below.
-        }
-        if (srcType.kind === "jsval" && ts.isObjectBindingPattern(pattern)) {
-            for (const el of pattern.elements) {
-                this.checkBindingElement(el);
-                // 7's BindingElement declares name optional (array elisions are
-                // nameless there); object-pattern elements always carry one.
-                if (el.name === undefined)
-                    continue;
-                const prop = el.propertyName ?? el.name;
-                if (!ts.isIdentifier(prop)) {
-                    this.unsupported("SC1031", el, "destructuring with computed or non-identifier keys");
-                }
-                const loc = locOf(el);
-                const read = {
-                    kind: "jsOp",
-                    op: "getProp",
-                    name: prop.text,
-                    args: [srcRef()],
-                    type: JSVAL,
-                    loc,
-                };
-                if (!ts.isIdentifier(el.name)) {
-                    // A nested pattern reads through its own handle temp.
-                    const tmp = this.declareHiddenLocal("%destr", JSVAL);
-                    out.push({ kind: "varDecl", localId: tmp.id, init: read, loc });
-                    this.lowerBindingPattern(el.name, () => ({ kind: "varRef", localId: tmp.id, type: JSVAL, loc }), JSVAL, isLet, out);
-                    continue;
-                }
-                const declared = this.mapTypeOf(this.typeOf(el.name));
-                const primitive = declared &&
-                    (declared.kind === "f64" || declared.kind === "bool" || declared.kind === "string");
-                const value = primitive
-                    ? { kind: "jsExit", value: read, type: declared, loc }
-                    : read;
-                const symbol = this.checker.getSymbolAtLocation(el.name);
-                const g = symbol ? this.globalsBySymbol.get(symbol) : undefined;
-                if (g) {
-                    out.push({
-                        kind: "assign",
-                        localId: g.id,
-                        value: this.coerceInto(el.name, value, g.type),
-                        loc,
-                    });
-                    continue;
-                }
-                const local = this.declareLocal(el.name, el.name.text, value.type, isLet);
-                out.push({ kind: "varDecl", localId: local.id, init: value, loc });
-            }
-            return;
-        }
         return lowerBindingPattern(this, pattern, srcRef, srcType, isLet, out, dynSpell, allowDynObject);
     }
     checkBindingElement(el, allowDefault = false) {
@@ -9100,97 +8637,6 @@ export class Lowerer {
         return lowerVarDeclList(this, list);
     }
     lowerVarDecl(decl, isLet) {
-        // ISLAND-HANDLE rescue (--dynamic): `const factory = (await
-        // import("./x.mjs")).default` / `const buf = islandReadFileSync(p)` —
-        // a binding whose DECLARED type either has no static mapping or has
-        // one no island value can EXIT to (bytes, functions, promises), but
-        // whose initializer is an island value. The declared type is a .d.ts
-        // surface over an engine value; the binding stays a HANDLE (jsval
-        // local) and typed use sites go through engine ops and validated
-        // exits like any island value. Exit-CAPABLE declared types (numbers,
-        // strings, JSON-safe composites, their undefined-armed unions) keep
-        // the standard path and its validated-exit machinery; so does
-        // everything non-island — including badType here when the
-        // initializer turns out not to be island-typed, which is exactly
-        // what the standard path would have reported.
-        // Only reference-shaped initializers are candidates (awaits, calls,
-        // member reads, identifiers, casts/parens over those): they are the
-        // island producers, and re-lowering one on the fall-through emits
-        // nothing twice — a lambda or literal initializer would (each
-        // lowering mints a fresh %fn), and is never an island value anyway.
-        const islandCandidate = (e) => {
-            let cur = e;
-            while (ts.isParenthesizedExpression(cur) ||
-                ts.isAsExpression(cur) ||
-                ts.isTypeAssertion(cur) ||
-                ts.isNonNullExpression(cur)) {
-                cur = cur.expression;
-            }
-            if (!ts.isAwaitExpression(cur) &&
-                !ts.isCallExpression(cur) &&
-                !ts.isPropertyAccessExpression(cur) &&
-                !ts.isElementAccessExpression(cur) &&
-                !ts.isIdentifier(cur)) {
-                return false;
-            }
-            // A lambda ANYWHERE inside (a call argument) would emit its %fn
-            // twice across the fall-through's re-lowering — skip those.
-            let lambda = false;
-            const scan = (n) => {
-                if (lambda)
-                    return;
-                if (ts.isArrowFunction(n) || ts.isFunctionExpression(n)) {
-                    lambda = true;
-                    return;
-                }
-                ts.forEachChild(n, scan);
-            };
-            scan(cur);
-            return !lambda;
-        };
-        if (this.dynamic &&
-            ts.isIdentifier(decl.name) &&
-            decl.initializer !== undefined &&
-            // `var` stays out: the rescue's block-positioned jsval local can't
-            // model the function-scoped hoisted binding (a redeclaration or an
-            // out-of-block read would split the variable in two) — vars take the
-            // standard path and its own fences.
-            (ts.getCombinedNodeFlags(decl) & ts.NodeFlags.BlockScoped) !== 0 &&
-            islandCandidate(decl.initializer) &&
-            // createRequire's plumbing decls are COMPILE-TIME erasures (the
-            // require binding and its builtin-namespace bindings) — never
-            // island values; the standard path's skips own them.
-            !createRequireBindingDecl(this, decl.name, decl.initializer) &&
-            !createRequireNamespaceDecl(this, decl.name, decl.initializer)) {
-            const mapped = this.mapTypeOf(this.typeOf(decl.name));
-            const handleOnly = mapped === null ||
-                (mapped.kind !== "jsval" &&
-                    mapped.kind !== "void" &&
-                    !canExitIslandToType(mapped, (id) => this.shapes.get(id), (id) => this.unions.get(id)));
-            const symbol = this.checker.getSymbolAtLocation(decl.name);
-            if (handleOnly && (!symbol || !this.globalsBySymbol.has(symbol))) {
-                const init = this.lowerExpr(decl.initializer);
-                if (init.type.kind === "jsval") {
-                    const local = this.declareLocal(decl.name, decl.name.text, JSVAL, isLet);
-                    return { kind: "varDecl", localId: local.id, init, loc: locOf(decl) };
-                }
-                // The CHECKED-DYNAMIC twin of the handle rescue (the runtime-world
-                // local rule): an unmappable declared type over a dyn initializer
-                // (`const first = plugins[0]` — the checker spells 'string |
-                // object' while the read is a dyn keyed read) keeps the binding
-                // dyn; typed use sites ride validated extractions and the routed
-                // engine ops, exactly the JSON.parse-binding story.
-                if (mapped === null && init.type.kind === "dyn") {
-                    const local = this.declareLocal(decl.name, decl.name.text, DYN, isLet);
-                    return { kind: "varDecl", localId: local.id, init, loc: locOf(decl) };
-                }
-                if (mapped === null)
-                    this.badType(decl.name, this.typeOf(decl.name));
-                // A mappable declared type with a non-island initializer: the
-                // standard path owns it (the initializer lowered clean; re-running
-                // it re-produces the same IR with no duplicate diagnostics).
-            }
-        }
         return lowerVarDecl(this, decl, isLet);
     }
     lowerSwitch(stmt) {
@@ -9252,13 +8698,6 @@ export class Lowerer {
     nodeTypesOnlySymbol(sym) {
         return nodeTypesOnlySymbol(this, sym);
     }
-    /** True for an npm package's shipped declaration files — under
-     * node_modules but NOT the standard library (typescript's own lib files
-     * live under node_modules too), or inside a registered workspace-linked
-     * package (a node_modules symlink whose realpath'd files carry no
-     * node_modules segment — workspace-registry.ts). The provenance half of the npm
-     * typing rule (package types are island handles) and of the per-package
-     * requires-dynamic attribution. */
     isNpmFile = (sf) => sf.isDeclarationFile &&
         (sf.fileName.includes("/node_modules/") || workspacePackageOfPath(sf.fileName) !== null) &&
         !this.isStdlibFile(sf);
@@ -9372,40 +8811,6 @@ export class Lowerer {
         return lowerTemplate(this, expr);
     }
     lowerAsExpression(expr) {
-        // ISLAND value cast to a PROMISE type (`factory(opts) as Promise<Mod>`
-        // — the Node-typed async-API shape): promises never have a validated
-        // exit, so instead of refusing the build the cast DEFERS the failure
-        // to runtime — island.castFail evaluates the value (its side effects
-        // are real) and throws a catchable TypeError naming the target, so
-        // typed-but-never-executed code (a wasm decode path behind a
-        // rejecting import) still compiles and a reached cast fails loudly at
-        // the exact site. Claimed only when the source is island-typed by the
-        // checker (jsval, or a promise whose inner is a handle); a source
-        // that lowers to a real static promise keeps erasure — the standard
-        // path's rule for non-island inners. Static builds keep their
-        // per-site diagnostics.
-        if (this.dynamic) {
-            const srcMapped = this.mapTypeOf(this.typeOf(expr.expression));
-            const island = srcMapped?.kind === "jsval" ||
-                (srcMapped?.kind === "promise" && srcMapped.inner.kind === "jsval");
-            if (island) {
-                const targetTs = this.checker.getTypeFromTypeNode(expr.type);
-                const target = this.mapTypeOf(targetTs);
-                if (target?.kind === "promise") {
-                    const inner = this.lowerExpr(expr.expression);
-                    if (inner.type.kind !== "jsval")
-                        return inner; // static promise: erasure
-                    const loc = locOf(expr);
-                    const name = {
-                        kind: "strLit",
-                        value: this.fmt(target),
-                        type: STRING,
-                        loc,
-                    };
-                    return { kind: "libCall", fn: "island.castFail", args: [inner, name], type: target, loc };
-                }
-            }
-        }
         return lowerAsExpression(this, expr);
     }
     lowerPrefixUnary(expr) {
@@ -9537,8 +8942,6 @@ export class Lowerer {
         }
     }
     lowerCall(expr) {
-        // Ambient fetch (native in static builds, island-backed under
-        // --dynamic) and dynamic import() claim their calls before the general
         // dispatch. The general identifier-call paths have no lowering for a
         // promise-returning ambient global, and `import` is a keyword callee no
         // identifier path matches.
@@ -9677,37 +9080,11 @@ export class Lowerer {
         return inheritsBuiltinEmitterCtor(this, info);
     }
     lowerNew(expr) {
-        // `new Uint8Array(handle)` (and the other typed-array ctors) over an
-        // ISLAND argument: the construction is an ENGINE operation — the
-        // engine's own constructor over the engine's own value (an Emscripten
-        // factory's `wasmBinary: new Uint8Array(buf)` where buf came off an
-        // island readFileSync) — and the instance stays a handle. The static
-        // bytes ctor cannot claim it (bytes never cross the boundary), so
-        // this preempts only when the single argument is island-typed;
-        // every static form keeps the standard path.
-        if (this.dynamic &&
-            ts.isIdentifier(expr.expression) &&
-            expr.arguments?.length === 1 &&
-            !ts.isSpreadElement(expr.arguments[0]) &&
-            /^(Uint8|Uint8Clamped|Int8|Uint16|Int16|Uint32|Int32|Float32|Float64|BigInt64|BigUint64)Array$/.test(expr.expression.text) &&
-            this.isStdlibSymbol(this.resolveValueSymbol(expr.expression) ?? undefined) &&
-            this.isIslandExpr(expr.arguments[0])) {
-            const loc = locOf(expr);
-            const ctor = {
-                kind: "jsOp",
-                op: "globalGet",
-                name: expr.expression.text,
-                args: [],
-                type: JSVAL,
-                loc,
-            };
-            const arg = this.lowerExpr(expr.arguments[0]);
-            return { kind: "jsOp", op: "construct", args: [ctor, arg], type: JSVAL, loc };
-        }
         const builtin = lowerAbortControllerNew(this, expr) ??
             lowerFetchWebNew(this, expr) ??
             lowerResponseNew(this, expr) ??
-            lowerStaticReadableStreamNew(this, expr);
+            lowerStaticReadableStreamNew(this, expr) ??
+            lowerConsoleNew(this, expr);
         return (builtin ?? this.withRuntimeOptionalClassValue(expr.expression, () => lowerNew(this, expr)));
     }
     lowerFieldRead(expr) {
@@ -10343,18 +9720,17 @@ export class Lowerer {
     lowerNumberStaticProperty(expr) {
         return lowerNumberStaticProperty(this, expr);
     }
-    /* ── the island-backed ambient surface (ISLAND_SURFACE) ───────────── */
-    requireDynamicApi(feature, node, hint) {
-        return requireDynamicApi(this, feature, node, hint);
+    refuseUnsupportedApi(feature, node, hint) {
+        return refuseUnsupportedApi(this, feature, node, hint);
     }
     lowerMathProperty(expr) {
         return lowerMathProperty(this, expr);
     }
-    islandGlobalFnOf(ident) {
-        return islandGlobalFnOf(this, ident);
+    stdlibGlobalFnOf(ident) {
+        return stdlibGlobalFnOf(this, ident);
     }
-    lowerIslandMethodCall(call, access) {
-        return lowerIslandMethodCall(this, call, access);
+    lowerStdlibMethodCall(call, access) {
+        return lowerStdlibMethodCall(this, call, access);
     }
 }
 //# sourceMappingURL=lowerer.js.map