@scriptc/compiler 0.1.7 → 0.2.1

package/dist/frontend/lowering/containers/bytes.js

@@ -1,11 +1,14 @@
+import { BUF_NUM_METHODS } from "./buffer-numeric-methods.js";
 import * as ts from "../../ts7/adapter.js";
-import { BIGINT_T, BOOL, BYTES_U8, DYN, F64, STRING, UNDEFINED_T, VOID, arrayOf, bytesOf, typeEquals } from "../../../ir/ir.js";
+import { BYTES_ELEMENT_SIZE, BIGINT_T, BOOL, BYTES_U8, DYN, F64, STRING, UNDEFINED_T, VOID, arrayOf, bytesOf, typeEquals } from "../../../ir/ir.js";
 import { locOf } from "../../program.js";
-import { dynUndefinedExpr, own } from "../lowerer.js";
+import { dynUndefinedExpr, newFnCtx, own } from "../lowerer.js";
 import { buildBytesSortFn } from "../lower-array-sort.js";
 import { isSafeToDiscard } from "../expressions/evaluation-safety.js";
 import { lowerDynObjectLiteral } from "../expressions/object-literals.js";
 import { defaultAfterUndefined, lowerOptionalArgument, lowerStaticallyUndefinedArgument } from "../optional-arguments.js";
+import { lowerCheckedArrayFrom } from "../lower-containers.js";
+import { varRef } from "../../../ir/build.js";
 /** Uint8Array.prototype.toSorted. The receiver/comparator expressions are
  * evaluated before entering the helper; the helper snapshots with
  * TypedArray.prototype.slice before its first comparison, then performs
@@ -17,7 +20,7 @@ function lowerBytesToSortedCall(lowerer, call, access, bytesT) {
     if (call.arguments.length > 1 || call.arguments.some(ts.isSpreadElement)) {
         lowerer.noLowering(`.toSorted with ${call.arguments.length} arguments on Uint8Array`, call);
     }
-    const receiver = lowerer.lowerExpr(access.expression);
+    const receiver = lowerer.lowerExprExpecting(access.expression, bytesT);
     const undefinedArg = call.arguments[0]
         ? lowerStaticallyUndefinedArgument(lowerer, call.arguments[0])
         : null;
@@ -85,27 +88,40 @@ function lowerBytesToSortedCall(lowerer, call, access, bytesT) {
 }
 /* ── typed arrays / Buffer ─────────────────────────────────────────────── */
 /** The typed-array constructors with a runtime representation, by lib
- * interface name. Other flavors (Int8Array, Float16Array, ...) fall through
+ * interface name. Other flavors (Float16Array, BigInt64Array, ...) fall through
  * to the generic stdlib-constructor fence. DataView is handled separately. */
 const BYTES_CTORS = {
     Uint8Array: "u8",
+    Uint8ClampedArray: "u8c",
+    Int8Array: "i8",
+    Uint16Array: "u16",
+    Int16Array: "i16",
     Uint32Array: "u32",
     Int32Array: "i32",
     Float32Array: "f32",
     Float64Array: "f64",
 };
-/** `new Uint8Array(...)` / `new Uint32Array(...)` / `new Float32Array(...)` / `new Float64Array(...)`
+/** Numeric typed-array constructors
    * (stdlib provenance — a user's own class with the name resolves through
    * classBySymbol). Lowered argument shapes: none (empty), a length
    * (zero-filled; ToIndex at runtime — invalid lengths throw Node's
-   * RangeError), a same-kind typed array or Buffer (an independent COPY —
+   * RangeError), a numeric typed array or Buffer (an independent COPY —
    * the readFile chain's `new Uint8Array(await readFile(p))`), a number[]
    * literal (element-coerced; its contextual type is the lib's
    * ArrayLike/Iterable union, which cannot map — the Set-seed pattern), or
-   * a number[]-typed value. ArrayBuffer/view forms are fenced: scriptc
-   * typed arrays own their storage. Null when this isn't a stdlib
+   * a number[]-typed value, or checked native input with runtime length /
+   * array-like dispatch. ArrayBuffer inputs create shared views.
+   * Null when this isn't a stdlib
    * typed-array construction. */
 export function lowerBytesNew(lowerer, expr, symbol) {
+    if (symbol != null && symbol.name === "ArrayBuffer" && lowerer.isStdlibSymbol(symbol)) {
+        const args = expr.arguments ?? [];
+        if (args.length > 1 || args.some(ts.isSpreadElement)) {
+            lowerer.noLowering("resizable ArrayBuffer construction", expr, "fixed-length ArrayBuffers accept a byte length; resizable storage is not supported yet");
+        }
+        const length = args[0] ? lowerer.coerceInto(args[0], lowerer.lowerExpr(args[0]), DYN) : dynUndefinedExpr(locOf(expr));
+        return { kind: "libCall", fn: "arrayBuffer.new", args: [length], type: DYN, loc: locOf(expr) };
+    }
     if (symbol && symbol.name === "DataView" && lowerer.isStdlibSymbol(symbol)) {
         return lowerDataViewNew(lowerer, expr);
     }
@@ -118,6 +134,9 @@ export function lowerBytesNew(lowerer, expr, symbol) {
     const args = expr.arguments ?? [];
     if (args.length === 0)
         return { kind: "bytesNew", source: null, type, loc };
+    if (args.length >= 2 && args.length <= 3 && !args.some(ts.isSpreadElement)) {
+        return lowerArrayBufferView(lowerer, args, elem, loc);
+    }
     if (args.length === 1 && !ts.isSpreadElement(args[0])) {
         const argNode = args[0];
         if (ts.isArrayLiteralExpression(argNode) && !argNode.elements.some(ts.isSpreadElement)) {
@@ -125,8 +144,7 @@ export function lowerBytesNew(lowerer, expr, symbol) {
             const seed = { kind: "arrayLit", elems, type: arrayOf(F64), loc };
             return { kind: "bytesNew", source: seed, type, loc };
         }
-        // The SYNTACTIC `new T(new ArrayBuffer(n))` and `new T(new
-        // SharedArrayBuffer(n))` forms — fresh-buffer construction (the
+        // The SYNTACTIC `new T(new SharedArrayBuffer(n))` form — 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
@@ -136,19 +154,17 @@ export function lowerBytesNew(lowerer, expr, symbol) {
         // 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.
+        // name: this erasure has no shared or growable buffer representation.
         if (ts.isNewExpression(argNode) &&
             ts.isIdentifier(argNode.expression) &&
-            (argNode.expression.text === "ArrayBuffer" ||
-                argNode.expression.text === "SharedArrayBuffer") &&
+            argNode.expression.text === "SharedArrayBuffer" &&
             lowerer.isStdlibSymbol(lowerer.resolveValueSymbol(argNode.expression) ?? undefined)) {
             const bufCtor = argNode.expression.text;
             if ((argNode.arguments?.length ?? 0) > 1) {
-                lowerer.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");
+                lowerer.noLowering(`new ${name} over a resizable ${bufCtor}`, argNode, "a maxByteLength options bag needs growable shared storage; the fixed-length " +
+                    "SharedArrayBuffer here erases into the view: drop the options bag");
             }
-            const elemSize = elem === "u8" ? 1 : elem === "f64" ? 8 : 4;
+            const elemSize = BYTES_ELEMENT_SIZE[elem];
             const lenArg = argNode.arguments?.length === 1 ? argNode.arguments[0] : undefined;
             const lenT = lenArg ? lowerer.typeOf(lenArg) : null;
             const byteLen = lenT?.isNumberLiteralType() ? lenT.value : null;
@@ -159,97 +175,98 @@ export function lowerBytesNew(lowerer, expr, symbol) {
             return { kind: "bytesNew", source: count, type, loc };
         }
         const src = lowerer.lowerExpr(argNode);
-        if (src.type.kind === "union" && lowerer.armTag(src.type.unionId, UNDEFINED_T) >= 0) {
-            const present = lowerer.stripUndefinedArm(src.type);
-            if (present.kind === "array" && present.elem.kind === "f64") {
-                const undefTag = lowerer.armTag(src.type.unionId, UNDEFINED_T);
-                const presentTag = lowerer.armTag(src.type.unionId, present);
-                if (undefTag >= 0 && presentTag >= 0) {
-                    const empty = { kind: "arrayLit", elems: [], type: present, loc };
-                    const source = {
-                        kind: "ternary",
-                        cond: { kind: "unionIsTag", unionId: src.type.unionId, tag: undefTag, negated: false, value: src, type: BOOL, loc },
-                        then: empty,
-                        else_: { kind: "unionNarrow", unionId: src.type.unionId, tag: presentTag, value: src, type: present, loc },
-                        type: present,
-                        loc,
-                    };
-                    return { kind: "bytesNew", source, type, loc };
-                }
+        if (src.type.kind === "union") {
+            const arms = lowerer.unions.get(src.type.unionId)?.arms;
+            if (arms?.every((arm) => arm.kind === "f64" || arm.kind === "bytes" ||
+                typeEquals(arm, UNDEFINED_T) || (arm.kind === "array" && arm.elem.kind === "f64"))) {
+                // The checked constructor dispatch preserves each arm's copy or
+                // length semantics, including undefined -> empty, and evaluates
+                // an effectful source expression exactly once.
+                return { kind: "bytesNew", source: lowerer.coerceInto(argNode, src, DYN), type, loc };
             }
         }
         if (src.type.kind === "f64" ||
-            typeEquals(src.type, type) ||
+            src.type.kind === "bytes" || src.type.kind === "dyn" ||
             (src.type.kind === "array" && src.type.elem.kind === "f64")) {
             return { kind: "bytesNew", source: src, type, loc };
         }
-        if (src.type.kind === "bytes") {
-            lowerer.noLowering(`new ${name} over a '${lowerer.fmt(src.type)}'`, argNode, "cross-kind typed-array conversion has no lowering — copy element by element");
-        }
         lowerer.noLowering(`new ${name} over '${lowerer.fmt(src.type)}' values`, argNode, `supported: new ${name}(), (length), (typedArray) — always a copy — or (number[]); ` +
-            "ArrayBuffers and views do not exist here (narrow unions first)");
+            "or (ArrayBuffer, byteOffset?, length?) for shared storage (narrow unions first)");
     }
     lowerer.noLowering(`new ${name} with ${args.length} arguments`, expr, `supported: new ${name}(), (length), (typedArray), or (number[])`);
 }
-/** `new DataView(x.buffer, byteOffset?, byteLength?)` (stdlib provenance).
-   * The first argument must be the SYNTACTIC `.buffer` of a typed-array/
-   * Buffer value — `x.buffer` names x's own storage (scriptc typed arrays
-   * always own it whole, byteOffset 0), so the view construction takes x
-   * itself as the receiver and no ArrayBuffer value ever exists.
-   * byteOffset/byteLength are optional f64s (omitted args OMITTED, like
-   * slice); bad indices THROW Node's RangeErrors catchably. The result is
-   * a true borrowed view: reads and writes through it alias x. */
-function lowerDataViewNew(lowerer, expr) {
-    const loc = locOf(expr);
-    const args = expr.arguments ?? [];
-    const bufNode = args[0];
-    if (!bufNode || args.length > 3 || args.some(ts.isSpreadElement)) {
-        lowerer.noLowering(`new DataView with ${args.length} arguments`, expr, "supported: new DataView(x.buffer), (x.buffer, byteOffset), or (x.buffer, byteOffset, byteLength)");
+/** TypedArray.from without a mapping callback. Preserve its iterable /
+ * array-like semantics separately from constructor length coercion. */
+export function lowerBytesStaticCall(lowerer, call, access) {
+    if (lowerer.chainBlocked(call, access))
+        return null;
+    if (lowerer.isStdlibGlobal(access.expression, "ArrayBuffer") && access.name.text === "isView") {
+        if (call.arguments.length !== 1 || call.arguments.some(ts.isSpreadElement))
+            lowerer.noLowering("ArrayBuffer.isView argument count", call);
+        const arg = call.arguments[0];
+        return { kind: "libCall", fn: "arrayBuffer.isView", args: [lowerer.coerceInto(arg, lowerer.lowerExpr(arg), DYN)], type: BOOL, loc: locOf(call) };
     }
-    // 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" &&
-        lowerer.isStdlibSymbol(lowerer.resolveValueSymbol(bufNode.expression) ?? undefined)) {
-        if ((bufNode.arguments?.length ?? 0) > 1) {
-            lowerer.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 ? lowerer.typeOf(lenArg) : null;
-        const byteLen = lenT?.isNumberLiteralType() ? lenT.value : null;
-        if (byteLen === null || !Number.isInteger(byteLen) || byteLen < 0) {
-            lowerer.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) => lowerer.lowerExprExpecting(a, F64));
-        return { kind: "bytesIntrinsic", method: "dataViewNew", receiver, args: idxArgs, type: BYTES_U8, loc };
+    if (access.name.text !== "from" || !ts.isIdentifier(access.expression))
+        return null;
+    const symbol = lowerer.resolveValueSymbol(access.expression);
+    const elem = symbol ? own(BYTES_CTORS, symbol.name) : undefined;
+    if (!elem || !lowerer.isStdlibSymbol(symbol ?? undefined))
+        return null;
+    if (call.arguments.length < 1 || call.arguments.length > 3 || call.arguments.some(ts.isSpreadElement)) {
+        lowerer.noLowering("TypedArray.from with this argument count", call);
     }
-    const hint = "views compile over a typed array's own storage — new DataView(x.buffer, byteOffset?, byteLength?) " +
-        "where x is a Uint8Array/Uint32Array/Float32Array/Float64Array/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) {
-        lowerer.noLowering("new DataView over this buffer expression", bufNode, hint);
+    const node = call.arguments[0];
+    const source = lowerer.lowerExpr(node);
+    if (call.arguments.length > 1) {
+        if (!["string", "array", "bytes"].includes(source.type.kind))
+            lowerer.noLowering("TypedArray.from mapper over this source representation", call);
+        const loc = locOf(call);
+        const key = `%builtin.${elem}.fromMapped`;
+        if (!lowerer.liftedFns.some((fn) => fn.name === key)) {
+            const context = newFnCtx(false, null, null, bytesOf(elem));
+            lowerer.fnStack.push(context);
+            try {
+                const locals = ["source", "mapper", "receiver"].map((name) => lowerer.declareHiddenLocal(name, DYN));
+                const [input, mapper, receiver] = locals.map((local) => varRef(local.id, DYN, loc));
+                const collected = lowerCheckedArrayFrom(lowerer, input, loc);
+                const mapped = lowerCheckedArrayFrom(lowerer, collected.result, loc, mapper, receiver, true);
+                // Consume the iterable before mapping, but validate the mapper first.
+                lowerer.liftedFns.push({ name: key, params: locals.map((local) => ({ localId: local.id, name: local.name, type: DYN })),
+                    returnType: bytesOf(elem), locals: context.locals, loc, body: [
+                        mapped.stmts[0], ...collected.stmts, ...mapped.stmts.slice(1),
+                        { kind: "return", value: { kind: "bytesNew", source: mapped.result, from: true, type: bytesOf(elem), loc }, loc },
+                    ] });
+            }
+            finally {
+                lowerer.fnStack.pop();
+            }
+        }
+        return { kind: "call", callee: key, args: [lowerer.coerceInto(node, source, DYN),
+                lowerer.lowerExprExpecting(call.arguments[1], DYN),
+                call.arguments[2] ? lowerer.lowerExprExpecting(call.arguments[2], DYN) : dynUndefinedExpr(loc)], type: bytesOf(elem), loc };
     }
-    const srcIr = lowerer.mapTypeOf(lowerer.typeOf(bufNode.expression));
-    if (srcIr?.kind !== "bytes" || !lowerer.isStdlibMember(bufNode)) {
-        lowerer.noLowering(`new DataView over '.buffer' of a '${lowerer.checker.typeToString(lowerer.typeOf(bufNode.expression))}'`, bufNode, hint);
+    if (source.type.kind === "bytes" || (source.type.kind === "array" && source.type.elem.kind === "f64")) {
+        return { kind: "bytesNew", source, type: bytesOf(elem), loc: locOf(call) };
     }
-    const receiver = lowerer.lowerExpr(bufNode.expression);
-    const idxArgs = args.slice(1).map((a) => lowerer.lowerExprExpecting(a, F64));
-    return { kind: "bytesIntrinsic", method: "dataViewNew", receiver, args: idxArgs, type: BYTES_U8, loc };
+    return { kind: "bytesNew", source: lowerer.coerceInto(node, source, DYN), from: true, type: bytesOf(elem), loc: locOf(call) };
+}
+/** Construct a view over the complete branded backing allocation. */
+function lowerArrayBufferView(lowerer, args, elem, loc) {
+    const values = [0, 1, 2].map((index) => {
+        const node = args[index];
+        return node ? lowerer.coerceInto(node, lowerer.lowerExpr(node), DYN) : dynUndefinedExpr(loc);
+    });
+    const fn = { u8c: "arrayBuffer.viewU8C", i8: "arrayBuffer.viewI8", u16: "arrayBuffer.viewU16", i16: "arrayBuffer.viewI16", u8: "arrayBuffer.viewU8", u32: "arrayBuffer.viewU32", i32: "arrayBuffer.viewI32", f32: "arrayBuffer.viewF32", f64: "arrayBuffer.viewF64", dv: "arrayBuffer.viewDV" };
+    return { kind: "libCall", fn: fn[elem], args: values, type: elem === "dv" ? BYTES_U8 : bytesOf(elem), loc };
 }
-/** Method calls on typed-array/Buffer receivers: slice and subarray (BOTH
-   * copy — subarray's sharing is the documented divergence), set(src,
+function lowerDataViewNew(lowerer, expr) {
+    const args = expr.arguments ?? [];
+    if (!args.length || args.length > 3 || args.some(ts.isSpreadElement))
+        lowerer.noLowering("DataView constructor argument count", expr);
+    return lowerArrayBufferView(lowerer, args, "dv", locOf(expr));
+}
+/** Method calls on typed-array/Buffer receivers: slice (copy), subarray
+   * (shared view), copyWithin, set(src,
    * offset?), and the u8-only Buffer surface: toString(enc?) plus the
    * whole numeric read/write family (fixed widths BE/LE and the
    * variable-width read/writeUIntLE quartet — BUF_NUM_METHODS). Everything
@@ -276,7 +293,7 @@ export function lowerBytesMethodCall(lowerer, call, access) {
         return {
             kind: "bytesIntrinsic",
             method: "toReversed",
-            receiver: lowerer.lowerExpr(access.expression),
+            receiver: lowerer.lowerExprExpecting(access.expression, receiverIr),
             args: [],
             type: receiverIr,
             loc,
@@ -289,7 +306,7 @@ export function lowerBytesMethodCall(lowerer, call, access) {
         return {
             kind: "bytesIntrinsic",
             method: "with",
-            receiver: lowerer.lowerExpr(access.expression),
+            receiver: lowerer.lowerExprExpecting(access.expression, receiverIr),
             args: [
                 lowerer.lowerExprExpecting(call.arguments[0], F64),
                 lowerer.lowerExprExpecting(call.arguments[1], F64),
@@ -298,9 +315,9 @@ export function lowerBytesMethodCall(lowerer, call, access) {
             loc,
         };
     }
-    if (receiverIr.elem === "u8" && name === "join") {
+    if (name === "join") {
         if (nArgs > 1 || call.arguments.some(ts.isSpreadElement)) {
-            lowerer.noLowering(`.join with ${nArgs} arguments on Uint8Array`, call);
+            lowerer.noLowering(`.join with ${nArgs} arguments on typed arrays`, call);
         }
         const separatorDefault = {
             kind: "strLit",
@@ -314,7 +331,7 @@ export function lowerBytesMethodCall(lowerer, call, access) {
         return {
             kind: "bytesIntrinsic",
             method: "join",
-            receiver: lowerer.lowerExpr(access.expression),
+            receiver: lowerer.lowerExprExpecting(access.expression, receiverIr),
             args: [separator],
             type: STRING,
             loc,
@@ -324,7 +341,7 @@ export function lowerBytesMethodCall(lowerer, call, access) {
         if (nArgs > 2) {
             lowerer.noLowering(`.${name} with ${nArgs} arguments on typed arrays`, call);
         }
-        const receiver = lowerer.lowerExpr(access.expression);
+        const receiver = lowerer.lowerExprExpecting(access.expression, receiverIr);
         const args = call.arguments.map((a) => lowerer.lowerExprExpecting(a, F64));
         // subarray is a VIEW (TypedArray.prototype.subarray aliases), and
         // Buffer's slice() is subarray's deprecated Node alias — resolved by
@@ -338,32 +355,44 @@ export function lowerBytesMethodCall(lowerer, call, access) {
         const method = name === "subarray" || declaredOnBuffer ? "subarray" : "slice";
         return { kind: "bytesIntrinsic", method, receiver, args, type: receiverIr, loc };
     }
-    if (name === "fill" && receiverIr.elem !== "u8") {
-        // TypedArray.prototype.fill on the non-u8 kinds: per-element value
-        // coercion, slice-clamped relative indices, never throws. u8
-        // receivers keep the Buffer fill family (string patterns, throwing
-        // offset validation) — lowerBufferInstanceMethod's surface.
-        if (nArgs < 1 || nArgs > 3) {
+    if (name === "copyWithin") {
+        if (nArgs > 3 || call.arguments.some(ts.isSpreadElement)) {
+            lowerer.noLowering(`.copyWithin with ${nArgs} arguments on typed arrays`, call);
+        }
+        const receiver = lowerer.lowerExprExpecting(access.expression, receiverIr);
+        const args = [0, 0, Infinity].map((value, i) => {
+            const fallback = { kind: "numLit", value, type: F64, loc };
+            const node = call.arguments[i];
+            return node ? lowerOptionalArgument(lowerer, node, F64, fallback) : fallback;
+        });
+        return { kind: "bytesIntrinsic", method: "copyWithin", receiver, args, type: receiverIr, loc };
+    }
+    if (name === "fill" && !(() => {
+        const symbol = lowerer.checker.getSymbolAtLocation(access.name);
+        return symbol !== undefined && lowerer.checker.declarationsOf(symbol).some((declaration) => ts.isInterfaceDeclaration(declaration.parent) && declaration.parent.name.text === "Buffer");
+    })()) {
+        // Typed arrays use element coercion and relative, clamped indices.
+        // Buffer's same-named method keeps its pattern and offset validation.
+        if (nArgs > 3 || call.arguments.some(ts.isSpreadElement)) {
             lowerer.noLowering(`.fill with ${nArgs} arguments on typed arrays`, call);
         }
-        const receiver = lowerer.lowerExpr(access.expression);
-        const v = lowerer.lowerExprExpecting(call.arguments[0], F64);
-        const idx = call.arguments.slice(1).map((a) => lowerer.lowerExprExpecting(a, F64));
+        const receiver = lowerer.lowerExprExpecting(access.expression, receiverIr);
+        const zero = { kind: "numLit", value: 0, type: F64, loc };
+        const v = call.arguments[0] ? lowerOptionalArgument(lowerer, call.arguments[0], F64, zero) : zero;
+        const idx = call.arguments.slice(1).map((a, i) => lowerOptionalArgument(lowerer, a, F64, { kind: "numLit", value: i === 0 ? 0 : Infinity, type: F64, loc }));
         return { kind: "bytesIntrinsic", method: "fillElem", receiver, args: [v, ...idx], type: receiverIr, loc };
     }
     if (name === "set") {
         if (nArgs < 1 || nArgs > 2) {
             lowerer.noLowering(`.set with ${nArgs} arguments on typed arrays`, call);
         }
-        const receiver = lowerer.lowerExpr(access.expression);
+        const receiver = lowerer.lowerExprExpecting(access.expression, receiverIr);
         const src = lowerer.lowerExpr(call.arguments[0]);
-        if (!typeEquals(src.type, receiverIr)) {
-            lowerer.noLowering(`.set from '${lowerer.fmt(src.type)}' values`, call.arguments[0], "only a same-kind typed array copies in (number[] sources have no lowering — narrow unions first)");
-        }
-        const args = [src];
+        const method = src.type.kind === "bytes" ? "setFrom" : "setFromDyn";
+        const args = [src.type.kind === "bytes" ? src : lowerer.coerceInto(call.arguments[0], src, DYN)];
         if (nArgs === 2)
-            args.push(lowerer.lowerExprExpecting(call.arguments[1], F64));
-        return { kind: "bytesIntrinsic", method: "setFrom", receiver, args, type: VOID, loc };
+            args.push(lowerOptionalArgument(lowerer, call.arguments[1], F64, { kind: "numLit", value: 0, type: F64, loc }));
+        return { kind: "bytesIntrinsic", method, receiver, args, type: VOID, loc };
     }
     if (name === "toString") {
         // Buffer's toString(encoding?) — utf8 by default. A 0-arg toString
@@ -378,7 +407,7 @@ export function lowerBytesMethodCall(lowerer, call, access) {
         }
         if (nArgs > 3)
             lowerer.noLowering(`.toString with ${nArgs} arguments on Buffers`, call);
-        const receiver = lowerer.lowerExpr(access.expression);
+        const receiver = lowerer.lowerExprExpecting(access.expression, receiverIr);
         const encNode = call.arguments[0];
         let method = "toString";
         let enc = { kind: "strLit", value: "utf8", type: STRING, loc };
@@ -447,7 +476,7 @@ export function lowerBytesMethodCall(lowerer, call, access) {
         if (nArgs < required || nArgs > required + 1) {
             lowerer.noLowering(`.${name} with ${nArgs} arguments`, call);
         }
-        const receiver = lowerer.lowerExpr(access.expression);
+        const receiver = lowerer.lowerExprExpecting(access.expression, receiverIr);
         const offsetNode = call.arguments[required];
         const offset = offsetNode
             ? lowerer.lowerExprExpecting(offsetNode, F64)
@@ -474,7 +503,7 @@ export function lowerBytesMethodCall(lowerer, call, access) {
         if (nArgs < required || nArgs > required + 1) {
             lowerer.noLowering(`.${name} with ${nArgs} arguments`, call);
         }
-        const receiver = lowerer.lowerExpr(access.expression);
+        const receiver = lowerer.lowerExprExpecting(access.expression, receiverIr);
         const kind = { kind: "strLit", value: numKind, type: STRING, loc };
         const args = [kind, ...call.arguments.map((a) => lowerer.lowerExprExpecting(a, F64))];
         if (nArgs === required) {
@@ -492,7 +521,7 @@ export function lowerBytesMethodCall(lowerer, call, access) {
         if (nArgs !== required) {
             lowerer.noLowering(`.${name} with ${nArgs} arguments`, call);
         }
-        const receiver = lowerer.lowerExpr(access.expression);
+        const receiver = lowerer.lowerExprExpecting(access.expression, receiverIr);
         const kind = { kind: "strLit", value: varKind, type: STRING, loc };
         const args = [kind, ...call.arguments.map((a) => lowerer.lowerExprExpecting(a, F64))];
         return { kind: "bytesIntrinsic", method: write ? "writeNumVar" : "readNumVar", receiver, args, type: F64, loc };
@@ -506,7 +535,7 @@ export function lowerBytesMethodCall(lowerer, call, access) {
     if (dvBigGetter !== undefined && receiverIr.elem === "u8") {
         if (nArgs < 1 || nArgs > 2)
             lowerer.noLowering(`.${name} with ${nArgs} arguments`, call);
-        const receiver = lowerer.lowerExpr(access.expression);
+        const receiver = lowerer.lowerExprExpecting(access.expression, receiverIr);
         const offset = lowerer.lowerExprExpecting(call.arguments[0], F64);
         const sign = { kind: "boolLit", value: dvBigGetter.sign, type: BOOL, loc };
         const le = call.arguments[1]
@@ -520,7 +549,7 @@ export function lowerBytesMethodCall(lowerer, call, access) {
         if (nArgs < 1 || nArgs > maxArgs) {
             lowerer.noLowering(`.${name} with ${nArgs} arguments`, call);
         }
-        const receiver = lowerer.lowerExpr(access.expression);
+        const receiver = lowerer.lowerExprExpecting(access.expression, receiverIr);
         const args = [lowerer.lowerExprExpecting(call.arguments[0], F64)];
         if (nArgs === 2)
             args.push(lowerer.lowerExprExpecting(call.arguments[1], BOOL));
@@ -536,7 +565,7 @@ export function lowerBytesMethodCall(lowerer, call, access) {
     if ((name === "setBigUint64" || name === "setBigInt64") && receiverIr.elem === "u8") {
         if (nArgs < 2 || nArgs > 3)
             lowerer.noLowering(`.${name} with ${nArgs} arguments`, call);
-        const receiver = lowerer.lowerExpr(access.expression);
+        const receiver = lowerer.lowerExprExpecting(access.expression, receiverIr);
         const offset = lowerer.lowerExprExpecting(call.arguments[0], F64);
         const value = lowerer.lowerExprExpecting(call.arguments[1], BIGINT_T);
         const le = call.arguments[2]
@@ -549,7 +578,7 @@ export function lowerBytesMethodCall(lowerer, call, access) {
         if (nArgs < 2 || nArgs > maxArgs) {
             lowerer.noLowering(`.${name} with ${nArgs} arguments`, call);
         }
-        const receiver = lowerer.lowerExpr(access.expression);
+        const receiver = lowerer.lowerExprExpecting(access.expression, receiverIr);
         const args = [
             lowerer.lowerExprExpecting(call.arguments[0], F64),
             lowerer.lowerExprExpecting(call.arguments[1], F64),
@@ -593,31 +622,6 @@ export function bufEncoding(lowerer, what, encNode) {
     }
     return v;
 }
-/** The fixed-width Buffer numeric methods by source name → the readNum/
- * writeNum kind token. Node declares BOTH capitalizations ("UInt" is the
- * original, "Uint" the aliased spelling) — the tables carry both. */
-const BUF_NUM_METHODS = (() => {
-    const out = {};
-    for (const rw of ["read", "write"]) {
-        for (const u of ["UInt", "Uint"]) {
-            out[`${rw}${u}8`] = "u8";
-            out[`${rw}${u}16BE`] = "u16be";
-            out[`${rw}${u}16LE`] = "u16le";
-            out[`${rw}${u}32BE`] = "u32be";
-            out[`${rw}${u}32LE`] = "u32le";
-        }
-        out[`${rw}Int8`] = "i8";
-        out[`${rw}Int16BE`] = "i16be";
-        out[`${rw}Int16LE`] = "i16le";
-        out[`${rw}Int32BE`] = "i32be";
-        out[`${rw}Int32LE`] = "i32le";
-        out[`${rw}FloatBE`] = "f32be";
-        out[`${rw}FloatLE`] = "f32le";
-        out[`${rw}DoubleBE`] = "f64be";
-        out[`${rw}DoubleLE`] = "f64le";
-    }
-    return out;
-})();
 const BUF_BIGINT_METHODS = {
     readBigInt64BE: { sign: true, le: false },
     readBigInt64LE: { sign: true, le: true },
@@ -691,12 +695,12 @@ function lowerBufferInstanceMethod(lowerer, call, access, name, loc) {
             lowerer.noLowering(`.equals with ${nArgs} arguments`, call);
         if (argIrKind(0)?.kind === "bytes") {
             const other = u8Arg(0);
-            const receiver = lowerer.lowerExpr(access.expression);
+            const receiver = lowerer.lowerExprExpecting(access.expression, BYTES_U8);
             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 = lowerer.lowerExpr(access.expression);
+        const receiver = lowerer.lowerExprExpecting(access.expression, BYTES_U8);
         return { kind: "libCall", fn: "bytes.equalsChk", args: [receiver, chkArg(0)], type: BOOL, loc };
     }
     if (name === "compare") {
@@ -708,14 +712,14 @@ function lowerBufferInstanceMethod(lowerer, call, access, name, loc) {
         if (fast) {
             const target = u8Arg(0);
             const idx = call.arguments.slice(1).map((a) => lowerer.lowerExprExpecting(a, F64));
-            const receiver = lowerer.lowerExpr(access.expression);
+            const receiver = lowerer.lowerExprExpecting(access.expression, BYTES_U8);
             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 = lowerer.lowerExpr(access.expression);
+        const receiver = lowerer.lowerExprExpecting(access.expression, BYTES_U8);
         const slots = [];
         for (let i = 0; i < 5; i++)
             slots.push(i < nArgs ? chkArg(i) : dynUndefinedExpr(loc));
@@ -740,7 +744,7 @@ function lowerBufferInstanceMethod(lowerer, call, access, name, loc) {
         }
         const resultT = name === "includes" ? BOOL : F64;
         const vT = lowerer.mapTypeOf(lowerer.typeOf(args[0]));
-        const receiver = lowerer.lowerExpr(access.expression);
+        const receiver = lowerer.lowerExprExpecting(access.expression, BYTES_U8);
         if (vT?.kind === "f64") {
             // A number needle wraps & 0xFF at runtime (Buffer semantics; the
             // encoding is irrelevant, like Node).
@@ -785,7 +789,7 @@ function lowerBufferInstanceMethod(lowerer, call, access, name, loc) {
         if (receiverT?.kind !== "bytes")
             lowerer.badType(access.expression, lowerer.typeOf(access.expression));
         const vT = lowerer.mapTypeOf(lowerer.typeOf(args[0]));
-        const receiver = lowerer.lowerExpr(access.expression);
+        const receiver = lowerer.lowerExprExpecting(access.expression, BYTES_U8);
         if (vT?.kind === "string") {
             const encName = encNode ? bufEncoding(lowerer, ".fill", encNode) : "utf8";
             const s = lowerer.lowerExprExpecting(args[0], STRING);
@@ -806,13 +810,13 @@ function lowerBufferInstanceMethod(lowerer, call, access, name, loc) {
             lowerer.noLowering(`.copy with ${nArgs} arguments`, call);
         const target = u8Arg(0);
         const idx = call.arguments.slice(1).map((a) => lowerer.lowerExprExpecting(a, F64));
-        const receiver = lowerer.lowerExpr(access.expression);
+        const receiver = lowerer.lowerExprExpecting(access.expression, BYTES_U8);
         return { kind: "bytesIntrinsic", method: "copy", receiver, args: [target, ...idx], type: F64, loc };
     }
     if (name === "swap16" || name === "swap32" || name === "swap64") {
         if (nArgs !== 0)
             lowerer.noLowering(`.${name} with ${nArgs} arguments`, call);
-        const receiver = lowerer.lowerExpr(access.expression);
+        const receiver = lowerer.lowerExprExpecting(access.expression, BYTES_U8);
         return { kind: "bytesIntrinsic", method: name, receiver, args: [], type: BYTES_U8, loc };
     }
     if (name === "write") {
@@ -835,7 +839,7 @@ function lowerBufferInstanceMethod(lowerer, call, access, name, loc) {
             ? lowerer.lowerExprExpecting(idxNodes[0], F64)
             : { kind: "numLit", value: 0, type: F64, loc };
         const writeArgs = [s, enc, offset, ...(idxNodes[1] ? [lowerer.lowerExprExpecting(idxNodes[1], F64)] : [])];
-        const receiver = lowerer.lowerExpr(access.expression);
+        const receiver = lowerer.lowerExprExpecting(access.expression, BYTES_U8);
         return { kind: "bytesIntrinsic", method: "writeStr", receiver, args: writeArgs, type: F64, loc };
     }
     return null;
@@ -902,6 +906,14 @@ function knownBufferProducer(lowerer, source, seen = new Set()) {
     return type?.kind === "cryptoHash" || type?.kind === "cryptoHmac";
 }
 export function lowerBufferStaticCall(lowerer, call, access) {
+    const value = lowerBufferStaticValue(lowerer, call, access);
+    // Every byte-valued Buffer factory creates a distinct view. Preserve its
+    // brand even when stored as Uint8Array or passed through checked values.
+    return value?.type.kind === "bytes"
+        ? { kind: "libCall", fn: "buffer.brand", args: [value], type: value.type, loc: value.loc }
+        : value;
+}
+function lowerBufferStaticValue(lowerer, call, access) {
     if (call.questionDotToken || access.questionDotToken)
         return null;
     if (!lowerer.isStdlibGlobal(access.expression, "Buffer"))
@@ -910,6 +922,10 @@ export function lowerBufferStaticCall(lowerer, call, access) {
     const loc = locOf(call);
     const args = call.arguments;
     if (member === "from") {
+        if (args.length >= 1 && args.length <= 3 && !args.some(ts.isSpreadElement) &&
+            ((symbol) => symbol != null && symbol.name === "ArrayBuffer")(lowerer.typeOf(args[0]).getSymbol())) {
+            return lowerArrayBufferView(lowerer, args, "u8", loc);
+        }
         // Buffer.from(x.buffer[, byteOffset[, length]]): a u8 VIEW sharing
         // x's storage (Node shares the ArrayBuffer; length is in BYTES).
         // The first argument must be the SYNTACTIC `.buffer` of a typed
@@ -926,7 +942,7 @@ export function lowerBufferStaticCall(lowerer, call, access) {
                 return { kind: "bytesIntrinsic", method: "dataViewNew", receiver, args: idxArgs, type: BYTES_U8, loc };
             }
         }
-        if (args.length >= 1 && args.length <= 2 && !ts.isSpreadElement(args[0])) {
+        if (args.length >= 1 && args.length <= 2 && !args.some(ts.isSpreadElement)) {
             const argNode = args[0];
             if (ts.isArrayLiteralExpression(argNode) && !argNode.elements.some(ts.isSpreadElement)) {
                 // A number[] literal (contextually typed by the lib's readonly
@@ -939,24 +955,32 @@ export function lowerBufferStaticCall(lowerer, call, access) {
             }
             else {
                 const srcIr = lowerer.mapTypeOf(lowerer.typeOf(argNode));
+                const value = lowerer.lowerExpr(argNode);
+                // JS callback storage can be native DYN even when the checker
+                // reports any (or a narrowed Buffer). Dispatch on its actual ABI.
+                if (value.type.kind === "dyn") {
+                    const encName = args[1] ? bufEncoding(lowerer, "Buffer.from", args[1]) : "utf8";
+                    const enc = { kind: "strLit", value: encName, type: STRING, loc };
+                    return { kind: "libCall", fn: "buffer.fromDyn", args: [value, enc], type: BYTES_U8, loc };
+                }
                 if (srcIr?.kind === "string") {
                     const encNode = args[1];
                     const encName = encNode ? bufEncoding(lowerer, "Buffer.from", encNode) : "utf8";
-                    const s = lowerer.lowerExprExpecting(argNode, STRING);
+                    const s = lowerer.coerceInto(argNode, value, STRING);
                     const enc = { kind: "strLit", value: encName, type: STRING, loc };
                     return { kind: "libCall", fn: "buffer.fromStr", args: [s, enc], type: BYTES_U8, loc };
                 }
                 if (args.length === 1 && srcIr?.kind === "bytes" && srcIr.elem === "u8") {
-                    return { kind: "bytesNew", source: lowerer.lowerExpr(argNode), type: BYTES_U8, loc };
+                    return { kind: "bytesNew", source: value, type: BYTES_U8, loc };
                 }
                 if (args.length === 1 && srcIr?.kind === "array" && srcIr.elem.kind === "f64") {
-                    return { kind: "bytesNew", source: lowerer.lowerExpr(argNode), type: BYTES_U8, loc };
+                    return { kind: "bytesNew", source: value, type: BYTES_U8, loc };
                 }
             }
         }
         lowerer.noLowering("Buffer.from with this argument shape", call, "supported: Buffer.from(string, encoding?) with a literal encoding, Buffer.from(u8Array) — a copy — " +
-            "Buffer.from(number[]), or Buffer.from(x.buffer, byteOffset?, length?) — a view sharing x's " +
-            "storage (no free-standing ArrayBuffer value exists; narrow unions first)");
+            "Buffer.from(number[]), or Buffer.from(arrayBuffer, byteOffset?, length?) — a view sharing " +
+            "the buffer's storage; narrow unions first");
     }
     if (member === "alloc" || member === "allocUnsafe") {
         const maxArgs = member === "alloc" ? 3 : 1;
@@ -1062,6 +1086,23 @@ export function lowerBufferStaticCall(lowerer, call, access) {
                     loc,
                 };
             }
+            // Untyped stream chunks retain the native checked value's Buffer
+            // flavor. Plain bytes are Uint8Arrays at this boundary; inspecting
+            // only the bytes tag would incorrectly identify them as Buffers.
+            if (v.type.kind === "dyn") {
+                return { kind: "dynTest", test: "buffer", value: v, type: BOOL, loc };
+            }
+            // Primitive storage cannot carry a Buffer. Keep argument effects
+            // even when its representation makes the answer constant.
+            if (v.type.kind === "string" || v.type.kind === "f64" || v.type.kind === "bool" ||
+                v.type.kind === "symbol" || v.type.kind === "bigint" || v.type.kind === "nullT" || v.type.kind === "undefinedT") {
+                if (isSafeToDiscard(v))
+                    return { kind: "boolLit", value: false, type: BOOL, loc };
+                return {
+                    kind: "seqExpr", stmts: [{ kind: "exprStmt", expr: v, loc: v.loc }],
+                    result: { kind: "boolLit", value: false, type: BOOL, loc }, type: BOOL, loc,
+                };
+            }
             if (v.type.kind === "union") {
                 const def = lowerer.unions.get(v.type.unionId);
                 const tag = def ? def.arms.findIndex((a) => a.kind === "bytes" && a.elem === "u8") : -1;
@@ -1085,6 +1126,10 @@ export function lowerBufferStaticCall(lowerer, call, access) {
                 const enc = { kind: "strLit", value: encName, type: STRING, loc };
                 return { kind: "libCall", fn: "buffer.byteLenStr", args: [s, enc], type: F64, loc };
             }
+            if ((srcIr === null || srcIr.kind === "dyn") && (!args[1] || ts.isStringLiteralLike(args[1]))) {
+                const encoding = { kind: "strLit", value: args[1] ? bufEncoding(lowerer, "Buffer.byteLength", args[1]) : "utf8", type: STRING, loc };
+                return { kind: "libCall", fn: "buffer.byteLenDyn", args: [lowerer.lowerExprExpecting(args[0], DYN), encoding], type: F64, loc };
+            }
             if (srcIr?.kind === "bytes" && args.length === 1) {
                 const receiver = lowerer.lowerExpr(args[0]);
                 return { kind: "bytesIntrinsic", method: "byteLength", receiver, args: [], type: F64, loc };