@scriptc/compiler 0.2.1 → 0.2.3

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

@@ -1,4 +1,5 @@
 import { lowerDynObjectLiteral } from "./expressions/object-literals.js";
+import { importMetaBindingSource } from "./import-meta.js";
 import { InternalCompilerError } from "../../errors.js";
 /* Statement lowering: the statement dispatch (lowerStmt), variable
  * declarations including destructuring patterns, scoped blocks, control
@@ -19,20 +20,19 @@ import { isProvenanceSourceFile } from "../provenance-registry.js";
 import { ambientUndefVarRootOf, lowerImportEquals, nsUndefRead, nsWritableTarget, trapDeclRootOf } from "./lower-namespaces.js";
 import { expandoWritableTarget, lowerExpandoAssignStmt } from "./lower-expando.js";
 import { lowerForOfArrayIter, lowerForOfMap, lowerForOfSearchParams, lowerForOfSet, lowerSafeIndexRead, objectIterOverIndexShape, strCharsCall } from "./lower-containers.js";
-import { bindingContextualGenericFnNodeOf, bindingGenericFnAliasInfoOf, bindingGenericFnInfoOf, bindingGenericFnNodeOf, bindingNeverReassigned, deadUnmappableBinding, implicitLocalFnInfoOf, implicitLocalFnNodeOf, implicitMethodCallInfersReturn, nullishExprUnitOf, nullishGenericBindingUnitOf, recordKeysArrayCall, registerOverloadedCallableAlias } from "./lower-calls.js";
+import { bindingContextualGenericFnNodeOf, bindingGenericFnAliasInfoOf, bindingGenericFnInfoOf, bindingGenericFnNodeOf, bindingNeverReassigned, deadUnmappableBinding, hasExplicitJsDocReturn, implicitLocalFnInfoOf, implicitLocalFnNodeOf, implicitMethodCallInfersReturn, nullishExprUnitOf, nullishGenericBindingUnitOf, recordKeysArrayCall, registerOverloadedCallableAlias } from "./lower-calls.js";
 import { isMixinFnBinding, mixinResultBindingClassOf } from "./lower-mixins.js";
 import { isCompiledPrototypeMember } from "./class-prototypes.js";
 import { classStaticDataFor } from "./class-static-data.js";
 import { objectFactorySignature } from "./object-factory-new.js";
 import { isClassCallback, lowerClassCallbackAssign } from "./class-callbacks.js";
-import { classPropertiesHelper } from "./class-dynamic-dispatch.js";
+import { classForInHasKey, classPropertiesHelper } from "./class-dynamic-dispatch.js";
 import { genericIfaceBindingKeepsClass, staticFieldWriteTarget } from "./lower-classes.js";
 import { lowerStreamUnderscoreAssign, streamClassAliasDecl } from "./lower-stream.js";
 import { lowerHttpResPropertyAssignment, lowerHttpServerTimeoutAssignment, lowerServerCloseOverrideAssignment } from "./lower-server.js";
-import { isNativeFfiRequire, builtinMemberRequireDecl, builtinNamespaceDestructureModuleOf, createRequireBindingDecl, createRequireCalleeFileOf, createRequireNamespaceDecl, createRequireProgramModuleDecl, createRequireProgramModuleOf, lowerNodeModuleCall, registerBuiltinCallableAlias } from "./lower-builtins.js";
+import { lowerUrlAssignment, isNativeFfiRequire, builtinMemberRequireDecl, builtinNamespaceDestructureModuleOf, createRequireBindingDecl, createRequireCalleeFileOf, createRequireNamespaceDecl, createRequireProgramModuleDecl, createRequireProgramModuleOf, lowerNodeModuleCall, registerBuiltinCallableAlias } from "./lower-builtins.js";
 import { lowerEnumDeclaration } from "./lower-enums.js";
-import { abstractPropertyDeclOf, aliasTypeofNarrows, isMatchSliceType, lowerAbsenceProbe, lowerCompoundValueToTarget, lowerElementCompound, lowerGroupsProjection, matchResultNamedGroupsOf, runtimeOptionalGuardIds, runtimeOptionalTrueIds, symbolFieldInfo, withRuntimeOptionalNarrowed } from "./lower-exprs.js";
-import { isSafeToRepeat } from "./expressions/evaluation-safety.js";
+import { abstractPropertyDeclOf, aliasTypeofNarrows, isMatchSliceType, lowerAbsenceProbe, lowerCompoundValueToTarget, lowerElementCompound, lowerIncDec, lowerGroupsProjection, matchResultNamedGroupsOf, runtimeOptionalGuardIds, runtimeOptionalTrueIds, symbolFieldInfo, withRuntimeOptionalNarrowed } from "./lower-exprs.js";
 import { globalSymbolKey } from "./expressions/global-symbols.js";
 import { lowerShortCircuitAssignment } from "./expressions/nullish-assignment.js";
 import { lowerEnvironmentKey, lowerNativeFunctionAssignment } from "./lower-exprs.js";
@@ -71,6 +71,8 @@ function npmStaticReturnedEmptyArrayType(lowerer, decl) {
     const ownerBody = owner !== undefined && ts.isFunctionLike(owner) ? owner.body : undefined;
     if (ownerBody === undefined || !ts.isBlock(ownerBody))
         return null;
+    if (owner && ts.isFunctionLike(owner) && !owner.type && !hasExplicitJsDocReturn(owner))
+        return null;
     let returned = false;
     ts.walkPreorder(ownerBody, (node) => {
         if (node !== ownerBody && ts.isFunctionLike(node))
@@ -593,7 +595,12 @@ export function predeclareForwardCapture(lowerer, symbol) {
         // TDZ read until the initializing assign completes — JS exactly.
         if (idx < entry.index || entry.ctx === lowerer.ctx || entry.ctx.tdzPredeclared.has(symbol))
             return false;
-        const type = lowerer.irTypeOf(decl.name);
+        let type = lowerer.irTypeOf(decl.name);
+        if (isJsSourceFile(decl.getSourceFile()) && !decl.type && !hasJsTypeAnnotation(decl) &&
+            (ts.isObjectLiteralExpression(decl.initializer) ||
+                (ts.isCallExpression(decl.initializer) && ts.isPropertyAccessExpression(decl.initializer.expression) &&
+                    decl.initializer.expression.name.text === "assign" && lowerer.isStdlibGlobal(decl.initializer.expression.expression, "Object"))) && lowerer.dynConvertible(type))
+            type = DYN;
         if (!TDZ_KINDS.has(type.kind) || isUnitType(type))
             return false;
         const name = decl.name.text;
@@ -1035,12 +1042,9 @@ export function lowerStmt(lowerer, stmt) {
         // (JS), which the undefined arm carries — tsc only allows the bare
         // form when the return type includes undefined/void. A CHECKED-
         // DYNAMIC return slot holds the dyn undefined directly (the
-        // appendImplicitUndefinedReturn rule). What remains is JS-only —
-        // a JSDoc return claim the body contradicts (ms's parse: `@return
-        // {Number}` with a bare early `return;`): no undefined fits the
-        // declared representation, so the statement fences honestly (the
-        // per-statement JS deferral — the claimed paths still run) instead
-        // of slipping an empty return past the validator.
+        // appendImplicitUndefinedReturn rule). JavaScript signatures include
+        // observed empty returns even when JSDoc omits undefined. Any remaining
+        // incompatible boundary keeps the ordinary per-statement refusal.
         let value = null;
         if (stmt.expression) {
             return lowerer.lowerReturnStmt(stmt.expression, locOf(stmt));
@@ -1092,9 +1096,18 @@ export function lowerStmt(lowerer, stmt) {
         // cell. `throw f()` of a void call has no value; Date has numeric
         // storage internally, but cannot preserve its object kind through the
         // untyped catch boundary. Reject both rather than changing JS identity.
-        const value = lowerer.lowerExpr(stmt.expression);
+        let value = lowerer.lowerExpr(stmt.expression);
         if (value.type.kind === "void")
             lowerer.badType(stmt.expression, lowerer.typeOf(stmt.expression));
+        // Preserve primitive reasons and readable record identity across the
+        // untyped catch boundary. Unit literals have no standalone native
+        // value, and native reference payloads otherwise lose their shape.
+        if (isUnitType(value.type) || value.type.kind === "symbol" || value.type.kind === "bigint") {
+            value = lowerer.coerceToExpected(value, DYN);
+        }
+        else if (value.type.kind === "record" && lowerer.dynConvertible(value.type)) {
+            value = { kind: "dynFrom", value, liveRef: true, type: DYN, loc: locOf(stmt.expression) };
+        }
         if (value.type.kind === "date") {
             lowerer.unsupported("SC1090", stmt.expression, "throwing Date values (catch bindings cannot preserve Date's object kind; throw an Error or primitive instead)");
         }
@@ -1424,7 +1437,7 @@ export function lowerDestructuringDecl(lowerer, decl, isLet) {
         if (tokenBound !== null)
             return tokenBound;
     }
-    let init = lowerer.lowerExpr(decl.initializer);
+    let init = importMetaBindingSource(lowerer, decl.name, decl.initializer) ?? 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
@@ -1885,6 +1898,10 @@ export function lowerBindingPattern(lowerer, pattern, srcRef, srcType, isLet, ou
     // scoped TypeScript exception: its declared result/token types are
     // deliberately carried by the checked-dynamic tree, so their ordinary
     // object patterns use the same exact keyed-read desugar.
+    if (srcType.kind === "union" && isJsSourceFile(pattern.getSourceFile()) && lowerer.dynConvertible(srcType)) {
+        lowerer.lowerBindingPattern(pattern, () => lowerer.coerceToExpected(srcRef(), DYN), DYN, isLet, out, dynSpell, allowDynObject);
+        return;
+    }
     if (srcType.kind === "dyn") {
         for (const el of pattern.elements) {
             if (el.name === undefined)
@@ -3323,7 +3340,7 @@ function inferredEvolvingLetType(lowerer, decl) {
                     invalid = true;
                     return "stop";
                 }
-                if (ts.isCallExpression(node.right) && implicitMethodCallInfersReturn(lowerer, node.right)) {
+                if (ts.isCallExpression(node.right) && (implicitMethodCallInfersReturn(lowerer, node.right) || isJsSourceFile(node.right.getSourceFile()))) {
                     invalid = true;
                     return "stop";
                 }
@@ -3545,7 +3562,8 @@ export function lowerVarDecl(lowerer, decl, isLet) {
         : (declSymbol ? lowerer.globalsBySymbol.get(declSymbol) : undefined);
     if (g) {
         let promotedGlobal = lowerer.runtimeOptionalBindingType(decl.name, g.type);
-        if (g.type.kind === "func" && decl.initializer !== undefined && ts.isIdentifier(decl.initializer)) {
+        if (g.type.kind === "func" && !decl.type && !hasJsTypeAnnotation(decl) &&
+            decl.initializer !== undefined && ts.isIdentifier(decl.initializer)) {
             const sig = lowerer.fnSigOf(decl.initializer);
             if (sig) {
                 promotedGlobal = {
@@ -3579,6 +3597,10 @@ export function lowerVarDecl(lowerer, decl, isLet) {
         }
         const raw = lowerVariableInitializer(lowerer, decl.initializer, g.type.kind === "dyn" && (isNativeBuiltinValueInitializer(lowerer, decl.initializer) ||
             ts.isArrayLiteralExpression(decl.initializer) || ts.isObjectLiteralExpression(decl.initializer)) ? DYN : undefined);
+        if (isJsSourceFile(decl.getSourceFile()) && !decl.type && !hasJsTypeAnnotation(decl) && raw.type.kind === "dyn" &&
+            (g.type.kind === "record" || g.type.kind === "object"))
+            g.type = DYN;
+        g.type = inferredOptionalRecordType(lowerer, decl, g.type, raw.type);
         const arithmetic = raw.type.kind === "union"
             ? lowerer.unions.get(raw.type.unionId)?.arms
             : undefined;
@@ -3651,7 +3673,10 @@ export function lowerVarDecl(lowerer, decl, isLet) {
         ? lowerer.unions.get(inferredObjectType.unionId)?.arms ?? [] : inferredObjectType ? [inferredObjectType] : [];
     const expandsObject = !decl.type && !hasJsTypeAnnotation(decl) && inferredObjectType !== null &&
         jsOpenObjectType(decl, inferredObjectType, lowerer.shapes, lowerer.unions).kind === "dyn" ||
-        inferredObjectArms.some((arm) => arm.kind === "record" && jsObjectBindingExpands(lowerer, decl, arm));
+        inferredObjectArms.some((arm) => arm.kind === "record" && jsObjectBindingExpands(lowerer, decl, arm)) ||
+        isJsSourceFile(decl.getSourceFile()) && !decl.type && !hasJsTypeAnnotation(decl) &&
+            ts.isObjectLiteralExpression(decl.initializer) && decl.initializer.properties.some((property) => ts.isMethodDeclaration(property) || ts.isAccessor(property) || ts.isPropertyAssignment(property) &&
+            (ts.isFunctionExpression(property.initializer) || ts.isArrowFunction(property.initializer)));
     let init;
     try {
         init = expandsObject || (isJsSourceFile(decl.getSourceFile()) && !decl.type &&
@@ -3806,6 +3831,8 @@ export function lowerVarDecl(lowerer, decl, isLet) {
         type = init.type;
         runtimeOptional = true;
     }
+    if (type !== null)
+        type = inferredOptionalRecordType(lowerer, decl, type, init.type);
     // A JS binding whose checker type spells a FUNCTION but whose VALUE is
     // already checked-dynamic (`const cb = mustCall(fn)` — the helper's
     // return rides its own box): keep the box. Extracting into the spelled
@@ -3817,6 +3844,9 @@ export function lowerVarDecl(lowerer, decl, isLet) {
             !decl.type && !hasJsTypeAnnotation(decl) && type.rest === true && type.restAbi === undefined)) {
         type = DYN;
     }
+    if (isJsSourceFile(decl.getSourceFile()) && !decl.type && !hasJsTypeAnnotation(decl) && init.type.kind === "dyn" &&
+        (type?.kind === "record" || type?.kind === "object"))
+        type = DYN;
     // A checker-`any` CONST whose initializer lowered to a STATIC type
     // (`const name = rawName ? rawName.replace(...) : null` — the
     // dyn-receiver machinery and the any-ternary join answer static IR):
@@ -3987,6 +4017,21 @@ export function lowerVarDecl(lowerer, decl, isLet) {
     }
     return { kind: "varDecl", localId: local.id, init, loc: locOf(decl) };
 }
+// lib.d.ts declares named captures as strings, but nonparticipating captures
+// are undefined. Inferred index records retain that runtime representation;
+// explicit annotations still require a checked conversion at the boundary.
+function inferredOptionalRecordType(lowerer, decl, declared, actual) {
+    if (decl.type || hasJsTypeAnnotation(decl) || declared.kind !== "record" || actual.kind !== "record")
+        return declared;
+    const target = lowerer.shapes.get(declared.shapeId);
+    const source = lowerer.shapes.get(actual.shapeId);
+    if (!target || !source || target.fields.length || source.fields.length || target.tuple || source.tuple ||
+        !target.indexValue || source.indexValue?.kind !== "union" ||
+        lowerer.armTag(source.indexValue.unionId, UNDEFINED_T) < 0 ||
+        !typeEquals(lowerer.stripUndefinedArm(source.indexValue), target.indexValue))
+        return declared;
+    return actual;
+}
 function lowerVariableInitializer(lowerer, node, expected) {
     let value = node;
     while (ts.isParenthesizedExpression(value) ||
@@ -4132,18 +4177,24 @@ export function jsBindingHasOpenWrites(lowerer, decl) {
     let owner = decl;
     while (owner.parent && !ts.isFunctionLike(owner) && !ts.isSourceFile(owner))
         owner = owner.parent;
-    let open = false;
-    ts.walkPreorder(owner, (node) => {
-        if (ts.isBinaryExpression(node) && node.operatorToken.kind >= ts.SyntaxKind.FirstAssignment &&
-            node.operatorToken.kind <= ts.SyntaxKind.LastAssignment && ts.isIdentifier(node.left) &&
-            lowerer.resolveValueSymbol(node.left) === symbol &&
-            (lowerer.typeOf(node.right).flags & (ts.TypeFlags.Any | ts.TypeFlags.Unknown)) !== 0) {
-            open = true;
-            return "stop";
-        }
-        return undefined;
-    });
-    return open;
+    let writes = lowerer.jsBindingWritesByOwner.get(owner);
+    if (!writes) {
+        const indexed = new Map();
+        ts.walkPreorder(owner, (node) => {
+            if (!ts.isBinaryExpression(node) || node.operatorToken.kind < ts.SyntaxKind.FirstAssignment ||
+                node.operatorToken.kind > ts.SyntaxKind.LastAssignment || !ts.isIdentifier(node.left))
+                return;
+            const entries = indexed.get(node.left.text);
+            if (entries)
+                entries.push(node);
+            else
+                indexed.set(node.left.text, [node]);
+        });
+        writes = indexed;
+        lowerer.jsBindingWritesByOwner.set(owner, writes);
+    }
+    return (writes.get(decl.name.text) ?? []).some((node) => lowerer.resolveValueSymbol(node.left) === symbol &&
+        (lowerer.typeOf(node.right).flags & (ts.TypeFlags.Any | ts.TypeFlags.Unknown)) !== 0);
 }
 function immediatelyGuardedAbsenceProbe(lowerer, decl) {
     if (decl.type || !ts.isIdentifier(decl.name) || !decl.initializer)
@@ -4257,11 +4308,10 @@ function lowerDynSwitch(lowerer, stmt, disc, labels) {
         if (test.kind === "unitLit") {
             return { kind: "dynTest", test: test.unit, value: stableDisc, type: BOOL, loc: locOf(expression) };
         }
-        if (test.type.kind !== "string" && test.type.kind !== "f64" &&
-            test.type.kind !== "bool" && test.type.kind !== "dyn") {
+        if (!lowerer.dynConvertible(test.type)) {
             lowerer.unsupported("SC1100", expression, "switch case values that cannot compare strictly with 'unknown'");
         }
-        return { kind: "dynScalarEq", left: stableDisc, right: test, type: BOOL, loc: locOf(expression) };
+        return { kind: "dynScalarEq", left: stableDisc, right: lowerer.coerceInto(expression, test, DYN), type: BOOL, loc: locOf(expression) };
     });
 }
 function lowerBranchSwitch(lowerer, stmt, disc, labels, compare) {
@@ -4954,6 +5004,11 @@ export function lowerExprStatement(lowerer, expr) {
                 loc: locOf(expr),
             };
         }
+        if (opKind === ts.SyntaxKind.EqualsToken || (opKind >= ts.SyntaxKind.FirstCompoundAssignment && opKind <= ts.SyntaxKind.LastCompoundAssignment)) {
+            const urlWrite = lowerUrlAssignment(lowerer, expr);
+            if (urlWrite)
+                return { kind: "exprStmt", expr: urlWrite, loc: locOf(expr) };
+        }
         if (opKind === ts.SyntaxKind.EqualsToken) {
             const callableWrite = lowerNativeFunctionAssignment(lowerer, expr);
             if (callableWrite)
@@ -5213,6 +5268,13 @@ export function lowerExprStatement(lowerer, expr) {
                 }
                 if (!expr.left.questionDotToken) {
                     const recv = tryLowerExpression(lowerer, expr.left.expression);
+                    if (recv && (recv.type.kind === "dyn" || isJsSourceFile(expr.getSourceFile()) &&
+                        recv.type.kind === "union" && lowerer.dynConvertible(recv.type))) {
+                        const loc = locOf(expr);
+                        return { kind: "exprStmt", expr: { kind: "libCall", fn: "dyn.keySet", args: [lowerer.coerceInto(expr.left.expression, recv, DYN),
+                                    { kind: "strLit", value: expr.left.name.text, type: STRING, loc },
+                                    lowerer.lowerExprExpecting(expr.right, DYN)], type: VOID, loc }, loc };
+                    }
                     if (recv?.type.kind === "object" && recv.type.className === "%Error") {
                         const loc = locOf(expr);
                         return { kind: "exprStmt", expr: { kind: "libCall", fn: "dyn.keySet", args: [
@@ -5322,6 +5384,16 @@ export function lowerExprStatement(lowerer, expr) {
     if ((ts.isPrefixUnaryExpression(expr) || ts.isPostfixUnaryExpression(expr)) &&
         (expr.operator === ts.SyntaxKind.PlusPlusToken ||
             expr.operator === ts.SyntaxKind.MinusMinusToken)) {
+        if (ts.isPropertyAccessExpression(expr.operand) || ts.isElementAccessExpression(expr.operand)) {
+            // Statement and value positions share ToNumeric and reference order.
+            // Namespace/expando globals retain their direct binding path below.
+            const binding = ts.isPropertyAccessExpression(expr.operand)
+                ? expandoWritableTarget(lowerer, expr.operand) ?? nsWritableTarget(lowerer, expr.operand)
+                : null;
+            if (binding)
+                return lowerIncDecToTarget(lowerer, expr, binding);
+            return { kind: "exprStmt", expr: lowerIncDec(lowerer, expr, ts.isPrefixUnaryExpression(expr)), loc: locOf(expr) };
+        }
         // Statement position only: pre/post distinction is unobservable, so
         // both desugar to `x = x ± 1`.
         if (ts.isPropertyAccessExpression(expr.operand) ||
@@ -6638,6 +6710,7 @@ export function lowerForOf(lowerer, stmt) {
     }
     iterSrc ??= stmt.expression;
     let iterable = lowerer.lowerExpr(iterSrc);
+    let tupleSource = null;
     // A nested loop receiver can be an OOB-safe array read from the outer
     // loop (`for (const row of grid) for (const cell of row)`). The checker
     // sees the inner value as an array, while its runtime slot retains
@@ -6650,7 +6723,8 @@ export function lowerForOf(lowerer, stmt) {
     if (iterable.type.kind === "union" && checkerIterable !== null &&
         (checkerIterable.kind === "array" || checkerIterable.kind === "map" || checkerIterable.kind === "set" ||
             checkerIterable.kind === "bytes" || checkerIterable.kind === "string" || checkerIterable.kind === "searchParams" ||
-            checkerIterable.kind === "generator" || checkerIterable.kind === "object")) {
+            checkerIterable.kind === "generator" || checkerIterable.kind === "object" ||
+            (checkerIterable.kind === "record" && lowerer.shapes.get(checkerIterable.shapeId)?.tuple))) {
         const helper = lowerer.narrowedArmHelper(iterable.type.unionId, checkerIterable, locOf(iterSrc));
         if (helper)
             iterable = { kind: "call", callee: helper, args: [iterable], type: checkerIterable, loc: locOf(iterSrc) };
@@ -6702,62 +6776,28 @@ export function lowerForOf(lowerer, stmt) {
         }
         if (iterable.type.kind === "record" &&
             lowerer.shapes.get(iterable.type.shapeId)?.tuple) {
-            // A tuple read PURELY iterates: the positions snapshot into a
-            // fresh array at loop entry and the ordinary array for-of runs
-            // over it — the allowlist-iteration idiom. HOMOGENEOUS tuples
-            // (`["a", "b"] as const`) snapshot at their one position type;
-            // heterogeneous tuples ([string, boolean]) snapshot into the
-            // positions' UNION when it interns, each read wrapping into its
-            // arm — exactly the string|boolean the checker gives the loop
-            // variable. Pure receivers only (the reads re-emit per position);
-            // JS reads positions lazily, so a body that WRITES a later
-            // position of a mutable tuple would observe its old value here —
-            // readonly (as-const) tuples, the shape that actually occurs,
-            // cannot be written at all.
+            // Retain the tuple once and read positions lazily through the
+            // indexed loop below. Copying positions into an array would hide
+            // writes made by earlier iterations and reject computed receivers.
             const shape = lowerer.shapes.get(iterable.type.shapeId);
-            const byIndex = [...shape.fields].sort((a, b) => Number(a.name) - Number(b.name));
-            const first = byIndex[0]?.type;
-            const homogeneous = first !== undefined && byIndex.every((f) => typeEquals(f.type, first));
-            let elemT = homogeneous ? first : null;
-            if (!homogeneous && byIndex.length > 0) {
-                const arms = [];
-                for (const f of byIndex) {
-                    const arm = f.type.kind === "union" ? null : f.type;
-                    if (arm === null) {
-                        elemT = null;
-                        break;
-                    }
-                    if (!arms.some((a) => typeEquals(a, arm)))
-                        arms.push(arm);
-                    elemT = { kind: "union", unionId: lowerer.unions.intern(arms) };
+            const fields = [...shape.fields].sort((a, b) => Number(a.name) - Number(b.name));
+            const first = fields[0]?.type;
+            const homogeneous = first !== undefined && fields.every((field) => typeEquals(field.type, first));
+            const arms = [];
+            if (!homogeneous) {
+                for (const field of fields) {
+                    const types = field.type.kind === "union" ? lowerer.unions.get(field.type.unionId).arms : [field.type];
+                    for (const type of types)
+                        if (!arms.some((arm) => typeEquals(arm, type)))
+                            arms.push(type);
                 }
             }
-            if (elemT !== null && isSafeToRepeat(iterable)) {
-                const loc = locOf(stmt.expression);
-                const shapeId = iterable.type.shapeId;
-                const snapshotElem = elemT;
-                iterable = {
-                    kind: "arrayLit",
-                    elems: byIndex.map((f) => {
-                        const read = {
-                            kind: "recordGet",
-                            obj: iterable,
-                            shapeId,
-                            field: f.name,
-                            type: f.type,
-                            loc,
-                        };
-                        return typeEquals(f.type, snapshotElem)
-                            ? read
-                            : lowerer.coerceInto(stmt.expression, read, snapshotElem);
-                    }),
-                    type: arrayOf(snapshotElem),
-                    loc,
-                };
-            }
-            else {
-                lowerer.noLowering("for-of over tuples", stmt.expression, "tuples with union-typed or unrepresentable positions are fixed-shape — read t[0], t[1], ... directly (plain-position tuples purely iterate)");
+            const elem = homogeneous ? first : arms.length === 1 ? arms[0] : arms.length > 1
+                ? { kind: "union", unionId: lowerer.unions.intern(arms) } : undefined;
+            if (elem === undefined) {
+                lowerer.noLowering("for-of over tuples", stmt.expression, "tuple positions must have represented value types");
             }
+            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
@@ -6775,20 +6815,21 @@ export function lowerForOf(lowerer, stmt) {
         if (iterable.type.kind === "dyn") {
             return lowerForOfDyn(lowerer, stmt, iterable, labels);
         }
-        if (iterable.type.kind !== "array") {
+        if (tupleSource === null) {
             lowerer.badType(stmt.expression, lowerer.typeOf(stmt.expression));
         }
     }
-    const yieldedT = arrayValueType(lowerer, iterable.type.elem);
+    const elementType = iterable.type.kind === "array" ? iterable.type.elem : tupleSource.elem;
+    const yieldedT = tupleSource === null ? arrayValueType(lowerer, elementType) : elementType;
     let elemValueT = yieldedT;
     let awaitPromiseTag = null;
     if (awaitArray) {
         let promiseElem = null;
-        if (iterable.type.elem.kind === "promise") {
-            promiseElem = iterable.type.elem;
+        if (elementType.kind === "promise") {
+            promiseElem = elementType;
         }
-        else if (iterable.type.elem.kind === "union") {
-            const arms = lowerer.unions.get(iterable.type.elem.unionId)?.arms;
+        else if (elementType.kind === "union") {
+            const arms = lowerer.unions.get(elementType.unionId)?.arms;
             if (arms?.length === 2 && arms.some((arm) => arm.kind === "undefinedT")) {
                 const arm = arms.find((candidate) => candidate.kind === "promise");
                 if (arm?.kind === "promise")
@@ -6813,7 +6854,7 @@ export function lowerForOf(lowerer, stmt) {
             awaitPromiseTag = lowerer.armTag(yieldedT.unionId, promiseElem);
             elemValueT = lowerer.withUndefinedArm(promiseElem.inner);
         }
-        else if (!nonThenable(iterable.type.elem)) {
+        else if (!nonThenable(elementType)) {
             lowerer.unsupported("SC1070", stmt.expression, "for-await over array values that may be promises or thenables");
         }
     }
@@ -6828,7 +6869,28 @@ export function lowerForOf(lowerer, stmt) {
         const needsClose = awaitArray ? lowerer.declareHiddenLocal("%arrayIteratorNeedsClose", BOOL) : null;
         if (needsClose)
             needsClose.mutable = true;
-        const yielded = arrayValueRead(lowerer, varRef(source.id, sourceT, loc), varRef(cursor.id, F64, loc), sourceT.elem, loc);
+        let yielded;
+        if (tupleSource !== null) {
+            const tuple = tupleSource;
+            const read = (index) => {
+                const field = tuple.fields[index];
+                return lowerer.coerceInto(stmt.expression, {
+                    kind: "recordGet", obj: varRef(source.id, sourceT, loc), shapeId: tuple.shapeId,
+                    field: field.name, type: field.type, loc,
+                }, elementType);
+            };
+            yielded = read(tuple.fields.length - 1);
+            for (let index = tuple.fields.length - 2; index >= 0; index--) {
+                yielded = {
+                    kind: "ternary", cond: {
+                        kind: "bin", op: "===", left: varRef(cursor.id, F64, loc), right: numLit(index, loc), type: BOOL, loc,
+                    }, then: read(index), else_: yielded, type: elementType, loc,
+                };
+            }
+        }
+        else {
+            yielded = arrayValueRead(lowerer, varRef(source.id, sourceT, loc), varRef(cursor.id, F64, loc), elementType, loc);
+        }
         const init = awaitPromiseTag === null ? yielded : {
             kind: "awaitUnionExpr", value: yielded, promiseTag: awaitPromiseTag, type: elemValueT, loc,
         };
@@ -6853,9 +6915,9 @@ export function lowerForOf(lowerer, stmt) {
             finallyBody: null,
             loc,
         } : readValue;
-        const length = () => ({
+        const length = () => tupleSource !== null ? numLit(tupleSource.fields.length, loc) : {
             kind: "arrIntrinsic", method: "length", receiver: varRef(source.id, sourceT, loc), args: [], type: F64, loc,
-        });
+        };
         const loop = {
             kind: "for",
             init: { kind: "varDecl", localId: cursor.id, init: numLit(0, loc), loc },
@@ -6992,7 +7054,7 @@ export function lowerForOf(lowerer, stmt) {
         }
         const local = lowerer.declareLocal(decl.name, decl.name.text, elemValueT, isLet);
         const declaredElement = lowerer.mapTypeOf(lowerer.typeOf(decl.name));
-        if (!typeEquals(elemValueT, sourceT.elem) ||
+        if (!typeEquals(elemValueT, elementType) ||
             (declaredElement !== null && lowerer.runtimeOptionalWidening(elemValueT, declaredElement) !== null)) {
             const root = lowerer.runtimeOptionalRootOf(local);
             lowerer.runtimeOptionalLocals.add(root);
@@ -7822,9 +7884,8 @@ function lowerForOfString(lowerer, stmt, iterable, labels) {
    *   properties, so the enumeration is honestly EMPTY (zero iterations;
    *   the body typechecked but never evaluates — SEMANTICS.md documents
    *   the divergence).
-   * - class instances fence: which keys exist on one depends on runtime
-   *   property creation (unset declared fields, useDefineForClassFields)
-   *   that the struct model does not track — named, not guessed.
+   * - JavaScript program classes use their live property-creation table.
+   *   TypeScript and runtime-owned layouts keep the class-instance fence.
    * Bindings mirror for-of's: const/let declare the per-iteration string
    * local, `var` assigns the hoisted shared slot, a pre-declared
    * identifier target assigns per pass; destructuring heads are tsc
@@ -7835,7 +7896,17 @@ function lowerForIn(lowerer, stmt) {
     if (stdlibGlobalNameOf(lowerer, stmt.expression) === "globalThis") {
         return { kind: "block", body: [], loc };
     }
-    const receiver = lowerer.lowerExpr(stmt.expression);
+    let receiver = lowerer.lowerExpr(stmt.expression);
+    if (receiver.type.kind === "object") {
+        const info = lowerer.classes.get(receiver.type.className);
+        let root = info;
+        while (root?.base)
+            root = root.base;
+        if (info?.decl && isJsSourceFile(info.decl.getSourceFile()) && !info.def.runtime &&
+            !root?.def.runtime && !info.builtinError && !info.builtinEmitter && !info.builtinStream) {
+            receiver = lowerer.coerceToExpected(receiver, DYN);
+        }
+    }
     const recvT = receiver.type;
     if (recvT.kind === "dyn") {
         const recv = lowerer.declareHiddenLocal("%indyn", DYN);
@@ -7844,9 +7915,7 @@ function lowerForIn(lowerer, stmt) {
             kind: "dynCheck", value: { kind: "libCall", fn: "dyn.forInKeys", args: [ref], type: DYN, loc },
             type: arrayOf(STRING), loc,
         };
-        const loop = lowerForInOverKeys(lowerer, stmt, keys, labels, (key) => ({
-            kind: "libCall", fn: "dyn.hasKey", args: [ref, key], type: BOOL, loc,
-        }));
+        const loop = lowerForInOverKeys(lowerer, stmt, keys, labels, (key) => classForInHasKey(lowerer, ref, key, loc));
         return { kind: "block", body: [{ kind: "varDecl", localId: recv.id, init: receiver, loc }, loop], loc };
     }
     if (recvT.kind === "array")