@scriptc/compiler 0.3.6 → 0.4.1

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

@@ -1,3 +1,4 @@
+import { dateJsonType, isDateJsonSource } from "../builtins/dates.js";
 import { dynUndefinedExpr, numLit, strLit, varRef } from "../../../ir/build.js";
 import { pathModuleValue } from "../lower-builtin-values.js";
 import { InternalCompilerError } from "../../../errors.js";
@@ -6,14 +7,14 @@ import { BOOL, DYN, F64, STRING, UNDEFINED_T, VOID, arrayOf, canDynCheckTo, isUn
 import { isCjsExportTableLiteral, isJsSourceFile, locOf } from "../../program.js";
 import { NARROW_FIRST } from "../surfaces.js";
 import { recordShapeMismatchDiag } from "../../../diagnostics/diagnostic.js";
-import { PoisonError, neverTaintedJsType } from "../lowerer.js";
+import { PoisonError, jsFuncNameOf, neverTaintedJsType } from "../lowerer.js";
 import { lowerIndexMergeHelper } from "../containers/indexed-objects.js";
 import { PERF_ENTRY_MARKER, isGenericCallableMemberType, jsOpenObjectType, } from "../../type-mapper.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";
-import { runtimeOptionalStorageOperand } from "../lower-exprs.js";
+import { jsHoldsDynObject, runtimeOptionalStorageOperand } from "../lower-exprs.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
@@ -51,7 +52,7 @@ export function foldedStringKeyOf(lowerer, expr) {
         // fallback (a template the checker DID type as one literal).
         let out = expr.head.text;
         let folded = true;
-        for (const span of expr.templateSpans) {
+        for (const span of expr.templateSpans.nodes) {
             const part = foldedStringKeyOf(lowerer, span.expression);
             if (part === null) {
                 folded = false;
@@ -146,7 +147,7 @@ function pureKeyExpr(lowerer, expr) {
             pureKeyExpr(lowerer, expr.whenFalse));
     }
     if (ts.isTemplateExpression(expr))
-        return expr.templateSpans.every((s) => pureKeyExpr(lowerer, s.expression));
+        return expr.templateSpans.nodes.every((s) => pureKeyExpr(lowerer, s.expression));
     return false;
 }
 /** A property's field name: identifier/string-literal keys directly,
@@ -165,6 +166,18 @@ function propNameText(lowerer, name) {
         return String(Number(name.text));
     return name.text;
 }
+/** The name an anonymous function or a method takes from its property key
+ * (NamedEvaluation): an identifier, string or numeric key, or a computed
+ * key that folds to one string. Null for other keys. */
+function propertyFunctionName(lowerer, name) {
+    if (ts.isComputedPropertyName(name))
+        return literalComputedKey(lowerer, name);
+    if (ts.isNumericLiteral(name))
+        return String(Number(name.text));
+    if (ts.isIdentifier(name) || ts.isStringLiteral(name))
+        return name.text;
+    return null;
+}
 /** The runtime-keyed JS object literal (a computed key that doesn't fold):
  * builds a dyn object member-by-member. Keys evaluate before their values,
  * properties in source order — JS's object-literal evaluation exactly.
@@ -221,7 +234,7 @@ export function lowerDynObjectLiteral(lowerer, expr, boxValue) {
                 : { kind: "libCall", fn: "dyn.assign", args: [acc, chunk], type: DYN, loc };
         fields = [];
     };
-    for (const prop of expr.properties) {
+    for (const prop of expr.properties.nodes) {
         if (ts.isPropertyAssignment(prop) &&
             !ts.isComputedPropertyName(prop.name) &&
             prop.name.text === "__proto__") {
@@ -243,7 +256,7 @@ export function lowerDynObjectLiteral(lowerer, expr, boxValue) {
             const builtin = lowerer.builtinNamespaceModuleOf(prop.expression);
             const raw = builtin === "path" || builtin === "path/posix" || builtin === "path/win32"
                 ? pathModuleValue(lowerer, builtin === "path" ? "path/posix" : builtin, locOf(prop))
-                : isJsSourceFile(expr.getSourceFile())
+                : isJsSourceFile(ts.getSourceFileOfNode(expr))
                     ? lowerer.lowerExprExpecting(prop.expression, DYN)
                     : lowerer.lowerExpr(prop.expression);
             fenceSymbolFieldCopy(lowerer, prop.expression, raw.type);
@@ -372,10 +385,29 @@ export function lowerDynObjectLiteral(lowerer, expr, boxValue) {
         let v = boxValue
             ? boxValue(valueExpr, raw)
             : lowerer.coerceToExpected(raw, DYN);
+        // A function that boxes into a property takes its name as Node gives
+        // it: a function read by name keeps that name (`{ f }`, `{ k: f }`),
+        // and an anonymous function or a method takes the property's name
+        // (`{ g: function () {} }`, `{ m() {} }`).
+        if (!boxValue &&
+            v.kind === "dynFrom" &&
+            v.value.type.kind === "func" &&
+            v.fnName === undefined) {
+            let anonymous = valueExpr;
+            while (ts.isParenthesizedExpression(anonymous))
+                anonymous = anonymous.expression;
+            const name = ts.isMethodDeclaration(prop) ||
+                ((ts.isFunctionExpression(anonymous) || ts.isArrowFunction(anonymous)) &&
+                    !(ts.isFunctionExpression(anonymous) && anonymous.name))
+                ? propertyFunctionName(lowerer, prop.name)
+                : jsFuncNameOf(valueExpr, lowerer);
+            if (name !== null)
+                v = { ...v, fnName: name };
+        }
         // 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()) &&
+            isJsSourceFile(ts.getSourceFileOfNode(prop)) &&
             v.kind === "dynFrom" &&
             v.value.type.kind === "array") {
             v = { ...v, liveRef: true };
@@ -442,7 +474,7 @@ function laterSpreadType(lowerer, expr) {
  * the fallback does not apply (not a JS file, not a lambda, no func slot)
  * — the caller lowers normally. ICEs (SC9001) never convert. */
 function fenceClosureProbe(lowerer, node, slotType, attempt) {
-    if (!isJsSourceFile(node.getSourceFile()))
+    if (!isJsSourceFile(ts.getSourceFileOfNode(node)))
         return null;
     let inner = node;
     while (ts.isParenthesizedExpression(inner))
@@ -458,7 +490,7 @@ function fenceClosureProbe(lowerer, node, slotType, attempt) {
     // admits.
     const fieldType = slotType !== undefined && slotType.kind === "func"
         ? slotType
-        : { kind: "func", params: inner.parameters.map(() => DYN), ret: DYN };
+        : { kind: "func", params: inner.parameters.nodes.map(() => DYN), ret: DYN };
     if (slotType !== undefined && slotType.kind !== "func")
         return null;
     const diagsBefore = lowerer.diags.length;
@@ -508,7 +540,7 @@ function literalUnionArmOf(lowerer, expr, tsType, recordArms) {
         return null;
     const props = [];
     let hasSpread = false;
-    for (const p of expr.properties) {
+    for (const p of expr.properties.nodes) {
         if (ts.isPropertyAssignment(p) && !ts.isComputedPropertyName(p.name)) {
             props.push({ name: propNameText(lowerer, p.name), type: lowerer.typeOf(p.initializer) });
         }
@@ -529,7 +561,10 @@ function literalUnionArmOf(lowerer, expr, tsType, recordArms) {
             return null;
         props.length = 0;
         for (const property of lowerer.checker.getPropertiesOfType(own)) {
-            props.push({ name: property.name, type: lowerer.checker.getTypeOfSymbol(property) });
+            props.push({
+                name: ts.symbolName(property),
+                type: lowerer.checker.getTypeOfSymbol(property),
+            });
         }
     }
     /** Cheap literal discriminants avoid checker traffic for unrelated arms.
@@ -596,6 +631,64 @@ function literalUnionArmOf(lowerer, expr, tsType, recordArms) {
 /** Object spread treats nullish sources as empty. Preserve evaluation once,
  * then turn `Record<K, V> | undefined` into either that record or a fresh
  * empty record of the same represented shape. */
+/** `{ ...unknownValue }` into a pure index-signature record (headers
+ * forwarded from an untyped parameter): Node copies the source's own
+ * enumerable keys in order, and spreads nothing for null, undefined,
+ * numbers and booleans. An object source converts through the checked
+ * extraction into the target's own shape, which keeps its keys and order
+ * and checks each value against the slot type (a value outside it throws
+ * the catchable TypeError of every unknown-to-typed conversion). A string
+ * source takes the same extraction, which rejects it, rather than
+ * silently dropping the characters Node would spread. Null for other
+ * sources and targets. */
+function dynIndexSpreadSource(lowerer, source, target, loc) {
+    if (source.type.kind !== "dyn" || target.kind !== "record")
+        return null;
+    const shape = lowerer.shapes.get(target.shapeId);
+    if (!shape?.indexValue || shape.fields.length > 0 || shape.tuple)
+        return null;
+    if (!canDynCheckTo(target, (id) => lowerer.shapes.get(id), (id) => lowerer.unions.get(id)))
+        return null;
+    const local = lowerer.declareHiddenLocal("%dynSpread", DYN);
+    const ref = varRef(local.id, DYN, loc);
+    const test = (kind) => ({
+        kind: "dynTest",
+        test: kind,
+        value: ref,
+        type: BOOL,
+        loc,
+    });
+    const extract = { kind: "dynCheck", value: ref, type: target, loc };
+    const empty = { kind: "recordLit", fields: [], type: target, loc };
+    return {
+        kind: "seqExpr",
+        stmts: [{ kind: "varDecl", localId: local.id, init: source, loc }],
+        result: {
+            kind: "ternary",
+            cond: test("nullish"),
+            then: empty,
+            else_: {
+                kind: "ternary",
+                cond: {
+                    kind: "logical",
+                    op: "||",
+                    left: test("object"),
+                    right: test("string"),
+                    type: BOOL,
+                    loc,
+                },
+                then: extract,
+                else_: empty,
+                type: target,
+                loc,
+            },
+            type: target,
+            loc,
+        },
+        type: target,
+        loc,
+    };
+}
 function lowerOptionalIndexSpreadSource(lowerer, source, loc) {
     if (source.type.kind !== "union")
         return null;
@@ -647,16 +740,16 @@ export function lowerObjectLiteral(lowerer, expr, expected) {
     // Unannotated JavaScript accumulator fields have no element contract.
     // Preserve their checked arrays instead of assigning never[] a numeric ABI.
     if (!expected &&
-        isJsSourceFile(expr.getSourceFile()) &&
-        expr.properties.some((prop) => ts.isPropertyAssignment(prop) &&
+        isJsSourceFile(ts.getSourceFileOfNode(expr)) &&
+        expr.properties.nodes.some((prop) => ts.isPropertyAssignment(prop) &&
             ((ts.isArrayLiteralExpression(prop.initializer) &&
-                prop.initializer.elements.length === 0) ||
+                prop.initializer.elements.nodes.length === 0) ||
                 neverTaintedJsType(lowerer, prop.initializer, lowerer.typeOf(prop.initializer))))) {
         return lowerDynObjectLiteral(lowerer, expr);
     }
     if (!expected &&
-        isJsSourceFile(expr.getSourceFile()) &&
-        expr.properties.some((prop) => ts.isPropertyAssignment(prop) &&
+        isJsSourceFile(ts.getSourceFileOfNode(expr)) &&
+        expr.properties.nodes.some((prop) => ts.isPropertyAssignment(prop) &&
             lowerer.mapTypeOf(lowerer.typeOf(prop.initializer))?.kind === "array" &&
             tryLowerExpression(lowerer, prop.initializer)?.type.kind === "dyn")) {
         return lowerDynObjectLiteral(lowerer, expr);
@@ -665,8 +758,8 @@ export function lowerObjectLiteral(lowerer, expr, expected) {
     // documentation names a number. Inferred literal fields must preserve
     // the represented binding rather than checking it back into that type.
     if (!expected &&
-        isJsSourceFile(expr.getSourceFile()) &&
-        expr.properties.some((prop) => {
+        isJsSourceFile(ts.getSourceFileOfNode(expr)) &&
+        expr.properties.nodes.some((prop) => {
             let value = ts.isPropertyAssignment(prop)
                 ? prop.initializer
                 : ts.isShorthandPropertyAssignment(prop)
@@ -674,6 +767,10 @@ export function lowerObjectLiteral(lowerer, expr, expected) {
                     : null;
             while (value && ts.isParenthesizedExpression(value))
                 value = value.expression;
+            // A nested literal holding such a binding: building it as a static
+            // record would copy the binding's object.
+            if (value && (ts.isArrayLiteralExpression(value) || ts.isObjectLiteralExpression(value)))
+                return jsHoldsDynObject(lowerer, value);
             if (!value || !ts.isIdentifier(value))
                 return false;
             const stored = lowerer.peekLocal(value)?.type ?? lowerer.globalOf(value)?.type;
@@ -687,9 +784,9 @@ export function lowerObjectLiteral(lowerer, expr, expected) {
     }
     // JavaScript object methods/accessors carry a live receiver. Keep the
     // literal in checked native storage instead of erasing its prototype ABI.
-    if (isJsSourceFile(expr.getSourceFile()) &&
-        (expr.properties.length === 0 ||
-            expr.properties.some((prop) => ts.isMethodDeclaration(prop) ||
+    if (isJsSourceFile(ts.getSourceFileOfNode(expr)) &&
+        (expr.properties.nodes.length === 0 ||
+            expr.properties.nodes.some((prop) => ts.isMethodDeclaration(prop) ||
                 ts.isGetAccessorDeclaration(prop) ||
                 ts.isSetAccessorDeclaration(prop)))) {
         return lowerDynObjectLiteral(lowerer, expr);
@@ -698,7 +795,7 @@ export function lowerObjectLiteral(lowerer, expr, expected) {
     // 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()) &&
+    if (isJsSourceFile(ts.getSourceFileOfNode(expr)) &&
         ts.isVariableDeclaration(expr.parent) &&
         expr.parent.initializer === expr &&
         ts.isIdentifier(expr.parent.name) &&
@@ -708,8 +805,8 @@ export function lowerObjectLiteral(lowerer, expr, expected) {
     // 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) &&
+        isJsSourceFile(ts.getSourceFileOfNode(expr)) &&
+        expr.properties.nodes.some((property) => ts.isSpreadAssignment(property) &&
             (lowerer.builtinNamespaceModuleOf(property.expression)?.startsWith("path") ||
                 tryLowerExpression(lowerer, property.expression)?.type.kind === "dyn"))) {
         return lowerDynObjectLiteral(lowerer, expr);
@@ -724,8 +821,8 @@ export function lowerObjectLiteral(lowerer, expr, expected) {
     // test/common's _mustCallInner context), where keys are runtime string
     // values. TypeScript keeps the record world and its fence: this shape
     // only arises in checked-dynamic JS.
-    if (isJsSourceFile(expr.getSourceFile()) &&
-        expr.properties.some((p) => {
+    if (isJsSourceFile(ts.getSourceFileOfNode(expr)) &&
+        expr.properties.nodes.some((p) => {
             const n = ts.isSpreadAssignment(p) ? undefined : p.name;
             return n !== undefined && ts.isComputedPropertyName(n);
         })) {
@@ -735,7 +832,7 @@ export function lowerObjectLiteral(lowerer, expr, expected) {
     // message even when they also make the literal's type unmappable
     // (a getter or a `this`-returning method would otherwise surface as an
     // opaque type fence on the whole literal).
-    for (const prop of expr.properties) {
+    for (const prop of expr.properties.nodes) {
         if (ts.isSpreadAssignment(prop)) {
             // Supported shapes: FULL spreads of known record shapes read as
             // identifiers or other side-effect-free reads, all BEFORE any
@@ -745,7 +842,7 @@ export function lowerObjectLiteral(lowerer, expr, expected) {
             // `k?: ...` — which desugar to one conditional field at the
             // spread's own position (any position: they introduce one fresh
             // name, collision-fenced below). Everything else stays fenced.
-            const cs = conditionalSpreadOf(prop.expression);
+            const cs = conditionalSpreadOf(prop.expression) ?? andSpreadOf(lowerer, prop.expression);
             if (cs === "unsupported" || (cs && cs.props.length !== 1)) {
                 lowerer.unsupported("SC1090", prop, "conditional spreads beyond `...(c ? { field: v } : {})` (exactly one property against an empty arm — spell other shapes as optional fields)");
             }
@@ -766,7 +863,7 @@ export function lowerObjectLiteral(lowerer, expr, expected) {
             // receiver (capturing the record under construction would be an
             // RC cycle), and the generic lexical-this walk would incorrectly
             // capture an ENCLOSING method's `this` — the object-method rule.
-            if (!isJsSourceFile(expr.getSourceFile())) {
+            if (!isJsSourceFile(ts.getSourceFileOfNode(expr))) {
                 rejectThisInObjectAccessor(lowerer, prop.body ?? prop);
             }
         }
@@ -838,7 +935,7 @@ export function lowerObjectLiteral(lowerer, expr, expected) {
     // type narrows away (a field written as `lanIp: null` types as bare
     // `null`, which maps to nothing on its own).
     if (tsType.isUnionType() &&
-        ts.constituentTypes(tsType).some((t) => t.getSymbol()?.name === "PromiseLike")) {
+        ts.constituentTypes(tsType).some((t) => ts.symbolNameOf(t.getSymbol()) === "PromiseLike")) {
         tsType = lowerer.checker.getAwaitedType(tsType) ?? tsType;
     }
     let mapped = lowerer.mapTypeOf(tsType);
@@ -847,13 +944,13 @@ export function lowerObjectLiteral(lowerer, expr, expected) {
     // 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")) {
+        expr.properties.nodes.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.
-    if (mapped?.kind === "string" && isJsSourceFile(expr.getSourceFile())) {
+    if (mapped?.kind === "string" && isJsSourceFile(ts.getSourceFileOfNode(expr))) {
         const own = lowerer.mapTypeOf(lowerer.typeOf(expr));
         if (own?.kind === "record")
             mapped = own;
@@ -863,7 +960,7 @@ export function lowerObjectLiteral(lowerer, expr, expected) {
     // object): `{}` carries no shape information, so the literal builds as
     // its OWN type, exactly the unmappable-context fallback below. An
     // empty LITERAL keeps the context (the shapes agree).
-    if (mapped?.kind === "record" && expr.properties.length > 0) {
+    if (mapped?.kind === "record" && expr.properties.nodes.length > 0) {
         const ctxShape = lowerer.shapes.get(mapped.shapeId);
         if (ctxShape && ctxShape.fields.length === 0 && !ctxShape.indexValue && !ctxShape.tuple) {
             mapped = lowerer.mapTypeOf(lowerer.typeOf(expr)) ?? mapped;
@@ -879,7 +976,7 @@ export function lowerObjectLiteral(lowerer, expr, expected) {
     // type carries but the shape dropped (settled value/reason,
     // generic-callable members) belongs to the drop paths below, and
     // index-signature contexts keep every key (overflow capture).
-    if (mapped?.kind === "record" && expr.properties.length > 0) {
+    if (mapped?.kind === "record" && expr.properties.nodes.length > 0) {
         const ctxShape = lowerer.shapes.get(mapped.shapeId);
         if (ctxShape && !ctxShape.indexValue && !ctxShape.tuple) {
             const names = new Set(ctxShape.fields.map((f) => f.name));
@@ -888,7 +985,7 @@ export function lowerObjectLiteral(lowerer, expr, expected) {
                 return members.some((m) => lowerer.checker.getPropertyOfType(m, name) !== undefined);
             };
             const extraOf = (text) => !names.has(text) && !ctxHasProp(text);
-            const extra = expr.properties.some((p) => {
+            const extra = expr.properties.nodes.some((p) => {
                 if (ts.isSpreadAssignment(p) || !p.name)
                     return false;
                 if (ts.isIdentifier(p.name) || ts.isStringLiteral(p.name))
@@ -945,7 +1042,7 @@ export function lowerObjectLiteral(lowerer, expr, expected) {
                     !armShape?.tuple &&
                     // `{} | undefined` supplies no layout for a populated options
                     // literal, just as a bare empty-record context supplies none.
-                    (expr.properties.length === 0 ||
+                    (expr.properties.nodes.length === 0 ||
                         (armShape && (armShape.fields.length > 0 || armShape.indexValue)))) {
                     mapped = recordArms[0];
                 }
@@ -970,7 +1067,7 @@ export function lowerObjectLiteral(lowerer, expr, expected) {
                 // already appears in the union.
                 if (ownShapeId === null ||
                     !recordArms.some((a) => a.shapeId === ownShapeId) ||
-                    expr.properties.some(ts.isSpreadAssignment)) {
+                    expr.properties.nodes.some(ts.isSpreadAssignment)) {
                     const arm = literalUnionArmOf(lowerer, expr, tsType, recordArms);
                     if (arm)
                         mapped = arm;
@@ -985,12 +1082,12 @@ export function lowerObjectLiteral(lowerer, expr, expected) {
     // lower; accessor entries and members with no value representation
     // (rest-param function types) narrow away. SEMANTICS.md documents the
     // enumeration divergence.
-    if (isJsSourceFile(expr.getSourceFile()) &&
+    if (isJsSourceFile(ts.getSourceFileOfNode(expr)) &&
         (!mapped ||
-            expr.properties.some((p) => ts.isGetAccessorDeclaration(p) || ts.isSetAccessorDeclaration(p))) &&
+            expr.properties.nodes.some((p) => ts.isGetAccessorDeclaration(p) || ts.isSetAccessorDeclaration(p))) &&
         isCjsExportTableLiteral(expr)) {
         const fields = [];
-        for (const prop of expr.properties) {
+        for (const prop of expr.properties.nodes) {
             if (ts.isGetAccessorDeclaration(prop) || ts.isSetAccessorDeclaration(prop))
                 continue;
             const propName = ts.isSpreadAssignment(prop) ? undefined : prop.name;
@@ -1024,7 +1121,7 @@ export function lowerObjectLiteral(lowerer, expr, expected) {
     // each field converts through the usual dyn boundary, and dynamic
     // consumers ride the keyed-dyn paths. TypeScript keeps the fence.
     if (mapped?.kind === "dyn" ||
-        (!mapped && isJsSourceFile(expr.getSourceFile())) ||
+        (!mapped && isJsSourceFile(ts.getSourceFileOfNode(expr))) ||
         (!expected &&
             mapped &&
             jsOpenObjectType(expr, mapped, lowerer.shapes, lowerer.unions).kind === "dyn")) {
@@ -1039,8 +1136,8 @@ export function lowerObjectLiteral(lowerer, expr, expected) {
     // 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))) {
+        !isJsSourceFile(ts.getSourceFileOfNode(expr)) &&
+        expr.properties.nodes.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 &&
@@ -1055,10 +1152,29 @@ export function lowerObjectLiteral(lowerer, expr, expected) {
             type = { kind: "record", shapeId: expected.shapeId };
         }
     }
+    // A Date's toJSON() result keeps its null in a field with no declared
+    // destination: the lib types say string.
+    if (!expected) {
+        for (const property of expr.properties.nodes) {
+            const value = ts.isPropertyAssignment(property)
+                ? property.initializer
+                : ts.isShorthandPropertyAssignment(property)
+                    ? property.name
+                    : null;
+            if (value &&
+                property.name &&
+                (ts.isIdentifier(property.name) || ts.isStringLiteral(property.name)) &&
+                isDateJsonSource(lowerer, value)) {
+                const widened = lowerer.runtimeOptionalRecordField(type, property.name.text, dateJsonType(lowerer));
+                if (widened.kind === "record")
+                    type = { kind: "record", shapeId: widened.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()) &&
+    if (isJsSourceFile(ts.getSourceFileOfNode(expr)) &&
         shape.fields.some((field) => field.type.kind === "date")) {
         return lowerDynObjectLiteral(lowerer, expr);
     }
@@ -1067,8 +1183,8 @@ export function lowerObjectLiteral(lowerer, expr, expected) {
     // so the literal's shape NARROWS to its plain fields (reads resolve
     // through the lifted accessors; Object.keys over the value omits
     // accessor names — the documented divergence).
-    if (isJsSourceFile(expr.getSourceFile())) {
-        const accessorNames = new Set(expr.properties
+    if (isJsSourceFile(ts.getSourceFileOfNode(expr))) {
+        const accessorNames = new Set(expr.properties.nodes
             .filter((p) => ts.isGetAccessorDeclaration(p) || ts.isSetAccessorDeclaration(p))
             .map((p) => p.name && (ts.isIdentifier(p.name) || ts.isStringLiteral(p.name)) ? p.name.text : "")
             .filter((n) => n !== ""));
@@ -1088,10 +1204,10 @@ export function lowerObjectLiteral(lowerer, expr, expected) {
         expr.parent.initializer === expr &&
         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));
+    const assignedProperties = expr.properties.nodes.filter((prop) => ts.isPropertyAssignment(prop) || ts.isShorthandPropertyAssignment(prop));
     if (topLevelJsDecl &&
-        isJsSourceFile(expr.getSourceFile()) &&
-        assignedProperties.length === expr.properties.length) {
+        isJsSourceFile(ts.getSourceFileOfNode(expr)) &&
+        assignedProperties.length === expr.properties.nodes.length) {
         const provided = new Set(assignedProperties.map((prop) => propNameText(lowerer, prop.name)));
         if (shape.fields.some((field) => !provided.has(field.name))) {
             return lowerDynObjectLiteral(lowerer, expr);
@@ -1114,14 +1230,15 @@ export function lowerObjectLiteral(lowerer, expr, expected) {
     // Stay deliberately narrow. Tuple/index/accessor shapes, conditional or
     // multiple spreads, spread-after-explicit order, and shape-changing width
     // copies retain their existing lowering and diagnostics.
-    if (!isJsSourceFile(expr.getSourceFile()) &&
+    if (!isJsSourceFile(ts.getSourceFileOfNode(expr)) &&
         !shape.indexValue &&
         !shape.tuple &&
         !shapeHasAccessorSlots(shape) &&
-        expr.properties.length >= 2 &&
-        ts.isSpreadAssignment(expr.properties[0]) &&
-        !conditionalSpreadOf(expr.properties[0].expression) &&
-        expr.properties
+        expr.properties.nodes.length >= 2 &&
+        ts.isSpreadAssignment(expr.properties.nodes[0]) &&
+        !conditionalSpreadOf(expr.properties.nodes[0].expression) &&
+        !andSpreadOf(lowerer, expr.properties.nodes[0].expression) &&
+        expr.properties.nodes
             .slice(1)
             .every((p) => (ts.isPropertyAssignment(p) || ts.isShorthandPropertyAssignment(p)) &&
             p.name !== undefined &&
@@ -1129,8 +1246,8 @@ export function lowerObjectLiteral(lowerer, expr, expected) {
                 ts.isStringLiteral(p.name) ||
                 ts.isNumericLiteral(p.name) ||
                 (ts.isComputedPropertyName(p.name) && literalComputedKey(lowerer, p.name) !== null)))) {
-        const spread = expr.properties[0];
-        const props = expr.properties.slice(1);
+        const spread = expr.properties.nodes[0];
+        const props = expr.properties.nodes.slice(1);
         const names = props.map((p) => propNameText(lowerer, p.name));
         const unique = new Set(names);
         const sourceType = lowerer.mapTypeOf(lowerer.typeOf(spread.expression));
@@ -1178,13 +1295,13 @@ export function lowerObjectLiteral(lowerer, expr, expected) {
     if (shape.indexValue &&
         shape.fields.length === 0 &&
         !shape.tuple &&
-        (expr.properties.some((p) => ts.isSpreadAssignment(p)) ||
-            expr.properties.some(isRuntimeComputedKey))) {
+        (expr.properties.nodes.some((p) => ts.isSpreadAssignment(p)) ||
+            expr.properties.nodes.some(isRuntimeComputedKey))) {
         const contributors = [];
         let mergeable = true;
-        for (const prop of expr.properties) {
+        for (const prop of expr.properties.nodes) {
             if (ts.isSpreadAssignment(prop)) {
-                const cs = conditionalSpreadOf(prop.expression);
+                const cs = conditionalSpreadOf(prop.expression) ?? andSpreadOf(lowerer, prop.expression);
                 if (cs === "unsupported" || (cs && cs.props.length !== 1)) {
                     lowerer.unsupported("SC1090", prop, "conditional spreads beyond `...(c ? { field: v } : {})` (exactly one property against an empty arm)");
                 }
@@ -1200,7 +1317,7 @@ export function lowerObjectLiteral(lowerer, expr, expected) {
                         ? lowerer.lowerExpr(csProp.initializer)
                         : lowerer.lowerShorthandValue(csProp), shape.indexValue, vNode);
                     contributors.push({
-                        kind: "field",
+                        kind: "condField",
                         name: csProp.name.text,
                         value: {
                             kind: "ternary",
@@ -1215,6 +1332,7 @@ export function lowerObjectLiteral(lowerer, expr, expected) {
                 }
                 let src = lowerer.lowerExpr(prop.expression);
                 src = lowerOptionalIndexSpreadSource(lowerer, src, locOf(prop)) ?? src;
+                src = dynIndexSpreadSource(lowerer, src, type, locOf(prop)) ?? src;
                 if (src.type.kind !== "record") {
                     lowerer.unsupported("SC1090", prop, `object spread of '${lowerer.fmt(src.type)}' sources into an index-signature shape (only index-signature records merge — ${NARROW_FIRST})`);
                 }
@@ -1272,7 +1390,7 @@ export function lowerObjectLiteral(lowerer, expr, expected) {
     }
     // Unfoldable computed keys outside the index-signature merge path:
     // no record shape can hold a runtime-decided name.
-    for (const prop of expr.properties) {
+    for (const prop of expr.properties.nodes) {
         if (isRuntimeComputedKey(prop)) {
             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)");
         }
@@ -1284,9 +1402,11 @@ export function lowerObjectLiteral(lowerer, expr, expected) {
     if (!shape.indexValue &&
         !shape.tuple &&
         shape.fields.length > 0 &&
-        expr.properties.length > 0 &&
-        expr.properties.every((p) => ts.isSpreadAssignment(p) && !conditionalSpreadOf(p.expression)) &&
-        expr.properties.some((p) => {
+        expr.properties.nodes.length > 0 &&
+        expr.properties.nodes.every((p) => ts.isSpreadAssignment(p) &&
+            !conditionalSpreadOf(p.expression) &&
+            !andSpreadOf(lowerer, p.expression)) &&
+        expr.properties.nodes.some((p) => {
             const t = lowerer.mapTypeOf(lowerer.typeOf(p.expression));
             return (t?.kind === "dyn" || (t?.kind === "record" && !!lowerer.shapes.get(t.shapeId)?.indexValue));
         })) {
@@ -1301,7 +1421,7 @@ export function lowerObjectLiteral(lowerer, expr, expected) {
     };
     const fields = [];
     const spreadStmts = [];
-    const hasSpread = expr.properties.some(ts.isSpreadAssignment);
+    const hasSpread = expr.properties.nodes.some(ts.isSpreadAssignment);
     const captured = new Set();
     const capture = (value) => {
         const local = lowerer.declareHiddenLocal("%spreadValue", value.type);
@@ -1380,7 +1500,9 @@ export function lowerObjectLiteral(lowerer, expr, expected) {
     // Member names DROPPED from the shape (JS deferral — unlowerable pure
     // member reads narrow away; see the catch in the property loop).
     const droppedNames = new Set();
-    for (const prop of expr.properties) {
+    // The order this literal creates its keys in (key-order-witness.ts).
+    const orderSegments = [];
+    for (const prop of expr.properties.nodes) {
         // 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.
@@ -1391,7 +1513,7 @@ export function lowerObjectLiteral(lowerer, expr, expected) {
             }
         }
         if (ts.isSpreadAssignment(prop)) {
-            const cs = conditionalSpreadOf(prop.expression);
+            const cs = conditionalSpreadOf(prop.expression) ?? andSpreadOf(lowerer, prop.expression);
             if (cs && cs !== "unsupported") {
                 // `...(c ? { k: v } : {})` — ONE conditional field at the
                 // spread's own position: cond evaluates exactly once, `v` only
@@ -1408,7 +1530,10 @@ export function lowerObjectLiteral(lowerer, expr, expected) {
                     }
                     shapeMismatch(prop);
                 }
-                const absent = lowerer.absentFieldValue(fieldType, locOf(prop));
+                // An 'unknown' slot holds the checked-dynamic undefined for the
+                // empty arm, the absent-property read the width copy uses too.
+                const absent = lowerer.absentFieldValue(fieldType, locOf(prop)) ??
+                    (fieldType.kind === "dyn" ? dynUndefinedExpr(locOf(prop)) : null);
                 if (!absent) {
                     lowerer.unsupported("SC1090", prop, `conditional spreads onto the required field '${name}' (the empty arm leaves it undefined — declare the field optional)`);
                 }
@@ -1424,6 +1549,7 @@ export function lowerObjectLiteral(lowerer, expr, expected) {
                 if (!typeEquals(v.type, fieldType))
                     lowerer.badType(valueNode, lowerer.typeOf(valueNode));
                 conditionalNames.add(name);
+                orderSegments.push({ kind: "key", name, definite: false });
                 fields.push({
                     name,
                     value: {
@@ -1447,7 +1573,7 @@ export function lowerObjectLiteral(lowerer, expr, expected) {
             let srcNode = prop.expression;
             while (ts.isParenthesizedExpression(srcNode))
                 srcNode = srcNode.expression;
-            const srcLowered = capture(prop === expr.properties[0] && leadingSpreadLowered !== null
+            const srcLowered = capture(prop === expr.properties.nodes[0] && leadingSpreadLowered !== null
                 ? leadingSpreadLowered
                 : lowerer.lowerExpr(srcNode));
             // Array callbacks can receive a record-or-undefined ABI even when
@@ -1491,9 +1617,9 @@ export function lowerObjectLiteral(lowerer, expr, expected) {
                     lowerer.unsupported("SC1090", prop, "object spread involving index-signature shapes (overflow keys are runtime state — copy the fields you need explicitly)");
                 }
                 const laterNames = new Set();
-                for (const later of expr.properties.slice(expr.properties.indexOf(prop) + 1)) {
+                for (const later of expr.properties.nodes.slice(expr.properties.nodes.indexOf(prop) + 1)) {
                     if (ts.isSpreadAssignment(later)) {
-                        if (conditionalSpreadOf(later.expression))
+                        if (conditionalSpreadOf(later.expression) || andSpreadOf(lowerer, later.expression))
                             continue;
                         const lt = laterSpreadType(lowerer, later.expression);
                         if (lt?.kind === "record") {
@@ -1514,6 +1640,7 @@ export function lowerObjectLiteral(lowerer, expr, expected) {
                     }
                 }
                 const srcRef = () => srcLowered ?? lowerer.lowerExpr(srcNode);
+                orderSegments.push({ kind: "spread", shapeId: recArm.shapeId, maybeAbsent: true });
                 for (const f of srcShape.fields) {
                     if (laterNames.has(f.name))
                         continue;
@@ -1689,9 +1816,9 @@ export function lowerObjectLiteral(lowerer, expr, expected) {
             // exactly like Node does. Conditional spreads don't count (their
             // empty arm defines nothing) — their own collision fences hold.
             const laterNames = new Set();
-            for (const later of expr.properties.slice(expr.properties.indexOf(prop) + 1)) {
+            for (const later of expr.properties.nodes.slice(expr.properties.nodes.indexOf(prop) + 1)) {
                 if (ts.isSpreadAssignment(later)) {
-                    if (conditionalSpreadOf(later.expression))
+                    if (conditionalSpreadOf(later.expression) || andSpreadOf(lowerer, later.expression))
                         continue;
                     const lt = laterSpreadType(lowerer, later.expression);
                     if (lt?.kind === "record") {
@@ -1711,6 +1838,10 @@ export function lowerObjectLiteral(lowerer, expr, expected) {
                     laterNames.add(propNameText(lowerer, later.name));
                 }
             }
+            // A checked-dynamic source's keys are a run-time fact.
+            orderSegments.push(srcLowered.type.kind === "dyn"
+                ? { kind: "opaque" }
+                : { kind: "spread", shapeId: srcType.shapeId, maybeAbsent: false });
             for (const f of srcShape.fields) {
                 if (laterNames.has(f.name))
                     continue;
@@ -1836,7 +1967,7 @@ export function lowerObjectLiteral(lowerer, expr, expected) {
             // closures is side-effect-free, so their position among the data
             // fields' source-order evaluation is unobservable — exactly JS,
             // where accessor definitions evaluate nothing.
-            if (isJsSourceFile(expr.getSourceFile()))
+            if (isJsSourceFile(ts.getSourceFileOfNode(expr)))
                 continue;
             const name = propNameText(lowerer, prop.name); // key-form-checked above
             const slotName = `${ts.isGetAccessorDeclaration(prop) ? "%get" : "%set"}:${name}`;
@@ -1912,7 +2043,7 @@ export function lowerObjectLiteral(lowerer, expr, expected) {
                         // reads; the field promotion below adopts that layout.
                         (fieldType?.kind === "record" &&
                             ts.isObjectLiteralExpression(init) &&
-                            init.properties.length > 0
+                            init.properties.nodes.length > 0
                             ? (() => {
                                 const nested = lowerer.lowerObjectLiteral(init, fieldType);
                                 return lowerer.isRuntimeOptionalRecordVariant(nested.type, fieldType)
@@ -1951,7 +2082,7 @@ export function lowerObjectLiteral(lowerer, expr, expected) {
                 (ts.isPropertyAssignment(prop) && ts.isIdentifier(prop.initializer));
             if (!(err instanceof PoisonError) ||
                 !pureMember ||
-                !isJsSourceFile(expr.getSourceFile()) ||
+                !isJsSourceFile(ts.getSourceFileOfNode(expr)) ||
                 lowerer.diagSink !== null ||
                 lowerer.diags.length <= propDiagsBefore ||
                 lowerer.diags.slice(propDiagsBefore).some((d) => d.code === "SC9001")) {
@@ -1999,6 +2130,7 @@ export function lowerObjectLiteral(lowerer, expr, expected) {
         if (at >= 0)
             fields.splice(at, 1);
         fields.push({ name, value });
+        orderSegments.push({ kind: "key", name, definite: true });
     }
     // Optional fields may be omitted: the field holds its absent state.
     // tsc rejects omission of required fields before lowering.
@@ -2024,7 +2156,7 @@ export function lowerObjectLiteral(lowerer, expr, expected) {
             fields.push({ name: f.name, value: absent });
         }
     }
-    const result = { kind: "recordLit", fields, type, loc };
+    const result = lowerer.keyOrder.literal({ kind: "recordLit", fields, type, loc }, orderSegments);
     return spreadStmts.length === 0
         ? result
         : { kind: "seqExpr", stmts: spreadStmts, result, type, loc };
@@ -2036,9 +2168,9 @@ export function lowerObjectLiteral(lowerer, expr, expected) {
  * 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()))
+    if (isJsSourceFile(ts.getSourceFileOfNode(expr)))
         return null;
-    const spread = expr.properties[0];
+    const spread = expr.properties.nodes[0];
     if (!spread || !ts.isSpreadAssignment(spread))
         return null;
     let sourceNode = spread.expression;
@@ -2056,7 +2188,7 @@ function lowerUnionRecordClone(lowerer, expr) {
         return null;
     const props = [];
     const names = [];
-    for (const prop of expr.properties.slice(1)) {
+    for (const prop of expr.properties.nodes.slice(1)) {
         if ((!ts.isPropertyAssignment(prop) && !ts.isShorthandPropertyAssignment(prop)) ||
             (!ts.isIdentifier(prop.name) && !ts.isStringLiteral(prop.name)))
             return null;
@@ -2196,6 +2328,73 @@ function lowerUnionRecordClone(lowerer, expr) {
         loc,
     };
 }
+/** `...(c && { k: v })`: spreading a falsy primitive (false, 0, "", NaN)
+ * copies nothing, so the idiom is `...(c ? { k: v } : {})` with `c`
+ * evaluated once. Recognized only where the spread's own type mixes the
+ * record with primitive arms; a record or record-or-unit spread keeps the
+ * ordinary source-copy path. */
+export function andSpreadOf(lowerer, expr) {
+    let e = expr;
+    while (ts.isParenthesizedExpression(e))
+        e = e.expression;
+    if (!ts.isBinaryExpression(e) || e.operatorToken.kind !== ts.SyntaxKind.AmpersandAmpersandToken)
+        return null;
+    let right = e.right;
+    while (ts.isParenthesizedExpression(right))
+        right = right.expression;
+    if (!ts.isObjectLiteralExpression(right))
+        return null;
+    const spreadType = lowerer.mapTypeOf(lowerer.typeOf(e));
+    // Every falsy value is a primitive, which spreads nothing, so `c && {
+    // ... }` contributes the literal's members exactly when c is truthy,
+    // whatever c's type. The checker's union of the two decides the
+    // representation where it maps; where it does not (a member typed by a
+    // checked-dynamic value such as an AbortSignal), the syntax decides.
+    if (spreadType === null || spreadType.kind === "dyn") {
+        return syntacticAndSpread(right, e.left);
+    }
+    if (spreadType?.kind !== "union")
+        return null;
+    const arms = lowerer.unions.get(spreadType.unionId)?.arms ?? [];
+    if (arms.filter((arm) => arm.kind === "record").length !== 1 ||
+        !arms.some((arm) => arm.kind === "bool" || arm.kind === "f64" || arm.kind === "string") ||
+        !arms.every((arm) => arm.kind === "record" ||
+            arm.kind === "bool" ||
+            arm.kind === "f64" ||
+            arm.kind === "string" ||
+            isUnitType(arm)))
+        return null;
+    if (right.properties.nodes.length === 0)
+        return "unsupported";
+    const props = [];
+    for (const p of right.properties.nodes) {
+        if ((ts.isPropertyAssignment(p) || ts.isShorthandPropertyAssignment(p)) &&
+            p.name &&
+            (ts.isIdentifier(p.name) || ts.isStringLiteral(p.name))) {
+            props.push(p);
+        }
+        else {
+            return "unsupported";
+        }
+    }
+    return { cond: e.left, props, whenTrue: true };
+}
+function syntacticAndSpread(right, cond) {
+    if (right.properties.nodes.length === 0)
+        return "unsupported";
+    const props = [];
+    for (const p of right.properties.nodes) {
+        if ((ts.isPropertyAssignment(p) || ts.isShorthandPropertyAssignment(p)) &&
+            p.name &&
+            (ts.isIdentifier(p.name) || ts.isStringLiteral(p.name))) {
+            props.push(p);
+        }
+        else {
+            return "unsupported";
+        }
+    }
+    return { cond, props, whenTrue: true };
+}
 export function conditionalSpreadOf(expr) {
     let e = expr;
     while (ts.isParenthesizedExpression(e))
@@ -2213,13 +2412,13 @@ export function conditionalSpreadOf(expr) {
     if (!ts.isObjectLiteralExpression(whenTrue) || !ts.isObjectLiteralExpression(whenFalse)) {
         return "unsupported";
     }
-    const trueCarries = whenFalse.properties.length === 0 && whenTrue.properties.length > 0;
-    const falseCarries = whenTrue.properties.length === 0 && whenFalse.properties.length > 0;
+    const trueCarries = whenFalse.properties.nodes.length === 0 && whenTrue.properties.nodes.length > 0;
+    const falseCarries = whenTrue.properties.nodes.length === 0 && whenFalse.properties.nodes.length > 0;
     if (!trueCarries && !falseCarries)
         return "unsupported"; // both empty is tsc-unreachable; both non-empty has no single desugar
     const carrier = trueCarries ? whenTrue : whenFalse;
     const props = [];
-    for (const p of carrier.properties) {
+    for (const p of carrier.properties.nodes) {
         if ((ts.isPropertyAssignment(p) || ts.isShorthandPropertyAssignment(p)) &&
             p.name &&
             (ts.isIdentifier(p.name) || ts.isStringLiteral(p.name))) {
@@ -2249,7 +2448,7 @@ export function conditionalSpreadOf(expr) {
  * (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) {
+    for (const prop of expr.properties.nodes) {
         const spread = prop; // caller-checked: all spreads
         const value = lowerer.lowerExpr(spread.expression);
         if (value.type.kind === "dyn") {
@@ -2620,7 +2819,7 @@ export function lowerShorthandValue(lowerer, prop) {
             return lowerer.maybeNarrow({ kind: "varRef", localId: g.id, type: g.type, loc }, propName);
         }
         const sig = lowerer.fnSigsBySymbol.get(resolved);
-        const decl = lowerer.checker.declarationsOf(resolved)[0];
+        const decl = resolved.declarations[0];
         if (sig &&
             decl &&
             ts.isFunctionDeclaration(decl) &&
@@ -2642,6 +2841,22 @@ export function lowerShorthandValue(lowerer, prop) {
         if (generic) {
             lowerer.unsupported("SC1090", prop, `generic functions as values (call '${propName.text}' directly)`);
         }
+        // A program class name (`{ parse, TomlError }`, an imported class
+        // included): the class object, exactly the long form `{ C: C }`.
+        // Generic classes keep the identifier path's contextual pinning.
+        const classInfo = lowerer.classBySymbol.get(resolved);
+        if (classInfo && !classInfo.generic) {
+            const decoratedGlobal = classInfo.classDecorators?.valueGlobalId;
+            if (decoratedGlobal !== undefined) {
+                return {
+                    kind: "varRef",
+                    localId: decoratedGlobal,
+                    type: { kind: "classval", className: classInfo.def.name },
+                    loc,
+                };
+            }
+            return lowerer.classValueRef(classInfo, propName);
+        }
     }
     lowerer.rejectUnresolvedSymbol(symbol
         ? symbol.flags & ts.SymbolFlags.Alias