@scriptc/compiler 0.2.9 → 0.3.0

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

@@ -13,8 +13,8 @@ import { bindingSource } from "../binding-source.js";
 import { arrayValueRead, arrayValueStore, arrayValueType, unionArrayValueRead, lowerSafeIndexRead, } from "./array-values.js";
 import { lowerForAwaitGenerator, lowerForOfGenerator, lowerYieldStarStatement, } from "./lower-generators.js";
 import { lowerForAwaitBuiltin } from "./lower-async-iteration.js";
-import { BOOL, BYTES_U8, CAUGHT, DYN, F64, JSVAL, STRING, UNDEFINED_T, VOID, arrayOf, isDynTypedRefType, isUnitType, shapeHasAccessorSlots, typeEquals, } from "../../ir/ir.js";
-import { PoisonError, boundIdentifiersOf, dynFallbackType, importCallHandleType, neverTaintedJsType, staticImportNamespaceType, stmtUsesIsland, uncheckedOverloadHandleCall, } from "./lowerer.js";
+import { BOOL, BYTES_U8, CAUGHT, DYN, F64, STRING, UNDEFINED_T, VOID, arrayOf, isDynTypedRefType, isUnitType, shapeHasAccessorSlots, typeEquals, } from "../../ir/ir.js";
+import { PoisonError, boundIdentifiersOf, dynFallbackType, neverTaintedJsType, staticImportNamespaceType, } from "./lowerer.js";
 import { enforceLibBoundary, lowerSurplusCalls } from "./lib-boundary.js";
 import { cjsExportAssignmentOf, cjsExportDiscardReason, cjsExportTargetLiteral, isCjsJsFile, isEsModuleStamp, isJsSourceFile, isNodeEsmFile, locOf, requireSpecOf, } from "../program.js";
 import { COMPOUND_ASSIGN_OPS, STR_METHODS, UNSUPPORTED_STMT, isStdlibMember, sideEffectFreeOptionValue, stdlibGlobalAliasDecl, stdlibGlobalAliasNameOf, stdlibGlobalNameOf, } from "./surfaces.js";
@@ -51,7 +51,7 @@ import { lowerEnvironmentKey, lowerNativeFunctionAssignment } from "./lower-expr
 import { isNativeProxyInitializer } from "./expressions/native-proxy.js";
 import { tryLowerExpression } from "./expressions/try-lower-expression.js";
 import { lowerUnionFieldWrite } from "./expressions/union-fields.js";
-import { UNSUPPORTED, checkerPanicDiag, isCheckerPanic, requiresDynamicDiag, } from "../../diagnostics/diagnostic.js";
+import { UNSUPPORTED, checkerPanicDiag, isCheckerPanic, unsupportedNativeExecutionDiag, } from "../../diagnostics/diagnostic.js";
 import { isParseArgsDynTypeName, isUnitOnlyTsType, jsOpenObjectType, unitOnlyUnion, } from "../type-mapper.js";
 import { canonicalBuiltinModule } from "../builtin-modules.js";
 import { isRelativeSpecifier } from "../workspace-registry.js";
@@ -489,15 +489,6 @@ export function lowerStmts(lowerer, stmts) {
                     if (!appended)
                         out.push(...rewritten);
                 }
-                // Island accounting (--dynamic coverage): a statement that lowered
-                // but carries island constructs compiles DYNAMICALLY — its work
-                // runs in the embedded engine, and the report says so instead of
-                // counting it as static.
-                if (!lowerer.suppressStats && lowered && stmtUsesIsland(lowered)) {
-                    lowerer.stats.statementsIsland++;
-                    if (sf !== undefined)
-                        lowerer.bumpFileStat(sf.fileName, "island");
-                }
                 // A JS statement that lowered CLEAN can still have flushed
                 // DEFERRED collection diagnostics (a symbol lookup on an alias
                 // resolves through flushDeferred — informational here, not a
@@ -573,16 +564,6 @@ export function lowerStmts(lowerer, stmts) {
     }
     return out;
 }
-/** The TDZ kinds: pointer-backed representations, where the box's empty
- * NULL slot IS the not-yet-initialized sentinel — plus the scalars
- * (f64/bool), whose TDZ boxes store a one-element ARRAY cell so the
- * empty-slot sentinel still works (a scalar slot has no spare state:
- * every bit pattern is a legal value — the setTimeout-handle shape,
- * `clearTimeout(timer)` captured above `const timer = setTimeout(...)`).
- * Checked-dynamic values use ref boxes with their own retain/release;
- * a NULL payload remains distinct from the allocated undefined value.
- * caught/jsval keep their existing capture fences. Unit-only types
- * never carry a useful forward capture. */
 const TDZ_KINDS = new Set([
     "func",
     "string",
@@ -812,22 +793,7 @@ function varBindingType(lowerer, nameNode) {
     }
     if (!type)
         type = dynFallbackType(lowerer, nameNode, lowerer.typeOf(nameNode));
-    // `var p = import("./m")` in a function body: the hoisted slot holds
-    // the island promise/handle — the import expression's only production
-    // (lowerVarDecl's rule for block-scoped bindings).
-    if (lowerer.dynamic &&
-        ts.isVariableDeclaration(nameNode.parent) &&
-        nameNode.parent.name === nameNode) {
-        type =
-            importCallHandleType(nameNode.parent.initializer) ??
-                // An unchecked-overload call result stores the handle, exactly the
-                // let/const rule (see uncheckedOverloadHandleCall).
-                (uncheckedOverloadHandleCall(lowerer, nameNode.parent.initializer) ? JSVAL : null) ??
-                type;
-    }
-    if (!lowerer.dynamic &&
-        ts.isVariableDeclaration(nameNode.parent) &&
-        nameNode.parent.name === nameNode) {
+    if (ts.isVariableDeclaration(nameNode.parent) && nameNode.parent.name === nameNode) {
         type = staticImportNamespaceType(lowerer, nameNode.parent.initializer) ?? type;
     }
     if (!type || type.kind === "void")
@@ -885,7 +851,6 @@ function hoistVarBinding(lowerer, symbol, nameNode) {
     lowerer.ctx.scopes[0].set(symbol, local);
     // A checked-dynamic slot holds the dyn undefined (a NULL dyn is a
     // trap); everything else rides unassignedSlotInit (interned union arm,
-    // engine undefined for jsval).
     const wrapped = type.kind === "dyn"
         ? dynUndefinedExpr(locOf(nameNode))
         : lowerer.unassignedSlotInit(type, locOf(nameNode));
@@ -933,10 +898,8 @@ export function predeclareForwardVar(lowerer, symbol) {
     const ctx = owner.ctx;
     if (ctx.hoistedVars.has(symbol))
         return false; // would have resolved
-    // Only a slot that can hold `undefined` can carry the pre-
-    // initialization reads: an undefined-armed union (the interned arm),
-    // a checked-dynamic binding (the dyn undefined), or a jsval 'any'
-    // binding (the engine's undefined).
+    // Only a slot that can hold `undefined` can carry pre-initialization
+    // reads: an undefined-armed union or a native checked-value binding.
     const type = varBindingType(lowerer, nameNode);
     if (!type)
         return false;
@@ -1562,19 +1525,12 @@ export function lowerDestructuringDecl(lowerer, decl, isLet) {
         lowerer.lowerExpr(decl.initializer);
     const parseArgsDynObject = init.type.kind === "dyn" &&
         isParseArgsDynCheckerType(lowerer, lowerer.typeOf(decl.initializer));
-    // A TS `any`-origin source whose lowered value is NOT a destructurable
-    // shape (`var { x } = <any>0` — the cast erases to the f64; a dyn
-    // value — the checked-dynamic tree has no destructure): JS reads the properties off
-    // whatever the value is (a number answers undefined) — engine
-    // semantics, the dynamic-family fence. Record and array sources fall
-    // through to their lowerings, island handles to theirs (--dynamic
-    // owns this construct), and JS files keep their per-site runtime
-    // fences unchanged.
+    // An `any`-origin source needs a represented record or array shape for
+    // destructuring. JS files retain their per-site runtime fences.
     if (lowerer.anyOrigin(decl.initializer) &&
         !isJsSourceFile(decl.getSourceFile()) &&
         init.type.kind !== "record" &&
-        init.type.kind !== "array" &&
-        init.type.kind !== "jsval") {
+        init.type.kind !== "array") {
         lowerer.anyOpFence("destructuring", decl);
     }
     // An IR-string source the CHECKER does not type as a string is a
@@ -1591,36 +1547,19 @@ export function lowerDestructuringDecl(lowerer, decl, isLet) {
             ? `array destructuring of non-array values (the source is '${lowerer.checker.typeToString(lowerer.typeOf(decl.initializer))}'-typed)`
             : `object destructuring of non-record values (the source is '${lowerer.checker.typeToString(lowerer.typeOf(decl.initializer))}'-typed)`);
     }
-    // PRIMITIVE and unit sources (`let { toString } = 1`, `const [c] =
-    // "xy"`, `var [] = null`): JS destructures any value by reading
-    // through its wrapper object — prototype members included — or throws
-    // its TypeError on null/undefined; both live in the engine. When the
-    // pattern has an engine form, --dynamic marshals the value in and
-    // runs the REAL pattern (lowerJsvalBindingPattern); a static build
-    // reports the dynamic-family choice instead of the dead-end type
-    // recitation. STRING sources whose pattern the static path claims
-    // whole (staticStringPattern — code-point positions, `length`
-    // bindings) skip the gate in STATIC builds: lowerBindingPattern's
-    // string branches are exact there, and the diagnostic would report a
-    // dynamic-engine dependency the program does not have. --dynamic
-    // keeps the engine route for every string pattern — the engine binds
-    // undefined past the last code point where the static chars array
-    // inherits the array divergence's trap.
+    // Primitive destructuring requires JS wrapper coercion. Only string
+    // patterns fully handled by staticStringPattern have native lowering.
     if ((init.type.kind === "f64" ||
         init.type.kind === "bool" ||
         init.type.kind === "string" ||
         isUnitType(init.type)) &&
         !isJsSourceFile(decl.getSourceFile()) &&
-        !(!lowerer.dynamic &&
-            init.type.kind === "string" &&
-            staticStringPattern(lowerer, decl.name)) &&
-        enginePatternSpec(lowerer, decl.name) !==
-            null) {
-        if (!lowerer.dynamic) {
-            lowerer.pushDiag(requiresDynamicDiag(`destructuring '${lowerer.fmt(init.type)}' values (the engine reads through JS's wrapper coercion)`, locOf(decl)));
+        !(init.type.kind === "string" &&
+            staticStringPattern(lowerer, decl.name))) {
+        {
+            lowerer.pushDiag(unsupportedNativeExecutionDiag(`destructuring '${lowerer.fmt(init.type)}' values through JavaScript wrapper coercion`, locOf(decl)));
             throw new PoisonError();
         }
-        init = lowerer.coerceToExpected(init, JSVAL);
     }
     const out = [];
     // JS: a union source with exactly ONE destructurable arm beside unit
@@ -2513,13 +2452,6 @@ function patternBindingType(lowerer, name) {
     return (lowerer.mapTypeOf(type) ??
         (isJsSourceFile(name.getSourceFile()) ? dynFallbackType(lowerer, name, type) : null));
 }
-/** The STATIC property name of a destructuring key: identifiers spell
- * themselves, string/numeric-literal keys and COMPUTED keys fold through
- * foldedStringKeyOf — pure single-name expressions only (`{ [k]: v }`
- * where k's checker type spells one property name; tsc late-bound the
- * source's field under exactly that name, and pure keys make skipping
- * the evaluation exact). Null for runtime-valued keys — the callers
- * fence, or route island sources to the engine pattern. */
 function patternKeyNameOf(lowerer, prop) {
     if (ts.isIdentifier(prop) || ts.isPrivateIdentifier(prop))
         return prop.text;
@@ -2576,16 +2508,6 @@ function checkerStringSource(lowerer, e) {
     };
     return stringLike(lowerer.typeOf(e));
 }
-/** True when a pattern over a STRING source lowers statically whole —
- * every element a form the chars-array/wrapper-read desugars carry.
- * Array patterns take positions, holes, defaults, rest (a nested rest
- * pattern must be an ARRAY pattern — it destructures the packed
- * string[]), and nested patterns, whose elements are single code
- * points and recurse through this same test. Object patterns take
- * `length` bindings — shorthand, renamed, or (dead-)defaulted.
- * Anything else — wrapper methods, computed keys, rest over the
- * wrapper — keeps the engine gate (--dynamic runs the real pattern;
- * a static build reports the dynamic-family choice). */
 function staticStringPattern(lowerer, pattern) {
     if (ts.isArrayBindingPattern(pattern)) {
         return pattern.elements.every((el) => {
@@ -3190,373 +3112,14 @@ function classInstanceRestValue(lowerer, blame, srcRef, srcType, info, consumed,
     });
     return { kind: "recordLit", fields, type: restT, loc };
 }
-/** The fences the island's element-wise object path shares: no rest
- * (surplus packing over a handle) and no defaults (an engine undefined
- * test) — the static positions now take both through their own
- * machinery above. */
 export function checkBindingElement(lowerer, el, allowDefault = false) {
     if (el.dotDotDotToken) {
-        lowerer.unsupported("SC1031", el, "rest elements in destructuring patterns over island sources");
+        lowerer.unsupported("SC1031", el, "rest elements in destructuring patterns over checked-value sources");
     }
     if (el.initializer && !allowDefault) {
-        lowerer.unsupported("SC1031", el, "defaults in destructuring positions over island sources");
+        lowerer.unsupported("SC1031", el, "defaults in destructuring positions over checked-value sources");
     }
 }
-/** The JS source text for a pattern default the ENGINE can evaluate —
- * side-effect-free literal data whose value cannot depend on compiled
- * scope: numeric/string/boolean/null literals (unary minus included),
- * provably-undefined expressions, and array/object literals of those.
- * Null for everything else (a default referencing compiled bindings or
- * calling functions has no honest engine form). */
-function transportableDefaultText(lowerer, e) {
-    while (ts.isParenthesizedExpression(e))
-        e = e.expression;
-    if (ts.isNumericLiteral(e))
-        return e.text;
-    if (ts.isPrefixUnaryExpression(e) &&
-        e.operator === ts.SyntaxKind.MinusToken &&
-        ts.isNumericLiteral(e.operand)) {
-        return `-${e.operand.text}`;
-    }
-    if (ts.isStringLiteral(e) || ts.isNoSubstitutionTemplateLiteral(e))
-        return JSON.stringify(e.text);
-    if (e.kind === ts.SyntaxKind.TrueKeyword)
-        return "true";
-    if (e.kind === ts.SyntaxKind.FalseKeyword)
-        return "false";
-    if (e.kind === ts.SyntaxKind.NullKeyword)
-        return "null";
-    // Any pure identifier whose CHECKER type is the undefined type holds
-    // undefined (shadowing included — a value of type undefined is
-    // undefined).
-    if (ts.isIdentifier(e) && (lowerer.typeOf(e).flags & ts.TypeFlags.Undefined) !== 0)
-        return "(void 0)";
-    if (ts.isArrayLiteralExpression(e)) {
-        const parts = [];
-        for (const elem of e.elements) {
-            if (ts.isOmittedExpression(elem)) {
-                parts.push("");
-                continue;
-            }
-            const t = transportableDefaultText(lowerer, elem);
-            if (t === null)
-                return null;
-            parts.push(t);
-        }
-        return `[${parts.join(",")}]`;
-    }
-    if (ts.isObjectLiteralExpression(e)) {
-        const parts = [];
-        for (const prop of e.properties) {
-            if (!ts.isPropertyAssignment(prop))
-                return null;
-            let key;
-            if (ts.isIdentifier(prop.name) ||
-                ts.isStringLiteral(prop.name) ||
-                ts.isNumericLiteral(prop.name)) {
-                key = JSON.stringify(prop.name.text);
-            }
-            else {
-                return null;
-            }
-            const t = transportableDefaultText(lowerer, prop.initializer);
-            if (t === null)
-                return null;
-            parts.push(`[${key}]:${t}`);
-        }
-        return `{${parts.join(",")}}`;
-    }
-    return null;
-}
-/** A declaration pattern rebuilt as ENGINE source with every bound name
- * renamed __0..__n (pattern order): holes, nesting, rest, and
- * transportable defaults all survive verbatim, so the engine runs the
- * REAL pattern — the iterator protocol on array patterns,
- * RequireObjectCoercible on object patterns, JS's own default rule.
- * Null when any element has no engine form (computed keys — a compiled
- * expression the pattern text cannot carry — or untransportable
- * defaults). */
-function enginePatternSpec(lowerer, pattern) {
-    const binds = [];
-    const extras = [];
-    // Every name the pattern itself binds, by text: a default referencing
-    // one is JS's earlier-element-in-scope (or TDZ) rule, which the
-    // pre-evaluated extras below cannot honor — those defaults have no
-    // engine form here.
-    const ownNames = new Set();
-    const collectOwn = (p) => {
-        for (const el of p.elements) {
-            if (ts.isOmittedExpression(el) || el.name === undefined)
-                continue;
-            if (ts.isIdentifier(el.name))
-                ownNames.add(el.name.text);
-            else
-                collectOwn(el.name);
-        }
-    };
-    collectOwn(pattern);
-    // A key or default with no literal engine text but a COMPILED-SCOPE
-    // form the engine can run exactly:
-    // - a plain identifier the pattern does not itself bind (`{ p: {} =
-    //   a } = a` with `a: any`) passes in as an extra parameter —
-    //   pre-evaluation of a bare variable read is unobservable (no side
-    //   effects, and the engine call is atomic);
-    // - an identifier bound by an EARLIER element of this pattern spells
-    //   its own temp (`[{ ...a }, b = a]` — the engine's mid-pattern
-    //   scope IS JS's, so the reference reads the just-bound value);
-    //   same-element and later names have no honest form (TDZ vs the
-    //   temps' var-undefined) and bail;
-    // - a CALL of such an identifier over transportable arguments
-    //   (`{ [order(1)]: x } = order(0)` — the evaluation-order corpus)
-    //   spells the call itself, so the engine runs it at exactly JS's
-    //   pattern position: keys in pattern order, defaults lazily. The
-    //   callee marshals through the host-function trampoline.
-    // `boundBefore` is the bind count when the current element's key/
-    // default began — the earlier-element boundary.
-    const tempIndexOf = (name, boundBefore) => {
-        for (let i = 0; i < boundBefore; i++) {
-            if (binds[i].text === name)
-                return i;
-        }
-        return -1;
-    };
-    const exprText = (init, boundBefore) => {
-        const t = transportableDefaultText(lowerer, init);
-        if (t !== null)
-            return t;
-        let e = init;
-        while (ts.isParenthesizedExpression(e))
-            e = e.expression;
-        if (ts.isIdentifier(e)) {
-            if (ownNames.has(e.text)) {
-                const idx = tempIndexOf(e.text, boundBefore);
-                return idx >= 0 ? `__${idx}` : null;
-            }
-            extras.push(e);
-            return `__d${extras.length - 1}`;
-        }
-        if (ts.isCallExpression(e) &&
-            !e.questionDotToken &&
-            ts.isIdentifier(e.expression) &&
-            e.typeArguments === undefined) {
-            const callee = exprText(e.expression, boundBefore);
-            if (callee === null)
-                return null;
-            const args = [];
-            for (const a of e.arguments) {
-                if (ts.isSpreadElement(a))
-                    return null;
-                const at = exprText(a, boundBefore);
-                if (at === null)
-                    return null;
-                args.push(at);
-            }
-            return `${callee}(${args.join(",")})`;
-        }
-        return null;
-    };
-    const target = (name) => {
-        if (ts.isIdentifier(name)) {
-            binds.push(name);
-            return `__${binds.length - 1}`;
-        }
-        return build(name);
-    };
-    const build = (p) => {
-        if (ts.isArrayBindingPattern(p)) {
-            const parts = [];
-            for (const el of p.elements) {
-                if (ts.isOmittedExpression(el) || el.name === undefined) {
-                    parts.push("");
-                    continue;
-                }
-                const boundBefore = binds.length;
-                let sub = target(el.name);
-                if (sub === null)
-                    return null;
-                if (el.initializer) {
-                    const d = exprText(el.initializer, boundBefore);
-                    if (d === null)
-                        return null;
-                    sub = sub + `=${d}`;
-                }
-                parts.push(el.dotDotDotToken ? `...${sub}` : sub);
-            }
-            return `[${parts.join(",")}]`;
-        }
-        const parts = [];
-        for (const el of p.elements) {
-            if (el.name === undefined)
-                continue;
-            if (el.dotDotDotToken) {
-                const sub = target(el.name);
-                if (sub === null)
-                    return null;
-                parts.push(`...${sub}`);
-                continue;
-            }
-            const boundBefore = binds.length;
-            const prop = el.propertyName ?? el.name;
-            let key = null;
-            if (ts.isIdentifier(prop) || ts.isPrivateIdentifier(prop)) {
-                key = JSON.stringify(prop.text);
-            }
-            else if (ts.isStringLiteral(prop) ||
-                ts.isNumericLiteral(prop) ||
-                ts.isNoSubstitutionTemplateLiteral(prop)) {
-                key = JSON.stringify(prop.text);
-            }
-            else if (ts.isComputedPropertyName(prop)) {
-                // A computed key: a FOLDABLE one (pure single-name expression)
-                // spells its static name; anything else takes the transportable
-                // form — extras for compiled-scope identifiers, temps for
-                // earlier-bound names, calls run at exactly JS's key position
-                // (pattern order, before the element's read).
-                const folded = lowerer.foldedStringKeyOf(prop.expression);
-                key = folded !== null ? JSON.stringify(folded) : exprText(prop.expression, boundBefore);
-            }
-            if (key === null) {
-                return null; // an unfoldable computed key with no engine form
-            }
-            let sub = target(el.name);
-            if (sub === null)
-                return null;
-            if (el.initializer) {
-                const d = exprText(el.initializer, boundBefore);
-                if (d === null)
-                    return null;
-                sub = sub + `=${d}`;
-            }
-            parts.push(`[${key}]:${sub}`);
-        }
-        return `{${parts.join(",")}}`;
-    };
-    const text = build(pattern);
-    return text === null ? null : { text, binds, extras };
-}
-/** Declaration-position destructuring over an ISLAND source: the ENGINE
- * runs the real pattern — a synthesized strict-mode
- * `new Function("v", ...)` exactly like the assignment chain's
- * (lowerJsvalDestructuringChain) — and the extracted values bind the
- * declared names: a name whose declared type is a primitive exits
- * eagerly (the island property-read rule), everything else stays a
- * HANDLE whose use sites dispatch to engine ops. Holes, nesting, empty
- * patterns (the object coercion check and the array iterator get+close
- * both run — destructuring undefined throws Node's TypeError at Node's
- * exit), rest, and transportable defaults all ride. False when the
- * pattern has no engine form (the caller fences). */
-export function lowerJsvalBindingPattern(lowerer, pattern, srcRef, isLet, out) {
-    const spec = enginePatternSpec(lowerer, pattern);
-    if (!spec)
-        return false;
-    const loc = locOf(pattern);
-    const temps = spec.binds.map((_, i) => `__${i}`);
-    const body = `"use strict";` +
-        (temps.length > 0 ? `var ${temps.join(",")};` : "") +
-        `(${spec.text} = v);return [${temps.join(",")}];`;
-    // Compiled-scope defaults (enginePatternSpec's extras) enter the
-    // synthesized function as additional parameters __d0..__dn, their
-    // values evaluated here and marshaled across.
-    const paramNames = ["v", ...spec.extras.map((_, i) => `__d${i}`)];
-    const helper = {
-        kind: "jsOp",
-        op: "construct",
-        args: [
-            { kind: "jsOp", op: "globalGet", name: "Function", args: [], type: JSVAL, loc },
-            ...paramNames.map((p) => ({
-                kind: "jsMarshal",
-                value: { kind: "strLit", value: p, type: STRING, loc },
-                type: JSVAL,
-                loc,
-            })),
-            {
-                kind: "jsMarshal",
-                value: { kind: "strLit", value: body, type: STRING, loc },
-                type: JSVAL,
-                loc,
-            },
-        ],
-        type: JSVAL,
-        loc,
-    };
-    const extraArgs = spec.extras.map((e) => lowerer.jsvalIn(lowerer.lowerExpr(e), e));
-    const run = {
-        kind: "jsOp",
-        op: "callFn",
-        args: [helper, srcRef(), ...extraArgs],
-        type: JSVAL,
-        loc,
-    };
-    if (spec.binds.length === 0) {
-        out.push({ kind: "exprStmt", expr: run, loc });
-        return true;
-    }
-    const res = lowerer.declareHiddenLocal("%dres", JSVAL);
-    out.push({ kind: "varDecl", localId: res.id, init: run, loc });
-    spec.binds.forEach((name, i) => {
-        const bindLoc = locOf(name);
-        const read = {
-            kind: "jsOp",
-            op: "getIdx",
-            args: [
-                { kind: "varRef", localId: res.id, type: JSVAL, loc: bindLoc },
-                {
-                    kind: "jsMarshal",
-                    value: { kind: "numLit", value: i, type: F64, loc: bindLoc },
-                    type: JSVAL,
-                    loc: bindLoc,
-                },
-            ],
-            type: JSVAL,
-            loc: bindLoc,
-        };
-        // The island property-read stance: a name the checker declares as a
-        // primitive exits eagerly to the static type; everything else stays
-        // a handle.
-        const declared = lowerer.mapTypeOf(lowerer.typeOf(name));
-        const primitive = declared &&
-            (declared.kind === "f64" || declared.kind === "bool" || declared.kind === "string");
-        const value = primitive
-            ? { kind: "jsExit", value: read, type: declared, loc: bindLoc }
-            : read;
-        const symbol = lowerer.checker.getSymbolAtLocation(name);
-        const g = symbol ? lowerer.globalsBySymbol.get(symbol) : undefined;
-        if (g) {
-            out.push({
-                kind: "assign",
-                localId: g.id,
-                value: lowerer.coerceInto(name, value, g.type),
-                ...(g.tdz ? { initializes: true } : {}),
-                loc: bindLoc,
-            });
-            return;
-        }
-        if (symbol && hostVariableDeclarationOf(name) !== null && isVarDeclared(name)) {
-            const hoisted = hoistVarBinding(lowerer, symbol, name);
-            out.push({
-                kind: "assign",
-                localId: hoisted.id,
-                value: lowerer.coerceInto(name, value, hoisted.type),
-                loc: bindLoc,
-            });
-            return;
-        }
-        const local = lowerer.declareLocal(name, name.text, value.type, isLet);
-        out.push({ kind: "varDecl", localId: local.id, init: value, loc: bindLoc });
-    });
-    return true;
-}
-/** Binds one destructured name to its value — the identifier tail of
- * lowerVarDecl (module-global assignment for pre-registered file-scope
- * names, declareLocal otherwise), or a nested pattern through its own
- * hidden temp. */
-/** An island-world ('any'-flavored) checker spelling: bare jsval or an
- * array of jsvals (`(string | object)[]` absorbed by its jsval arm) —
- * the shapes the runtime-world local rule keeps DYN when the value
- * lowered checked-dynamic. */
-function jsvalFlavoredType(t) {
-    return t.kind === "jsval" || (t.kind === "array" && t.elem.kind === "jsval");
-}
 export function bindPatternTarget(lowerer, name, value, isLet, out, allowDynObject = false) {
     const loc = value.loc;
     if (ts.isIdentifier(name)) {
@@ -3588,19 +3151,12 @@ export function bindPatternTarget(lowerer, name, value, isLet, out, allowDynObje
             });
             return;
         }
-        // The runtime-world local rule, dyn side (383(d)'s dispatch stance):
-        // a pattern binding whose VALUE lowered checked-dynamic stays dyn
-        // where the checker spells an island-world type (`function f({
-        // plugins = [] } = {})` over a JSDoc '(string | object)[]=' member —
-        // the read is a dyn keyed read whose members may be wrapped island
-        // values) or a type with no mapping at all (the varDecl rule's
-        // unmappable-declared-type stance, `string | object` bindings
-        // included). Marshaling here would fence or deep-copy; the value's
-        // world is the honest dispatch.
+        // Preserve checked-value pattern bindings when the inferred type
+        // cannot represent them without a refusal or an alias-breaking copy.
         const dynStays = value.type.kind === "dyn" &&
             (() => {
                 const mapped = lowerer.mapTypeOf(lowerer.typeOf(name));
-                return mapped === null || (lowerer.dynamic && jsvalFlavoredType(mapped));
+                return mapped === null;
             })();
         let type = dynStays
             ? DYN
@@ -3742,11 +3298,7 @@ function inferredEvolvingLetType(lowerer, decl) {
                     return "stop";
                 }
                 const mapped = lowerer.mapTypeOf(lowerer.typeOf(node.right));
-                if (!mapped ||
-                    mapped.kind === "dyn" ||
-                    mapped.kind === "jsval" ||
-                    mapped.kind === "void" ||
-                    isUnitType(mapped)) {
+                if (!mapped || mapped.kind === "dyn" || mapped.kind === "void" || isUnitType(mapped)) {
                     invalid = true;
                     return "stop";
                 }
@@ -4002,9 +3554,8 @@ export function lowerVarDecl(lowerer, decl, isLet) {
             // a loop — must NOT reset the persisting binding.
             if (isVarDeclared(decl))
                 return null;
-            // Checked-dynamic globals hold the dyn undefined from their
-            // declaration statement on; unions and jsval ride
-            // unassignedSlotInit's arms.
+            // Checked-value globals hold native undefined; typed slots use
+            // unassignedSlotInit's union arms.
             const wrapped = g.type.kind === "dyn"
                 ? dynUndefinedExpr(locOf(decl))
                 : lowerer.unassignedSlotInit(g.type, locOf(decl));
@@ -4092,9 +3643,7 @@ export function lowerVarDecl(lowerer, decl, isLet) {
             lowerer.badType(decl.name, lowerer.typeOf(decl.name));
         const local = lowerer.declareLocal(decl.name, decl.name.text, type, isLet);
         // tsc's definite-assignment analysis never guards `any` reads, so
-        // uninitialized bindings must hold their world's undefined, never
-        // NULL: unions the interned arm, dyn the dyn undefined, jsval the
-        // engine's — all readable immediately, exactly Node.
+        // uninitialized checked-value bindings must hold native undefined.
         const init = type.kind === "dyn"
             ? dynUndefinedExpr(locOf(decl))
             : lowerer.unassignedSlotInit(type, locOf(decl));
@@ -4154,41 +3703,11 @@ export function lowerVarDecl(lowerer, decl, isLet) {
     // `any`, which a static build cannot hold): the VALUE is a dyn
     // subtree, so the local stays dyn — later narrowing tests and checked
     // casts read it like any JSON.parse result.
-    // `const p = import("./m")` / `const ns = await import("./m")`: the
-    // island promise/handle is the import expression's only production —
-    // the binding holds it, whatever the checker's namespace type mapped
-    // to (the island-HANDLE local story). Below that: a never-tainted JS
-    // binding type (`const cmd = ['pwd', []]` infers (string | never[])[])
+    // A binding type (`const cmd = ['pwd', []]` infers (string | never[])[])
     // is inference residue, not element information — unmappable, so the
     // dyn initializer keeps the binding checked-dynamic.
     const bindingTainted = neverTaintedJsType(lowerer, decl.name, lowerer.typeOf(decl.name));
-    let type = (lowerer.dynamic &&
-        (init.type.kind === "jsval" ||
-            (init.type.kind === "promise" && init.type.inner.kind === "jsval"))
-        ? (importCallHandleType(decl.initializer) ??
-            // An unchecked-overload call result (the resolved overload's
-            // return type was never checked against the jsval-returning
-            // implementation): the binding stores the handle — see
-            // uncheckedOverloadHandleCall.
-            (init.type.kind === "jsval" && uncheckedOverloadHandleCall(lowerer, decl.initializer)
-                ? JSVAL
-                : null))
-        : null) ??
-        // The runtime-world local rule, dyn side (383(d)'s dispatch stance —
-        // the island-HANDLE local rule's mirror): a binding whose
-        // INITIALIZER lowered checked-dynamic stays dyn even where the
-        // checker spells 'any' (`const parsers = options.parsers ?? {}` over
-        // an 'object'-typed bag — the read is a dyn keyed read). Marshaling
-        // into the engine here would deep-copy data and sever aliasing; the
-        // value's world is the honest dispatch, and every use site already
-        // handles dyn (validated exits, routed engine ops for wrapped
-        // island members).
-        (lowerer.dynamic &&
-            init.type.kind === "dyn" &&
-            jsvalFlavoredType(lowerer.mapTypeOf(lowerer.typeOf(decl.name)) ?? DYN)
-            ? DYN
-            : null) ??
-        (bindingTainted ? null : lowerer.mapTypeOf(lowerer.typeOf(decl.name))) ??
+    let type = (bindingTainted ? null : lowerer.mapTypeOf(lowerer.typeOf(decl.name))) ??
         staticImportNamespaceType(lowerer, decl.initializer) ??
         (init.type.kind === "moduleNs" ? init.type : null) ??
         (init.type.kind === "dyn" ? DYN : null);
@@ -4376,7 +3895,6 @@ export function lowerVarDecl(lowerer, decl, isLet) {
             (type === null && isJsSourceFile(decl.getSourceFile()))) &&
         init.type.kind !== "void" &&
         init.type.kind !== "caught" &&
-        init.type.kind !== "jsval" &&
         !isUnitType(init.type)) {
         type = init.type;
     }
@@ -4456,39 +3974,6 @@ export function lowerVarDecl(lowerer, decl, isLet) {
     }
     if (settledType.kind === "void")
         lowerer.badType(decl.name, lowerer.typeOf(decl.name));
-    // A PACKAGE promise stored in a local stays an island HANDLE — the
-    // engine's promise has no static promise value to coerce into. Awaits
-    // and .catch/.finally chains on the local bridge per use site (each
-    // bridge is an independent observer of the same settlement).
-    if (init.type.kind === "jsval" && settledType.kind === "promise")
-        settledType = JSVAL;
-    // An island value under an `any[]`-declared LOCAL spelling stays an
-    // island HANDLE too (the runtime-world rule): the jsval-element-array
-    // exit is a CALL-boundary conversion (the loadPlugins param ABI) —
-    // converting a local would strand the engine's own prototypes
-    // (join/map/... on a native handle-element array), where the handle
-    // routes every use engine-side.
-    if (init.type.kind === "jsval" &&
-        settledType.kind === "array" &&
-        settledType.elem.kind === "jsval") {
-        settledType = JSVAL;
-    }
-    // A STATIC array of island HANDLES under an unannotated declared type
-    // spelling evolved elements (`const kept = fns.filter(...)` over an
-    // evolving-`any` receiver — the handle-element lowering keeps the
-    // elements jsval, while tsc's evolving-array analysis types the
-    // result by the pushed elements): the value's element type is the
-    // truth, so the binding keeps the handle-element array (the
-    // island-HANDLE local story, one level down) and later method calls
-    // ride the handle-element lowering. Explicit annotations keep the
-    // validated-boundary fence.
-    if (!decl.type &&
-        init.type.kind === "array" &&
-        init.type.elem.kind === "jsval" &&
-        settledType.kind === "array" &&
-        settledType.elem.kind !== "jsval") {
-        settledType = init.type;
-    }
     // `const runner = options.runner || defaultRunner`: the checker types
     // the || as the union/merge of two structurally-compatible function
     // types — a signature whose RETURN is the arms' union, or the
@@ -5720,7 +5205,7 @@ export function lowerExprStatement(lowerer, expr) {
                     if (arrayType?.kind === "array") {
                         const arr = lowerer.lowerExpr(expr.left.expression);
                         if (arr.type.kind !== "array") {
-                            lowerer.unsupported("SC1090", expr.left.expression, "writing the length of an array-typed value that remains an island handle");
+                            lowerer.unsupported("SC1090", expr.left.expression, "writing the length of an array-typed value without native array storage");
                         }
                         const length = lowerer.lowerExprExpecting(expr.right, F64);
                         return { kind: "arraySetLength", arr, length, loc: locOf(expr) };
@@ -5754,47 +5239,6 @@ export function lowerExprStatement(lowerer, expr) {
                     // this method's own `this` — super dispatch is static in JS.
                     return lowerer.lowerSuperAccessorWrite(expr.left, expr.right, locOf(expr));
                 }
-                if (lowerer.isIslandExpr(expr.left.expression)) {
-                    // o.x = v on an island receiver: engine property write; the
-                    // value marshals in (a static RHS crosses by value/copy).
-                    const obj = lowerer.lowerExpr(expr.left.expression);
-                    const loc = locOf(expr);
-                    // Dispatch follows the RUNTIME world (383(d)): a checker-'any'
-                    // receiver whose value LOWERED checked-dynamic (`bag.nested.x
-                    // = v` behind an 'object'-typed bag) takes the dyn keyed
-                    // write — the routed JSVAL arm lands it on the real engine
-                    // object.
-                    if (obj.type.kind === "dyn") {
-                        const key = {
-                            kind: "strLit",
-                            value: expr.left.name.text,
-                            type: STRING,
-                            loc: locOf(expr.left.name),
-                        };
-                        const value = lowerer.coerceToExpected(lowerer.lowerExpr(expr.right), DYN);
-                        if (value.type.kind !== "dyn") {
-                            lowerer.unsupported("SC1100", expr.right, `assigning '${lowerer.fmt(value.type)}' values through 'unknown' receivers`);
-                        }
-                        return {
-                            kind: "exprStmt",
-                            expr: { kind: "libCall", fn: "dyn.keySet", args: [obj, key, value], type: VOID, loc },
-                            loc,
-                        };
-                    }
-                    const value = lowerer.jsvalIn(lowerer.lowerExpr(expr.right), expr.right);
-                    return {
-                        kind: "exprStmt",
-                        expr: {
-                            kind: "jsOp",
-                            op: "setProp",
-                            name: expr.left.name.text,
-                            args: [obj, value],
-                            type: VOID,
-                            loc,
-                        },
-                        loc,
-                    };
-                }
                 // wrapper.close = fn — the net.Server close-override idiom
                 // (routed to lower-server; the generic fences stay for
                 // everything else).
@@ -6095,15 +5539,6 @@ export function lowerExprStatement(lowerer, expr) {
                 }
             }
             if (ts.isObjectLiteralExpression(expr.left) || ts.isArrayLiteralExpression(expr.left)) {
-                // Destructuring assignment (chains included) whose SOURCE is an
-                // island value: the ENGINE runs the pattern (JS-exact coercions
-                // — RequireObjectCoercible on object patterns, the iterator
-                // protocol on array patterns) and hands the extracted values
-                // back for the compiled targets. Static sources fall through to
-                // the general assignment lowering below.
-                const viaIsland = lowerJsvalDestructuringChain(lowerer, expr);
-                if (viaIsland)
-                    return viaIsland;
                 // Destructuring ASSIGNMENT to existing bindings:
                 // `({ dir, port } = await discoverState());`, `[a, b = 0, ...rest] = t` —
                 // the RHS evaluates once into a hidden temp, then each target
@@ -6307,198 +5742,6 @@ function lowerCompoundToTarget(lowerer, expr, compound, target) {
         loc: locOf(expr),
     };
 }
-/** One destructuring-assignment pattern the island can run: empty object/
- * array patterns and flat identifier targets — shorthand `{ x }`,
- * renamed `{ a: x }`, FOLDED computed keys `{ [k]: x }` (2105's
- * static-fold rule: a pure key expression whose checker type spells one
- * property name — skipping its evaluation is exact), array elements
- * `[x, y]`. Answers the source FIELD key (object patterns) and the
- * target identifier per binding, in pattern order; null for any other
- * pattern form (defaults, rest, nesting, holes, non-identifier targets,
- * runtime-valued keys — the existing fences own those). */
-function islandRunnablePattern(lowerer, pattern) {
-    if (ts.isObjectLiteralExpression(pattern)) {
-        const binds = [];
-        for (const prop of pattern.properties) {
-            if (ts.isShorthandPropertyAssignment(prop)) {
-                if (prop.objectAssignmentInitializer)
-                    return null;
-                // 7 types the shorthand's name as PropertyName; the grammar
-                // allows nothing but an Identifier there (lowerShorthandValue).
-                const name = prop.name;
-                binds.push({ field: name.text, target: name, shorthand: prop });
-            }
-            else if (ts.isPropertyAssignment(prop) &&
-                ts.isIdentifier(prop.name) &&
-                ts.isIdentifier(prop.initializer)) {
-                binds.push({ field: prop.name.text, target: prop.initializer, shorthand: null });
-            }
-            else if (ts.isPropertyAssignment(prop) &&
-                ts.isComputedPropertyName(prop.name) &&
-                ts.isIdentifier(prop.initializer)) {
-                const key = lowerer.foldedStringKeyOf(prop.name.expression);
-                if (key === null)
-                    return null;
-                binds.push({ field: key, target: prop.initializer, shorthand: null });
-            }
-            else {
-                return null;
-            }
-        }
-        return { kind: "object", binds };
-    }
-    const binds = [];
-    for (let i = 0; i < pattern.elements.length; i++) {
-        const el = pattern.elements[i];
-        if (!ts.isIdentifier(el))
-            return null; // holes, spreads, nesting
-        binds.push({ field: i, target: el, shorthand: null });
-    }
-    return { kind: "array", binds };
-}
-/** `({} = {x, y} = a);` — destructuring assignment (chains included) from
- * an ISLAND source, statement position (--dynamic). The ENGINE runs each
- * pattern over the source value — a synthesized
- * `new Function("v", "\"use strict\"; var __0…; (<pattern> = v); return [__0…]")`
- * — so the coercions are JS-exact: object patterns RequireObjectCoercible
- * (destructuring undefined throws Node's TypeError), array patterns run
- * the real iterator protocol (empty patterns get-and-close). The
- * extracted values come back as an engine array and assign the compiled
- * targets in pattern order, inner assignment first (JS's right-
- * associativity). Null when the innermost source is not jsval-typed or
- * any pattern is outside the island-runnable set — the existing
- * record-source path and fences own those. */
-function lowerJsvalDestructuringChain(lowerer, expr) {
-    if (!lowerer.dynamic)
-        return null;
-    const strip = (e) => {
-        while (ts.isParenthesizedExpression(e))
-            e = e.expression;
-        return e;
-    };
-    const patterns = [];
-    let node = expr;
-    for (;;) {
-        const s = strip(node);
-        if (ts.isBinaryExpression(s) &&
-            s.operatorToken.kind === ts.SyntaxKind.EqualsToken &&
-            (ts.isObjectLiteralExpression(strip(s.left)) || ts.isArrayLiteralExpression(strip(s.left)))) {
-            patterns.push(strip(s.left));
-            node = s.right;
-        }
-        else {
-            break;
-        }
-    }
-    if (patterns.length === 0)
-        return null;
-    // A single pattern over a PLAIN-VARIABLE island source takes the
-    // general assignment lowering below, whose island arm throws V8's
-    // exact destructure TypeErrors — the spelling embeds the source
-    // text, which only a plain variable survives (corpus 2074). Chains
-    // and non-variable sources ride the engine here (corpus 2054); the
-    // general path fences those with SC1031.
-    if (patterns.length === 1 && ts.isIdentifier(strip(node)))
-        return null;
-    const shapes = [];
-    for (const p of patterns) {
-        const s = islandRunnablePattern(lowerer, p);
-        if (!s)
-            return null;
-        shapes.push(s);
-    }
-    // Checker-type gate BEFORE lowering the source (a declined claim must
-    // not leave a discarded lowering behind): only island sources ride
-    // the engine; record/array sources keep their existing paths.
-    if (lowerer.mapTypeOf(lowerer.typeOf(node))?.kind !== "jsval")
-        return null;
-    const source = lowerer.lowerExpr(node);
-    if (source.type.kind !== "jsval")
-        return null;
-    const loc = locOf(expr);
-    const tmp = lowerer.declareHiddenLocal("%dsrc", JSVAL);
-    const out = [{ kind: "varDecl", localId: tmp.id, init: source, loc }];
-    const srcRef = () => ({ kind: "varRef", localId: tmp.id, type: JSVAL, loc });
-    // Inner pattern first: `A = B = v` runs B's destructure before A's.
-    for (let p = patterns.length - 1; p >= 0; p--) {
-        const shape = shapes[p];
-        const temps = shape.binds.map((_, i) => `__${i}`);
-        const patternSrc = shape.kind === "object"
-            ? `({${shape.binds.map((b, i) => `[${JSON.stringify(String(b.field))}]: __${i}`).join(",")}} = v)`
-            : `([${temps.join(",")}] = v)`;
-        const body = `"use strict";` +
-            (temps.length > 0 ? `var ${temps.join(",")};` : "") +
-            `${patternSrc};return [${temps.join(",")}];`;
-        const helper = {
-            kind: "jsOp",
-            op: "construct",
-            args: [
-                { kind: "jsOp", op: "globalGet", name: "Function", args: [], type: JSVAL, loc },
-                {
-                    kind: "jsMarshal",
-                    value: { kind: "strLit", value: "v", type: STRING, loc },
-                    type: JSVAL,
-                    loc,
-                },
-                {
-                    kind: "jsMarshal",
-                    value: { kind: "strLit", value: body, type: STRING, loc },
-                    type: JSVAL,
-                    loc,
-                },
-            ],
-            type: JSVAL,
-            loc,
-        };
-        const run = { kind: "jsOp", op: "callFn", args: [helper, srcRef()], type: JSVAL, loc };
-        if (shape.binds.length === 0) {
-            out.push({ kind: "exprStmt", expr: run, loc });
-            continue;
-        }
-        const res = lowerer.declareHiddenLocal("%dres", JSVAL);
-        out.push({ kind: "varDecl", localId: res.id, init: run, loc });
-        shape.binds.forEach((b, i) => {
-            // Shorthand names resolve to the PROPERTY symbol at their
-            // location; the VALUE symbol comes from the checker's shorthand
-            // query (lowerDestructuringAssign's rule).
-            let target;
-            if (b.shorthand) {
-                const valueSymbol = lowerer.checker.getShorthandAssignmentValueSymbol(b.shorthand) ?? null;
-                const local = valueSymbol ? lowerer.resolveKey(valueSymbol, b.target) : null;
-                const g = valueSymbol ? lowerer.globalsBySymbol.get(valueSymbol) : undefined;
-                target = local ? { id: local.id, type: local.type } : g ? { id: g.id, type: g.type } : null;
-            }
-            else {
-                target = lowerer.resolveWritable(b.target);
-            }
-            if (!target) {
-                lowerer.rejectUnresolved(b.target, `assignment to '${b.target.text}' (not a writable local or module global)`);
-            }
-            const read = {
-                kind: "jsOp",
-                op: "getIdx",
-                args: [
-                    { kind: "varRef", localId: res.id, type: JSVAL, loc },
-                    {
-                        kind: "jsMarshal",
-                        value: { kind: "numLit", value: i, type: F64, loc },
-                        type: JSVAL,
-                        loc,
-                    },
-                ],
-                type: JSVAL,
-                loc,
-            };
-            out.push({
-                kind: "assign",
-                localId: target.id,
-                value: lowerer.coerceInto(b.target, read, target.type),
-                loc,
-            });
-        });
-    }
-    return { kind: "block", body: out, loc };
-}
 /** `({ a, b: x } = e);`, `[a, b = 0, ...rest] = xs;` — destructuring
  * assignment to EXISTING writable bindings, statement position, from a
  * PRE-LOWERED source: for-of expression heads hand the per-iteration
@@ -6611,12 +5854,10 @@ function destructuringAssignInto(lowerer, target, init, rhs, blame, loc) {
         lowerArrayAssignInto(lowerer, out, target, tmpRef, blame, loc);
         return { stmts: out, value };
     }
-    if (init.type.kind === "dyn" || init.type.kind === "jsval") {
-        // Checked-dynamic and island sources: RequireObjectCoercible with
+    if (init.type.kind === "dyn") {
         // V8's exact destructuring TypeError (it names the SOURCE and, for
         // non-empty patterns, the first property), then keyed reads — GetV
-        // answers undefined for absent members and primitive receivers
-        // alike (the engine's own property semantics on the island side).
+        // answers undefined for absent members and primitive receivers.
         // An RHS that is ITSELF a destructuring assignment (`({} = {x} = a)`)
         // already proved the value coercible — its own pattern threw first
         // if it wasn't — so the outer check is dead code and needs no
@@ -6659,31 +5900,14 @@ function destructuringAssignInto(lowerer, target, init, rhs, blame, loc) {
             });
         }
         for (const prop of target.properties) {
-            const piece = destructAssignPiece(lowerer, prop, init.type.kind === "jsval");
-            const read = piece.keyExpr !== undefined
-                ? {
-                    kind: "jsOp",
-                    op: "getIdx",
-                    args: [tmpRef(), lowerer.jsvalIn(lowerer.lowerExpr(piece.keyExpr), piece.keyExpr)],
-                    type: JSVAL,
-                    loc: locOf(prop),
-                }
-                : init.type.kind === "jsval"
-                    ? {
-                        kind: "jsOp",
-                        op: "getProp",
-                        name: piece.field,
-                        args: [tmpRef()],
-                        type: JSVAL,
-                        loc: locOf(prop),
-                    }
-                    : {
-                        kind: "dynKeyGet",
-                        key: { kind: "strLit", value: piece.field, type: STRING, loc: locOf(prop) },
-                        value: tmpRef(),
-                        type: DYN,
-                        loc: locOf(prop),
-                    };
+            const piece = destructAssignPiece(lowerer, prop);
+            const read = {
+                kind: "dynKeyGet",
+                key: { kind: "strLit", value: piece.field, type: STRING, loc: locOf(prop) },
+                value: tmpRef(),
+                type: DYN,
+                loc: locOf(prop),
+            };
             out.push({
                 kind: "assign",
                 localId: piece.target.id,
@@ -7060,21 +6284,6 @@ function destructuringAssignInto(lowerer, target, init, rhs, blame, loc) {
     }
     return { stmts: out, value };
 }
-/** A destructuring-ASSIGNMENT target that is not a plain variable:
- * PROPERTY targets (`({ a: this.x } = o)`, `[c.x, c.y] = t` — the
- * receiver evaluates into a hidden temp at the element's pattern
- * position, BEFORE the element's value read, JS's get-the-reference-
- * then-GetV order), ELEMENT targets over arrays (runtime f64 index)
- * and tuples/records (literal keys) with the same receiver/key temp
- * discipline, and NESTED patterns (`({ p: { q } } = o)`, `[[a], b] = t`
- * — the element's value destructures through the same assignment
- * machinery, its own hidden temp included). `valueOf` builds the
- * (defaulted) source value at the target's own type; it receives null
- * exactly for nested patterns, which have no single binding type —
- * defaults there keep a fence (JS would need the pattern's implied
- * type to test against). Optional-chain targets are not assignment
- * targets in JS at all; index-signature runtime keys and island/dyn
- * receivers keep the fence below. */
 function lowerAssignTargetInto(lowerer, out, targetNode, blame, dflt, valueOf) {
     let t = targetNode;
     while (ts.isParenthesizedExpression(t))
@@ -7152,14 +6361,8 @@ function lowerAssignTargetInto(lowerer, out, targetNode, blame, dflt, valueOf) {
     }
     lowerer.unsupported("SC1031", targetNode, "destructuring assignment to targets with no static write form (assign a variable, then write the parts out)");
 }
-/** One object-pattern property's pieces for the checked-dynamic path:
- * the source FIELD name (or, over ISLAND sources, a runtime KEY
- * expression the engine indexes with) and the resolved writable target.
- * Shorthand (`{ a }`) and renamed (`{ a: x }`) identifier targets only —
- * the record path's rules, shared fences. */
-function destructAssignPiece(lowerer, prop, islandSource) {
+function destructAssignPiece(lowerer, prop) {
     let fieldName;
-    let keyExpr;
     let bindTo;
     if (ts.isShorthandPropertyAssignment(prop)) {
         if (prop.objectAssignmentInitializer) {
@@ -7169,20 +6372,10 @@ function destructAssignPiece(lowerer, prop, islandSource) {
         bindTo = prop.name;
     }
     else if (ts.isPropertyAssignment(prop)) {
-        // Identifier keys spell themselves; literal and FOLDABLE computed
-        // keys resolve statically (the record path's rule) — the keyed read
-        // below takes the folded name. A RUNTIME-valued key over an ISLAND
-        // source reads through the engine's own indexing at the element's
-        // pattern position (`({ [key]: w } = src)`); over the checked-dynamic tree the fence
-        // stays.
+        // Identifier, literal, and foldable computed keys resolve statically.
         const folded = patternKeyNameOf(lowerer, prop.name);
         if (folded === null) {
-            if (islandSource && ts.isComputedPropertyName(prop.name)) {
-                keyExpr = prop.name.expression;
-            }
-            else {
-                lowerer.unsupported("SC1031", prop, "destructuring assignment with computed keys that do not fold to one property name");
-            }
+            lowerer.unsupported("SC1031", prop, "destructuring assignment with computed keys that do not fold to one property name");
         }
         fieldName = folded ?? "";
         bindTo = prop.initializer;
@@ -7206,7 +6399,7 @@ function destructAssignPiece(lowerer, prop, islandSource) {
     if (!target) {
         lowerer.rejectUnresolved(bindTo, `assignment to '${bindTo.text}' (not a writable local or module global)`);
     }
-    return { field: fieldName, ...(keyExpr !== undefined ? { keyExpr } : {}), target };
+    return { field: fieldName, target };
 }
 /** The ARRAY half of destructuring assignment: element assigns from a
  * tuple/array/checked-dynamic source pushed into `out` (see
@@ -7253,10 +6446,9 @@ function lowerArrayAssignInto(lowerer, out, target, tmpRef, blame, loc) {
     const shape = srcType.kind === "record" ? lowerer.shapes.get(srcType.shapeId) : undefined;
     const isTuple = shape?.tuple === true;
     let elemsRef = null;
-    if (srcType.kind === "dyn" || srcType.kind === "jsval") {
-        // GetIterator + the pattern's width, V8's exact TypeErrors
-        // (dynIterN — the engine's real iterator protocol on the island
-        // side); the empty pattern is pure validation.
+    if (srcType.kind === "dyn") {
+        // Read the pattern's width through the native iterator with Node's
+        // TypeErrors. The empty pattern only validates iterability.
         const iterTmp = lowerer.declareHiddenLocal("%destrIter", srcType);
         out.push({
             kind: "varDecl",
@@ -7279,16 +6471,6 @@ function lowerArrayAssignInto(lowerer, out, target, tmpRef, blame, loc) {
     const elemRead = (i, at) => {
         if (elemsRef) {
             const elems = elemsRef();
-            if (elems.type.kind === "jsval") {
-                const key = { kind: "numLit", value: i, type: F64, loc: locOf(at) };
-                return {
-                    kind: "jsOp",
-                    op: "getIdx",
-                    args: [elems, lowerer.jsvalIn(key, at)],
-                    type: JSVAL,
-                    loc: locOf(at),
-                };
-            }
             return {
                 kind: "dynKeyGet",
                 key: { kind: "strLit", value: String(i), type: STRING, loc: locOf(at) },
@@ -7334,8 +6516,8 @@ function lowerArrayAssignInto(lowerer, out, target, tmpRef, blame, loc) {
         if (ts.isSpreadElement(el)) {
             // `[a, ...rest]`: the tail packs FRESH (JS's surplus packing
             // builds a new array) — array slices, tuple tails under the
-            // target's own type. Checked-dynamic sources keep the fence (the
-            // engine's iterator would have to drain into a compiled array).
+            // target's own type. Checked-value sources keep the fence because
+            // this path has no native array drain.
             if (elemsRef) {
                 lowerer.unsupported("SC1031", el, "rest elements in destructuring assignment from checked-dynamic sources (collect with .slice() instead)");
             }
@@ -7394,7 +6576,7 @@ function lowerArrayAssignInto(lowerer, out, target, tmpRef, blame, loc) {
             // undefined where the plain read would trap).
             let read = elemRead(i, el);
             if (defaultNode !== null) {
-                if (read.type.kind === "dyn" || read.type.kind === "jsval") {
+                if (read.type.kind === "dyn") {
                     const boundary = read.type;
                     const elemTmp = lowerer.declareHiddenLocal("%destrElem", boundary);
                     out.push({ kind: "varDecl", localId: elemTmp.id, init: read, loc: locOf(el) });
@@ -7404,31 +6586,18 @@ function lowerArrayAssignInto(lowerer, out, target, tmpRef, blame, loc) {
                         type: boundary,
                         loc: locOf(el),
                     });
-                    const isUndef = boundary.kind === "jsval"
-                        ? {
-                            kind: "jsOp",
-                            op: "eq",
-                            args: [
-                                elemVar(),
-                                { kind: "jsOp", op: "undefLit", args: [], type: JSVAL, loc: locOf(el) },
-                            ],
-                            type: BOOL,
-                            loc: locOf(el),
-                        }
-                        : {
-                            kind: "dynTest",
-                            test: "undefined",
-                            value: elemVar(),
-                            type: BOOL,
-                            loc: locOf(el),
-                        };
+                    const isUndef = {
+                        kind: "dynTest",
+                        test: "undefined",
+                        value: elemVar(),
+                        type: BOOL,
+                        loc: locOf(el),
+                    };
                     const dflt = lowerer.lowerExpr(defaultNode);
                     read = {
                         kind: "ternary",
                         cond: isUndef,
-                        then: boundary.kind === "jsval"
-                            ? lowerer.jsvalIn(dflt, defaultNode)
-                            : lowerer.coerceInto(defaultNode, dflt, DYN),
+                        then: lowerer.coerceInto(defaultNode, dflt, DYN),
                         else_: elemVar(),
                         type: boundary,
                         loc: locOf(el),
@@ -7732,19 +6901,9 @@ export function lowerForOf(lowerer, stmt) {
             }
             tupleSource = { shapeId: iterable.type.shapeId, fields, elem };
         }
-        // An ISLAND value (`for (const store of stores)` where stores is a
-        // package-typed array — one engine handle): the engine's OWN
-        // iterator protocol drives the loop — GetIterator through the
-        // pinned prelude helper (V8's not-iterable TypeError on refusal),
-        // next() through callMethod, done/value reads through getProp — so
-        // engine arrays, Maps, Sets, generators, and Symbol.iterator
-        // implementations all iterate exactly as Node runs them.
-        if (iterable.type.kind === "jsval") {
-            return lowerForOfIsland(lowerer, stmt, iterable, labels);
-        }
         // A CHECKED-DYNAMIC iterable (`unknown[]`, the collapsed
-        // `(string | object)[]`, JSON-parsed values, wrapped engine
-        // values): a checked IteratorRecord binds each yielded dyn value.
+        // `(string | object)[]`, JSON-parsed values): a checked IteratorRecord
+        // binds each yielded dyn value.
         if (iterable.type.kind === "dyn") {
             return lowerForOfDyn(lowerer, stmt, iterable, labels);
         }
@@ -7760,7 +6919,6 @@ export function lowerForOf(lowerer, stmt) {
         !privateSplit &&
         !awaitArray &&
         elementType.kind !== "dyn" &&
-        elementType.kind !== "jsval" &&
         lowerer.presentElementLoops.has(stmt);
     const yieldedT = tupleSource === null && !privateSplit && !presentElements
         ? arrayValueType(lowerer, elementType)
@@ -7802,7 +6960,7 @@ export function lowerForOf(lowerer, stmt) {
         };
         if (promiseElem &&
             yieldedT.kind === "union" &&
-            !["void", "union", "dyn", "jsval", "undefinedT", "nullT"].includes(promiseElem.inner.kind)) {
+            !["void", "union", "dyn", "undefinedT", "nullT"].includes(promiseElem.inner.kind)) {
             awaitPromiseTag = lowerer.armTag(yieldedT.unionId, promiseElem);
             elemValueT = lowerer.withUndefinedArm(promiseElem.inner);
         }
@@ -8901,122 +8059,6 @@ function lowerForOfDyn(lowerer, stmt, iterable, labels) {
         lowerer.scopes.pop();
     }
 }
-/** for-of over an ISLAND value (see lowerForOf's jsval arm): the
- * engine's iterator protocol desugared over jsOps —
- *
- *   it = iterNew(v);            // GetIterator (prelude; may throw)
- *   while (true) {
- *     r = it.next();            // callMethod
- *     if (truthy(r.done)) break;
- *     <bind loop var(s) from r.value>  // getProp
- *     ...body
- *   }
- *
- * The loop variable's ELEMENT is an island handle (jsval — exactly what
- * the checker's package-typed element maps to); identifier heads bind
- * it per iteration, destructuring heads run the jsval pattern desugar,
- * pre-declared and var heads keep their fences (the array path's
- * stories don't carry over mechanically). IteratorClose on early exit
- * (break/return out of a partial iteration calling it.return()) is NOT
- * run — a divergence only a custom island iterator with a return()
- * method can observe. */
-function lowerForOfIsland(lowerer, stmt, iterable, labels) {
-    const loc = locOf(stmt);
-    if (!ts.isVariableDeclarationList(stmt.initializer)) {
-        lowerer.unsupported("SC1090", stmt.initializer, "for-of over a package ('any') iterable with a pre-declared loop variable (declare it in the loop: for (const x of ...))");
-    }
-    const list = stmt.initializer;
-    if ((list.flags & ts.NodeFlags.Using) !== 0) {
-        lowerer.unsupported("SC1090", list, "'using' declarations (dispose-at-scope-exit semantics)");
-    }
-    const isLet = (list.flags & ts.NodeFlags.Let) !== 0 || (list.flags & ts.NodeFlags.BlockScoped) === 0;
-    const decl = list.declarations[0];
-    const itLocal = lowerer.declareHiddenLocal("%vofit", JSVAL);
-    const rLocal = lowerer.declareHiddenLocal("%vofr", JSVAL);
-    const itRef = { kind: "varRef", localId: itLocal.id, type: JSVAL, loc };
-    const rRef = { kind: "varRef", localId: rLocal.id, type: JSVAL, loc };
-    const valueOf = {
-        kind: "jsOp",
-        op: "getProp",
-        name: "value",
-        args: [rRef],
-        type: JSVAL,
-        loc,
-    };
-    lowerer.scopes.push(new Map());
-    try {
-        const binds = [];
-        if (ts.isArrayBindingPattern(decl.name) || ts.isObjectBindingPattern(decl.name)) {
-            const tmp = lowerer.declareHiddenLocal("%destr", JSVAL);
-            binds.push({ kind: "varDecl", localId: tmp.id, init: valueOf, loc });
-            lowerer.lowerBindingPattern(decl.name, () => ({ kind: "varRef", localId: tmp.id, type: JSVAL, loc }), JSVAL, isLet, binds);
-        }
-        else if (ts.isIdentifier(decl.name)) {
-            if (forOfVarTarget(lowerer, decl)) {
-                lowerer.unsupported("SC1090", decl.name, "for (var x of ...) over a package ('any') iterable (use const or let)");
-            }
-            const local = lowerer.declareLocal(decl.name, decl.name.text, JSVAL, isLet);
-            binds.push({ kind: "varDecl", localId: local.id, init: valueOf, loc });
-        }
-        else {
-            lowerer.unsupported("SC1031", decl.name);
-        }
-        const body = lowerer.inCtl("loop", () => lowerer.lowerScopedBlock(stmt.statement), labels);
-        return {
-            kind: "block",
-            body: [
-                {
-                    kind: "varDecl",
-                    localId: itLocal.id,
-                    init: { kind: "jsOp", op: "iterNew", args: [iterable], type: JSVAL, loc },
-                    loc,
-                },
-                {
-                    kind: "while",
-                    cond: { kind: "boolLit", value: true, type: BOOL, loc },
-                    body: [
-                        {
-                            kind: "varDecl",
-                            localId: rLocal.id,
-                            init: {
-                                kind: "jsOp",
-                                op: "callMethod",
-                                name: "next",
-                                args: [itRef],
-                                type: JSVAL,
-                                loc,
-                            },
-                            loc,
-                        },
-                        {
-                            kind: "if",
-                            cond: {
-                                kind: "jsOp",
-                                op: "truthy",
-                                args: [
-                                    { kind: "jsOp", op: "getProp", name: "done", args: [rRef], type: JSVAL, loc },
-                                ],
-                                type: BOOL,
-                                loc,
-                            },
-                            then: [{ kind: "break", loc }],
-                            else_: null,
-                            loc,
-                        },
-                        ...binds,
-                        ...body,
-                    ],
-                    ...(labels && { labels }),
-                    loc,
-                },
-            ],
-            loc,
-        };
-    }
-    finally {
-        lowerer.scopes.pop();
-    }
-}
 function lowerForOfString(lowerer, stmt, iterable, labels) {
     let exprTarget = null;
     let exprTargetNode = null;