@scriptc/compiler 0.0.7 → 0.0.9

package/dist/frontend/lowering/lower-containers.d.ts

@@ -388,8 +388,10 @@ export declare function lowerObjectFromEntriesCall(L: Lowerer, call: ts.CallExpr
    * every source value (declared fields, and the overflow slot when the
    * source carries one) must enter the target's value slot (identity, a
    * width lift — arm wrap/re-tag/nested reshape, or JSON-safe into a dyn
-   * slot), and every target field must be optional-flavored (the fresh
-   * record's default) and writable at runtime. */
+   * slot), and every target field must either be initialized directly by
+   * a same-named source declared field (the rule that admits REQUIRED
+   * declared members) or be optional-flavored (the fresh record's
+   * default) and writable at runtime. */
 export declare function lowerRecordOvfCaptureHelper(L: Lowerer, fromId: string, toId: string, loc: SrcLoc): string | null;
 /** `Object.assign(target, ...sources)` into an INDEX-SIGNATURE record:
    * the capture helper's keyed-write walk aimed at the EXISTING target —

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

@@ -5,12 +5,12 @@
 import * as ts from "../ts7/adapter.js";
 import { BOOL, BYTES_U8, CAUGHT, DYN, F64, JSVAL, STRING, UNDEFINED_T, VOID, arrayOf, bytesOf, funcOf, isRefCounted, isSupportedIndexValue, isUnitType, typeEquals } from "../../ir/nodes.js";
 import { ARRAY_METHODS, MAP_METHODS, SET_COMBINE_METHODS, SET_METHODS, STR_METHODS } from "./surfaces.js";
-import { isRequireMainFilename, probeLower, pureReemittable } from "./lower-exprs.js";
+import { isRequireMainFilename, lowerDynObjectLiteral, probeLower, pureReemittable } from "./lower-exprs.js";
 import { forOfVarTarget, lowerDestructuringAssign } from "./lower-stmts.js";
 import { isJsSourceFile, locOf } from "../program.js";
 import { DYN_DISPATCH_METHODS, islandPrimitiveExit } from "./lower-calls.js";
 import { typeKey } from "../types.js";
-import { own } from "./lowerer.js";
+import { dynUndefinedExpr, own } from "./lowerer.js";
 /** Ambient array method calls. `push`/`pop`/`indexOf`/`includes`/`join`
    * lower to arrIntrinsic; the HOF family — `map`/`filter`/`forEach`/
    * `find`/`some`/`every`/`flatMap`/`reduce`/`reduceRight` — desugars to a
@@ -49,7 +49,7 @@ export function lowerArrayMethodCall(L, call, access) {
         return null;
     if (!probedUntyped && !L.isStdlibMember(access))
         return null;
-    const elem = receiverIr.elem;
+    let elem = receiverIr.elem;
     const loc = locOf(call);
     // An island handle behind an array-typed .d.ts surface
     // (`parts().join("-")` — arrays never exit eagerly, so the value
@@ -91,6 +91,19 @@ export function lowerArrayMethodCall(L, call, access) {
             }
             L.noLowering(`.${name} on an array value held in a checked-dynamic binding`, call, "assign it to an array-typed binding first (the validated extraction), then call the method");
         }
+        // An evolving-`any` array binding under --dynamic whose flow type
+        // EVOLVED past `any[]` (`const fns = []; fns.push(() => 1);
+        // fns.map(...)` — the binding lowered array<jsval> at its `any[]`
+        // declaration, while tsc's evolving-array analysis answers the
+        // pushed element type at this site): the VALUE's element type is
+        // the truth — ride the explicit-`any[]` handle-element lowering
+        // (pushes marshal in, HOF callbacks bind the handle, results exit
+        // per the checker type), never a typed intrinsic over a jsval-
+        // element array (the validator ICE).
+        if (receiver.type.kind === "array" && receiver.type.elem.kind === "jsval" && !typeEquals(receiverIr, receiver.type)) {
+            receiverIr = receiver.type;
+            elem = receiver.type.elem;
+        }
     }
     if (name === "sort")
         return lowerArraySortCall(L, call, access, elem, receiverIr);
@@ -214,6 +227,20 @@ export function lowerArrayMethodCall(L, call, access) {
                 args.push(arg);
                 continue;
             }
+            // A handle-element receiver given an argument whose CHECKER type
+            // spells evolved elements while its VALUE is a jsval-element
+            // array (`fns.concat(tail)` — both sides of the evolving-`any`
+            // adoption): the value's array-ness decides, exactly JS's
+            // IsArray — spread it. Non-array values fall through to the
+            // element push (the jsvalIn coercion).
+            if (elem.kind === "jsval") {
+                const arg = L.lowerExpr(argNode);
+                if (arg.type.kind === "array" && arg.type.elem.kind === "jsval") {
+                    shape.push("a");
+                    args.push(arg);
+                    continue;
+                }
+            }
             // An element value — union elements wrap exactly like a push.
             shape.push("e");
             args.push(L.lowerExprExpecting(argNode, elem));
@@ -324,6 +351,21 @@ function hofCallbackArg(L, argNode, lead, arrT) {
             }
         }
     }
+    // A JSVAL-element receiver behind an EVOLVED contextual type (the
+    // evolving-`any` array under --dynamic — lowerArrayMethodCall adopted
+    // the value's handle element while tsc's evolving analysis types the
+    // callback's params by the pushed elements): the lead params BIND the
+    // handles the loop passes, whatever the contextual type spelled —
+    // paramShape's island-handle early-out, the then-handler rule.
+    if (ts.isArrowFunction(argNode) || ts.isFunctionExpression(argNode)) {
+        argNode.parameters.forEach((p, i) => {
+            if (i >= lead.length || lead[i].kind !== "jsval")
+                return;
+            if (!ts.isIdentifier(p.name) || p.type || p.initializer || p.dotDotDotToken)
+                return;
+            L.jsvalParamOverrides.add(p);
+        });
+    }
     let fnArg;
     try {
         fnArg = L.lowerExpr(argNode);
@@ -4062,25 +4104,35 @@ export function lowerBytesNew(L, expr, symbol) {
             const seed = { kind: "arrayLit", elems, type: arrayOf(F64), loc };
             return { kind: "bytesNew", source: seed, type, loc };
         }
-        // The SYNTACTIC `new T(new SharedArrayBuffer(n))` form — the
-        // Atomics.wait sleep idiom's construction. The buffer never exists
-        // as a value: n must be a byte-length LITERAL divisible by the
-        // element size (tsc would admit any number; a bad one is Node's
-        // RangeError — rejected at compile time instead of half-lowering),
-        // and the whole expression is a zero-filled typed array of
-        // n/elemSize elements. Sharing is unobservable without threads
-        // (scriptc has none), so erasing the SharedArrayBuffer is exact —
-        // SEMANTICS.md documents the stance.
+        // The SYNTACTIC `new T(new ArrayBuffer(n))` and `new T(new
+        // SharedArrayBuffer(n))` forms — fresh-buffer construction (the
+        // shared spelling is the Atomics.wait sleep idiom's). The buffer
+        // never exists as a value: n must be a byte-length LITERAL divisible
+        // by the element size (tsc would admit any number; a bad one is
+        // Node's RangeError — rejected at compile time instead of
+        // half-lowering), and the whole expression is a zero-filled typed
+        // array of n/elemSize elements. Erasing the buffer is exact: nothing
+        // else can ever reference it, so neither sharing (scriptc has no
+        // threads) nor aliasing is observable — SEMANTICS.md documents the
+        // stance. The RESIZABLE form (a maxByteLength options bag) fences by
+        // name: resize needs the buffer to exist as a value, and none does.
         if (ts.isNewExpression(argNode) &&
             ts.isIdentifier(argNode.expression) &&
-            argNode.expression.text === "SharedArrayBuffer" &&
+            (argNode.expression.text === "ArrayBuffer" ||
+                argNode.expression.text === "SharedArrayBuffer") &&
             L.isStdlibSymbol(L.resolveValueSymbol(argNode.expression) ?? undefined)) {
+            const bufCtor = argNode.expression.text;
+            if ((argNode.arguments?.length ?? 0) > 1) {
+                L.noLowering(`new ${name} over a resizable ${bufCtor}`, argNode, "a maxByteLength options bag makes the buffer resizable, and resizing needs the buffer " +
+                    "to exist as a runtime value — no free-standing ArrayBuffer value exists (the buffer here " +
+                    "erases into the view): drop the options bag");
+            }
             const elemSize = elem === "u8" ? 1 : 4;
             const lenArg = argNode.arguments?.length === 1 ? argNode.arguments[0] : undefined;
             const lenT = lenArg ? L.typeOf(lenArg) : null;
             const byteLen = lenT?.isNumberLiteralType() ? lenT.value : null;
             if (byteLen === null || byteLen % elemSize !== 0 || byteLen < 0) {
-                L.noLowering(`new ${name} over this SharedArrayBuffer`, argNode, `the byte length must be a number literal divisible by ${elemSize} — new ${name}(new SharedArrayBuffer(${elemSize}))`);
+                L.noLowering(`new ${name} over this ${bufCtor}`, argNode, `the byte length must be a number literal divisible by ${elemSize} — new ${name}(new ${bufCtor}(${elemSize}))`);
             }
             const count = { kind: "numLit", value: byteLen / elemSize, type: F64, loc };
             return { kind: "bytesNew", source: count, type, loc };
@@ -4114,8 +4166,37 @@ function lowerDataViewNew(L, expr) {
     if (!bufNode || args.length > 3 || args.some(ts.isSpreadElement)) {
         L.noLowering(`new DataView with ${args.length} arguments`, expr, "supported: new DataView(x.buffer), (x.buffer, byteOffset), or (x.buffer, byteOffset, byteLength)");
     }
+    // The FRESH-BUFFER form: `new DataView(new ArrayBuffer(n), ...)` — the
+    // buffer erases into the view (nothing else can ever reference it, so
+    // the aliasing a shared buffer would exhibit is unobservable): the
+    // view's storage is a fresh zero-filled n-byte allocation. n must be a
+    // non-negative integer LITERAL (tsc admits any number; a fractional
+    // one is ToIndex truncation nothing here implements). byteOffset and
+    // byteLength keep their runtime Node-RangeError story. The RESIZABLE
+    // form (a maxByteLength options bag) fences by name.
+    if (ts.isNewExpression(bufNode) &&
+        ts.isIdentifier(bufNode.expression) &&
+        bufNode.expression.text === "ArrayBuffer" &&
+        L.isStdlibSymbol(L.resolveValueSymbol(bufNode.expression) ?? undefined)) {
+        if ((bufNode.arguments?.length ?? 0) > 1) {
+            L.noLowering("new DataView over a resizable ArrayBuffer", bufNode, "a maxByteLength options bag makes the buffer resizable, and resizing needs the buffer " +
+                "to exist as a runtime value — no free-standing ArrayBuffer value exists (the buffer here " +
+                "erases into the view): drop the options bag");
+        }
+        const lenArg = bufNode.arguments?.length === 1 ? bufNode.arguments[0] : undefined;
+        const lenT = lenArg ? L.typeOf(lenArg) : null;
+        const byteLen = lenT?.isNumberLiteralType() ? lenT.value : null;
+        if (byteLen === null || !Number.isInteger(byteLen) || byteLen < 0) {
+            L.noLowering("new DataView over this ArrayBuffer", bufNode, "the byte length must be a non-negative integer literal — new DataView(new ArrayBuffer(8))");
+        }
+        const count = { kind: "numLit", value: byteLen, type: F64, loc };
+        const receiver = { kind: "bytesNew", source: count, type: BYTES_U8, loc };
+        const idxArgs = args.slice(1).map((a) => L.lowerExprExpecting(a, F64));
+        return { kind: "bytesIntrinsic", method: "dataViewNew", receiver, args: idxArgs, type: BYTES_U8, loc };
+    }
     const hint = "views compile over a typed array's own storage — new DataView(x.buffer, byteOffset?, byteLength?) " +
-        "where x is a Uint8Array/Uint32Array/Float32Array/Buffer value; free-standing ArrayBuffers have no representation";
+        "where x is a Uint8Array/Uint32Array/Float32Array/Buffer value — or a fresh buffer erased into " +
+        "the view: new DataView(new ArrayBuffer(n), ...); free-standing ArrayBuffers have no representation";
     if (!ts.isPropertyAccessExpression(bufNode) || bufNode.name.text !== "buffer" || bufNode.questionDotToken) {
         L.noLowering("new DataView over this buffer expression", bufNode, hint);
     }
@@ -4287,6 +4368,27 @@ export function lowerBytesMethodCall(L, call, access) {
             args.push(L.lowerExprExpecting(call.arguments[1], BOOL));
         return { kind: "bytesIntrinsic", method: dvGetter.method, receiver, args, type: F64, loc };
     }
+    // DataView setters — the getters' mirror: (byteOffset, value) plus the
+    // optional littleEndian bool on the multi-byte kinds. Void results;
+    // the same constant Node RangeError on a bad offset (may-throw seeds).
+    // setBigUint64/setBigInt64 never lower (bigint ARGUMENTS have no
+    // representation and no composed form exists) — they keep the member
+    // fence, as does setFloat16.
+    const dvSetter = own(DV_SETTERS, name);
+    if (dvSetter !== undefined && receiverIr.elem === "u8") {
+        const maxArgs = dvSetter.le ? 3 : 2;
+        if (nArgs < 2 || nArgs > maxArgs) {
+            L.noLowering(`.${name} with ${nArgs} arguments`, call);
+        }
+        const receiver = L.lowerExpr(access.expression);
+        const args = [
+            L.lowerExprExpecting(call.arguments[0], F64),
+            L.lowerExprExpecting(call.arguments[1], F64),
+        ];
+        if (nArgs === 3)
+            args.push(L.lowerExprExpecting(call.arguments[2], BOOL));
+        return { kind: "bytesIntrinsic", method: dvSetter.method, receiver, args, type: VOID, loc };
+    }
     return null;
 }
 /** Node's Buffer encoding names → the runtime's canonical spelling (every
@@ -4376,20 +4478,59 @@ function lowerBufferInstanceMethod(L, call, access, name, loc) {
         }
         return v;
     };
+    // The checked-dynamic crossing for a compare/equals argument slot: dyn
+    // passes through, convertible statics (the invalid-input probes'
+    // literals) wrap in dynFrom, `undefined` literals ride the same wrap.
+    // Fences (never returns) when the value cannot cross — an island jsval.
+    const chkArg = (i) => {
+        // Object literals take the DOM literal path directly (method members
+        // box as dyn functions — the typed record fence never applies).
+        if (ts.isObjectLiteralExpression(args[i])) {
+            return lowerDynObjectLiteral(L, args[i]);
+        }
+        const v = L.lowerExpr(args[i]);
+        if (v.type.kind === "dyn")
+            return v;
+        if (v.kind === "unitLit" || L.dynConvertible(v.type)) {
+            return { kind: "dynFrom", value: v, type: DYN, loc: v.loc };
+        }
+        L.noLowering(`.${name} of '${L.fmt(v.type)}' values`, args[i], "a Buffer/Uint8Array argument is the lowered shape (narrow unions first)");
+    };
+    const argIrKind = (i) => L.mapTypeOf(L.typeOf(args[i]));
     if (name === "equals") {
         if (nArgs !== 1)
             L.noLowering(`.equals with ${nArgs} arguments`, call);
-        const other = u8Arg(0);
+        if (argIrKind(0)?.kind === "bytes") {
+            const other = u8Arg(0);
+            const receiver = L.lowerExpr(access.expression);
+            return { kind: "bytesIntrinsic", method: "equals", receiver, args: [other], type: BOOL, loc };
+        }
+        // Not statically bytes (the invalid-input probes, untyped JS
+        // helpers): Node's "otherBuffer" argument ladder runs at runtime.
         const receiver = L.lowerExpr(access.expression);
-        return { kind: "bytesIntrinsic", method: "equals", receiver, args: [other], type: BOOL, loc };
+        return { kind: "libCall", fn: "bytes.equalsChk", args: [receiver, chkArg(0)], type: BOOL, loc };
     }
     if (name === "compare") {
-        if (nArgs < 1 || nArgs > 5)
+        if (nArgs > 5)
             L.noLowering(`.compare with ${nArgs} arguments`, call);
-        const target = u8Arg(0);
-        const idx = call.arguments.slice(1).map((a) => L.lowerExprExpecting(a, F64));
+        const fast = nArgs >= 1 &&
+            argIrKind(0)?.kind === "bytes" &&
+            call.arguments.slice(1).every((a) => L.mapTypeOf(L.typeOf(a))?.kind === "f64");
+        if (fast) {
+            const target = u8Arg(0);
+            const idx = call.arguments.slice(1).map((a) => L.lowerExprExpecting(a, F64));
+            const receiver = L.lowerExpr(access.expression);
+            return { kind: "bytesIntrinsic", method: "compareBuf", receiver, args: [target, ...idx], type: F64, loc };
+        }
+        // An absent/ill-typed target or offset (`a.compare()`, string
+        // offsets, explicit undefined): Node's target/targetStart/targetEnd/
+        // sourceStart/sourceEnd ladder runs at runtime; absent slots pass
+        // the undefined dyn (Node defaults apply there).
         const receiver = L.lowerExpr(access.expression);
-        return { kind: "bytesIntrinsic", method: "compareBuf", receiver, args: [target, ...idx], type: F64, loc };
+        const slots = [];
+        for (let i = 0; i < 5; i++)
+            slots.push(i < nArgs ? chkArg(i) : dynUndefinedExpr(loc));
+        return { kind: "libCall", fn: "bytes.compareChk", args: [receiver, ...slots], type: F64, loc };
     }
     if (name === "indexOf" || name === "lastIndexOf" || name === "includes") {
         if (nArgs < 1 || nArgs > 3)
@@ -4526,6 +4667,16 @@ const DV_GETTERS = {
     getBigUint64: { method: "dvGetBigUint64Number", le: true },
     getBigInt64: { method: "dvGetBigInt64Number", le: true },
 };
+const DV_SETTERS = {
+    setUint8: { method: "dvSetUint8", le: false },
+    setInt8: { method: "dvSetInt8", le: false },
+    setUint16: { method: "dvSetUint16", le: true },
+    setInt16: { method: "dvSetInt16", le: true },
+    setUint32: { method: "dvSetUint32", le: true },
+    setInt32: { method: "dvSetInt32", le: true },
+    setFloat32: { method: "dvSetFloat32", le: true },
+    setFloat64: { method: "dvSetFloat64", le: true },
+};
 /** The Buffer statics — `Buffer.from(...)`, `Buffer.alloc(n)`,
    * `Buffer.concat(list)`, `Buffer.isBuffer(x)` — on THE stdlib Buffer
    * global (name + provenance; fallback and @types/node alike). Null when
@@ -4634,14 +4785,22 @@ export function lowerBufferStaticCall(L, call, access) {
         if (args.length !== 2 || args.some(ts.isSpreadElement)) {
             L.noLowering(`Buffer.compare with ${args.length} arguments`, call);
         }
-        const sides = args.map((a) => {
-            const v = L.lowerExpr(a);
-            if (!(v.type.kind === "bytes" && v.type.elem === "u8")) {
-                L.noLowering(`Buffer.compare of '${L.fmt(v.type)}' values`, a, "Buffer/Uint8Array values compare (narrow unions first)");
+        const sides = args.map((a) => L.lowerExpr(a));
+        if (sides.every((v) => v.type.kind === "bytes" && v.type.elem === "u8")) {
+            return { kind: "bytesIntrinsic", method: "compareBuf", receiver: sides[0], args: [sides[1]], type: F64, loc };
+        }
+        // A side that is not statically bytes (the invalid-input probes,
+        // untyped JS helpers): Node's "buf1"/"buf2" argument ladder runs
+        // at runtime — a well-typed dyn still compares.
+        const dyns = sides.map((v, i) => {
+            if (v.type.kind === "dyn")
+                return v;
+            if (v.kind === "unitLit" || L.dynConvertible(v.type)) {
+                return { kind: "dynFrom", value: v, type: DYN, loc: v.loc };
             }
-            return v;
+            L.noLowering(`Buffer.compare of '${L.fmt(v.type)}' values`, args[i], "Buffer/Uint8Array values compare (narrow unions first)");
         });
-        return { kind: "bytesIntrinsic", method: "compareBuf", receiver: sides[0], args: [sides[1]], type: F64, loc };
+        return { kind: "libCall", fn: "buffer.compareChk", args: dyns, type: F64, loc };
     }
     if (member === "isBuffer") {
         // The type-predicate narrowing test. Lowered where it DECIDES
@@ -5150,8 +5309,10 @@ function lowerFromEntriesStringRows(L, call, argNode, argIr) {
    * every source value (declared fields, and the overflow slot when the
    * source carries one) must enter the target's value slot (identity, a
    * width lift — arm wrap/re-tag/nested reshape, or JSON-safe into a dyn
-   * slot), and every target field must be optional-flavored (the fresh
-   * record's default) and writable at runtime. */
+   * slot), and every target field must either be initialized directly by
+   * a same-named source declared field (the rule that admits REQUIRED
+   * declared members) or be optional-flavored (the fresh record's
+   * default) and writable at runtime. */
 export function lowerRecordOvfCaptureHelper(L, fromId, toId, loc) {
     const from = L.shapes.get(fromId);
     const to = L.shapes.get(toId);
@@ -5172,11 +5333,16 @@ export function lowerRecordOvfCaptureHelper(L, fromId, toId, loc) {
     // signature have no overflow to carry over).
     if (fIv && slotLift(fIv) === null)
         return null;
-    // Every target field defaults to its undefined arm (fresh record) and
-    // must accept a runtime collision (dyn slots validate via dynCheck —
-    // fields must be DOM-convertible; typed slots write through directly).
-    const defaults = [];
+    const inits = [];
+    const consumed = new Set();
     for (const tf of to.fields) {
+        const sf = from.fields.find((f) => f.name === tf.name);
+        const directLift = sf ? L.widthLiftPlan(sf.type, tf.type) : null;
+        if (sf && directLift) {
+            inits.push({ name: tf.name, kind: "direct", src: sf.type, lift: directLift });
+            consumed.add(tf.name);
+            continue;
+        }
         if (tf.type.kind !== "union")
             return null;
         const utag = L.armTag(tf.type.unionId, UNDEFINED_T);
@@ -5184,7 +5350,7 @@ export function lowerRecordOvfCaptureHelper(L, fromId, toId, loc) {
             return null;
         if (tIv.kind === "dyn" ? !L.dynConvertible(tf.type) : !typeEquals(tf.type, tIv))
             return null;
-        defaults.push({ name: tf.name, unionId: tf.type.unionId, utag });
+        inits.push({ name: tf.name, kind: "undef", unionId: tf.type.unionId, utag });
     }
     // Every source declared field must flow into the keyed-write slot —
     // in DECLARATION order (insertion order below; declaredOrder omits
@@ -5197,11 +5363,30 @@ export function lowerRecordOvfCaptureHelper(L, fromId, toId, loc) {
         : from.fields;
     const fieldLifts = new Map();
     for (const ff of orderedFields) {
+        if (consumed.has(ff.name))
+            continue; // direct-initialized above
         const lift = slotLift(ff.type);
         if (lift === null)
             return null;
         fieldLifts.set(ff.name, lift);
     }
+    // DISPATCH writes — keys that can hit a declared target slot: the
+    // overflow loop's runtime keys, and a literal source-field name the
+    // target also declares. Non-dyn slots store THROUGH on a collision, so
+    // such writes need every declared field to BE the slot type (the
+    // validator's recordKeySet rule); dyn slots validate per field
+    // (dynCheck), so each field must be DOM-convertible. Writes to
+    // literal names the target does NOT declare are overflowOnly and
+    // exempt — which is what lets a direct-initialized required field
+    // (`id: number` beside a `number | undefined` slot) coexist with a
+    // declared-only source, while an index-signature source declines.
+    const dispatchWrites = fIv !== undefined ||
+        orderedFields.some((ff) => !consumed.has(ff.name) && to.fields.some((f) => f.name === ff.name));
+    if (dispatchWrites) {
+        if (tIv.kind === "dyn" ? !to.fields.every((f) => L.dynConvertible(f.type)) : !to.fields.every((f) => typeEquals(f.type, tIv))) {
+            return null;
+        }
+    }
     const key = `ovf:${fromId}:${toId}`;
     const existing = L.widthHelpers.get(key);
     if (existing)
@@ -5223,16 +5408,18 @@ export function lowerRecordOvfCaptureHelper(L, fromId, toId, loc) {
             localId: "out.0",
             init: {
                 kind: "recordLit",
-                fields: defaults.map((d) => ({
+                fields: inits.map((d) => ({
                     name: d.name,
-                    value: {
-                        kind: "unionWrap",
-                        unionId: d.unionId,
-                        tag: d.utag,
-                        value: { kind: "unitLit", unit: "undefined", type: UNDEFINED_T, loc },
-                        type: to.fields.find((f) => f.name === d.name).type,
-                        loc,
-                    },
+                    value: d.kind === "direct"
+                        ? L.applyWidthLift(d.lift, { kind: "recordGet", obj: sRef, shapeId: fromId, field: d.name, type: d.src, loc }, to.fields.find((f) => f.name === d.name).type, loc)
+                        : {
+                            kind: "unionWrap",
+                            unionId: d.unionId,
+                            tag: d.utag,
+                            value: { kind: "unitLit", unit: "undefined", type: UNDEFINED_T, loc },
+                            type: to.fields.find((f) => f.name === d.name).type,
+                            loc,
+                        },
                 })),
                 type: toT,
                 loc,
@@ -5241,8 +5428,10 @@ export function lowerRecordOvfCaptureHelper(L, fromId, toId, loc) {
         },
     ];
     // Source declared fields in declaration order, skipping unset
-    // optionals (stance 37).
+    // optionals (stance 37) and the direct-initialized (consumed) names.
     for (const ff of orderedFields) {
+        if (consumed.has(ff.name))
+            continue;
         const raw = { kind: "recordGet", obj: sRef, shapeId: fromId, field: ff.name, type: ff.type, loc };
         const utag = ff.type.kind === "union" ? L.armTag(ff.type.unionId, UNDEFINED_T) : -1;
         const write = {
@@ -5251,6 +5440,9 @@ export function lowerRecordOvfCaptureHelper(L, fromId, toId, loc) {
             shapeId: toId,
             key: { kind: "strLit", value: ff.name, type: STRING, loc },
             value: intoSlot(raw, fieldLifts.get(ff.name)),
+            // A literal name the target does not declare can only land in the
+            // overflow — skip the declared dispatch (and its validator gate).
+            ...(to.fields.some((f) => f.name === ff.name) ? {} : { overflowOnly: true }),
             loc,
         };
         body.push(utag >= 0 && ff.type.kind === "union"