@scriptc/compiler 0.2.4 → 0.2.5

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

@@ -1,3 +1,4 @@
+import { dynUndefinedExpr, numLit, strLit, varRef } from "../../../ir/build.js";
 import { pathModuleValue } from "../lower-builtin-values.js";
 import { InternalCompilerError } from "../../../errors.js";
 import * as ts from "../../ts7/adapter.js";
@@ -5,10 +6,9 @@ import { BOOL, DYN, F64, JSVAL, STRING, UNDEFINED_T, VOID, arrayOf, canDynCheckT
 import { isCjsExportTableLiteral, isJsSourceFile, locOf } from "../../program.js";
 import { NARROW_FIRST } from "../surfaces.js";
 import { recordShapeMismatchDiag } from "../../../diagnostics/diagnostic.js";
-import { PoisonError, dynUndefinedExpr, neverTaintedJsType } from "../lowerer.js";
-import { lowerIndexMergeHelper } from "../lower-containers.js";
+import { PoisonError, neverTaintedJsType } from "../lowerer.js";
+import { lowerIndexMergeHelper } from "../containers/indexed-objects.js";
 import { isGenericCallableMemberType, jsOpenObjectType } from "../../type-mapper.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";
@@ -31,7 +31,9 @@ function settledDropNames(lowerer, tsType) {
     for (const part of parts) {
         const sym = part.getSymbol();
         if (!sym ||
-            !lowerer.checker.declarationsOf(sym).some((d) => ts.isInterfaceDeclaration(d) && lowerer.isStdlibFile(d.getSourceFile()))) {
+            !lowerer.checker
+                .declarationsOf(sym)
+                .some((d) => ts.isInterfaceDeclaration(d) && lowerer.isStdlibFile(d.getSourceFile()))) {
             continue;
         }
         if (sym.name === "PromiseFulfilledResult" || sym.name === "PromiseRejectedResult") {
@@ -106,7 +108,11 @@ function literalKeySpellingOf(t) {
     if (t.isUnionType()) {
         let out = null;
         for (const arm of ts.constituentTypes(t)) {
-            const s = arm.isStringLiteralType() ? arm.value : arm.isNumberLiteralType() ? String(arm.value) : null;
+            const s = arm.isStringLiteralType()
+                ? arm.value
+                : arm.isNumberLiteralType()
+                    ? String(arm.value)
+                    : null;
             if (s === null || (out !== null && s !== out))
                 return null;
             out = s;
@@ -129,7 +135,8 @@ function pureKeyExpr(lowerer, expr) {
         return true;
     if (ts.isStringLiteralLike(expr) || ts.isNumericLiteral(expr))
         return true;
-    if (expr.kind === ts.SyntaxKind.TrueKeyword || expr.kind === ts.SyntaxKind.FalseKeyword ||
+    if (expr.kind === ts.SyntaxKind.TrueKeyword ||
+        expr.kind === ts.SyntaxKind.FalseKeyword ||
         expr.kind === ts.SyntaxKind.NullKeyword)
         return true;
     if (ts.isPropertyAccessExpression(expr)) {
@@ -139,20 +146,27 @@ function pureKeyExpr(lowerer, expr) {
         return pureKeyExpr(lowerer, expr.expression);
     }
     if (ts.isPrefixUnaryExpression(expr) &&
-        (expr.operator === ts.SyntaxKind.MinusToken || expr.operator === ts.SyntaxKind.PlusToken ||
-            expr.operator === ts.SyntaxKind.ExclamationToken || expr.operator === ts.SyntaxKind.TildeToken)) {
+        (expr.operator === ts.SyntaxKind.MinusToken ||
+            expr.operator === ts.SyntaxKind.PlusToken ||
+            expr.operator === ts.SyntaxKind.ExclamationToken ||
+            expr.operator === ts.SyntaxKind.TildeToken)) {
         return pureKeyExpr(lowerer, expr.operand);
     }
     if (ts.isBinaryExpression(expr)) {
         const op = expr.operatorToken.kind;
-        const pureOp = op === ts.SyntaxKind.AmpersandAmpersandToken || op === ts.SyntaxKind.BarBarToken ||
+        const pureOp = op === ts.SyntaxKind.AmpersandAmpersandToken ||
+            op === ts.SyntaxKind.BarBarToken ||
             op === ts.SyntaxKind.QuestionQuestionToken ||
-            (op >= ts.SyntaxKind.LessThanToken && op <= ts.SyntaxKind.CaretToken &&
-                op !== ts.SyntaxKind.InstanceOfKeyword && op !== ts.SyntaxKind.InKeyword);
+            (op >= ts.SyntaxKind.LessThanToken &&
+                op <= ts.SyntaxKind.CaretToken &&
+                op !== ts.SyntaxKind.InstanceOfKeyword &&
+                op !== ts.SyntaxKind.InKeyword);
         return pureOp && pureKeyExpr(lowerer, expr.left) && pureKeyExpr(lowerer, expr.right);
     }
     if (ts.isConditionalExpression(expr)) {
-        return pureKeyExpr(lowerer, expr.condition) && pureKeyExpr(lowerer, expr.whenTrue) && pureKeyExpr(lowerer, expr.whenFalse);
+        return (pureKeyExpr(lowerer, expr.condition) &&
+            pureKeyExpr(lowerer, expr.whenTrue) &&
+            pureKeyExpr(lowerer, expr.whenFalse));
     }
     if (ts.isTemplateExpression(expr))
         return expr.templateSpans.every((s) => pureKeyExpr(lowerer, s.expression));
@@ -195,31 +209,56 @@ export function lowerDynObjectLiteral(lowerer, expr, boxValue) {
             return;
         if (hasAccessors) {
             for (const field of fields) {
-                const descriptor = { kind: "dynObjLit", type: DYN, loc, 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 => ({
+                        ...["writable", "enumerable", "configurable"].map((name) => ({
                             key: strLit(name, loc),
-                            value: { kind: "dynFrom", value: { kind: "boolLit", value: true, type: BOOL, loc }, type: DYN, 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 };
+                    ],
+                };
+                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
-            : { kind: "libCall", fn: "dyn.assign", args: [acc, chunk], type: DYN, loc };
+        acc =
+            acc === null
+                ? chunk
+                : { kind: "libCall", fn: "dyn.assign", args: [acc, chunk], type: DYN, loc };
         fields = [];
     };
     for (const prop of expr.properties) {
-        if (ts.isPropertyAssignment(prop) && !ts.isComputedPropertyName(prop.name) && prop.name.text === "__proto__") {
+        if (ts.isPropertyAssignment(prop) &&
+            !ts.isComputedPropertyName(prop.name) &&
+            prop.name.text === "__proto__") {
             if (prop.initializer.kind !== ts.SyntaxKind.NullKeyword)
                 lowerer.unsupported("SC1090", prop, "object-literal prototypes other than null (use Object.setPrototypeOf)");
             flushFields();
             acc ??= { kind: "dynObjLit", fields: [], type: DYN, loc };
-            acc = { kind: "libCall", fn: "dyn.setPrototype", args: [acc, lowerer.lowerExprExpecting(prop.initializer, DYN)], type: DYN, loc: locOf(prop) };
+            acc = {
+                kind: "libCall",
+                fn: "dyn.setPrototype",
+                args: [acc, lowerer.lowerExprExpecting(prop.initializer, DYN)],
+                type: DYN,
+                loc: locOf(prop),
+            };
             continue;
         }
         if (ts.isSpreadAssignment(prop)) {
@@ -231,14 +270,18 @@ export function lowerDynObjectLiteral(lowerer, expr, boxValue) {
                     ? lowerer.lowerExprExpecting(prop.expression, DYN)
                     : lowerer.lowerExpr(prop.expression);
             fenceSymbolFieldCopy(lowerer, prop.expression, raw.type);
-            const source = boxValue
-                ? boxValue(prop.expression, raw)
-                : lowerer.coerceToExpected(raw, DYN);
+            const source = boxValue ? boxValue(prop.expression, raw) : lowerer.coerceToExpected(raw, DYN);
             if (source.type.kind !== "dyn") {
                 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.copyDataProperties", args: [acc, source], type: DYN, loc: locOf(prop) };
+            acc = {
+                kind: "libCall",
+                fn: "dyn.copyDataProperties",
+                args: [acc, source],
+                type: DYN,
+                loc: locOf(prop),
+            };
             continue;
         }
         const name = prop.name;
@@ -282,15 +325,37 @@ export function lowerDynObjectLiteral(lowerer, expr, boxValue) {
                 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 => ({
+                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 },
+                        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 };
+            acc = {
+                kind: "libCall",
+                fn: "dyn.defineProperty",
+                args: [acc, lowerer.coerceToExpected(key, DYN), descriptor],
+                type: DYN,
+                loc,
+            };
             continue;
         }
         const valueExpr = ts.isMethodDeclaration(prop)
@@ -305,13 +370,13 @@ export function lowerDynObjectLiteral(lowerer, expr, boxValue) {
         const propDiagsBefore = lowerer.diags.length;
         try {
             const lowerValue = () => ts.isMethodDeclaration(prop)
-                ? (isJsSourceFile(expr.getSourceFile()) ? lowerer.lowerLambda(prop) : (lowerer.rejectThisInObjectMethod(prop.body ?? prop), lowerer.lowerLambda(prop)))
+                ? 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();
+            raw = fenceClosureProbe(lowerer, valueExpr, undefined, lowerValue) ?? lowerValue();
         }
         catch (err) {
             // A PURE member read a JS file cannot lower (a namespace object
@@ -336,7 +401,10 @@ export function lowerDynObjectLiteral(lowerer, expr, boxValue) {
             : 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") {
+        if (!boxValue &&
+            isJsSourceFile(prop.getSourceFile()) &&
+            v.kind === "dynFrom" &&
+            v.value.type.kind === "array") {
             v = { ...v, liveRef: true };
         }
         if (v.type.kind !== "dyn") {
@@ -406,7 +474,9 @@ function fenceClosureProbe(lowerer, node, slotType, attempt) {
     let inner = node;
     while (ts.isParenthesizedExpression(inner))
         inner = inner.expression;
-    if (!ts.isArrowFunction(inner) && !ts.isFunctionExpression(inner) && !ts.isMethodDeclaration(inner)) {
+    if (!ts.isArrowFunction(inner) &&
+        !ts.isFunctionExpression(inner) &&
+        !ts.isMethodDeclaration(inner)) {
         return null;
     }
     // The trap's ABI: the field's func slot when one exists; otherwise (the
@@ -498,7 +568,8 @@ function literalUnionArmOf(lowerer, expr, tsType, recordArms) {
         if (ftT.isNumberLiteralType())
             return litT.isNumberLiteralType() && litT.value === ftT.value;
         if (ftT.flags & ts.TypeFlags.BooleanLiteral) {
-            return (litT.flags & ts.TypeFlags.BooleanLiteral) !== 0 && lowerer.checker.typeToString(litT) === lowerer.checker.typeToString(ftT);
+            return ((litT.flags & ts.TypeFlags.BooleanLiteral) !== 0 &&
+                lowerer.checker.typeToString(litT) === lowerer.checker.typeToString(ftT));
         }
         if (ftT.flags & ts.TypeFlags.Null)
             return (litT.flags & ts.TypeFlags.Null) !== 0;
@@ -510,7 +581,9 @@ function literalUnionArmOf(lowerer, expr, tsType, recordArms) {
     const candidates = new Set();
     for (const member of ts.constituentTypes(tsType)) {
         const mMapped = lowerer.mapTypeOf(member);
-        if (mMapped?.kind !== "record" || !armShapeIds.has(mMapped.shapeId) || candidates.has(mMapped.shapeId))
+        if (mMapped?.kind !== "record" ||
+            !armShapeIds.has(mMapped.shapeId) ||
+            candidates.has(mMapped.shapeId))
             continue;
         const shape = lowerer.shapes.get(mMapped.shapeId);
         if (!shape || shape.tuple || shape.indexValue)
@@ -572,59 +645,100 @@ function lowerOptionalIndexSpreadSource(lowerer, source, loc) {
     }
     const selected = {
         kind: "ternary",
-        cond: { kind: "unionIsTag", unionId: source.type.unionId, tag: undefinedTag, negated: false, value: stable, type: BOOL, loc },
+        cond: {
+            kind: "unionIsTag",
+            unionId: source.type.unionId,
+            tag: undefinedTag,
+            negated: false,
+            value: stable,
+            type: BOOL,
+            loc,
+        },
         then: { kind: "recordLit", fields: [], type: recordType, loc },
-        else_: { kind: "unionNarrow", unionId: source.type.unionId, tag: recordTag, value: stable, type: recordType, loc },
+        else_: {
+            kind: "unionNarrow",
+            unionId: source.type.unionId,
+            tag: recordTag,
+            value: stable,
+            type: recordType,
+            loc,
+        },
         type: recordType,
         loc,
     };
-    return prefix.length === 0 ? selected : { kind: "seqExpr", stmts: prefix, result: selected, type: recordType, loc };
+    return prefix.length === 0
+        ? selected
+        : { kind: "seqExpr", stmts: prefix, result: selected, type: recordType, loc };
 }
 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) && (ts.isArrayLiteralExpression(prop.initializer) &&
-        prop.initializer.elements.length === 0 || neverTaintedJsType(lowerer, prop.initializer, lowerer.typeOf(prop.initializer))))) {
+    if (!expected &&
+        isJsSourceFile(expr.getSourceFile()) &&
+        expr.properties.some((prop) => ts.isPropertyAssignment(prop) &&
+            ((ts.isArrayLiteralExpression(prop.initializer) &&
+                prop.initializer.elements.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) && lowerer.mapTypeOf(lowerer.typeOf(prop.initializer))?.kind === "array" &&
-        tryLowerExpression(lowerer, prop.initializer)?.type.kind === "dyn")) {
+    if (!expected &&
+        isJsSourceFile(expr.getSourceFile()) &&
+        expr.properties.some((prop) => ts.isPropertyAssignment(prop) &&
+            lowerer.mapTypeOf(lowerer.typeOf(prop.initializer))?.kind === "array" &&
+            tryLowerExpression(lowerer, prop.initializer)?.type.kind === "dyn")) {
         return lowerDynObjectLiteral(lowerer, expr);
     }
     // A JS constructor parameter can hold omitted values even when its
     // 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) => {
-        let value = ts.isPropertyAssignment(prop) ? prop.initializer
-            : ts.isShorthandPropertyAssignment(prop) ? prop.name : null;
-        while (value && ts.isParenthesizedExpression(value))
-            value = value.expression;
-        if (!value || !ts.isIdentifier(value))
-            return false;
-        const stored = lowerer.peekLocal(value)?.type ?? lowerer.globalOf(value)?.type;
-        const inferred = lowerer.mapTypeOf(lowerer.typeOf(value));
-        return stored?.kind === "dyn" && inferred !== null && inferred.kind !== "dyn" && lowerer.dynConvertible(inferred);
-    })) {
+    if (!expected &&
+        isJsSourceFile(expr.getSourceFile()) &&
+        expr.properties.some((prop) => {
+            let value = ts.isPropertyAssignment(prop)
+                ? prop.initializer
+                : ts.isShorthandPropertyAssignment(prop)
+                    ? prop.name
+                    : null;
+            while (value && ts.isParenthesizedExpression(value))
+                value = value.expression;
+            if (!value || !ts.isIdentifier(value))
+                return false;
+            const stored = lowerer.peekLocal(value)?.type ?? lowerer.globalOf(value)?.type;
+            const inferred = lowerer.mapTypeOf(lowerer.typeOf(value));
+            return (stored?.kind === "dyn" &&
+                inferred !== null &&
+                inferred.kind !== "dyn" &&
+                lowerer.dynConvertible(inferred));
+        })) {
         return lowerDynObjectLiteral(lowerer, expr);
     }
     // 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) || ts.isGetAccessorDeclaration(prop) || ts.isSetAccessorDeclaration(prop)))) {
+    if (isJsSourceFile(expr.getSourceFile()) &&
+        (expr.properties.length === 0 ||
+            expr.properties.some((prop) => ts.isMethodDeclaration(prop) ||
+                ts.isGetAccessorDeclaration(prop) ||
+                ts.isSetAccessorDeclaration(prop)))) {
         return lowerDynObjectLiteral(lowerer, expr);
     }
     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) &&
+    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) && (lowerer.builtinNamespaceModuleOf(property.expression)?.startsWith("path") ||
-        tryLowerExpression(lowerer, property.expression)?.type.kind === "dyn"))) {
+    if (!expected &&
+        isJsSourceFile(expr.getSourceFile()) &&
+        expr.properties.some((property) => ts.isSpreadAssignment(property) &&
+            (lowerer.builtinNamespaceModuleOf(property.expression)?.startsWith("path") ||
+                tryLowerExpression(lowerer, property.expression)?.type.kind === "dyn"))) {
         return lowerDynObjectLiteral(lowerer, expr);
     }
     const unionClone = lowerUnionRecordClone(lowerer, expr);
@@ -694,8 +808,10 @@ export function lowerObjectLiteral(lowerer, expr, expected) {
         // stores "16" — JS's ToPropertyKey; the checker names the property
         // symbol the same way), and FOLDABLE computed keys (above).
         if (!prop.name ||
-            !(ts.isIdentifier(prop.name) || ts.isStringLiteral(prop.name) ||
-                ts.isNumericLiteral(prop.name) || ts.isComputedPropertyName(prop.name))) {
+            !(ts.isIdentifier(prop.name) ||
+                ts.isStringLiteral(prop.name) ||
+                ts.isNumericLiteral(prop.name) ||
+                ts.isComputedPropertyName(prop.name))) {
             lowerer.unsupported("SC1090", prop, "non-identifier property names");
         }
         // Shorthand methods are just closure-valued fields — but their `this`
@@ -710,8 +826,11 @@ export function lowerObjectLiteral(lowerer, expr, expected) {
     // An inferred binding pattern supplies placeholders such as
     // { nested: { value: any } }. Construct the literal's own fields so
     // those placeholders do not erase instantiated generic storage.
-    if (!expected && ts.isVariableDeclaration(expr.parent) && !expr.parent.type &&
-        ts.isObjectBindingPattern(expr.parent.name) && expr.parent.initializer === expr) {
+    if (!expected &&
+        ts.isVariableDeclaration(expr.parent) &&
+        !expr.parent.type &&
+        ts.isObjectBindingPattern(expr.parent.name) &&
+        expr.parent.initializer === expr) {
         tsType = lowerer.typeOf(expr);
     }
     // `as never` supplies no construction layout. Keep the literal's own
@@ -745,7 +864,8 @@ export function lowerObjectLiteral(lowerer, expr, expected) {
     // slot's field types (`lanIp: string | null`), which the literal's own
     // 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")) {
+    if (tsType.isUnionType() &&
+        ts.constituentTypes(tsType).some((t) => t.getSymbol()?.name === "PromiseLike")) {
         tsType = lowerer.checker.getAwaitedType(tsType) ?? tsType;
     }
     let mapped = lowerer.mapTypeOf(tsType);
@@ -753,7 +873,8 @@ export function lowerObjectLiteral(lowerer, expr, expected) {
     // 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")) {
+    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
@@ -826,7 +947,12 @@ export function lowerObjectLiteral(lowerer, expr, expected) {
     // 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") {
+    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
@@ -851,7 +977,8 @@ 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 || (armShape && (armShape.fields.length > 0 || armShape.indexValue)))) {
+                    (expr.properties.length === 0 ||
+                        (armShape && (armShape.fields.length > 0 || armShape.indexValue)))) {
                     mapped = recordArms[0];
                 }
             }
@@ -873,7 +1000,9 @@ export function lowerObjectLiteral(lowerer, expr, expected) {
                 // 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)) {
+                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;
@@ -889,7 +1018,8 @@ export function lowerObjectLiteral(lowerer, expr, expected) {
     // (rest-param function types) narrow away. SEMANTICS.md documents the
     // enumeration divergence.
     if (isJsSourceFile(expr.getSourceFile()) &&
-        (!mapped || expr.properties.some((p) => ts.isGetAccessorDeclaration(p) || ts.isSetAccessorDeclaration(p))) &&
+        (!mapped ||
+            expr.properties.some((p) => ts.isGetAccessorDeclaration(p) || ts.isSetAccessorDeclaration(p))) &&
         isCjsExportTableLiteral(expr)) {
         const fields = [];
         for (const prop of expr.properties) {
@@ -925,8 +1055,11 @@ export function lowerObjectLiteral(lowerer, expr, expected) {
     // 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?.kind === "dyn" || (!mapped && isJsSourceFile(expr.getSourceFile())) ||
-        (!expected && mapped && jsOpenObjectType(expr, mapped, lowerer.shapes, lowerer.unions).kind === "dyn")) {
+    if (mapped?.kind === "dyn" ||
+        (!mapped && isJsSourceFile(expr.getSourceFile())) ||
+        (!expected &&
+            mapped &&
+            jsOpenObjectType(expr, mapped, lowerer.shapes, lowerer.unions).kind === "dyn")) {
         return lowerDynObjectLiteral(lowerer, expr);
     }
     if (!mapped || mapped.kind !== "record")
@@ -937,14 +1070,19 @@ export function lowerObjectLiteral(lowerer, expr, expected) {
     // 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()) &&
+    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) &&
+        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) &&
+                (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 };
         }
@@ -952,7 +1090,8 @@ export function lowerObjectLiteral(lowerer, expr, expected) {
     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")) {
+    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
@@ -963,7 +1102,7 @@ export function lowerObjectLiteral(lowerer, expr, expected) {
     if (isJsSourceFile(expr.getSourceFile())) {
         const accessorNames = new Set(expr.properties
             .filter((p) => ts.isGetAccessorDeclaration(p) || ts.isSetAccessorDeclaration(p))
-            .map((p) => (p.name && (ts.isIdentifier(p.name) || ts.isStringLiteral(p.name)) ? p.name.text : ""))
+            .map((p) => p.name && (ts.isIdentifier(p.name) || ts.isStringLiteral(p.name)) ? p.name.text : "")
             .filter((n) => n !== ""));
         if (accessorNames.size > 0) {
             const narrowed = shape.fields.filter((f) => !accessorNames.has(f.name));
@@ -982,7 +1121,8 @@ export function lowerObjectLiteral(lowerer, expr, expected) {
         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()) &&
+    if (topLevelJsDecl &&
+        isJsSourceFile(expr.getSourceFile()) &&
         assignedProperties.length === expr.properties.length) {
         const provided = new Set(assignedProperties.map((prop) => propNameText(lowerer, prop.name)));
         if (shape.fields.some((field) => !provided.has(field.name))) {
@@ -1013,7 +1153,9 @@ export function lowerObjectLiteral(lowerer, expr, expected) {
         expr.properties.length >= 2 &&
         ts.isSpreadAssignment(expr.properties[0]) &&
         !conditionalSpreadOf(expr.properties[0].expression) &&
-        expr.properties.slice(1).every((p) => (ts.isPropertyAssignment(p) || ts.isShorthandPropertyAssignment(p)) &&
+        expr.properties
+            .slice(1)
+            .every((p) => (ts.isPropertyAssignment(p) || ts.isShorthandPropertyAssignment(p)) &&
             p.name !== undefined &&
             (ts.isIdentifier(p.name) ||
                 ts.isStringLiteral(p.name) ||
@@ -1068,7 +1210,8 @@ 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.some((p) => ts.isSpreadAssignment(p)) ||
+            expr.properties.some(isRuntimeComputedKey))) {
         const contributors = [];
         let mergeable = true;
         for (const prop of expr.properties) {
@@ -1085,7 +1228,9 @@ export function lowerObjectLiteral(lowerer, expr, expected) {
                     const csProp = cs.props[0];
                     const cond = lowerer.lowerCondition(cs.cond);
                     const vNode = ts.isPropertyAssignment(csProp) ? csProp.initializer : csProp;
-                    const v = lowerer.intoIndexValueSlot(ts.isPropertyAssignment(csProp) ? lowerer.lowerExpr(csProp.initializer) : lowerer.lowerShorthandValue(csProp), shape.indexValue, vNode);
+                    const v = lowerer.intoIndexValueSlot(ts.isPropertyAssignment(csProp)
+                        ? lowerer.lowerExpr(csProp.initializer)
+                        : lowerer.lowerShorthandValue(csProp), shape.indexValue, vNode);
                     contributors.push({
                         kind: "field",
                         name: csProp.name.text,
@@ -1175,7 +1320,7 @@ export function lowerObjectLiteral(lowerer, expr, expected) {
         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 === "dyn" || 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);
     }
@@ -1337,7 +1482,8 @@ export function lowerObjectLiteral(lowerer, expr, expected) {
                         (ts.isIdentifier(later.name) ||
                             ts.isStringLiteral(later.name) ||
                             ts.isNumericLiteral(later.name) ||
-                            (ts.isComputedPropertyName(later.name) && literalComputedKey(lowerer, later.name) !== null))) {
+                            (ts.isComputedPropertyName(later.name) &&
+                                literalComputedKey(lowerer, later.name) !== null))) {
                         laterNames.add(propNameText(lowerer, later.name));
                     }
                 }
@@ -1355,13 +1501,28 @@ export function lowerObjectLiteral(lowerer, expr, expected) {
                     }
                     const fRead = () => ({
                         kind: "recordGet",
-                        obj: { kind: "unionNarrow", unionId: srcType.unionId, tag: recTag, value: srcRef(), type: recArm, loc: locOf(prop) },
+                        obj: {
+                            kind: "unionNarrow",
+                            unionId: srcType.unionId,
+                            tag: recTag,
+                            value: srcRef(),
+                            type: recArm,
+                            loc: locOf(prop),
+                        },
                         shapeId: recArm.shapeId,
                         field: f.name,
                         type: f.type,
                         loc: locOf(prop),
                     });
-                    let cond = { kind: "unionIsTag", unionId: srcType.unionId, tag: recTag, negated: false, value: srcRef(), type: BOOL, loc: locOf(prop) };
+                    let cond = {
+                        kind: "unionIsTag",
+                        unionId: srcType.unionId,
+                        tag: recTag,
+                        negated: false,
+                        value: srcRef(),
+                        type: BOOL,
+                        loc: locOf(prop),
+                    };
                     let thenVal;
                     if (typeEquals(f.type, targetType)) {
                         thenVal = fRead();
@@ -1377,7 +1538,15 @@ export function lowerObjectLiteral(lowerer, expr, expected) {
                             kind: "logical",
                             op: "&&",
                             left: cond,
-                            right: { kind: "unionIsTag", unionId: f.type.unionId, tag: ftUndef, negated: true, value: fRead(), type: BOOL, loc: locOf(prop) },
+                            right: {
+                                kind: "unionIsTag",
+                                unionId: f.type.unionId,
+                                tag: ftUndef,
+                                negated: true,
+                                value: fRead(),
+                                type: BOOL,
+                                loc: locOf(prop),
+                            },
                             type: BOOL,
                             loc: locOf(prop),
                         };
@@ -1388,10 +1557,25 @@ export function lowerObjectLiteral(lowerer, expr, expected) {
                                 lowerer.pushDiag(recordShapeMismatchDiag(lowerer.fmt(type), lowerer.fmt(recArm), locOf(prop), `spread field '${f.name}': '${lowerer.fmt(f.type)}' cannot re-tag into '${lowerer.fmt(targetType)}' behind the present-test`));
                                 throw new PoisonError();
                             }
-                            thenVal = { kind: "call", callee: retag, args: [fRead()], type: targetType, loc: locOf(prop) };
+                            thenVal = {
+                                kind: "call",
+                                callee: retag,
+                                args: [fRead()],
+                                type: targetType,
+                                loc: locOf(prop),
+                            };
                         }
-                        else if (ftDef && ftDef.arms.length === 2 && lowerer.armTag(f.type.unionId, targetType) >= 0) {
-                            thenVal = { kind: "unionNarrow", unionId: f.type.unionId, tag: lowerer.armTag(f.type.unionId, targetType), value: fRead(), type: targetType, loc: locOf(prop) };
+                        else if (ftDef &&
+                            ftDef.arms.length === 2 &&
+                            lowerer.armTag(f.type.unionId, targetType) >= 0) {
+                            thenVal = {
+                                kind: "unionNarrow",
+                                unionId: f.type.unionId,
+                                tag: lowerer.armTag(f.type.unionId, targetType),
+                                value: fRead(),
+                                type: targetType,
+                                loc: locOf(prop),
+                            };
                         }
                         else {
                             lowerer.pushDiag(recordShapeMismatchDiag(lowerer.fmt(type), lowerer.fmt(recArm), locOf(prop), `spread field '${f.name}': '${lowerer.fmt(f.type)}' cannot narrow into '${lowerer.fmt(targetType)}' behind the present-test`));
@@ -1416,7 +1600,14 @@ export function lowerObjectLiteral(lowerer, expr, expected) {
                     if (!elseVal) {
                         lowerer.unsupported("SC1090", prop, `object spread of '${lowerer.fmt(srcType)}' sources where '${f.name}' has no earlier contributor (the absent arm leaves the required field unset — spread defaults first: { ...defaults, ...overrides })`);
                     }
-                    const merged = { kind: "ternary", cond, then: thenVal, else_: elseVal, type: targetType, loc: locOf(prop) };
+                    const merged = {
+                        kind: "ternary",
+                        cond,
+                        then: thenVal,
+                        else_: elseVal,
+                        type: targetType,
+                        loc: locOf(prop),
+                    };
                     if (at >= 0)
                         fields[at] = { name: f.name, value: merged };
                     else
@@ -1459,7 +1650,8 @@ export function lowerObjectLiteral(lowerer, expr, expected) {
                     (ts.isIdentifier(later.name) ||
                         ts.isStringLiteral(later.name) ||
                         ts.isNumericLiteral(later.name) ||
-                        (ts.isComputedPropertyName(later.name) && literalComputedKey(lowerer, later.name) !== null))) {
+                        (ts.isComputedPropertyName(later.name) &&
+                            literalComputedKey(lowerer, later.name) !== null))) {
                     laterNames.add(propNameText(lowerer, later.name));
                 }
             }
@@ -1619,8 +1811,12 @@ export function lowerObjectLiteral(lowerer, expr, expected) {
                     // compile time; anything else — the awaited mapper — runs
                     // (and may throw into the enclosing catch) with its result
                     // released by the statement frame.
-                    if (v.kind !== "unitLit" && v.kind !== "numLit" && v.kind !== "strLit" &&
-                        v.kind !== "boolLit" && v.kind !== "varRef" && v.kind !== "closure") {
+                    if (v.kind !== "unitLit" &&
+                        v.kind !== "numLit" &&
+                        v.kind !== "strLit" &&
+                        v.kind !== "boolLit" &&
+                        v.kind !== "varRef" &&
+                        v.kind !== "closure") {
                         fields.push({ name, value: v, drop: true });
                     }
                 }
@@ -1642,7 +1838,10 @@ export function lowerObjectLiteral(lowerer, expr, expected) {
                     init = init.expression;
                 value =
                     fenceClosureProbe(lowerer, prop.initializer, fieldType, () => lowerer.lowerExpr(prop.initializer)) ??
-                        (fieldType !== undefined && (ts.isArrayLiteralExpression(init) || ts.isObjectLiteralExpression(init) || ts.isConditionalExpression(init))
+                        (fieldType !== undefined &&
+                            (ts.isArrayLiteralExpression(init) ||
+                                ts.isObjectLiteralExpression(init) ||
+                                ts.isConditionalExpression(init))
                             ? lowerer.lowerExprExpecting(prop.initializer, fieldType)
                             : lowerer.lowerExpr(prop.initializer));
             }
@@ -1651,7 +1850,8 @@ export function lowerObjectLiteral(lowerer, expr, expected) {
             }
             else if (ts.isMethodDeclaration(prop)) {
                 value =
-                    fenceClosureProbe(lowerer, prop, fieldType, () => lowerer.lowerLambda(prop)) ?? lowerer.lowerLambda(prop);
+                    fenceClosureProbe(lowerer, prop, fieldType, () => lowerer.lowerLambda(prop)) ??
+                        lowerer.lowerLambda(prop);
             }
             else {
                 lowerer.unsupported("SC1090", prop, `syntax '${ts.syntaxKindName(prop.kind)}'`);
@@ -1734,7 +1934,9 @@ export function lowerObjectLiteral(lowerer, expr, expected) {
             // 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 optional = ((lowerer.checker.getPropertyOfType(tsType, f.name)?.flags ?? 0) & ts.SymbolFlags.Optional) !== 0;
+            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;
@@ -1747,7 +1949,9 @@ export function lowerObjectLiteral(lowerer, expr, expected) {
         }
     }
     const result = { kind: "recordLit", fields, type, loc };
-    return spreadStmts.length === 0 ? result : { kind: "seqExpr", stmts: spreadStmts, result, 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
@@ -1790,7 +1994,10 @@ function lowerUnionRecordClone(lowerer, expr) {
         if (arm.kind !== "record")
             return null;
         const shape = lowerer.shapes.get(arm.shapeId);
-        if (!shape || shape.indexValue || shape.tuple || shapeHasAccessorSlots(shape) ||
+        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++) {
@@ -1807,10 +2014,14 @@ function lowerUnionRecordClone(lowerer, expr) {
             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")))
+                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")
@@ -1821,14 +2032,24 @@ function lowerUnionRecordClone(lowerer, expr) {
     // 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)) {
+    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 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 };
+                source = {
+                    kind: "call",
+                    callee: helper,
+                    args: [source],
+                    type: sourceType,
+                    loc: source.loc,
+                };
         }
     }
     if (!typeEquals(source.type, sourceType)) {
@@ -1853,18 +2074,50 @@ function lowerUnionRecordClone(lowerer, expr) {
                 : lowerer.coerceInto(prop, lowerer.lowerShorthandValue(prop), fieldType);
             overrides.push({ name, value });
         }
-        const clone = { kind: "recordClone",
+        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,
+            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 };
+    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
@@ -1899,7 +2152,8 @@ export function conditionalSpreadOf(expr) {
     const props = [];
     for (const p of carrier.properties) {
         if ((ts.isPropertyAssignment(p) || ts.isShorthandPropertyAssignment(p)) &&
-            p.name && (ts.isIdentifier(p.name) || ts.isStringLiteral(p.name))) {
+            p.name &&
+            (ts.isIdentifier(p.name) || ts.isStringLiteral(p.name))) {
             props.push(p);
         }
         else {
@@ -1967,32 +2221,77 @@ function lowerDeclaredSpreadMerge(lowerer, expr, type, shape, loc) {
                     stmts: (write) => {
                         const chain = (i) => {
                             if (i >= def.arms.length) {
-                                return [{
+                                return [
+                                    {
                                         kind: "throw",
                                         value: {
                                             kind: "libCall",
                                             fn: "error.new",
-                                            args: [{ kind: "strLit", value: `expected ${lowerer.fmt(fUnion)} at $.${f.name}`, type: STRING, loc }],
+                                            args: [
+                                                {
+                                                    kind: "strLit",
+                                                    value: `expected ${lowerer.fmt(fUnion)} at $.${f.name}`,
+                                                    type: STRING,
+                                                    loc,
+                                                },
+                                            ],
                                             type: { kind: "object", className: "%TypeError" },
                                             loc,
                                         },
                                         loc,
-                                    }];
+                                    },
+                                ];
                             }
                             const arm = def.arms[i];
                             const toTag = lowerer.armTag(fUnion.unionId, arm);
                             if (toTag < 0)
                                 return chain(i + 1);
                             const extracted = isUnitType(arm)
-                                ? { kind: "unionWrap", unionId: fUnion.unionId, tag: toTag, value: { kind: "unitLit", unit: arm.kind === "undefinedT" ? "undefined" : "null", type: arm, loc }, type: fUnion, loc }
-                                : { kind: "unionWrap", unionId: fUnion.unionId, tag: toTag, value: { kind: "unionNarrow", unionId: iv.unionId, tag: i, value: v, type: arm, loc }, type: fUnion, loc };
-                            return [{
+                                ? {
+                                    kind: "unionWrap",
+                                    unionId: fUnion.unionId,
+                                    tag: toTag,
+                                    value: {
+                                        kind: "unitLit",
+                                        unit: arm.kind === "undefinedT" ? "undefined" : "null",
+                                        type: arm,
+                                        loc,
+                                    },
+                                    type: fUnion,
+                                    loc,
+                                }
+                                : {
+                                    kind: "unionWrap",
+                                    unionId: fUnion.unionId,
+                                    tag: toTag,
+                                    value: {
+                                        kind: "unionNarrow",
+                                        unionId: iv.unionId,
+                                        tag: i,
+                                        value: v,
+                                        type: arm,
+                                        loc,
+                                    },
+                                    type: fUnion,
+                                    loc,
+                                };
+                            return [
+                                {
                                     kind: "if",
-                                    cond: { kind: "unionIsTag", unionId: iv.unionId, tag: i, negated: false, value: v, type: BOOL, loc },
+                                    cond: {
+                                        kind: "unionIsTag",
+                                        unionId: iv.unionId,
+                                        tag: i,
+                                        negated: false,
+                                        value: v,
+                                        type: BOOL,
+                                        loc,
+                                    },
                                     then: [write(extracted)],
                                     else_: chain(i + 1),
                                     loc,
-                                }];
+                                },
+                            ];
                         };
                         return chain(0);
                     },
@@ -2006,16 +2305,27 @@ function lowerDeclaredSpreadMerge(lowerer, expr, type, shape, loc) {
     // 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 },
+    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,
-        }];
+        },
+    ];
     for (const source of srcs) {
         const key = `declmerge-source:${type.shapeId}:${source.shapeId}`;
-        let helper = lowerer.widthHelpers.get(key);
+        let helper = lowerer.valueHelpers.get(key);
         if (!helper) {
-            helper = `%rec.declmerge.${lowerer.widthHelpers.size}`;
+            helper = `%rec.declmerge.${lowerer.valueHelpers.size}`;
             const sourceType = source.value.type;
             const destination = varRef("out.0", type, loc);
             const receiver = varRef("source.0", sourceType, loc);
@@ -2028,31 +2338,57 @@ function lowerDeclaredSpreadMerge(lowerer, expr, type, shape, loc) {
                 // 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,
+                    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 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,
+                    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 });
+                    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);
@@ -2066,42 +2402,123 @@ function lowerDeclaredSpreadMerge(lowerer, expr, type, shape, 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 write = (value) => ({
+                        kind: "recordSet",
+                        obj: destination,
+                        shapeId: type.shapeId,
+                        field: field.name,
+                        value,
+                        loc,
+                    });
                     const converted = conv(iv, field, value);
-                    return [{
+                    return [
+                        {
                             kind: "if",
-                            cond: { kind: "strEq", negated: false, left: name, right: { kind: "strLit", value: field.name, type: STRING, loc }, type: BOOL, loc },
+                            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,
-                        }];
+                            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 }, {
+                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 },
+                    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 },
+                        {
+                            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,
+                    ],
+                    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,
+                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);
+            lowerer.valueHelpers.set(key, helper);
         }
-        stmts.push({ kind: "exprStmt", expr: { kind: "call", callee: helper, args: [outRef, source.value], type, loc }, loc });
+        stmts.push({
+            kind: "exprStmt",
+            expr: { kind: "call", callee: helper, args: [outRef, source.value], type, loc },
+            loc,
+        });
     }
     return { kind: "seqExpr", stmts, result: outRef, type, loc };
 }
@@ -2138,8 +2555,11 @@ 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) || (decl.parent !== undefined && lowerer.nsBlocks.get(decl.parent) === "flattened"))) {
+        if (sig &&
+            decl &&
+            ts.isFunctionDeclaration(decl) &&
+            (ts.isSourceFile(decl.parent) ||
+                (decl.parent !== undefined && lowerer.nsBlocks.get(decl.parent) === "flattened"))) {
             lowerer.noteEdge(sig.name);
             const funcType = {
                 kind: "func",
@@ -2157,12 +2577,19 @@ export function lowerShorthandValue(lowerer, prop) {
             lowerer.unsupported("SC1090", prop, `generic functions as values (call '${propName.text}' directly)`);
         }
     }
-    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)`);
+    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 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))
+    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");