@scriptc/compiler 0.1.6 → 0.2.0

package/dist/frontend/lowering/expressions/object-literals.js

@@ -1,15 +1,17 @@
 import { InternalCompilerError } from "../../../errors.js";
 import * as ts from "../../ts7/adapter.js";
-import { BOOL, DYN, F64, STRING, UNDEFINED_T, VOID, arrayOf, canDynCheckTo, isUnitType, shapeHasAccessorSlots, typeEquals, } from "../../../ir/ir.js";
+import { BOOL, DYN, F64, JSVAL, STRING, UNDEFINED_T, VOID, arrayOf, canDynCheckTo, isUnitType, shapeHasAccessorSlots, typeEquals, } from "../../../ir/ir.js";
 import { isCjsExportTableLiteral, isJsSourceFile, locOf } from "../../program.js";
 import { NARROW_FIRST } from "../surfaces.js";
 import { recordShapeMismatchDiag } from "../../../diagnostics/diagnostic.js";
 import { PoisonError, dynUndefinedExpr } from "../lowerer.js";
 import { lowerIndexMergeHelper } from "../lower-containers.js";
 import { isGenericCallableMemberType } from "../../type-mapper.js";
-import { numLit, varRef } from "../../../ir/build.js";
+import { numLit, strLit, varRef } from "../../../ir/build.js";
 import { isSafeToRepeat } from "./evaluation-safety.js";
 import { tryLowerExpression } from "./try-lower-expression.js";
+import { fenceSymbolFieldCopy } from "../symbol-fields.js";
+import { planUnionRetag } from "../union-retag.js";
 /** `{ a: 1, b: "x" }` → recordLit. The record type comes from the
  * contextual type when tsc has one (annotated declarations, arguments,
  * nested literals) and from the literal's own type otherwise — both intern
@@ -31,10 +33,11 @@ function settledDropNames(lowerer, tsType) {
             !lowerer.checker.declarationsOf(sym).some((d) => ts.isInterfaceDeclaration(d) && lowerer.isStdlibFile(d.getSourceFile()))) {
             continue;
         }
-        if (sym.name === "PromiseFulfilledResult")
-            (names ??= new Set()).add("value");
-        if (sym.name === "PromiseRejectedResult")
-            (names ??= new Set()).add("reason");
+        if (sym.name === "PromiseFulfilledResult" || sym.name === "PromiseRejectedResult") {
+            if (names === null)
+                names = new Set();
+            names.add(sym.name === "PromiseFulfilledResult" ? "value" : "reason");
+        }
     }
     return names;
 }
@@ -179,15 +182,30 @@ function propNameText(lowerer, name) {
  * dyn's String() for dyn operands — `{ [field]: v }` where field is a
  * checked-dynamic param). Values convert through the usual dyn boundary
  * (dynFrom's domain, functions box); a value with no dyn representation
- * fences per property. Spreads copy through dyn.assign in source order;
- * accessors stay fenced. */
+ * fences per property. Spreads create own data properties in source order;
+ * accessors retain their captured getter and setter closures. */
 export function lowerDynObjectLiteral(lowerer, expr, boxValue) {
     const loc = locOf(expr);
     let fields = [];
     let acc = null;
+    let hasAccessors = false;
     const flushFields = () => {
         if (fields.length === 0)
             return;
+        if (hasAccessors) {
+            for (const field of fields) {
+                const descriptor = { kind: "dynObjLit", type: DYN, loc, fields: [
+                        { key: { kind: "strLit", value: "value", type: STRING, loc }, value: field.value },
+                        ...["writable", "enumerable", "configurable"].map(name => ({
+                            key: strLit(name, loc),
+                            value: { kind: "dynFrom", value: { kind: "boolLit", value: true, type: BOOL, loc }, type: DYN, loc },
+                        })),
+                    ] };
+                acc = { kind: "libCall", fn: "dyn.defineProperty", args: [acc, lowerer.coerceToExpected(field.key, DYN), descriptor], type: DYN, loc };
+            }
+            fields = [];
+            return;
+        }
         const chunk = { kind: "dynObjLit", fields, type: DYN, loc };
         acc = acc === null
             ? chunk
@@ -198,6 +216,7 @@ export function lowerDynObjectLiteral(lowerer, expr, boxValue) {
         if (ts.isSpreadAssignment(prop)) {
             flushFields();
             const raw = lowerer.lowerExpr(prop.expression);
+            fenceSymbolFieldCopy(lowerer, prop.expression, raw.type);
             const source = boxValue
                 ? boxValue(prop.expression, raw)
                 : lowerer.coerceToExpected(raw, DYN);
@@ -205,14 +224,9 @@ export function lowerDynObjectLiteral(lowerer, expr, boxValue) {
                 lowerer.unsupported("SC1101", prop.expression, `spreading '${lowerer.fmt(source.type)}' into a checked-dynamic object literal`);
             }
             acc ??= { kind: "dynObjLit", fields: [], type: DYN, loc };
-            acc = { kind: "libCall", fn: "dyn.assign", args: [acc, source], type: DYN, loc: locOf(prop) };
+            acc = { kind: "libCall", fn: "dyn.copyDataProperties", args: [acc, source], type: DYN, loc: locOf(prop) };
             continue;
         }
-        if (!ts.isPropertyAssignment(prop) &&
-            !ts.isShorthandPropertyAssignment(prop) &&
-            !ts.isMethodDeclaration(prop)) {
-            lowerer.unsupported("SC1090", prop, "accessors in a runtime-keyed (computed-key) object literal");
-        }
         const name = prop.name;
         let key;
         if (ts.isComputedPropertyName(name)) {
@@ -222,10 +236,14 @@ export function lowerDynObjectLiteral(lowerer, expr, boxValue) {
             }
             else {
                 let k = lowerer.lowerExpr(name.expression);
-                if (k.type.kind === "f64" || k.type.kind === "bool" || k.type.kind === "dyn") {
+                if (k.type.kind === "symbol")
+                    k = lowerer.coerceToExpected(k, DYN);
+                else if (k.type.kind === "dyn")
+                    k = { kind: "libCall", fn: "dyn.propertyKey", args: [k], type: DYN, loc: locOf(name) };
+                else if (k.type.kind === "f64" || k.type.kind === "bool") {
                     k = { kind: "toString", operand: k, type: STRING, loc: locOf(name) };
                 }
-                if (k.type.kind !== "string") {
+                if (k.type.kind !== "string" && k.type.kind !== "dyn") {
                     lowerer.unsupported("SC1090", name, `'${lowerer.fmt(k.type)}'-typed computed property keys (string, number, boolean, and unknown keys stringify)`);
                 }
                 key = k;
@@ -240,6 +258,25 @@ export function lowerDynObjectLiteral(lowerer, expr, boxValue) {
         else {
             lowerer.unsupported("SC1090", prop, "non-identifier property names");
         }
+        if (ts.isGetAccessorDeclaration(prop) || ts.isSetAccessorDeclaration(prop)) {
+            flushFields();
+            hasAccessors = true;
+            acc ??= { kind: "dynObjLit", fields: [], type: DYN, loc };
+            if (!isJsSourceFile(expr.getSourceFile()))
+                lowerer.rejectThisInObjectMethod(prop.body ?? prop);
+            const fn = lowerer.lowerLambda(prop);
+            const descriptor = {
+                kind: "dynObjLit", type: DYN, loc: locOf(prop), fields: [
+                    { key: { kind: "strLit", value: ts.isGetAccessorDeclaration(prop) ? "get" : "set", type: STRING, loc }, value: lowerer.coerceToExpected(fn, DYN) },
+                    ...["enumerable", "configurable"].map(name => ({
+                        key: strLit(name, loc),
+                        value: { kind: "dynFrom", value: { kind: "boolLit", value: true, type: BOOL, loc }, type: DYN, loc },
+                    })),
+                ],
+            };
+            acc = { kind: "libCall", fn: "dyn.defineProperty", args: [acc, lowerer.coerceToExpected(key, DYN), descriptor], type: DYN, loc };
+            continue;
+        }
         const valueExpr = ts.isMethodDeclaration(prop)
             ? prop
             : ts.isShorthandPropertyAssignment(prop)
@@ -252,8 +289,10 @@ export function lowerDynObjectLiteral(lowerer, expr, boxValue) {
         const propDiagsBefore = lowerer.diags.length;
         try {
             const lowerValue = () => ts.isMethodDeclaration(prop)
-                ? (lowerer.rejectThisInObjectMethod(prop.body ?? prop), lowerer.lowerLambda(prop))
-                : lowerer.lowerExpr(valueExpr);
+                ? (isJsSourceFile(expr.getSourceFile()) ? lowerer.lowerLambda(prop) : (lowerer.rejectThisInObjectMethod(prop.body ?? prop), lowerer.lowerLambda(prop)))
+                : !boxValue && ts.isObjectLiteralExpression(valueExpr)
+                    ? lowerer.lowerExprExpecting(valueExpr, DYN)
+                    : lowerer.lowerExpr(valueExpr);
             raw =
                 fenceClosureProbe(lowerer, valueExpr, undefined, lowerValue) ??
                     lowerValue();
@@ -279,6 +318,11 @@ export function lowerDynObjectLiteral(lowerer, expr, boxValue) {
         let v = boxValue
             ? boxValue(valueExpr, raw)
             : lowerer.coerceToExpected(raw, DYN);
+        // A JS object's array-valued properties retain the same source array.
+        // Repeated references must compare equal and mutations remain shared.
+        if (!boxValue && isJsSourceFile(prop.getSourceFile()) && v.kind === "dynFrom" && v.value.type.kind === "array") {
+            v = { ...v, liveRef: true };
+        }
         if (v.type.kind !== "dyn") {
             const convDiagsBefore = lowerer.diags.length;
             try {
@@ -307,7 +351,9 @@ export function lowerDynObjectLiteral(lowerer, expr, boxValue) {
         fields.push({ key, value: v });
     }
     flushFields();
-    return acc ?? { kind: "dynObjLit", fields: [], type: DYN, loc };
+    if (acc !== null)
+        return acc;
+    return { kind: "dynObjLit", fields: [], type: DYN, loc };
 }
 /** Spreading a source whose shape carries accessor slots: Node's copy
  * invokes each getter exactly once in insertion order — even for keys a
@@ -319,6 +365,16 @@ function fenceAccessorSpreadSource(lowerer, prop, srcShape) {
         lowerer.unsupported("SC1090", prop, "object spread of sources carrying get/set accessor properties (Node invokes each getter once during the copy — the field-copy desugar cannot model the calls; bind the reads to consts first)");
     }
 }
+/** Only definitely present later records replace earlier defaults. A
+ * callback binding may store undefined despite its checker annotation. */
+function laterSpreadType(lowerer, expr) {
+    let source = expr;
+    while (ts.isParenthesizedExpression(source))
+        source = source.expression;
+    if (ts.isIdentifier(source))
+        return lowerer.lowerExpr(source).type;
+    return lowerer.mapTypeOf(lowerer.typeOf(source));
+}
 /** The JS trap-closure fallback for FUNCTION-VALUED object properties: a
  * lambda whose body fails to lower inside a JS object literal becomes a
  * closure of the field's exact func type whose body is the runtime fence —
@@ -379,33 +435,48 @@ function fenceClosureProbe(lowerer, node, slotType, attempt) {
  * (excess-property freshness — tsc already enforced it), every arm field
  * missing from the literal must be optional-flavored (an undefined-armed
  * union, or a dyn slot — the absent-completion rule), and each present
- * field's LITERAL type must fit the member's field type — literal against
- * literal decides by VALUE (the discriminant), everything else by the
- * widened IR pair under the width-lift relation. Exactly ONE fitting arm
+ * field's TypeScript type must fit the member's field type — literal against
+ * literal decides by VALUE (the discriminant), everything else through the
+ * checker. The chosen arm then directs construction of nested literals;
+ * probing their inferred IR layout too early can reject the right arm and
+ * select a smaller unrelated record that drops fields. Exactly ONE fitting arm
  * answers it; zero or several answer null and the caller keeps its
- * fences. Plain property-assignment/shorthand literals only — spreads,
- * accessors, methods, and unfoldable computed keys keep their own paths. */
+ * fences. A spread uses the checker's resulting properties so overridden
+ * discriminants and narrowed recursive source arms keep their identity.
+ * Accessors, methods, and unfoldable computed keys keep their own paths. */
 function literalUnionArmOf(lowerer, expr, tsType, recordArms) {
     if (!tsType.isUnionType())
         return null;
     const props = [];
+    let hasSpread = false;
     for (const p of expr.properties) {
         if (ts.isPropertyAssignment(p) && !ts.isComputedPropertyName(p.name)) {
-            props.push({ name: propNameText(lowerer, p.name), node: p.initializer });
+            props.push({ name: propNameText(lowerer, p.name), type: lowerer.typeOf(p.initializer) });
         }
         else if (ts.isShorthandPropertyAssignment(p) && ts.isIdentifier(p.name)) {
-            props.push({ name: p.name.text, node: p.name });
+            props.push({ name: p.name.text, type: lowerer.typeOf(p.name) });
+        }
+        else if (ts.isSpreadAssignment(p)) {
+            hasSpread = true;
         }
         else {
             return null;
         }
     }
-    /** litT fits ftT: unions per arm; literal-vs-literal by value; unit
-     * types only into their own unit; otherwise the widened IR pair must be
-     * equal or width-liftable. */
+    if (hasSpread) {
+        const own = lowerer.typeOf(expr);
+        // Conditional/union spreads need runtime selection, not one guessed arm.
+        if (own.isUnionType())
+            return null;
+        props.length = 0;
+        for (const property of lowerer.checker.getPropertiesOfType(own)) {
+            props.push({ name: property.name, type: lowerer.checker.getTypeOfSymbol(property) });
+        }
+    }
+    /** Cheap literal discriminants avoid checker traffic for unrelated arms.
+     * Compound types need the checker's semantic assignability, including
+     * recursive unions, never intersections, and contextual empty arrays. */
     const fits = (litT, ftT) => {
-        if (ftT.isUnionType())
-            return ts.constituentTypes(ftT).some((a) => fits(litT, a));
         if (ftT.isStringLiteralType())
             return litT.isStringLiteralType() && litT.value === ftT.value;
         if (ftT.isNumberLiteralType())
@@ -417,13 +488,7 @@ function literalUnionArmOf(lowerer, expr, tsType, recordArms) {
             return (litT.flags & ts.TypeFlags.Null) !== 0;
         if (ftT.flags & ts.TypeFlags.Undefined)
             return (litT.flags & ts.TypeFlags.Undefined) !== 0;
-        if (litT.flags & (ts.TypeFlags.Null | ts.TypeFlags.Undefined))
-            return false;
-        const li = lowerer.mapTypeOf(lowerer.checker.getBaseTypeOfLiteralType(litT));
-        const fi = lowerer.mapTypeOf(ftT);
-        if (!li || !fi)
-            return false;
-        return typeEquals(li, fi) || lowerer.widthLiftPlan(li, fi) !== null;
+        return lowerer.checker.isTypeAssignableTo(litT, ftT);
     };
     const armShapeIds = new Set(recordArms.map((a) => a.shapeId));
     const candidates = new Set();
@@ -456,14 +521,14 @@ function literalUnionArmOf(lowerer, expr, tsType, recordArms) {
             const sym = lowerer.checker.getPropertyOfType(member, p.name);
             if (!sym)
                 return false;
-            return fits(lowerer.typeOf(p.node), lowerer.checker.getTypeOfSymbol(sym));
+            return fits(p.type, lowerer.checker.getTypeOfSymbol(sym));
         });
         if (fieldsFit)
             candidates.add(mMapped.shapeId);
     }
     if (candidates.size !== 1)
         return null;
-    const [only] = candidates;
+    const [only] = [...candidates];
     return recordArms.find((a) => a.shapeId === only) ?? null;
 }
 /** Object spread treats nullish sources as empty. Preserve evaluation once,
@@ -499,8 +564,24 @@ function lowerOptionalIndexSpreadSource(lowerer, source, loc) {
     };
     return prefix.length === 0 ? selected : { kind: "seqExpr", stmts: prefix, result: selected, type: recordType, loc };
 }
-export function lowerObjectLiteral(lowerer, expr) {
+export function lowerObjectLiteral(lowerer, expr, expected) {
     const loc = locOf(expr);
+    // Module collection already chose checked storage for this JavaScript
+    // binding. Construct in that representation: an intermediate record would
+    // check nested aliases back into inferred shapes and lose their identity.
+    if (isJsSourceFile(expr.getSourceFile()) && ts.isVariableDeclaration(expr.parent) &&
+        expr.parent.initializer === expr && ts.isIdentifier(expr.parent.name) &&
+        lowerer.globalOf(expr.parent.name)?.type.kind === "dyn") {
+        return lowerDynObjectLiteral(lowerer, expr);
+    }
+    // A checked spread carries runtime symbol keys and receiver-sensitive
+    // methods absent from its inferred record shape. Copy the real properties.
+    if (!expected && isJsSourceFile(expr.getSourceFile()) && expr.properties.some((property) => ts.isSpreadAssignment(property) && tryLowerExpression(lowerer, property.expression)?.type.kind === "dyn")) {
+        return lowerDynObjectLiteral(lowerer, expr);
+    }
+    const unionClone = lowerUnionRecordClone(lowerer, expr);
+    if (unionClone !== null)
+        return unionClone;
     // The RUNTIME-KEYED literal (JS): a computed key that doesn't fold to a
     // compile-time string means the literal's shape is not a compile-time
     // fact — no record shape can hold it. The whole literal builds as a dyn
@@ -578,6 +659,10 @@ export function lowerObjectLiteral(lowerer, expr) {
             lowerer.rejectThisInObjectMethod(prop.body ?? prop);
     }
     let tsType = lowerer.checker.getContextualType(expr) ?? lowerer.typeOf(expr);
+    // `as never` supplies no construction layout. Keep the literal's own
+    // fields so an exhaustiveness witness cannot erase a reachable value.
+    if (lowerer.checker.isNeverType(tsType))
+        tsType = lowerer.typeOf(expr);
     // `lit satisfies T` is TYPE-LEVEL only: the expression's checker type —
     // and therefore the shape every downstream consumer sees — is the
     // literal's OWN type (T still contextually types members, so inferred
@@ -609,6 +694,13 @@ export function lowerObjectLiteral(lowerer, expr) {
         tsType = lowerer.checker.getAwaitedType(tsType) ?? tsType;
     }
     let mapped = lowerer.mapTypeOf(tsType);
+    // A checked-dynamic source has runtime keys even when later explicit
+    // fields make the literal's inferred type look like a fixed record.
+    // Keep a checked-dynamic destination in that representation so copying
+    // preserves keys, evaluation order, and fields overwritten afterwards.
+    if (mapped?.kind === "dyn" && expr.properties.some((p) => ts.isSpreadAssignment(p) && lowerer.mapTypeOf(lowerer.typeOf(p.expression))?.kind === "dyn")) {
+        return lowerDynObjectLiteral(lowerer, expr);
+    }
     // A JavaScript call can contextually type an object literal as string even
     // though the literal itself is a record. Keep its own shape so a caller
     // performing ToString can convert it after the value is built.
@@ -675,7 +767,11 @@ export function lowerObjectLiteral(lowerer, expr) {
     // gate DECLINED it (a project-declared typedef that absorbed to the
     // island through checker-`any` field residue): the literal builds at
     // its own type like every unmappable context.
-    if (mapped === null || mapped.kind === "union" || mapped.kind === "dyn" || mapped.kind === "object" || mapped.kind === "jsval") {
+    // An index-signature literal can inherit a callable contextual type for
+    // a prototype-named DATA property (notably `toString`). Object literals
+    // have no call signature; construct their own data shape and let the
+    // surrounding assignment/assertion enforce the destination contract.
+    if (mapped === null || mapped.kind === "union" || mapped.kind === "dyn" || mapped.kind === "object" || mapped.kind === "jsval" || mapped.kind === "func") {
         const ctxUnion = mapped?.kind === "union" ? mapped : null;
         mapped = lowerer.mapTypeOf(lowerer.typeOf(expr)) ?? mapped;
         // A literal whose own shape re-tags into NO arm of the contextual
@@ -697,7 +793,10 @@ export function lowerObjectLiteral(lowerer, expr) {
             if (recordArms.length === 1) {
                 const armShape = lowerer.shapes.get(recordArms[0].shapeId);
                 if ((mapped?.kind !== "record" || mapped.shapeId !== recordArms[0].shapeId) &&
-                    !armShape?.tuple) {
+                    !armShape?.tuple &&
+                    // `{} | undefined` supplies no layout for a populated options
+                    // literal, just as a bare empty-record context supplies none.
+                    (expr.properties.length === 0 || (armShape && (armShape.fields.length > 0 || armShape.indexValue)))) {
                     mapped = recordArms[0];
                 }
             }
@@ -715,7 +814,11 @@ export function lowerObjectLiteral(lowerer, expr) {
                 // exactly ONE member fits, build AS that arm — its field types
                 // drive every property's coercion, exactly the single-record-arm
                 // rule above. Ambiguous literals keep the SC2003 fence.
-                if (ownShapeId === null || !recordArms.some((a) => a.shapeId === ownShapeId)) {
+                // Recursive arms can have identical stored field layouts while
+                // retaining distinct nominal knots. An inferred spread shape can
+                // match the wrong knot, so consult discriminants even if that shape
+                // already appears in the union.
+                if (ownShapeId === null || !recordArms.some((a) => a.shapeId === ownShapeId) || expr.properties.some(ts.isSpreadAssignment)) {
                     const arm = literalUnionArmOf(lowerer, expr, tsType, recordArms);
                     if (arm)
                         mapped = arm;
@@ -767,13 +870,35 @@ export function lowerObjectLiteral(lowerer, expr) {
     // descriptor records with `any` values) — builds as a dyn OBJECT:
     // each field converts through the usual dyn boundary, and dynamic
     // consumers ride the keyed-dyn paths. TypeScript keeps the fence.
-    if ((!mapped || mapped.kind === "dyn") && isJsSourceFile(expr.getSourceFile())) {
+    if (mapped?.kind === "dyn" || (!mapped && isJsSourceFile(expr.getSourceFile()))) {
         return lowerDynObjectLiteral(lowerer, expr);
     }
     if (!mapped || mapped.kind !== "record")
         lowerer.badType(expr, tsType);
     let type = mapped;
+    // A fresh, plain literal can construct its fields directly for a known
+    // destination with the same field set. This matters for inferred
+    // conditional records: an empty array in one arm has no element layout
+    // until the join supplies it. Existing values still use width coercion;
+    // extra fields, spreads, accessors, and keyed shapes retain their paths.
+    if (expected && !isJsSourceFile(expr.getSourceFile()) &&
+        expr.properties.every((p) => ts.isPropertyAssignment(p) || ts.isShorthandPropertyAssignment(p))) {
+        const own = lowerer.shapes.get(type.shapeId);
+        const target = lowerer.shapes.get(expected.shapeId);
+        if (!own.tuple && !target.tuple && !own.indexValue && !target.indexValue &&
+            !shapeHasAccessorSlots(own) && !shapeHasAccessorSlots(target) &&
+            target.fields.every((field) => own.fields.some((candidate) => candidate.name === field.name) ||
+                field.type.kind === "union" && lowerer.armTag(field.type.unionId, UNDEFINED_T) >= 0) &&
+            own.fields.every((field) => target.fields.some((candidate) => candidate.name === field.name))) {
+            type = { kind: "record", shapeId: expected.shapeId };
+        }
+    }
     let shape = lowerer.shapes.get(type.shapeId);
+    // JavaScript Dates carry native object identity in checked storage. An
+    // inferred scalar Date field would erase that identity before boxing.
+    if (isJsSourceFile(expr.getSourceFile()) && shape.fields.some((field) => field.type.kind === "date")) {
+        return lowerDynObjectLiteral(lowerer, expr);
+    }
     // ACCESSOR properties, JS literals only (TS accessors fill the shape's
     // %get:/%set: closure slots below): no record storage exists for them,
     // so the literal's shape NARROWS to its plain fields (reads resolve
@@ -793,21 +918,20 @@ export function lowerObjectLiteral(lowerer, expr) {
     }
     const fieldTypes = new Map(shape.fields.map((f) => [f.name, f.type]));
     // File-scope JavaScript object bindings live in the checked-dynamic tree
-    // to preserve open writes and identity. Build an optional-field literal
-    // from its actually written keys so Object.hasOwn can distinguish an
-    // omitted property from a present property whose value is undefined.
+    // to preserve open writes and identity. The checker can infer fields
+    // from later writes; those fields must remain absent when the literal
+    // is first evaluated.
     const topLevelJsDecl = ts.isVariableDeclaration(expr.parent) &&
         expr.parent.initializer === expr &&
-        ts.isVariableStatement(expr.parent.parent.parent) &&
-        ts.isSourceFile(expr.parent.parent.parent.parent);
+        ts.isVariableStatement(expr.parent?.parent?.parent) &&
+        ts.isSourceFile(expr.parent?.parent?.parent?.parent);
     const assignedProperties = expr.properties.filter((prop) => ts.isPropertyAssignment(prop) || ts.isShorthandPropertyAssignment(prop));
     if (topLevelJsDecl && isJsSourceFile(expr.getSourceFile()) &&
         assignedProperties.length === expr.properties.length) {
         const provided = new Set(assignedProperties.map((prop) => propNameText(lowerer, prop.name)));
-        const omittedOptional = shape.fields.some((field) => !provided.has(field.name) && field.type.kind === "union" &&
-            lowerer.armTag(field.type.unionId, UNDEFINED_T) >= 0);
-        if (omittedOptional)
+        if (shape.fields.some((field) => !provided.has(field.name))) {
             return lowerDynObjectLiteral(lowerer, expr);
+        }
     }
     // The clone probe may lower the leading spread before declining (a
     // static `as` cast can make the checker-visible shape match while its
@@ -982,15 +1106,10 @@ export function lowerObjectLiteral(lowerer, expr) {
             lowerer.unsupported("SC1090", prop.name, "computed property keys (compile-time-known keys fold — a pure expression whose checker type is one string or number literal: consts, enum members, quoted keys, templates of those — `{ [MARKER]: v }`; runtime string keys write through an index-signature target; symbol keys stay out)");
         }
     }
-    // A DECLARED-fields target built ENTIRELY from index-signature spreads —
-    // `{ ...Object.fromEntries(...), ...Object.fromEntries(...) }` typed
-    // AppConfig (the defaults-merge idiom over runtime-keyed sources): the
-    // field-by-field desugar cannot enumerate runtime keys, so the literal
-    // lowers as ONE interned merge-helper call — sources evaluate once each
-    // in source order (the call's argument order — computed sources
-    // included, no re-read), contributors apply in order with per-key
-    // dispatch onto the declared fields (JS last-write-wins). Divergence 68
-    // has the runtime rules (validated collisions, extra keys dropped).
+    // A declared destination combining fixed records and runtime-keyed
+    // sources needs both layouts. Apply each source before evaluating the
+    // next expression, with checked overflow collisions and optional-field
+    // completion. Extra runtime keys follow the declared-shape width policy.
     if (!shape.indexValue &&
         !shape.tuple &&
         shape.fields.length > 0 &&
@@ -998,7 +1117,7 @@ export function lowerObjectLiteral(lowerer, expr) {
         expr.properties.every((p) => ts.isSpreadAssignment(p) && !conditionalSpreadOf(p.expression)) &&
         expr.properties.some((p) => {
             const t = lowerer.mapTypeOf(lowerer.typeOf(p.expression));
-            return t?.kind === "record" && !!lowerer.shapes.get(t.shapeId)?.indexValue;
+            return t?.kind === "dyn" || t?.kind === "record" && !!lowerer.shapes.get(t.shapeId)?.indexValue;
         })) {
         return lowerDeclaredSpreadMerge(lowerer, expr, type, shape, loc);
     }
@@ -1010,6 +1129,16 @@ export function lowerObjectLiteral(lowerer, expr) {
         throw new PoisonError();
     };
     const fields = [];
+    const spreadStmts = [];
+    const hasSpread = expr.properties.some(ts.isSpreadAssignment);
+    const captured = new Set();
+    const capture = (value) => {
+        const local = lowerer.declareHiddenLocal("%spreadValue", value.type);
+        spreadStmts.push({ kind: "varDecl", localId: local.id, init: value, loc: value.loc });
+        const ref = varRef(local.id, value.type, value.loc);
+        captured.add(ref);
+        return ref;
+    };
     // Field names introduced by conditional spreads: their ternary carries
     // the spread's whole evaluation (cond once, value lazily), so a LATER
     // contributor overriding one would silently drop that evaluation —
@@ -1019,6 +1148,21 @@ export function lowerObjectLiteral(lowerer, expr) {
     // member reads narrow away; see the catch in the property loop).
     const droppedNames = new Set();
     for (const prop of expr.properties) {
+        // A later contributor can mutate an earlier source or overwrite a
+        // value with effects. Snapshot pending fields at their source position,
+        // before evaluating the next contributor, even if they are overwritten.
+        if (hasSpread) {
+            for (let i = 0; i < fields.length; i++) {
+                const field = fields[i];
+                if (field.drop) {
+                    spreadStmts.push({ kind: "exprStmt", expr: field.value, loc: field.value.loc });
+                    fields.splice(i--, 1);
+                    continue;
+                }
+                if (!captured.has(field.value))
+                    field.value = capture(field.value);
+            }
+        }
         if (ts.isSpreadAssignment(prop)) {
             const cs = conditionalSpreadOf(prop.expression);
             if (cs && cs !== "unsupported") {
@@ -1035,7 +1179,7 @@ export function lowerObjectLiteral(lowerer, expr) {
                     if (shape.indexValue) {
                         lowerer.unsupported("SC1090", prop, "conditional spreads into index-signature keys (overflow entries model presence — write the key in an if statement instead)");
                     }
-                    throw shapeMismatch(prop);
+                    shapeMismatch(prop);
                 }
                 const absent = lowerer.wrappedUndefined(fieldType, locOf(prop));
                 if (!absent) {
@@ -1070,28 +1214,22 @@ export function lowerObjectLiteral(lowerer, expr) {
             // shape. Every source field must land on the target shape with an
             // equal type (a wider source would silently DROP fields JS keeps —
             // the width fence, same as literals). Later contributors override
-            // earlier ones (JS last-write-wins; the reads are side-effect-free,
-            // so dropping the earlier read is exact). Identifier sources
-            // re-read per field (historic path); any OTHER source must be a
-            // re-emittable pure read, sharing one lowered node per field.
-            // The desugar's one-entry-per-name list reads spread fields
-            // EAGERLY at the spread's position, so an explicit property
-            // BEFORE a spread would need JS's overwrite — order-fenced (the
-            // index-signature merge path above takes any order).
-            if (expr.properties
-                .slice(0, expr.properties.indexOf(prop))
-                .some((p) => !ts.isSpreadAssignment(p))) {
-                lowerer.unsupported("SC1090", prop, "object spread after explicit properties (spreads must come first — a later spread would overwrite them with JS semantics the desugar does not model)");
-            }
+            // earlier ones (JS last-write-wins). Evaluate the source exactly
+            // once, including empty sources and those whose fields are all
+            // overridden. Field snapshots above preserve the copy order.
             let srcNode = prop.expression;
             while (ts.isParenthesizedExpression(srcNode))
                 srcNode = srcNode.expression;
-            const srcLowered = prop === expr.properties[0] && leadingSpreadLowered !== null
+            const srcLowered = capture(prop === expr.properties[0] && leadingSpreadLowered !== null
                 ? leadingSpreadLowered
-                : ts.isIdentifier(srcNode)
-                    ? null
-                    : lowerer.lowerExpr(srcNode);
-            const srcType = srcLowered ? srcLowered.type : lowerer.mapTypeOf(lowerer.typeOf(srcNode));
+                : lowerer.lowerExpr(srcNode));
+            // Array callbacks can receive a record-or-undefined ABI even when
+            // TypeScript describes a required record. Select the copy strategy
+            // from that stored representation so absent sources copy nothing.
+            // Checked-dynamic bindings still use the checker's field contract.
+            const srcType = srcLowered.type.kind === "dyn"
+                ? lowerer.mapTypeOf(lowerer.typeOf(srcNode))
+                : srcLowered.type;
             // `...options.installConfig` — a spread of `Partial<X> | undefined`
             // (the optional-options merge idiom `{ ...DEFAULTS, ...overrides }`):
             // JS spreads nothing for the unit arm and copies present keys
@@ -1108,9 +1246,6 @@ export function lowerObjectLiteral(lowerer, expr) {
                     !def.arms.every((a) => a.kind === "record" || isUnitType(a))) {
                     lowerer.unsupported("SC1090", prop, `object spread of '${lowerer.fmt(srcType)}' sources (only known record shapes spread — ${NARROW_FIRST})`);
                 }
-                if (srcLowered && !isSafeToRepeat(srcLowered)) {
-                    lowerer.unsupported("SC1090", prop, "object spread of computed sources (the field copies re-read the source — bind it to a const first)");
-                }
                 const recArm = recArms[0];
                 const recTag = def.arms.indexOf(recArm);
                 // A checked-dynamic VALUE under the union-mapped checker type
@@ -1133,7 +1268,7 @@ export function lowerObjectLiteral(lowerer, expr) {
                     if (ts.isSpreadAssignment(later)) {
                         if (conditionalSpreadOf(later.expression))
                             continue;
-                        const lt = lowerer.mapTypeOf(lowerer.typeOf(later.expression));
+                        const lt = laterSpreadType(lowerer, later.expression);
                         if (lt?.kind === "record") {
                             for (const lf of lowerer.shapes.get(lt.shapeId)?.fields ?? [])
                                 laterNames.add(lf.name);
@@ -1234,9 +1369,6 @@ export function lowerObjectLiteral(lowerer, expr) {
             if (srcType?.kind !== "record") {
                 lowerer.unsupported("SC1090", prop, `object spread of '${srcType ? lowerer.fmt(srcType) : lowerer.checker.typeToString(lowerer.typeOf(srcNode))}' sources (only known record shapes spread — ${NARROW_FIRST})`);
             }
-            if (srcLowered && !isSafeToRepeat(srcLowered)) {
-                lowerer.unsupported("SC1090", prop, "object spread of computed sources (the field copies re-read the source — bind it to a const first)");
-            }
             const srcShape = lowerer.shapes.get(srcType.shapeId);
             if (!srcShape)
                 throw new InternalCompilerError(`lowerer bug: spread of unknown shape ${srcType.shapeId}`);
@@ -1258,7 +1390,7 @@ export function lowerObjectLiteral(lowerer, expr) {
                 if (ts.isSpreadAssignment(later)) {
                     if (conditionalSpreadOf(later.expression))
                         continue;
-                    const lt = lowerer.mapTypeOf(lowerer.typeOf(later.expression));
+                    const lt = laterSpreadType(lowerer, later.expression);
                     if (lt?.kind === "record") {
                         for (const lf of lowerer.shapes.get(lt.shapeId)?.fields ?? [])
                             laterNames.add(lf.name);
@@ -1372,7 +1504,7 @@ export function lowerObjectLiteral(lowerer, expr) {
                 if (fieldTypes.has(name)) {
                     lowerer.unsupported("SC1090", prop, `a get/set accessor satisfying the data property '${name}' of '${lowerer.fmt(type)}' (the record slot stores a plain value — Node would keep the accessor live through this type)`);
                 }
-                throw shapeMismatch(prop);
+                shapeMismatch(prop);
             }
             const closure = lowerer.coerceInto(prop, lowerer.lowerLambda(prop), slotT);
             if (!typeEquals(closure.type, slotT))
@@ -1396,7 +1528,7 @@ export function lowerObjectLiteral(lowerer, expr) {
         // side effects; calls resolve statically against this declaration);
         // a computed initializer would need its evaluation kept — fenced.
         if (!fieldType && !ts.isSpreadAssignment(prop)) {
-            const memberSym = prop.name && lowerer.checker.getSymbolAtLocation(prop.name);
+            const memberSym = prop.name ? lowerer.checker.getSymbolAtLocation(prop.name) : undefined;
             const memberT = memberSym ? lowerer.checker.getTypeOfSymbol(memberSym) : undefined;
             if (memberT && isGenericCallableMemberType(memberT, lowerer.checker)) {
                 const pureInit = (() => {
@@ -1436,7 +1568,7 @@ export function lowerObjectLiteral(lowerer, expr) {
                 }
                 continue;
             }
-            throw shapeMismatch(prop);
+            shapeMismatch(prop);
         }
         let value;
         let valueNode = prop;
@@ -1444,17 +1576,15 @@ export function lowerObjectLiteral(lowerer, expr) {
         try {
             if (ts.isPropertyAssignment(prop)) {
                 valueNode = prop.initializer;
-                // ARRAY-LITERAL initializers route through the expected-type
-                // lowering: a union field with one array-family arm builds the
-                // literal AS that arm (lowerExprExpecting's IR-directed rule —
-                // the option-table `default: [{ value: [] }]` shape), where the
-                // bare lowering would take the JS dyn fallback and fence.
+                // Fresh construction gets the field's destination before lowering
+                // nested arrays, records, or conditional branches. Existing values
+                // retain their runtime representation until the field coercion.
                 let init = prop.initializer;
-                while (ts.isParenthesizedExpression(init))
+                while (ts.isParenthesizedExpression(init) || ts.isSatisfiesExpression(init))
                     init = init.expression;
                 value =
                     fenceClosureProbe(lowerer, prop.initializer, fieldType, () => lowerer.lowerExpr(prop.initializer)) ??
-                        (fieldType !== undefined && ts.isArrayLiteralExpression(init)
+                        (fieldType !== undefined && (ts.isArrayLiteralExpression(init) || ts.isObjectLiteralExpression(init) || ts.isConditionalExpression(init))
                             ? lowerer.lowerExprExpecting(prop.initializer, fieldType)
                             : lowerer.lowerExpr(prop.initializer));
             }
@@ -1466,7 +1596,7 @@ export function lowerObjectLiteral(lowerer, expr) {
                     fenceClosureProbe(lowerer, prop, fieldType, () => lowerer.lowerLambda(prop)) ?? lowerer.lowerLambda(prop);
             }
             else {
-                lowerer.unsupported("SC1090", prop, `syntax '${ts.SyntaxKind[prop.kind]}'`);
+                lowerer.unsupported("SC1090", prop, `syntax '${ts.syntaxKindName(prop.kind)}'`);
             }
         }
         catch (err) {
@@ -1525,11 +1655,10 @@ export function lowerObjectLiteral(lowerer, expr) {
             fields.splice(at, 1);
         fields.push({ name, value });
     }
-    // Optional fields (undefined-armed union slots) may be omitted: the
-    // absent field holds the interned undefined arm, exactly like writing
-    // `a: undefined` (without exactOptionalPropertyTypes tsc treats the two
-    // the same, and only optional fields may be omitted — tsc rejects
-    // omission of required fields before lowering, undefined-armed or not).
+    // Optional fields may be omitted: the absent field holds an undefined
+    // union arm or, for an island handle slot, the engine's undefined cell.
+    // This matches writing `a: undefined` without exactOptionalPropertyTypes;
+    // tsc rejects omission of required fields before lowering.
     // A REQUIRED missing field keeps the shape-mismatch rejection (possible
     // through `as`: the cast smuggles a narrower literal past freshness).
     if (droppedNames.size > 0) {
@@ -1547,13 +1676,137 @@ export function lowerObjectLiteral(lowerer, expr) {
             // property reads as undefined in Node, and a dyn slot holds
             // exactly that (the options-record call shape against
             // `{ plugins: unknown, ... }` — a JS caller the checker admits).
-            const absent = lowerer.wrappedUndefined(f.type, loc) ?? (f.type.kind === "dyn" ? dynUndefinedExpr(loc) : null);
+            const optional = ((lowerer.checker.getPropertyOfType(tsType, f.name)?.flags ?? 0) & ts.SymbolFlags.Optional) !== 0;
+            const absentHandle = f.type.kind === "jsval" && optional
+                ? { kind: "jsOp", op: "undefLit", args: [], type: JSVAL, loc }
+                : null;
+            const absent = lowerer.wrappedUndefined(f.type, loc) ??
+                (f.type.kind === "dyn" ? dynUndefinedExpr(loc) : null) ??
+                absentHandle;
             if (!absent)
-                throw shapeMismatch(expr); // only optional (undefined-armed) and 'unknown' fields may be omitted
+                shapeMismatch(expr); // only optional and 'unknown' fields may be omitted
             fields.push({ name: f.name, value: absent });
         }
     }
-    return { kind: "recordLit", fields, type, loc };
+    const result = { kind: "recordLit", fields, type, loc };
+    return spreadStmts.length === 0 ? result : { kind: "seqExpr", stmts: spreadStmts, result, type, loc };
+}
+/** A union of plain records can preserve its existing variant while
+ * replacing shared fields. Dispatch before constructing the copy: only
+ * the selected arm evaluates overrides, and recordClone snapshots fields
+ * before an override can mutate the original. Nested references retain
+ * their identity. Changing a discriminator or adding variant-specific
+ * fields needs a different result layout and stays on the ordinary path. */
+function lowerUnionRecordClone(lowerer, expr) {
+    if (isJsSourceFile(expr.getSourceFile()))
+        return null;
+    const spread = expr.properties[0];
+    if (!spread || !ts.isSpreadAssignment(spread))
+        return null;
+    let sourceNode = spread.expression;
+    while (ts.isParenthesizedExpression(sourceNode) || ts.isSatisfiesExpression(sourceNode))
+        sourceNode = sourceNode.expression;
+    // Conditional spreads construct optional keys, including the empty arm.
+    // Their dedicated lowering owns that layout rather than a union clone.
+    if (ts.isConditionalExpression(sourceNode))
+        return null;
+    const sourceType = lowerer.mapTypeOf(lowerer.typeOf(spread.expression));
+    if (sourceType?.kind !== "union")
+        return null;
+    const def = lowerer.unions.get(sourceType.unionId);
+    if (!def || def.arms.length < 2 || !def.arms.every((arm) => arm.kind === "record"))
+        return null;
+    const props = [];
+    const names = [];
+    for (const prop of expr.properties.slice(1)) {
+        if ((!ts.isPropertyAssignment(prop) && !ts.isShorthandPropertyAssignment(prop)) ||
+            (!ts.isIdentifier(prop.name) && !ts.isStringLiteral(prop.name)))
+            return null;
+        const name = prop.name.text;
+        if (names.includes(name) || name === def.discriminant?.field || name === "__proto__")
+            return null;
+        props.push(prop);
+        names.push(name);
+    }
+    for (const arm of def.arms) {
+        if (arm.kind !== "record")
+            return null;
+        const shape = lowerer.shapes.get(arm.shapeId);
+        if (!shape || shape.indexValue || shape.tuple || shapeHasAccessorSlots(shape) ||
+            !names.every((name) => shape.fields.some((field) => field.name === name)))
+            return null;
+        for (let index = 0; index < props.length; index++) {
+            const prop = props[index];
+            const node = ts.isPropertyAssignment(prop) ? prop.initializer : prop.name;
+            const valueType = lowerer.mapTypeOf(lowerer.typeOf(node));
+            const fieldType = shape.fields.find((field) => field.name === names[index]).type;
+            const lift = valueType ? lowerer.widthLiftPlan(valueType, fieldType) : null;
+            // The inferred result must retain an override's own fields and
+            // aliases. A structural copy into the source field's narrower shape
+            // would silently reshape an unannotated spread expression.
+            if (!lift)
+                return null;
+            if (lift.how === "retag" && valueType?.kind === "union" && fieldType.kind === "union") {
+                const from = lowerer.unions.get(valueType.unionId);
+                const to = lowerer.unions.get(fieldType.unionId);
+                const plan = from && to ? planUnionRetag(from, to, (id) => lowerer.shapes.get(id), (source, target) => lowerer.widthLiftPlan(source, target)) : null;
+                if (!plan || !plan.every((arm) => arm.kind === "direct"
+                    ? arm.route.lift.how === "copy" || arm.route.lift.how === "upcast"
+                    : arm.kind === "discriminant" && arm.routes.every((route) => route.lift.how === "copy" || route.lift.how === "upcast")))
+                    return null;
+            }
+            else if (lift.how !== "copy" && lift.how !== "wrap" && lift.how !== "upcast")
+                return null;
+        }
+    }
+    let source = lowerer.lowerExpr(spread.expression);
+    // Hidden runtime absence must never be mistaken for a record payload.
+    // An earlier guard can remove that arm; an unguarded optional spread
+    // still needs a destination able to represent the empty copy.
+    if (!typeEquals(source.type, sourceType) && source.type.kind === "union" && ts.isIdentifier(spread.expression)) {
+        const local = lowerer.resolveLocal(spread.expression);
+        const symbol = lowerer.resolveValueSymbol(spread.expression);
+        const captured = local?.boxed === true || symbol && lowerer.ctx.captureBySymbol.has(symbol);
+        if (local && !captured && !lowerer.runtimeOptionalLocals.has(lowerer.runtimeOptionalRootOf(local))) {
+            const helper = lowerer.narrowedRetagHelper(spread.expression, source.type.unionId, sourceType.unionId, source.loc);
+            if (helper)
+                source = { kind: "call", callee: helper, args: [source], type: sourceType, loc: source.loc };
+        }
+    }
+    if (!typeEquals(source.type, sourceType)) {
+        lowerer.unsupported("SC1090", spread, "a union record clone whose stored source still includes absence");
+    }
+    const loc = locOf(expr);
+    const saved = lowerer.declareHiddenLocal("%unionClone", sourceType);
+    const ref = varRef(saved.id, sourceType, loc);
+    let result = null;
+    for (let tag = def.arms.length - 1; tag >= 0; tag--) {
+        const arm = def.arms[tag];
+        if (arm.kind !== "record")
+            throw new InternalCompilerError("union clone arm is not a record");
+        const shape = lowerer.shapes.get(arm.shapeId);
+        const overrides = [];
+        for (let index = 0; index < props.length; index++) {
+            const prop = props[index];
+            const name = names[index];
+            const fieldType = shape.fields.find((field) => field.name === name).type;
+            const value = ts.isPropertyAssignment(prop)
+                ? lowerer.lowerExprExpecting(prop.initializer, fieldType)
+                : lowerer.coerceInto(prop, lowerer.lowerShorthandValue(prop), fieldType);
+            overrides.push({ name, value });
+        }
+        const clone = { kind: "recordClone",
+            source: { kind: "unionNarrow", value: ref, unionId: sourceType.unionId, tag, type: arm, loc },
+            overrides, type: arm, loc };
+        const wrapped = { kind: "unionWrap", value: clone, unionId: sourceType.unionId, tag, type: sourceType, loc };
+        result = result === null ? wrapped : {
+            kind: "ternary", cond: { kind: "unionIsTag", value: ref, unionId: sourceType.unionId, tag, negated: false, type: BOOL, loc },
+            then: wrapped, else_: result, type: sourceType, loc,
+        };
+    }
+    if (result === null)
+        throw new InternalCompilerError("union clone has no arms");
+    return { kind: "seqExpr", stmts: [{ kind: "varDecl", localId: saved.id, init: source, loc }], result, type: sourceType, loc };
 }
 /** Parses the conditional-spread idiom `...(c ? { k: v, ... } : {})`
  * (either orientation). Returns the condition, the non-empty arm's
@@ -1612,17 +1865,22 @@ export function conditionalSpreadOf(expr) {
  * untyped copy would store the lie) — and a key naming NO declared field
  * is DROPPED (the shape cannot represent it; Node keeps it invisibly —
  * divergence 68). Later contributors overwrite earlier ones
- * (last-write-wins). Sources must be PURE index-signature records. */
+ * (last-write-wins). Fixed, hybrid, and pure index records may contribute. */
 function lowerDeclaredSpreadMerge(lowerer, expr, type, shape, loc) {
     const srcs = [];
     for (const prop of expr.properties) {
         const spread = prop; // caller-checked: all spreads
         const value = lowerer.lowerExpr(spread.expression);
+        if (value.type.kind === "dyn") {
+            srcs.push({ value, shapeId: "dyn" });
+            continue;
+        }
         const srcShape = value.type.kind === "record" ? lowerer.shapes.get(value.type.shapeId) : undefined;
-        if (value.type.kind !== "record" || !srcShape?.indexValue || srcShape.tuple || srcShape.fields.length > 0) {
-            lowerer.unsupported("SC1090", prop, `object spread of '${lowerer.fmt(value.type)}' into '${lowerer.fmt(type)}' (only PURE index-signature records — Object.fromEntries results, Record<string, T> values — spread into a declared shape)`);
+        if (value.type.kind !== "record" || !srcShape || srcShape.tuple) {
+            lowerer.unsupported("SC1090", prop, `object spread of '${lowerer.fmt(value.type)}' into '${lowerer.fmt(type)}' (only records spread into a declared shape)`);
         }
-        srcs.push({ value, shapeId: value.type.shapeId, iv: srcShape.indexValue });
+        fenceAccessorSpreadSource(lowerer, prop, srcShape);
+        srcs.push({ value, shapeId: value.type.shapeId, shape: srcShape });
     }
     // Every target field must be optional: absent keys leave the undefined
     // arm, exactly the unset-optional representation.
@@ -1685,75 +1943,109 @@ function lowerDeclaredSpreadMerge(lowerer, expr, type, shape, loc) {
         }
         lowerer.unsupported("SC1090", expr, `object spread into '${lowerer.fmt(type)}' where the source's '${lowerer.fmt(iv)}' values cannot reach the '${lowerer.fmt(f.type)}' field '${f.name}' (the value slot must be the field type, 'unknown', or a union covering the field's arms)`);
     };
-    const key = `declmerge:${type.shapeId}:${srcs.map((s) => s.shapeId).join(",")}`;
-    let helper = lowerer.widthHelpers.get(key);
-    if (!helper) {
-        helper = `%rec.declmerge.${lowerer.widthHelpers.size}`;
-        const outRef = varRef("out.0", type, loc);
-        const ksT = arrayOf(STRING);
-        const locals = [{ id: "out.0", name: "out", type, mutable: false }];
-        const params = srcs.map((s, j) => {
-            locals.push({ id: `s${j}.0`, name: `s${j}`, type: s.value.type, mutable: true });
-            return { localId: `s${j}.0`, name: `s${j}`, type: s.value.type };
-        });
-        const body = [
-            {
-                kind: "varDecl",
-                localId: "out.0",
-                init: {
-                    kind: "recordLit",
-                    fields: shape.fields.map((f) => ({ name: f.name, value: lowerer.wrappedUndefined(f.type, loc) })),
-                    type,
-                    loc,
-                },
-                loc,
-            },
-        ];
-        srcs.forEach((s, j) => {
-            const sRef = varRef(`s${j}.0`, s.value.type, loc);
-            const kRef = varRef(`k${j}.0`, STRING, loc);
-            const vRef = varRef(`v${j}.0`, s.iv, loc);
-            locals.push({ id: `ks${j}.0`, name: `ks${j}`, type: ksT, mutable: false }, { id: `i${j}.0`, name: `i${j}`, type: F64, mutable: true }, { id: `k${j}.0`, name: `k${j}`, type: STRING, mutable: false }, { id: `v${j}.0`, name: `v${j}`, type: s.iv, mutable: false });
-            // Per-key dispatch: if (k === "a") { write a } else if ... else drop.
-            const dispatch = shape.fields.reduceRight((rest, f) => {
-                const write = (value) => ({ kind: "recordSet", obj: outRef, shapeId: type.shapeId, field: f.name, value, loc });
-                const c = conv(s.iv, f, vRef);
-                const thenBody = "value" in c ? [write(c.value)] : c.stmts(write);
-                return [{
-                        kind: "if",
-                        cond: { kind: "strEq", negated: false, left: kRef, right: { kind: "strLit", value: f.name, type: STRING, loc }, type: BOOL, loc },
-                        then: thenBody,
-                        else_: rest.length > 0 ? rest : null,
-                        loc,
-                    }];
-            }, []);
-            body.push({ kind: "varDecl", localId: `ks${j}.0`, init: { kind: "recordOvfKeys", obj: sRef, shapeId: s.shapeId, type: ksT, loc }, loc }, {
-                kind: "for",
-                init: { kind: "varDecl", localId: `i${j}.0`, init: numLit(0, loc), loc },
-                cond: { kind: "bin", op: "<", left: varRef(`i${j}.0`, F64, loc), right: { kind: "arrIntrinsic", method: "length", receiver: varRef(`ks${j}.0`, ksT, loc), args: [], type: F64, loc }, type: BOOL, loc },
-                update: { kind: "assign", localId: `i${j}.0`, value: { kind: "bin", op: "+", left: varRef(`i${j}.0`, F64, loc), right: numLit(1, loc), type: F64, loc }, loc },
-                body: [
-                    { kind: "varDecl", localId: `k${j}.0`, init: { kind: "arrayGet", arr: varRef(`ks${j}.0`, ksT, loc), index: varRef(`i${j}.0`, F64, loc), type: STRING, loc }, loc },
-                    { kind: "varDecl", localId: `v${j}.0`, init: { kind: "recordKeyGet", obj: sRef, shapeId: s.shapeId, key: kRef, overflowOnly: true, type: s.iv, loc }, loc },
-                    ...dispatch,
-                ],
-                loc,
-            });
-        });
-        body.push({ kind: "return", value: outRef, loc });
-        lowerer.liftedFns.push({
-            name: helper,
-            params,
-            returnType: type,
-            locals,
-            body,
+    // Apply each source before evaluating the next expression. Passing all
+    // sources as one helper's arguments would read an earlier record after a
+    // later source factory mutated it, contrary to object spread evaluation.
+    const out = lowerer.declareHiddenLocal("%declMerge", type);
+    const outRef = varRef(out.id, type, loc);
+    const stmts = [{
+            kind: "varDecl", localId: out.id,
+            init: { kind: "recordLit", fields: shape.fields.map((f) => ({ name: f.name, value: lowerer.wrappedUndefined(f.type, loc) })), type, loc },
             loc,
-        });
-        // Registered only after a fence-free build: a conv() fence mid-build
-        // must not leave a phantom helper behind for the next literal.
-        lowerer.widthHelpers.set(key, helper);
+        }];
+    for (const source of srcs) {
+        const key = `declmerge-source:${type.shapeId}:${source.shapeId}`;
+        let helper = lowerer.widthHelpers.get(key);
+        if (!helper) {
+            helper = `%rec.declmerge.${lowerer.widthHelpers.size}`;
+            const sourceType = source.value.type;
+            const destination = varRef("out.0", type, loc);
+            const receiver = varRef("source.0", sourceType, loc);
+            const locals = [
+                { id: "out.0", name: "out", type, mutable: false },
+                { id: "source.0", name: "source", type: sourceType, mutable: false },
+            ];
+            const body = [];
+            if (!source.shape) {
+                // CopyDataProperties skips nullish sources, even when an erased
+                // record view supplies the checker's apparent object type.
+                body.push({
+                    kind: "if", cond: { kind: "dynTest", test: "nullish", value: receiver, type: BOOL, loc },
+                    then: [{ kind: "return", value: destination, loc }], else_: null, loc,
+                });
+            }
+            for (const field of source.shape?.fields ?? []) {
+                const target = shape.fields.find((candidate) => candidate.name === field.name);
+                if (!target)
+                    continue; // The declared destination drops extra keys.
+                const raw = { kind: "recordGet", obj: receiver, shapeId: source.shapeId, field: field.name, type: field.type, loc };
+                const lift = lowerer.widthLiftPlan(field.type, target.type);
+                if (!lift) {
+                    lowerer.unsupported("SC1090", expr, `object spread of field '${field.name}' from '${lowerer.fmt(field.type)}' into '${lowerer.fmt(target.type)}'`);
+                }
+                const write = {
+                    kind: "recordSet", obj: destination, shapeId: type.shapeId, field: field.name,
+                    value: lowerer.applyWidthLift(lift, raw, target.type, loc), loc,
+                };
+                // Optional declared fields use the established unset convention.
+                // A dyn field, including a present undefined, is a real property;
+                // its checked conversion runs and can overwrite an earlier value.
+                const absent = field.type.kind === "union" ? lowerer.armTag(field.type.unionId, UNDEFINED_T) : -1;
+                if (absent >= 0 && field.type.kind === "union") {
+                    body.push({ kind: "if", cond: {
+                            kind: "unionIsTag", unionId: field.type.unionId, tag: absent, negated: true, value: raw, type: BOOL, loc,
+                        }, then: [write], else_: null, loc });
+                }
+                else
+                    body.push(write);
+            }
+            const iv = source.shape ? source.shape.indexValue : DYN;
+            if (iv) {
+                const keysType = arrayOf(STRING);
+                const keys = varRef("keys.0", keysType, loc);
+                const index = varRef("index.0", F64, loc);
+                const name = varRef("key.0", STRING, loc);
+                const value = varRef("value.0", iv, loc);
+                locals.push({ id: "keys.0", name: "keys", type: keysType, mutable: false }, { id: "index.0", name: "index", type: F64, mutable: true }, { id: "key.0", name: "key", type: STRING, mutable: false }, { id: "value.0", name: "value", type: iv, mutable: false });
+                const dispatch = shape.fields.reduceRight((rest, field) => {
+                    const write = (value) => ({ kind: "recordSet", obj: destination, shapeId: type.shapeId, field: field.name, value, loc });
+                    const converted = conv(iv, field, value);
+                    return [{
+                            kind: "if",
+                            cond: { kind: "strEq", negated: false, left: name, right: { kind: "strLit", value: field.name, type: STRING, loc }, type: BOOL, loc },
+                            then: "value" in converted ? [write(converted.value)] : converted.stmts(write),
+                            else_: rest.length > 0 ? rest : null, loc,
+                        }];
+                }, []);
+                body.push({ kind: "varDecl", localId: "keys.0", init: source.shape
+                        ? { kind: "recordOvfKeys", obj: receiver, shapeId: source.shapeId, type: keysType, loc }
+                        : { kind: "dynCheck", value: { kind: "libCall", fn: "dyn.objKeys", args: [receiver], type: DYN, loc }, type: keysType, loc }, loc }, {
+                    kind: "for",
+                    init: { kind: "varDecl", localId: "index.0", init: numLit(0, loc), loc },
+                    cond: { kind: "bin", op: "<", left: index, right: { kind: "arrIntrinsic", method: "length", receiver: keys, args: [], type: F64, loc }, type: BOOL, loc },
+                    update: { kind: "assign", localId: "index.0", value: { kind: "bin", op: "+", left: index, right: numLit(1, loc), type: F64, loc }, loc },
+                    body: [
+                        { kind: "varDecl", localId: "key.0", init: { kind: "arrayGet", arr: keys, index, type: STRING, loc }, loc },
+                        { kind: "varDecl", localId: "value.0", init: source.shape
+                                ? { kind: "recordKeyGet", obj: receiver, shapeId: source.shapeId, key: name, overflowOnly: true, type: iv, loc }
+                                : { kind: "dynKeyGet", value: receiver, key: name, type: DYN, loc }, loc },
+                        ...dispatch,
+                    ], loc,
+                });
+            }
+            body.push({ kind: "return", value: destination, loc });
+            lowerer.liftedFns.push({
+                name: helper,
+                params: [{ localId: "out.0", name: "out", type }, { localId: "source.0", name: "source", type: sourceType }],
+                returnType: type, locals, body, loc,
+            });
+            // Publish only a fully checked helper: rejected conversions must not
+            // leave an entry that a later literal could reuse without a body.
+            lowerer.widthHelpers.set(key, helper);
+        }
+        stmts.push({ kind: "exprStmt", expr: { kind: "call", callee: helper, args: [outRef, source.value], type, loc }, loc });
     }
-    return { kind: "call", callee: helper, args: srcs.map((s) => s.value), type, loc };
+    return { kind: "seqExpr", stmts, result: outRef, type, loc };
 }
 /** The value of a shorthand property (`{ x }`): the binding `x` refers to.
  * The property name's own symbol is the PROPERTY, so resolution goes
@@ -1764,6 +2056,14 @@ export function lowerShorthandValue(lowerer, prop) {
     const propName = prop.name;
     const loc = locOf(propName);
     const symbol = lowerer.checker.getShorthandAssignmentValueSymbol(prop);
+    // Import identifiers in shorthand position carry the property's symbol,
+    // so the ordinary identifier expression path cannot resolve them.
+    const builtin = lowerer.builtinImportOf(propName);
+    if (builtin) {
+        const callable = lowerer.lowerBuiltinCallableValue(builtin, loc);
+        if (callable)
+            return callable;
+    }
     if (symbol) {
         if (lowerer.ctx.selfSymbol === symbol) {
             return { kind: "selfRef", type: lowerer.ctx.selfType, loc };
@@ -1781,7 +2081,7 @@ export function lowerShorthandValue(lowerer, prop) {
         const sig = lowerer.fnSigsBySymbol.get(resolved);
         const decl = lowerer.checker.declarationsOf(resolved)[0];
         if (sig && decl && ts.isFunctionDeclaration(decl) &&
-            (ts.isSourceFile(decl.parent) || lowerer.nsBlocks.get(decl.parent) === "flattened")) {
+            (ts.isSourceFile(decl.parent) || (decl.parent !== undefined && lowerer.nsBlocks.get(decl.parent) === "flattened"))) {
             lowerer.noteEdge(sig.name);
             const funcType = {
                 kind: "func",
@@ -1798,11 +2098,11 @@ export function lowerShorthandValue(lowerer, prop) {
     }
     lowerer.rejectUnresolvedSymbol(symbol ? (symbol.flags & ts.SymbolFlags.Alias ? lowerer.checker.getAliasedSymbol(symbol) : symbol) : null, propName.text, prop, `the reference to '${propName.text}' (a binding form with no lowering)`);
 }
-/** Rejects any `this` inside an object-literal method body — including in
- * nested arrows, which inherit the method's `this` (nested function
- * expressions reset it, but their bare `this` is already a tsc error
- * under noImplicitThis, so over-rejecting them here changes nothing). */
+/** Rejects the method's own receiver, including lexical captures in
+ * arrows. Nested ordinary functions bind their own ambient receiver. */
 export function rejectThisInObjectMethod(lowerer, node) {
+    if (ts.isFunctionExpression(node) || ts.isFunctionDeclaration(node) || ts.isMethodDeclaration(node) || ts.isAccessor(node))
+        return;
     if (node.kind === ts.SyntaxKind.ThisKeyword) {
         lowerer.unsupported("SC1090", node, "references to 'this' in object literal methods");
     }