@scriptc/compiler 0.2.0 → 0.2.2

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

@@ -1,3 +1,4 @@
+import { lowerDynObjectLiteral } from "./expressions/object-literals.js";
 import { InternalCompilerError } from "../../errors.js";
 /* Statement lowering: the statement dispatch (lowerStmt), variable
  * declarations including destructuring patterns, scoped blocks, control
@@ -10,7 +11,7 @@ import { lowerForAwaitGenerator, lowerForOfGenerator, lowerYieldStarStatement }
 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, dynUndefinedExpr, importCallHandleType, neverTaintedJsType, staticImportNamespaceType, stmtUsesIsland, uncheckedOverloadHandleCall } from "./lowerer.js";
-import { enforceLibBoundary } from "./lib-boundary.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";
 import { isNativeBuiltinValueInitializer } from "./lower-builtin-values.js";
@@ -18,18 +19,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 { lowerClassCallbackAssign } from "./class-callbacks.js";
+import { isClassCallback, lowerClassCallbackAssign } from "./class-callbacks.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 { lowerEnumDeclaration } from "./lower-enums.js";
-import { abstractPropertyDeclOf, aliasTypeofNarrows, isMatchSliceType, lowerAbsenceProbe, lowerCompoundValueToTarget, lowerElementCompound, lowerGroupsProjection, matchResultNamedGroupsOf, runtimeOptionalGuardIds, runtimeOptionalTrueIds, symbolFieldInfo, withRuntimeOptionalNarrowed } from "./lower-exprs.js";
+import { abstractPropertyDeclOf, aliasTypeofNarrows, isMatchSliceType, lowerAbsenceProbe, lowerCompoundValueToTarget, lowerElementCompound, lowerIncDec, lowerGroupsProjection, matchResultNamedGroupsOf, runtimeOptionalGuardIds, runtimeOptionalTrueIds, symbolFieldInfo, withRuntimeOptionalNarrowed } from "./lower-exprs.js";
 import { isSafeToRepeat } from "./expressions/evaluation-safety.js";
 import { globalSymbolKey } from "./expressions/global-symbols.js";
 import { lowerShortCircuitAssignment } from "./expressions/nullish-assignment.js";
@@ -69,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))
@@ -424,13 +428,16 @@ export function lowerStmts(lowerer, stmts) {
                 // fence — inside this statement's poison window, so a JS fence
                 // becomes the statement's runtimeFence exactly like every other
                 // deferred rejection.
-                if (lowered)
-                    enforceLibBoundary(lowerer, lowered);
-                if (!appended) {
+                if (lowered) {
+                    const body = [];
                     if (Array.isArray(lowered))
-                        out.push(...lowered);
-                    else if (lowered)
-                        out.push(lowered);
+                        body.push(...lowered);
+                    else
+                        body.push(lowered);
+                    const rewritten = lowerSurplusCalls(lowerer, body);
+                    enforceLibBoundary(lowerer, rewritten);
+                    if (!appended)
+                        out.push(...rewritten);
                 }
                 // Island accounting (--dynamic coverage): a statement that lowered
                 // but carries island constructs compiles DYNAMICALLY — its work
@@ -588,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;
@@ -1030,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));
@@ -1562,8 +1571,11 @@ export function lowerDestructuringDecl(lowerer, decl, isLet) {
    * bound name, recursing through hidden temps for nested patterns. */
 export function lowerBindingPattern(lowerer, pattern, srcRef, srcType, isLet, out, dynSpell, allowDynObject = false) {
     if (ts.isObjectBindingPattern(pattern)) {
-        const patternSymbol = lowerer.typeOf(pattern).getSymbol();
+        const patternType = lowerer.typeOf(pattern);
+        const patternSymbol = patternType.getSymbol();
         allowDynObject ||= patternSymbol?.name === "SegmentData" && lowerer.isStdlibSymbol(patternSymbol);
+        allowDynObject ||= (patternType.flags & ts.TypeFlags.Object) !== 0 && lowerer.mapTypeOf(patternType)?.kind === "dyn";
+        allowDynObject ||= (patternType.flags & ts.TypeFlags.Any) !== 0;
     }
     const present = patternSourceValue(lowerer, srcRef(), ts.isArrayBindingPattern(pattern), out, locOf(pattern), dynSpell);
     if (!typeEquals(present.type, srcType)) {
@@ -1724,13 +1736,13 @@ export function lowerBindingPattern(lowerer, pattern, srcRef, srcType, isLet, ou
             out.push({
                 kind: "varDecl",
                 localId: pack.id,
-                init: {
+                init: pattern.elements.some((element) => ts.isBindingElement(element) && element.dotDotDotToken) ? {
                     kind: "libCall",
                     fn: "dyn.iterPack",
                     args: [srcRef(), { kind: "strLit", value: dynSpell ?? "", type: STRING, loc }],
                     type: DYN,
                     loc,
-                },
+                } : { kind: "dynIterN", value: srcRef(), count: pattern.elements.length, ...(dynSpell ? { notIterableMessage: dynSpell } : {}), type: DYN, loc },
                 loc,
             });
             pattern.elements.forEach((el, i) => {
@@ -1738,7 +1750,9 @@ export function lowerBindingPattern(lowerer, pattern, srcRef, srcType, isLet, ou
                     return; // hole: the position skips
                 const elLoc = locOf(el);
                 if (el.dotDotDotToken) {
-                    lowerer.unsupported("SC1031", el, "rest elements over checked-dynamic sources");
+                    lowerer.bindPatternTarget(el.name, { kind: "dynInvoke", recv: varRef(pack.id, DYN, elLoc),
+                        method: "slice", calleeName: "Array.prototype.slice", args: [lowerer.coerceToExpected(numLit(i, elLoc), DYN)], type: DYN, loc: elLoc }, isLet, out);
+                    return;
                 }
                 let value = {
                     kind: "dynKeyGet",
@@ -1752,7 +1766,7 @@ export function lowerBindingPattern(lowerer, pattern, srcRef, srcType, isLet, ou
                     // its value converting into the checked-dynamic tree like any dyn-slot value.
                     const rl = lowerer.declareHiddenLocal("%delem", DYN);
                     out.push({ kind: "varDecl", localId: rl.id, init: value, loc: elLoc });
-                    const dflt = lowerer.coerceToExpected(lowerer.lowerExpr(el.initializer), DYN);
+                    const dflt = lowerer.coerceInto(el.initializer, lowerer.lowerExpr(el.initializer), DYN);
                     if (dflt.type.kind !== "dyn") {
                         lowerer.unsupported("SC1031", el.initializer, `defaults of '${lowerer.fmt(dflt.type)}' type over checked-dynamic sources (the value cannot convert into the checked-dynamic tree)`);
                     }
@@ -1875,14 +1889,30 @@ 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 === "dyn" &&
-        (isJsSourceFile(pattern.getSourceFile()) || allowDynObject)) {
+    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)
                 continue;
             const loc = locOf(el);
             if (el.dotDotDotToken) {
-                lowerer.unsupported("SC1031", el, "rest elements over checked-dynamic sources (the remaining-fields object has no lowering yet)");
+                const keys = [];
+                for (const sibling of pattern.elements) {
+                    if (sibling === el || sibling.dotDotDotToken)
+                        continue;
+                    const key = sibling.propertyName ?? sibling.name;
+                    const name = ts.isIdentifier(key) || ts.isStringLiteralLike(key) || ts.isNumericLiteral(key) || ts.isComputedPropertyName(key)
+                        ? patternKeyNameOf(lowerer, key) : null;
+                    if (name === null)
+                        lowerer.unsupported("SC1031", sibling, "rest bindings beside runtime computed keys");
+                    keys.push({ kind: "dynFrom", value: { kind: "strLit", value: name, type: STRING, loc }, type: DYN, loc });
+                }
+                lowerer.bindPatternTarget(el.name, { kind: "libCall", fn: "dyn.objectRest", args: [srcRef(),
+                        { kind: "dynArrLit", elems: keys, type: DYN, loc }], type: DYN, loc }, isLet, out, allowDynObject);
+                continue;
             }
             const prop = el.propertyName ?? el.name;
             const propName = ts.isIdentifier(prop) || ts.isComputedPropertyName(prop) || ts.isStringLiteralLike(prop) || ts.isNumericLiteral(prop)
@@ -2117,6 +2147,17 @@ export function lowerBindingPattern(lowerer, pattern, srcRef, srcType, isLet, ou
             lowerer.bindPatternTarget(el.name, value, isLet, out);
             continue;
         }
+        if (!fieldType && isJsSourceFile(el.getSourceFile())) {
+            // Inferred JavaScript shapes can omit optional own properties and
+            // inherit values from their prototype. Read the live checked view.
+            const loc = locOf(el);
+            let value = { kind: "dynKeyGet", value: lowerer.coerceToExpected(srcRef(), DYN),
+                key: { kind: "strLit", value: propName, type: STRING, loc }, type: DYN, loc };
+            if (el.initializer)
+                value = applyBindingDefault(lowerer, el, value);
+            lowerer.bindPatternTarget(el.name, value, isLet, out);
+            continue;
+        }
         if (!fieldType) {
             // The pattern names a field the source SHAPE does not carry —
             // `for (let {x = 1} of [{}])` (signature 08): tsc types the binding
@@ -2437,6 +2478,14 @@ function stdlibGlobalTokenDestructure(lowerer, decl, isLet) {
    * alike (the caller's bindPatternTarget recurses through the latter). */
 function applyBindingDefault(lowerer, el, value) {
     const name = el.name; // callers skip nameless elisions
+    if (value.type.kind === "dyn") {
+        const loc = value.loc;
+        const local = lowerer.declareHiddenLocal("%bindingDefault", DYN);
+        const ref = varRef(local.id, DYN, loc);
+        const result = { kind: "ternary", cond: { kind: "dynTest", test: "undefined", value: ref, type: BOOL, loc },
+            then: lowerer.lowerExprExpecting(el.initializer, DYN), else_: ref, type: DYN, loc };
+        return { kind: "seqExpr", stmts: [{ kind: "varDecl", localId: local.id, init: value, loc }], result, type: DYN, loc };
+    }
     if (value.type.kind !== "union")
         return value; // no undefined arm: dead default
     if (lowerer.armTag(value.type.unionId, UNDEFINED_T) < 0)
@@ -3282,7 +3331,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";
                 }
@@ -3504,7 +3553,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 = {
@@ -3537,7 +3587,11 @@ export function lowerVarDecl(lowerer, decl, isLet) {
             return null;
         }
         const raw = lowerVariableInitializer(lowerer, decl.initializer, g.type.kind === "dyn" && (isNativeBuiltinValueInitializer(lowerer, decl.initializer) ||
-            ts.isArrayLiteralExpression(decl.initializer)) ? DYN : undefined);
+            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;
@@ -3606,7 +3660,14 @@ export function lowerVarDecl(lowerer, decl, isLet) {
     // poisons, still declare the local when its type is representable, so
     // later references to this name don't produce cascading errors.
     const inferredObjectType = isJsSourceFile(decl.getSourceFile()) ? lowerer.mapTypeOf(lowerer.typeOf(decl.name)) : null;
-    const expandsObject = inferredObjectType?.kind === "record" && jsObjectBindingExpands(lowerer, decl, inferredObjectType);
+    const inferredObjectArms = inferredObjectType?.kind === "union"
+        ? 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)) ||
+        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 &&
@@ -3661,6 +3722,8 @@ export function lowerVarDecl(lowerer, decl, isLet) {
         staticImportNamespaceType(lowerer, decl.initializer) ??
         (init.type.kind === "moduleNs" ? init.type : null) ??
         (init.type.kind === "dyn" ? DYN : null);
+    if (isJsSourceFile(decl.getSourceFile()) && !decl.type && !hasJsTypeAnnotation(decl) && init.type.kind === "func")
+        type = init.type;
     if (lowerer.implicitParamTypes !== null &&
         init.type.kind === "dyn" &&
         isJsSourceFile(decl.getSourceFile()) &&
@@ -3669,10 +3732,12 @@ export function lowerVarDecl(lowerer, decl, isLet) {
     }
     const preservesObjectIdentity = init.type.kind === "dyn" &&
         (inferredObjectType?.kind === "record" || inferredObjectType?.kind === "array" ||
+            (isJsSourceFile(decl.getSourceFile()) && inferredObjectArms.some((arm) => arm.kind === "record") &&
+                inferredObjectArms.every((arm) => isUnitType(arm) || arm.kind === "record")) ||
             (isJsSourceFile(decl.getSourceFile()) && inferredObjectType !== null &&
-                (inferredObjectType.kind === "date" || inferredObjectType.kind === "func" || jsOpenObjectType(decl, inferredObjectType, lowerer.shapes, lowerer.unions).kind === "dyn")) ||
+                (inferredObjectType.kind === "date" || inferredObjectType.kind === "func" || inferredObjectType.kind === "object" || jsOpenObjectType(decl, inferredObjectType, lowerer.shapes, lowerer.unions).kind === "dyn")) ||
             (isJsSourceFile(decl.getSourceFile()) && inferredObjectType !== null &&
-                (isUnitType(inferredObjectType) || inferredObjectType.kind === "union" && lowerer.unions.get(inferredObjectType.unionId)?.arms.every(isUnitType)))) &&
+                (inferredObjectType.kind === "void" || isUnitType(inferredObjectType) || inferredObjectType.kind === "union" && lowerer.unions.get(inferredObjectType.unionId)?.arms.every(isUnitType)))) &&
         !decl.type && !hasJsTypeAnnotation(decl);
     if (expandsObject || preservesObjectIdentity || (isJsSourceFile(decl.getSourceFile()) &&
         !decl.type && isNativeBuiltinValueInitializer(lowerer, decl.initializer))) {
@@ -3694,6 +3759,10 @@ export function lowerVarDecl(lowerer, decl, isLet) {
         if (shape && shape.fields.length === 0 && !shape.indexValue && !shape.tuple)
             type = DYN;
     }
+    if (isLet && type !== null && isJsSourceFile(decl.getSourceFile()) && !decl.type && !hasJsTypeAnnotation(decl) &&
+        (type.kind === "object" || type.kind === "symbol" || jsBindingHasOpenWrites(lowerer, decl))) {
+        type = DYN;
+    }
     const returnedEmptyArrayType = npmStaticReturnedEmptyArrayType(lowerer, decl);
     if (returnedEmptyArrayType !== null) {
         type = returnedEmptyArrayType;
@@ -3753,6 +3822,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
@@ -3764,6 +3835,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):
@@ -3799,7 +3873,7 @@ export function lowerVarDecl(lowerer, decl, isLet) {
         lowerer.badType(decl.name, lowerer.typeOf(decl.name));
     let settledType = type;
     if (!isLet && isJsSourceFile(decl.getSourceFile()) && !hasJsTypeAnnotation(decl) && decl.initializer && ts.isNewExpression(decl.initializer)) {
-        settledType = objectFactorySignature(lowerer, decl.initializer)?.returnType ?? settledType;
+        settledType = init.type.kind === "dyn" ? DYN : objectFactorySignature(lowerer, decl.initializer)?.returnType ?? settledType;
     }
     const arithmeticType = decl.initializer ? lowerer.runtimeOptionalArithmeticTypes.get(decl.initializer) : undefined;
     const isStringArithmeticUnion = (t) => {
@@ -3934,6 +4008,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) ||
@@ -3954,6 +4043,8 @@ function lowerVariableInitializer(lowerer, node, expected) {
         return ts.isArrayLiteralExpression(value) || ts.isConditionalExpression(value)
             ? lowerer.lowerExprExpecting(node, expected) : lowerer.lowerExpr(node);
     }
+    if (expected?.kind === "dyn")
+        return lowerDynObjectLiteral(lowerer, value);
     const previous = new Map();
     for (const property of value.properties) {
         if (!ts.isPropertyAssignment(property) || !ts.isComputedPropertyName(property.name))
@@ -3987,7 +4078,7 @@ function jsObjectBindingExpands(lowerer, decl, type) {
     let initializer = decl.initializer;
     while (ts.isParenthesizedExpression(initializer))
         initializer = initializer.expression;
-    if (!ts.isObjectLiteralExpression(initializer))
+    if (!ts.isObjectLiteralExpression(initializer) && !ts.isCallExpression(initializer))
         return false;
     if (hasJsTypeAnnotation(decl))
         return false;
@@ -4050,6 +4141,13 @@ function jsObjectBindingExpands(lowerer, decl, type) {
         }
         if (ts.isDeleteExpression(node) && property(node.expression) !== undefined)
             expands = true;
+        if (ts.isCallExpression(node) && ts.isPropertyAccessExpression(node.expression) && node.expression.name.text === "setPrototypeOf" &&
+            lowerer.isStdlibGlobal(node.expression.expression, "Object")) {
+            const target = node.arguments[0];
+            const sym = target && ts.isIdentifier(target) ? lowerer.resolveValueSymbol(target) : undefined;
+            if (sym && aliases.has(sym))
+                expands = true;
+        }
         ts.forEachChild(node, visit);
     };
     visit(scope);
@@ -4059,6 +4157,36 @@ export function hasJsTypeAnnotation(decl) {
     const statement = decl.parent?.parent;
     return !!statement && /@type\b/.test(decl.getSourceFile().text.slice(statement.pos, decl.getStart()));
 }
+/** Inferred JS scalar initializers do not constrain later writes through
+ * an any-valued callback. Keep those bindings open, including captured writes. */
+export function jsBindingHasOpenWrites(lowerer, decl) {
+    if (!isJsSourceFile(decl.getSourceFile()) || decl.type || hasJsTypeAnnotation(decl) || !ts.isIdentifier(decl.name))
+        return false;
+    const symbol = lowerer.resolveValueSymbol(decl.name);
+    if (!symbol)
+        return false;
+    let owner = decl;
+    while (owner.parent && !ts.isFunctionLike(owner) && !ts.isSourceFile(owner))
+        owner = owner.parent;
+    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)
         return false;
@@ -4171,11 +4299,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) {
@@ -4228,9 +4355,10 @@ function lowerBranchSwitch(lowerer, stmt, disc, labels, compare) {
    *   narrowing tests (`e instanceof C` over hierarchy classes, `typeof e
    *   === "string"/"number"/"boolean"`), reads under a proven narrow
    *   (caughtRead bridges them with caughtNarrow, trust-the-checker like
-   *   unionNarrow), and rethrow (`throw e`). Raw uses, captures, and
-   *   assignment are fenced (SC1063 and friends); destructuring patterns
-   *   are SC1062. The `: any` / `: unknown` annotations tsc admits both
+   *   unionNarrow), and rethrow (`throw e`). Unsupported raw uses and
+   *   assignments are fenced (SC1063 and friends); destructuring patterns
+   *   are SC1062. Captures retain the snapshot beyond the catch scope.
+   *   The `: any` / `: unknown` annotations tsc admits both
    *   lower the same way (tsc narrows either through the tests).
    * - `finally` runs on normal completion, exception paths, and every
    *   abrupt completion that crosses it. Return values are snapshotted
@@ -4343,6 +4471,16 @@ function lowerDeleteStatement(lowerer, expr) {
         };
     }
     let obj = lowerer.lowerExpr(target.expression);
+    if (isJsSourceFile(expr.getSourceFile()) && obj.type.kind === "object") {
+        const info = lowerer.classes.get(obj.type.className);
+        const keyType = ts.isElementAccessExpression(target) ? lowerer.typeOf(target.argumentExpression) : null;
+        const name = ts.isPropertyAccessExpression(target) ? target.name.text
+            : keyType?.isStringLiteralType() ? keyType.value : null;
+        if (info && name !== null && isClassCallback(lowerer, info, name)) {
+            obj = { kind: "call", callee: classPropertiesHelper(lowerer, loc).name,
+                args: [lowerer.coerceToExpected(obj, DYN)], type: DYN, loc };
+        }
+    }
     if (isJsSourceFile(expr.getSourceFile()) && obj.type.kind === "func" && lowerer.dynConvertible(obj.type)) {
         obj = lowerer.coerceToExpected(obj, DYN);
     }
@@ -4650,7 +4788,7 @@ function lowerCjsSingleValueExport(lowerer, expr, loc) {
         const exportSym = lowerer.checker.getSymbolAtLocation(expr.left);
         if (exportSym && !lowerer.classBySymbol.has(exportSym))
             lowerer.classBySymbol.set(exportSym, info);
-        return { kind: "block", body: [], loc };
+        return { kind: "exprStmt", expr: lowerer.lowerClassExpression(rhs), loc };
     }
     const g = lowerer.globalsByDeclNode.get(expr);
     if (!g)
@@ -5092,6 +5230,11 @@ export function lowerExprStatement(lowerer, expr) {
                     if (viaStream)
                         return viaStream;
                 }
+                if (expr.left.name.text === "lastIndex" && lowerer.mapTypeOf(lowerer.typeOf(expr.left.expression))?.kind === "regex") {
+                    const loc = locOf(expr);
+                    return { kind: "exprStmt", expr: { kind: "libCall", fn: "regex.resetLastIndex",
+                            args: [lowerer.lowerExpr(expr.left.expression), lowerer.lowerExprExpecting(expr.right, F64)], type: VOID, loc }, loc };
+                }
                 const unionWrite = lowerUnionFieldWrite(lowerer, expr.left, expr.right);
                 if (unionWrite)
                     return unionWrite;
@@ -5111,6 +5254,20 @@ 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: [
+                                    lowerer.coerceToExpected(recv, DYN), { kind: "strLit", value: expr.left.name.text, type: STRING, loc },
+                                    lowerer.lowerExprExpecting(expr.right, DYN),
+                                ], type: VOID, loc }, loc };
+                    }
                     if (recv && isDynTypedRefType(recv.type)) {
                         const info = lowerer.classes.get(recv.type.className);
                         if (info && !info.def.runtime && !info.builtinError && !info.builtinEmitter && !info.builtinStream &&
@@ -5213,6 +5370,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) ||
@@ -7713,9 +7880,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
@@ -7726,7 +7892,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);
@@ -7735,9 +7911,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")