@scriptc/compiler 0.0.8 → 0.0.10

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
@@ -2649,23 +2649,27 @@ export function lowerIteratorHelperCall(L, call, access) {
     const terminal = access.name.text;
     if (!ITER_TERMINALS.has(terminal))
         return null;
-    // Walk receiver: stage* ← values() ← array-typed source.
+    // Walk receiver: stage* ← values()/entries() ← array-typed source
+    // (entries seeds the chain with [index, element] pairs — the
+    // checker's own tuple type).
     const stages = [];
     let cur = access.expression;
     let source = null;
+    let srcProj = "values";
     for (;;) {
         if (!ts.isCallExpression(cur) || !ts.isPropertyAccessExpression(cur.expression))
             return null;
         if (cur.questionDotToken || cur.expression.questionDotToken)
             return null;
         const name = cur.expression.name.text;
-        if (name === "values" && cur.arguments.length === 0) {
+        if ((name === "values" || name === "entries") && cur.arguments.length === 0) {
             const recvIr = L.mapTypeOf(L.typeOf(cur.expression.expression));
             if (recvIr?.kind !== "array")
                 return null;
             if (!L.isStdlibMember(cur.expression))
                 return null;
             source = cur.expression.expression;
+            srcProj = name;
             break;
         }
         if (!ITER_STAGES.has(name) || cur.arguments.length !== 1 || ts.isSpreadElement(cur.arguments[0]))
@@ -2687,7 +2691,12 @@ export function lowerIteratorHelperCall(L, call, access) {
     const items = L.lowerExpr(source);
     if (items.type.kind !== "array")
         return null;
-    let elem = items.type.elem;
+    // The entries() seed: the interned [number, T] tuple — the same shape
+    // the checker's own [number, T] maps to, so stage callbacks typed
+    // against the lib's pairs intern equal.
+    let elem = srcProj === "entries"
+        ? { kind: "record", shapeId: L.shapes.intern([{ name: "0", type: F64 }, { name: "1", type: items.type.elem }], true) }
+        : items.type.elem;
     const stageIrs = [];
     for (const s of stages) {
         if (s.name === "take" || s.name === "drop") {
@@ -2774,12 +2783,12 @@ export function lowerIteratorHelperCall(L, call, access) {
         L.noLowering(`.${terminal} at this result type`, call, "the chain's element and result types must be representable — annotate the callbacks' types");
     }
     const stageKeys = stageIrs.map((s) => (s.kind === "take" || s.kind === "drop" ? s.kind : `${s.kind}:${typeKey(s.fn.type)}`));
-    const key = `iter:${typeKey(items.type)}:${stageKeys.join(",")}:${terminal}:${termArgs.map((a) => typeKey(a.type)).join(",")}`;
+    const key = `iter:${srcProj}:${typeKey(items.type)}:${stageKeys.join(",")}:${terminal}:${termArgs.map((a) => typeKey(a.type)).join(",")}`;
     let helper = L.arrHofHelpers.get(key);
     if (!helper) {
         helper = `%iter.${terminal}.${L.arrHofHelpers.size}`;
         L.arrHofHelpers.set(key, helper);
-        L.liftedFns.push(buildIterChainFn(L, helper, items.type, stageIrs, terminal, termArgs.map((a) => a.type), resultT, loc));
+        L.liftedFns.push(buildIterChainFn(L, helper, items.type, srcProj, stageIrs, terminal, termArgs.map((a) => a.type), resultT, loc));
     }
     const budgetOrFn = stageIrs.map((s) => (s.kind === "take" || s.kind === "drop" ? s.budget : s.fn));
     return { kind: "call", callee: helper, args: [items, ...budgetOrFn, ...termArgs], type: resultT, loc };
@@ -2862,7 +2871,7 @@ function internBudgetChecker(L, loc) {
    * source order, flatMap as an inner loop over its returned array.
    * Pre-loop, a zero take budget marks done immediately — Node pulls
    * nothing at all through a take(0). */
-function buildIterChainFn(L, name, itemsT, stages, terminal, termArgTs, resultT, loc) {
+function buildIterChainFn(L, name, itemsT, srcProj, stages, terminal, termArgTs, resultT, loc) {
     const ref = (localId, type) => ({ kind: "varRef", localId, type, loc });
     const num = (value) => ({ kind: "numLit", value, type: F64, loc });
     const boolLit = (value) => ({ kind: "boolLit", value, type: BOOL, loc });
@@ -2883,7 +2892,12 @@ function buildIterChainFn(L, name, itemsT, stages, terminal, termArgTs, resultT,
     const doneId = addLocal("done", BOOL, true);
     const done = () => ref(doneId, BOOL);
     const setDone = { kind: "assign", localId: doneId, value: boolLit(true), loc };
-    let elem = itemsT.elem;
+    // The entries() seed builds each pass's [index, element] pair — the
+    // same interned tuple the caller computed its stage types against.
+    const seedT = srcProj === "entries"
+        ? { kind: "record", shapeId: L.shapes.intern([{ name: "0", type: F64 }, { name: "1", type: itemsT.elem }], true) }
+        : itemsT.elem;
+    let elem = seedT;
     const slots = [];
     for (const s of stages) {
         if (s.kind === "take" || s.kind === "drop") {
@@ -3128,7 +3142,19 @@ function buildIterChainFn(L, name, itemsT, stages, terminal, termArgTs, resultT,
         }
     }
     const iId = addLocal("i", F64, true);
-    const vId = addLocal("v", itemsT.elem, false);
+    const vId = addLocal("v", seedT, false);
+    const elemRead = () => ({ kind: "arrayGet", arr: ref("items.0", itemsT), index: ref(iId, F64), type: itemsT.elem, loc });
+    const seedInit = srcProj === "entries"
+        ? {
+            kind: "recordLit",
+            fields: [
+                { name: "0", value: ref(iId, F64) },
+                { name: "1", value: elemRead() },
+            ],
+            type: seedT,
+            loc,
+        }
+        : elemRead();
     const loop = {
         kind: "for",
         init: { kind: "varDecl", localId: iId, init: num(0), loc },
@@ -3142,8 +3168,8 @@ function buildIterChainFn(L, name, itemsT, stages, terminal, termArgTs, resultT,
         },
         update: { kind: "assign", localId: iId, value: { kind: "bin", op: "+", left: ref(iId, F64), right: num(1), type: F64, loc }, loc },
         body: [
-            { kind: "varDecl", localId: vId, init: { kind: "arrayGet", arr: ref("items.0", itemsT), index: ref(iId, F64), type: itemsT.elem, loc }, loc },
-            ...emit(ref(vId, itemsT.elem)),
+            { kind: "varDecl", localId: vId, init: seedInit, loc },
+            ...emit(ref(vId, seedT)),
         ],
         loc,
     };
@@ -3436,6 +3462,143 @@ export function lowerForOfSearchParams(L, stmt, iterable, proj) {
         L.scopes.pop();
     }
 }
+/** for-of over an ARRAY's keys()/entries() projections consumed directly
+   * by the head (`for (const [index, line] of lines.entries())` — the
+   * dominant formatter idiom): the LIVE index walk — the length re-reads
+   * every pass, exactly the array iterator's contract (elements appended
+   * mid-walk are visited; a shrink ends the loop early) — yielding the
+   * index (`keys`, a number) or the [index, element] pair (`entries`).
+   * `values` never lands here: lowerForOf's receiver unwrap owns it. A
+   * `[i, v]` head of plain identifiers binds straight from the reads (the
+   * tuple never materializes); identifier heads and the remaining
+   * patterns bind through the checker's own element type — the interned
+   * [number, T] tuple record. Stored iterator OBJECTS keep their fence
+   * (only the direct for-of position unwraps). */
+export function lowerForOfArrayIter(L, stmt, iterable, proj) {
+    const loc = locOf(stmt);
+    const arrT = iterable.type;
+    const elemT = arrT.elem;
+    const yieldsPair = proj === "entries";
+    if (!ts.isVariableDeclarationList(stmt.initializer)) {
+        L.unsupported("SC1090", stmt.initializer, "for-of over a pre-declared variable (declare the loop variable in the loop: for (const x of ...))");
+    }
+    const list = stmt.initializer;
+    if ((list.flags & ts.NodeFlags.Using) !== 0) {
+        L.unsupported("SC1090", list, "'using' declarations (dispose-at-scope-exit semantics)");
+    }
+    const isVar = (list.flags & ts.NodeFlags.BlockScoped) === 0;
+    const isLet = (list.flags & ts.NodeFlags.Let) !== 0 || isVar;
+    const decl = list.declarations[0]; // the grammar allows exactly one
+    L.scopes.push(new Map());
+    try {
+        const arr = L.declareHiddenLocal("%arof", arrT);
+        const i = L.declareHiddenLocal("%iterof", F64);
+        i.mutable = true;
+        const ref = (localId, type) => ({ kind: "varRef", localId, type, loc });
+        const num = (value) => ({ kind: "numLit", value, type: F64, loc });
+        const keyRead = () => ref(i.id, F64);
+        const valRead = () => ({ kind: "arrayGet", arr: ref(arr.id, arrT), index: ref(i.id, F64), type: elemT, loc });
+        const binds = [];
+        const isPlainIdent = (el) => ts.isBindingElement(el) && el.name !== undefined && ts.isIdentifier(el.name) && !el.initializer && !el.dotDotDotToken;
+        if (yieldsPair &&
+            !isVar && // var pattern names assign hoisted slots — the generic desugar below owns them
+            ts.isArrayBindingPattern(decl.name) &&
+            decl.name.elements.length >= 1 && decl.name.elements.length <= 2 &&
+            decl.name.elements.every(isPlainIdent)) {
+            // `for (const [i, v] of xs.entries())` — bind straight from the
+            // reads; the tuple never exists. `[i]` alone reads only the index.
+            const els = decl.name.elements;
+            const kLocal = L.declareLocal(els[0].name, els[0].name.text, F64, isLet);
+            binds.push({ kind: "varDecl", localId: kLocal.id, init: keyRead(), loc });
+            if (els[1]) {
+                const vLocal = L.declareLocal(els[1].name, els[1].name.text, elemT, isLet);
+                binds.push({ kind: "varDecl", localId: vLocal.id, init: valRead(), loc });
+            }
+        }
+        else {
+            // Identifier heads and the remaining patterns bind through the
+            // checker's own element type — [number, T] for pair yields,
+            // number otherwise — the Map desugar's exact shape.
+            const declT = L.mapTypeOf(L.checker.getTypeAtLocation(decl.name));
+            if (yieldsPair) {
+                const shape = declT?.kind === "record" ? L.shapes.get(declT.shapeId) : null;
+                if (declT?.kind !== "record" || !shape?.tuple || shape.fields.length !== 2 ||
+                    shape.fields.find((f) => f.name === "0")?.type.kind !== "f64" ||
+                    !typeEquals(shape.fields.find((f) => f.name === "1")?.type ?? F64, elemT)) {
+                    L.badType(decl.name, L.checker.getTypeAtLocation(decl.name)); // defensive: the lib declares [number, T]
+                }
+            }
+            else if (declT?.kind !== "f64") {
+                L.badType(decl.name, L.checker.getTypeAtLocation(decl.name)); // defensive: the lib declares number
+            }
+            const elemInit = yieldsPair
+                ? {
+                    kind: "recordLit",
+                    fields: [
+                        { name: "0", value: keyRead() },
+                        { name: "1", value: valRead() },
+                    ],
+                    type: declT,
+                    loc,
+                }
+                : keyRead();
+            if (ts.isIdentifier(decl.name)) {
+                const varTarget = forOfVarTarget(L, decl);
+                if (varTarget) {
+                    // `for (var x of ...)`: one function-scoped binding, assigned
+                    // per pass — closures made in the loop share it, and the value
+                    // persists after the loop (both Node-exact for var).
+                    const tmp = L.declareHiddenLocal("%vof", declT);
+                    binds.push({ kind: "varDecl", localId: tmp.id, init: elemInit, loc });
+                    binds.push({
+                        kind: "assign",
+                        localId: varTarget.id,
+                        value: L.coerceInto(decl.name, { kind: "varRef", localId: tmp.id, type: declT, loc }, varTarget.type),
+                        loc,
+                    });
+                }
+                else {
+                    const local = L.declareLocal(decl.name, decl.name.text, declT, isLet);
+                    binds.push({ kind: "varDecl", localId: local.id, init: elemInit, loc });
+                }
+            }
+            else {
+                const tmp = L.declareHiddenLocal("%destr", declT);
+                binds.push({ kind: "varDecl", localId: tmp.id, init: elemInit, loc });
+                L.lowerBindingPattern(decl.name, () => ({ kind: "varRef", localId: tmp.id, type: declT, loc }), declT, isLet, binds);
+            }
+        }
+        const body = L.inCtl("loop", () => L.lowerScopedBlock(stmt.statement));
+        const loop = {
+            kind: "for",
+            init: { kind: "varDecl", localId: i.id, init: num(0), loc },
+            cond: {
+                kind: "bin",
+                op: "<",
+                left: ref(i.id, F64),
+                right: { kind: "arrIntrinsic", method: "length", receiver: ref(arr.id, arrT), args: [], type: F64, loc },
+                type: BOOL,
+                loc,
+            },
+            update: {
+                kind: "assign",
+                localId: i.id,
+                value: { kind: "bin", op: "+", left: ref(i.id, F64), right: num(1), type: F64, loc },
+                loc,
+            },
+            body: [...binds, ...body],
+            loc,
+        };
+        return {
+            kind: "block",
+            body: [{ kind: "varDecl", localId: arr.id, init: iterable, loc }, loop],
+            loc,
+        };
+    }
+    finally {
+        L.scopes.pop();
+    }
+}
 export function lowerForOfMap(L, stmt, iterable, mapT, proj) {
     return lowerForOfMapOrSet(L, stmt, iterable, mapT, proj);
 }
@@ -4104,25 +4267,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 };
@@ -4156,8 +4329,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);
     }
@@ -4329,6 +4531,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
@@ -4418,20 +4641,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)
@@ -4568,6 +4830,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
@@ -4676,14 +4948,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
@@ -5192,8 +5472,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);
@@ -5214,11 +5496,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);
@@ -5226,7 +5513,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
@@ -5239,11 +5526,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)
@@ -5265,16 +5571,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,
@@ -5283,8 +5591,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 = {
@@ -5293,6 +5603,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"
@@ -6155,6 +6468,26 @@ export function lowerDynArrayFlatMapCall(L, call, access, recv) {
     const { fnArg, arity } = hofCallbackArg(L, argNode, [DYN], DYN);
     const ret = fnArg.type.ret;
     if (ret.kind !== "array") {
+        // A DYNAMIC-returning callback (`plugins.flatMap((plugin) =>
+        // plugin.languages ?? [])` — the getSupportInfo shape, where the
+        // callback's members ride the DOM): the call dispatches on the
+        // RECEIVER's runtime kind (dynInvoke) with the callback boxed —
+        // a wrapped ISLAND receiver runs the ENGINE's own JS-exact
+        // Array.prototype.flatMap (the routed-ops lane), a native DOM
+        // array runs the runtime's flatMap, and non-arrays throw Node's
+        // TypeError. The result stays dyn, checked per use.
+        if (ret.kind === "dyn" || ret.kind === "jsval") {
+            const boxed = { kind: "dynFrom", value: fnArg, type: DYN, loc };
+            return {
+                kind: "dynInvoke",
+                recv,
+                method: "flatMap",
+                calleeName: access.getText(),
+                args: [boxed],
+                type: DYN,
+                loc,
+            };
+        }
         L.unsupported("SC1090", call, `'.flatMap' on 'unknown' receivers whose callback returns '${L.fmt(ret)}' ` +
             `(only callbacks returning a typed ARRAY compile — the results concatenate ` +
             `without validation; return one-element/empty arrays instead of bare values)`);