@scriptc/compiler 0.1.1 → 0.1.2

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

@@ -0,0 +1,1021 @@
+import * as ts from "../../ts7/adapter.js";
+import { 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 { 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";
+/** 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
+ * the same stable merge walk as Array.toSorted. Uint8Array's default
+ * comparator is numeric ascending, so its comparator-less form needs no
+ * string-conversion machinery. */
+function lowerBytesToSortedCall(lowerer, call, access, bytesT) {
+    const loc = locOf(call);
+    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 undefinedArg = call.arguments[0]
+        ? lowerStaticallyUndefinedArgument(lowerer, call.arguments[0])
+        : null;
+    if (call.arguments.length === 0 || undefinedArg) {
+        const key = "bytes.toSorted:u8:default";
+        let helper = lowerer.arrHofHelpers.get(key);
+        if (!helper) {
+            helper = `%bytes.toSorted.${lowerer.arrHofHelpers.size}`;
+            lowerer.arrHofHelpers.set(key, helper);
+            lowerer.liftedFns.push(buildBytesSortFn(helper, 0, false, loc));
+        }
+        if (!undefinedArg || isSafeToDiscard(undefinedArg)) {
+            return { kind: "call", callee: helper, args: [receiver], type: bytesT, loc };
+        }
+        // The default helper takes no comparator argument. Snapshot the
+        // receiver into a hidden local so the discarded undefined argument
+        // still evaluates after the receiver and before the helper call.
+        const saved = lowerer.declareHiddenLocal("%bytesSortRecv", bytesT);
+        const savedRef = {
+            kind: "varRef",
+            localId: saved.id,
+            type: bytesT,
+            loc,
+        };
+        return {
+            kind: "seqExpr",
+            stmts: [
+                { kind: "varDecl", localId: saved.id, init: receiver, loc },
+                { kind: "exprStmt", expr: undefinedArg, loc: undefinedArg.loc },
+            ],
+            result: {
+                kind: "call",
+                callee: helper,
+                args: [savedRef],
+                type: bytesT,
+                loc,
+            },
+            type: bytesT,
+            loc,
+        };
+    }
+    const argNode = call.arguments[0];
+    const fnArg = lowerer.lowerExpr(argNode);
+    if (fnArg.type.kind !== "func" ||
+        fnArg.type.params.length > 2 ||
+        !fnArg.type.params.every((p) => p.kind === "f64") ||
+        fnArg.type.ret.kind !== "f64") {
+        lowerer.badType(argNode, lowerer.typeOf(argNode));
+    }
+    const arity = fnArg.type.params.length;
+    const key = `bytes.toSorted:u8:${arity}`;
+    let helper = lowerer.arrHofHelpers.get(key);
+    if (!helper) {
+        helper = `%bytes.toSorted.${lowerer.arrHofHelpers.size}`;
+        lowerer.arrHofHelpers.set(key, helper);
+        lowerer.liftedFns.push(buildBytesSortFn(helper, arity, true, loc));
+    }
+    return {
+        kind: "call",
+        callee: helper,
+        args: [receiver, fnArg],
+        type: bytesT,
+        loc,
+    };
+}
+/* ── typed arrays / Buffer ─────────────────────────────────────────────── */
+/** The typed-array constructors with a runtime representation, by lib
+ * interface name. The other TypedArray flavors (Int8Array, Float64Array,
+ * DataView, ...) fall through to the generic stdlib-constructor fence. */
+const BYTES_CTORS = {
+    Uint8Array: "u8",
+    Uint32Array: "u32",
+    Int32Array: "i32",
+    Float32Array: "f32",
+};
+/** `new Uint8Array(...)` / `new Uint32Array(...)` / `new Float32Array(...)`
+   * (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 —
+   * 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
+   * typed-array construction. */
+export function lowerBytesNew(lowerer, expr, symbol) {
+    if (symbol && symbol.name === "DataView" && lowerer.isStdlibSymbol(symbol)) {
+        return lowerDataViewNew(lowerer, expr);
+    }
+    const elem = symbol ? own(BYTES_CTORS, symbol.name) : undefined;
+    if (!elem || !symbol || !lowerer.isStdlibSymbol(symbol))
+        return null;
+    const name = symbol.name;
+    const type = bytesOf(elem);
+    const loc = locOf(expr);
+    const args = expr.arguments ?? [];
+    if (args.length === 0)
+        return { kind: "bytesNew", source: null, type, loc };
+    if (args.length === 1 && !ts.isSpreadElement(args[0])) {
+        const argNode = args[0];
+        if (ts.isArrayLiteralExpression(argNode) && !argNode.elements.some(ts.isSpreadElement)) {
+            const elems = argNode.elements.map((el) => lowerer.lowerExprExpecting(el, F64));
+            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
+        // 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 === "ArrayBuffer" ||
+                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");
+            }
+            const elemSize = elem === "u8" ? 1 : 4;
+            const lenArg = argNode.arguments?.length === 1 ? argNode.arguments[0] : undefined;
+            const lenT = lenArg ? lowerer.typeOf(lenArg) : null;
+            const byteLen = lenT?.isNumberLiteralType() ? lenT.value : null;
+            if (byteLen === null || byteLen % elemSize !== 0 || byteLen < 0) {
+                lowerer.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 };
+        }
+        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 === "f64" ||
+            typeEquals(src.type, type) ||
+            (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)");
+    }
+    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)");
+    }
+    // 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 };
+    }
+    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 — 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 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);
+    }
+    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 };
+}
+/** Method calls on typed-array/Buffer receivers: slice and subarray (BOTH
+   * copy — subarray's sharing is the documented divergence), 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
+   * else the lib declares (fill, indexOf, reverse, ...) falls through to
+   * the SC2020 member fence. Null when this isn't a bytes method call. */
+export function lowerBytesMethodCall(lowerer, call, access) {
+    if (lowerer.chainBlocked(access, call))
+        return null;
+    const name = access.name.text;
+    const receiverIr = lowerer.mapTypeOf(lowerer.typeOf(access.expression));
+    if (receiverIr?.kind !== "bytes")
+        return null;
+    if (!lowerer.isStdlibMember(access))
+        return null;
+    const loc = locOf(call);
+    const nArgs = call.arguments.length;
+    if (receiverIr.elem === "u8" && name === "toSorted") {
+        return lowerBytesToSortedCall(lowerer, call, access, receiverIr);
+    }
+    if (receiverIr.elem === "u8" && name === "toReversed") {
+        if (nArgs !== 0) {
+            lowerer.noLowering(`.toReversed with ${nArgs} arguments on Uint8Array`, call);
+        }
+        return {
+            kind: "bytesIntrinsic",
+            method: "toReversed",
+            receiver: lowerer.lowerExpr(access.expression),
+            args: [],
+            type: receiverIr,
+            loc,
+        };
+    }
+    if (receiverIr.elem === "u8" && name === "with") {
+        if (nArgs !== 2 || call.arguments.some(ts.isSpreadElement)) {
+            lowerer.noLowering(`.with with ${nArgs} arguments on Uint8Array`, call);
+        }
+        return {
+            kind: "bytesIntrinsic",
+            method: "with",
+            receiver: lowerer.lowerExpr(access.expression),
+            args: [
+                lowerer.lowerExprExpecting(call.arguments[0], F64),
+                lowerer.lowerExprExpecting(call.arguments[1], F64),
+            ],
+            type: receiverIr,
+            loc,
+        };
+    }
+    if (receiverIr.elem === "u8" && name === "join") {
+        if (nArgs > 1 || call.arguments.some(ts.isSpreadElement)) {
+            lowerer.noLowering(`.join with ${nArgs} arguments on Uint8Array`, call);
+        }
+        const separatorDefault = {
+            kind: "strLit",
+            value: ",",
+            type: STRING,
+            loc,
+        };
+        const separator = call.arguments[0]
+            ? lowerOptionalArgument(lowerer, call.arguments[0], STRING, separatorDefault)
+            : separatorDefault;
+        return {
+            kind: "bytesIntrinsic",
+            method: "join",
+            receiver: lowerer.lowerExpr(access.expression),
+            args: [separator],
+            type: STRING,
+            loc,
+        };
+    }
+    if (name === "slice" || name === "subarray") {
+        if (nArgs > 2) {
+            lowerer.noLowering(`.${name} with ${nArgs} arguments on typed arrays`, call);
+        }
+        const receiver = lowerer.lowerExpr(access.expression);
+        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
+        // where the member is declared, the toString discipline below. Only
+        // the plain typed arrays' slice() copies (JS-exact).
+        const declaredOnBuffer = name === "slice" &&
+            (() => {
+                const nameSym = lowerer.checker.getSymbolAtLocation(access.name);
+                return nameSym !== undefined && lowerer.checker.declarationsOf(nameSym).some((d) => ts.isInterfaceDeclaration(d.parent) && d.parent.name.text === "Buffer");
+            })();
+        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) {
+            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));
+        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 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];
+        if (nArgs === 2)
+            args.push(lowerer.lowerExprExpecting(call.arguments[1], F64));
+        return { kind: "bytesIntrinsic", method: "setFrom", receiver, args, type: VOID, loc };
+    }
+    if (name === "toString") {
+        // Buffer's toString(encoding?) — utf8 by default. A 0-arg toString
+        // resolved against the plain Uint8Array interface is JS's
+        // Array-toString (comma join), a different operation: fenced.
+        const declaredOnBuffer = (() => {
+            const nameSym = lowerer.checker.getSymbolAtLocation(access.name);
+            return nameSym !== undefined && lowerer.checker.declarationsOf(nameSym).some((d) => ts.isInterfaceDeclaration(d.parent) && d.parent.name.text === "Buffer");
+        })();
+        if (receiverIr.elem !== "u8" || !declaredOnBuffer) {
+            lowerer.noLowering("typed-array toString", call, 'Buffer.from(x).toString("utf8" | "hex" | "base64") is the lowered string conversion');
+        }
+        if (nArgs > 3)
+            lowerer.noLowering(`.toString with ${nArgs} arguments on Buffers`, call);
+        const receiver = lowerer.lowerExpr(access.expression);
+        const encNode = call.arguments[0];
+        let method = "toString";
+        let enc = { kind: "strLit", value: "utf8", type: STRING, loc };
+        if (encNode) {
+            const encType = lowerer.typeOf(encNode);
+            const encName = encType.isStringLiteralType()
+                ? knownBufEncoding(encType.value)
+                : undefined;
+            if (encName !== undefined) {
+                // Keep literals on the canonical, non-throwing fast path.
+                enc = { kind: "strLit", value: encName, type: STRING, loc };
+            }
+            else {
+                const undefinedArg = lowerStaticallyUndefinedArgument(lowerer, encNode);
+                if (undefinedArg) {
+                    // An explicit undefined is the omitted-encoding default. Keep
+                    // the canonical, non-throwing path while preserving effects
+                    // from equivalent spellings such as `void sideEffect()`.
+                    enc = defaultAfterUndefined(undefinedArg, enc);
+                }
+                else {
+                    // A BufferEncoding-typed variable selects its decoder at
+                    // runtime. Optional variables default their undefined arm to
+                    // utf8; the checked intrinsic canonicalizes every present
+                    // alias/case and raises Node's ERR_UNKNOWN_ENCODING when a cast
+                    // lets a bad value through.
+                    enc = lowerOptionalArgument(lowerer, encNode, STRING, enc);
+                    method = "toStringVar";
+                }
+            }
+        }
+        // The range form toString(enc, start[, end]) decodes the clamped
+        // [start, end) byte window (Node's slice-then-decode). An omitted
+        // end stays omitted (2 intrinsic args) — the emitter supplies the
+        // receiver's length, because EXPLICIT negative ends clamp to empty
+        // in Node and no in-band sentinel can represent "omitted" safely.
+        if (nArgs > 1) {
+            const start = lowerer.lowerExprExpecting(call.arguments[1], F64);
+            if (nArgs === 3) {
+                const end = lowerer.lowerExprExpecting(call.arguments[2], F64);
+                return { kind: "bytesIntrinsic", method, receiver, args: [enc, start, end], type: STRING, loc };
+            }
+            return { kind: "bytesIntrinsic", method, receiver, args: [enc, start], type: STRING, loc };
+        }
+        return { kind: "bytesIntrinsic", method, receiver, args: [enc], type: STRING, loc };
+    }
+    // The Buffer-declared comparison/search/mutation surface. All of
+    // these resolve against the Buffer interface (the checker keeps most
+    // off plain typed arrays; where the lib DOES declare a same-named
+    // TypedArray member — indexOf, includes, fill — the semantics differ,
+    // so only Buffer-declared resolutions lower and u8 receivers gate the
+    // rest).
+    const declOnBuffer = (() => {
+        const nameSym = lowerer.checker.getSymbolAtLocation(access.name);
+        return nameSym !== undefined && lowerer.checker.declarationsOf(nameSym).some((d) => ts.isInterfaceDeclaration(d.parent) && d.parent.name.text === "Buffer");
+    })();
+    if (declOnBuffer && receiverIr.elem === "u8") {
+        const bufMethod = lowerBufferInstanceMethod(lowerer, call, access, name, loc);
+        if (bufMethod)
+            return bufMethod;
+    }
+    // The Buffer numeric read/write families — every fixed-width kind in
+    // both endiannesses ("Uint" and "UInt" alike: Node aliases both), plus
+    // the variable-width read/writeUIntLE quartet. The kind token rides as
+    // a strLit args[0]; omitted offsets complete to Node's default 0.
+    const numKind = own(BUF_NUM_METHODS, name);
+    if (numKind !== undefined) {
+        if (receiverIr.elem !== "u8") {
+            lowerer.noLowering(`.${name} on a '${lowerer.fmt(receiverIr)}'`, call, "the numeric families read/write Buffer bytes");
+        }
+        const write = name.startsWith("write");
+        const required = write ? 1 : 0; // value; offset defaults to 0
+        if (nArgs < required || nArgs > required + 1) {
+            lowerer.noLowering(`.${name} with ${nArgs} arguments`, call);
+        }
+        const receiver = lowerer.lowerExpr(access.expression);
+        const kind = { kind: "strLit", value: numKind, type: STRING, loc };
+        const args = [kind, ...call.arguments.map((a) => lowerer.lowerExprExpecting(a, F64))];
+        if (nArgs === required) {
+            args.push({ kind: "numLit", value: 0, type: F64, loc }); // Node's offset default
+        }
+        return { kind: "bytesIntrinsic", method: write ? "writeNum" : "readNum", receiver, args, type: F64, loc };
+    }
+    const varKind = own(BUF_NUM_VAR_METHODS, name);
+    if (varKind !== undefined) {
+        if (receiverIr.elem !== "u8") {
+            lowerer.noLowering(`.${name} on a '${lowerer.fmt(receiverIr)}'`, call, "the numeric families read/write Buffer bytes");
+        }
+        const write = name.startsWith("write");
+        const required = write ? 3 : 2; // Node declares offset AND byteLength required
+        if (nArgs !== required) {
+            lowerer.noLowering(`.${name} with ${nArgs} arguments`, call);
+        }
+        const receiver = lowerer.lowerExpr(access.expression);
+        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 };
+    }
+    // DataView getters (DataView maps to bytes<u8>, so the receiver kind
+    // and stdlib provenance land here; the checker keeps these names off
+    // typed arrays and Buffers). The multi-byte kinds take the optional
+    // littleEndian bool (omitted = big-endian, the JS default). All THROW
+    // Node's RangeError on a bad offset (may-throw seeds).
+    const dvGetter = own(DV_GETTERS, name);
+    if (dvGetter !== undefined && receiverIr.elem === "u8") {
+        if (dvGetter.method === "dvGetBigUint64Number" || dvGetter.method === "dvGetBigInt64Number") {
+            // bigint values have no representation — only the COMPOSED
+            // `Number(view.getBigUint64/getBigInt64(...))` compiles (the
+            // randomBytesToString pattern): the 8-byte integer converts to
+            // double exactly as Number(bigint) would, and the bigint never
+            // exists as a value (the f64-typed intrinsic result IS what the
+            // identity Number(f64) lowering hands back).
+            const p = call.parent;
+            const composed = ts.isCallExpression(p) &&
+                p.arguments.length === 1 &&
+                p.arguments[0] === call &&
+                ts.isIdentifier(p.expression) &&
+                p.expression.text === "Number" &&
+                lowerer.isStdlibSymbol(lowerer.resolveValueSymbol(p.expression) ?? undefined);
+            if (!composed) {
+                lowerer.noLowering(`.${name} outside Number(...)`, call, `bigint values have no representation — Number(view.${name}(offset, littleEndian?)) is the lowered form`);
+            }
+        }
+        const maxArgs = dvGetter.le ? 2 : 1;
+        if (nArgs < 1 || nArgs > maxArgs) {
+            lowerer.noLowering(`.${name} with ${nArgs} arguments`, call);
+        }
+        const receiver = lowerer.lowerExpr(access.expression);
+        const args = [lowerer.lowerExprExpecting(call.arguments[0], F64)];
+        if (nArgs === 2)
+            args.push(lowerer.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) {
+            lowerer.noLowering(`.${name} with ${nArgs} arguments`, call);
+        }
+        const receiver = lowerer.lowerExpr(access.expression);
+        const args = [
+            lowerer.lowerExprExpecting(call.arguments[0], F64),
+            lowerer.lowerExprExpecting(call.arguments[1], F64),
+        ];
+        if (nArgs === 3)
+            args.push(lowerer.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
+ * alias folds at compile time; the runtime sees only canonical names).
+ * Shared by toString, Buffer.from, and Buffer.byteLength. */
+const BUF_ENCODINGS = {
+    utf8: "utf8",
+    "utf-8": "utf8",
+    hex: "hex",
+    base64: "base64",
+    base64url: "base64url",
+    latin1: "latin1",
+    binary: "latin1",
+    ascii: "ascii",
+    utf16le: "utf16le",
+    "utf-16le": "utf16le",
+    ucs2: "utf16le",
+    "ucs-2": "utf16le",
+};
+/** A literal encoding's canonical name, or undefined for a spelling Node
+ * does not know — the ladder callers (stream options) turn unknown
+ * literals into Node's runtime ERR_UNKNOWN_ENCODING throw. */
+export function knownBufEncoding(name) {
+    return own(BUF_ENCODINGS, name);
+}
+/** The literal encoding argument of a Buffer surface, normalized — or a
+ * fence when it isn't a literal alias Node knows. */
+export function bufEncoding(lowerer, what, encNode) {
+    const t = lowerer.typeOf(encNode);
+    const v = t.isStringLiteralType() ? own(BUF_ENCODINGS, t.value) : undefined;
+    if (v === undefined) {
+        lowerer.noLowering(`${what} with this encoding`, encNode, 'a literal "utf8", "hex", "base64", "base64url", "latin1", "binary", "ascii", "utf16le", or "ucs2" spelling is the lowered encoding surface');
+    }
+    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;
+})();
+/** The variable-width quartet (offset + byteLength) → sign/endian token. */
+const BUF_NUM_VAR_METHODS = {
+    readUIntBE: "ube",
+    readUintBE: "ube",
+    readUIntLE: "ule",
+    readUintLE: "ule",
+    readIntBE: "ibe",
+    readIntLE: "ile",
+    writeUIntBE: "ube",
+    writeUintBE: "ube",
+    writeUIntLE: "ule",
+    writeUintLE: "ule",
+    writeIntBE: "ibe",
+    writeIntLE: "ile",
+};
+/** The Buffer-declared comparison/search/mutation methods on a u8
+ * receiver: equals, compare, indexOf/lastIndexOf/includes (number,
+ * string-with-encoding, and Buffer needles), fill, copy, swap16/32/64,
+ * and write. Null when `name` isn't one of them (the numeric families
+ * and the generic bytes surface try next). Encodings must be literals
+ * (bufEncoding's fence); a trailing string-typed argument is the
+ * encoding, exactly Node's overloads. */
+function lowerBufferInstanceMethod(lowerer, call, access, name, loc) {
+    const args = call.arguments;
+    const nArgs = args.length;
+    if (args.some(ts.isSpreadElement))
+        return null;
+    const isStringArg = (i) => lowerer.mapTypeOf(lowerer.typeOf(args[i]))?.kind === "string";
+    const u8Arg = (i) => {
+        const v = lowerer.lowerExpr(args[i]);
+        if (!(v.type.kind === "bytes" && v.type.elem === "u8")) {
+            lowerer.noLowering(`.${name} of '${lowerer.fmt(v.type)}' values`, args[i], "a Buffer/Uint8Array argument is the lowered shape (narrow unions first)");
+        }
+        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 dyn literal path directly (method members
+        // box as dyn functions — the typed record fence never applies).
+        if (ts.isObjectLiteralExpression(args[i])) {
+            return lowerDynObjectLiteral(lowerer, args[i]);
+        }
+        const v = lowerer.lowerExpr(args[i]);
+        if (v.type.kind === "dyn")
+            return v;
+        if (v.kind === "unitLit" || lowerer.dynConvertible(v.type)) {
+            return { kind: "dynFrom", value: v, type: DYN, loc: v.loc };
+        }
+        lowerer.noLowering(`.${name} of '${lowerer.fmt(v.type)}' values`, args[i], "a Buffer/Uint8Array argument is the lowered shape (narrow unions first)");
+    };
+    const argIrKind = (i) => lowerer.mapTypeOf(lowerer.typeOf(args[i]));
+    if (name === "equals") {
+        if (nArgs !== 1)
+            lowerer.noLowering(`.equals with ${nArgs} arguments`, call);
+        if (argIrKind(0)?.kind === "bytes") {
+            const other = u8Arg(0);
+            const receiver = lowerer.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 = lowerer.lowerExpr(access.expression);
+        return { kind: "libCall", fn: "bytes.equalsChk", args: [receiver, chkArg(0)], type: BOOL, loc };
+    }
+    if (name === "compare") {
+        if (nArgs > 5)
+            lowerer.noLowering(`.compare with ${nArgs} arguments`, call);
+        const fast = nArgs >= 1 &&
+            argIrKind(0)?.kind === "bytes" &&
+            call.arguments.slice(1).every((a) => lowerer.mapTypeOf(lowerer.typeOf(a))?.kind === "f64");
+        if (fast) {
+            const target = u8Arg(0);
+            const idx = call.arguments.slice(1).map((a) => lowerer.lowerExprExpecting(a, F64));
+            const receiver = lowerer.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 = lowerer.lowerExpr(access.expression);
+        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)
+            lowerer.noLowering(`.${name} with ${nArgs} arguments`, call);
+        // The overloads: (v), (v, byteOffset), (v, encoding), (v, byteOffset,
+        // encoding) — a trailing string-typed arg is the encoding.
+        let encName = "utf8";
+        let offNode;
+        if (nArgs === 3) {
+            offNode = args[1];
+            encName = bufEncoding(lowerer, `.${name}`, args[2]);
+        }
+        else if (nArgs === 2) {
+            if (isStringArg(1))
+                encName = bufEncoding(lowerer, `.${name}`, args[1]);
+            else
+                offNode = args[1];
+        }
+        const resultT = name === "includes" ? BOOL : F64;
+        const vT = lowerer.mapTypeOf(lowerer.typeOf(args[0]));
+        const receiver = lowerer.lowerExpr(access.expression);
+        if (vT?.kind === "f64") {
+            // A number needle wraps & 0xFF at runtime (Buffer semantics; the
+            // encoding is irrelevant, like Node).
+            const v = lowerer.lowerExprExpecting(args[0], F64);
+            const numArgs = [v, ...(offNode ? [lowerer.lowerExprExpecting(offNode, F64)] : [])];
+            const method = name === "indexOf" ? "indexOfNum" : name === "lastIndexOf" ? "lastIndexOfNum" : "includesNum";
+            return { kind: "bytesIntrinsic", method, receiver, args: numArgs, type: resultT, loc };
+        }
+        let needle;
+        let align = 1;
+        if (vT?.kind === "string") {
+            const s = lowerer.lowerExprExpecting(args[0], STRING);
+            const enc = { kind: "strLit", value: encName, type: STRING, loc };
+            needle = { kind: "libCall", fn: "buffer.fromStr", args: [s, enc], type: BYTES_U8, loc };
+            if (encName === "utf16le")
+                align = 2;
+        }
+        else if (vT?.kind === "bytes" && vT.elem === "u8") {
+            needle = lowerer.lowerExpr(args[0]);
+        }
+        else {
+            lowerer.noLowering(`.${name} of '${lowerer.checker.typeToString(lowerer.typeOf(args[0]))}' values`, args[0], "string, number, and Buffer/Uint8Array needles search (narrow unions first)");
+        }
+        const alignLit = { kind: "numLit", value: align, type: F64, loc };
+        const searchArgs = [needle, alignLit, ...(offNode ? [lowerer.lowerExprExpecting(offNode, F64)] : [])];
+        return { kind: "bytesIntrinsic", method: name, receiver, args: searchArgs, type: resultT, loc };
+    }
+    if (name === "fill") {
+        if (nArgs < 1 || nArgs > 4)
+            lowerer.noLowering(`.fill with ${nArgs} arguments`, call);
+        // A trailing string-typed arg past the value is the encoding.
+        let encNode;
+        let idxNodes = call.arguments.slice(1);
+        if (idxNodes.length > 0 && isStringArg(nArgs - 1)) {
+            encNode = idxNodes[idxNodes.length - 1];
+            idxNodes = idxNodes.slice(0, -1);
+        }
+        if (idxNodes.length > 2)
+            lowerer.noLowering(`.fill with ${nArgs} arguments`, call);
+        const idx = idxNodes.map((a) => lowerer.lowerExprExpecting(a, F64));
+        const receiverT = lowerer.mapTypeOf(lowerer.typeOf(access.expression));
+        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);
+        if (vT?.kind === "string") {
+            const encName = encNode ? bufEncoding(lowerer, ".fill", encNode) : "utf8";
+            const s = lowerer.lowerExprExpecting(args[0], STRING);
+            const enc = { kind: "strLit", value: encName, type: STRING, loc };
+            return { kind: "bytesIntrinsic", method: "fillStr", receiver, args: [s, enc, ...idx], type: BYTES_U8, loc };
+        }
+        if (encNode)
+            lowerer.noLowering(".fill with an encoding on a non-string value", encNode);
+        if (vT?.kind === "f64") {
+            const v = lowerer.lowerExprExpecting(args[0], F64);
+            return { kind: "bytesIntrinsic", method: "fillNum", receiver, args: [v, ...idx], type: BYTES_U8, loc };
+        }
+        const pattern = u8Arg(0);
+        return { kind: "bytesIntrinsic", method: "fill", receiver, args: [pattern, ...idx], type: BYTES_U8, loc };
+    }
+    if (name === "copy") {
+        if (nArgs < 1 || nArgs > 4)
+            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);
+        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);
+        return { kind: "bytesIntrinsic", method: name, receiver, args: [], type: BYTES_U8, loc };
+    }
+    if (name === "write") {
+        if (nArgs < 1 || nArgs > 4)
+            lowerer.noLowering(`.write with ${nArgs} arguments`, call);
+        // (str), (str, enc), (str, offset), (str, offset, enc),
+        // (str, offset, length), (str, offset, length, enc).
+        let encNode;
+        let idxNodes = call.arguments.slice(1);
+        if (idxNodes.length > 0 && isStringArg(nArgs - 1)) {
+            encNode = idxNodes[idxNodes.length - 1];
+            idxNodes = idxNodes.slice(0, -1);
+        }
+        if (idxNodes.length > 2)
+            lowerer.noLowering(`.write with ${nArgs} arguments`, call);
+        const encName = encNode ? bufEncoding(lowerer, "Buffer.write", encNode) : "utf8";
+        const s = lowerer.lowerExprExpecting(args[0], STRING);
+        const enc = { kind: "strLit", value: encName, type: STRING, loc };
+        const offset = idxNodes[0]
+            ? 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);
+        return { kind: "bytesIntrinsic", method: "writeStr", receiver, args: writeArgs, type: F64, loc };
+    }
+    return null;
+}
+/** The DataView getter surface by source name. `le` marks the multi-byte
+ * kinds whose lib signature declares the optional littleEndian parameter
+ * (the 8-bit getters take none). The Big pair only compiles composed
+ * inside Number(...) — see the use site. */
+const DV_GETTERS = {
+    getUint8: { method: "dvGetUint8", le: false },
+    getInt8: { method: "dvGetInt8", le: false },
+    getUint16: { method: "dvGetUint16", le: true },
+    getInt16: { method: "dvGetInt16", le: true },
+    getUint32: { method: "dvGetUint32", le: true },
+    getInt32: { method: "dvGetInt32", le: true },
+    getFloat32: { method: "dvGetFloat32", le: true },
+    getFloat64: { method: "dvGetFloat64", le: true },
+    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
+   * the callee isn't a Buffer-static access. */
+export function lowerBufferStaticCall(lowerer, call, access) {
+    if (call.questionDotToken || access.questionDotToken)
+        return null;
+    if (!lowerer.isStdlibGlobal(access.expression, "Buffer"))
+        return null;
+    const member = access.name.text;
+    const loc = locOf(call);
+    const args = call.arguments;
+    if (member === "from") {
+        // 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
+        // array — the DataView peel — and the construction rides the same
+        // dataViewNew intrinsic (offset/length validation throws Node's
+        // DataView-shaped RangeErrors; valid indices behave exactly).
+        if (args.length >= 1 && args.length <= 3 && !args.some(ts.isSpreadElement) &&
+            ts.isPropertyAccessExpression(args[0]) && args[0].name.text === "buffer") {
+            const srcNode = args[0].expression;
+            const srcIr = lowerer.mapTypeOf(lowerer.typeOf(srcNode));
+            if (srcIr?.kind === "bytes") {
+                const receiver = lowerer.lowerExpr(srcNode);
+                const idxArgs = args.slice(1).map((a) => lowerer.lowerExprExpecting(a, F64));
+                return { kind: "bytesIntrinsic", method: "dataViewNew", receiver, args: idxArgs, type: BYTES_U8, loc };
+            }
+        }
+        if (args.length >= 1 && args.length <= 2 && !ts.isSpreadElement(args[0])) {
+            const argNode = args[0];
+            if (ts.isArrayLiteralExpression(argNode) && !argNode.elements.some(ts.isSpreadElement)) {
+                // A number[] literal (contextually typed by the lib's readonly
+                // number[] slot — build it element-wise, the Set-seed pattern).
+                if (args.length === 1) {
+                    const elems = argNode.elements.map((el) => lowerer.lowerExprExpecting(el, F64));
+                    const seed = { kind: "arrayLit", elems, type: arrayOf(F64), loc };
+                    return { kind: "bytesNew", source: seed, type: BYTES_U8, loc };
+                }
+            }
+            else {
+                const srcIr = lowerer.mapTypeOf(lowerer.typeOf(argNode));
+                if (srcIr?.kind === "string") {
+                    const encNode = args[1];
+                    const encName = encNode ? bufEncoding(lowerer, "Buffer.from", encNode) : "utf8";
+                    const s = lowerer.lowerExprExpecting(argNode, 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 };
+                }
+                if (args.length === 1 && srcIr?.kind === "array" && srcIr.elem.kind === "f64") {
+                    return { kind: "bytesNew", source: lowerer.lowerExpr(argNode), 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)");
+    }
+    if (member === "alloc" || member === "allocUnsafe") {
+        const maxArgs = member === "alloc" ? 3 : 1;
+        if (args.length < 1 || args.length > maxArgs || args.some(ts.isSpreadElement)) {
+            lowerer.noLowering(`Buffer.${member} with ${args.length} arguments`, call);
+        }
+        // allocUnsafe's contents are UNSPECIFIED in Node (uninitialized pool
+        // memory); a zero-filled buffer is a valid instance of unspecified,
+        // and the deterministic choice — a program observing the difference
+        // is depending on garbage.
+        const size = lowerer.lowerExprExpecting(args[0], F64);
+        const fresh = { kind: "bytesNew", source: size, type: BYTES_U8, loc };
+        if (args.length === 1)
+            return fresh;
+        // alloc(size, fill, encoding?): the fill semantics ARE fill()'s —
+        // the fresh buffer is the receiver of a whole-range fill.
+        const fillT = lowerer.mapTypeOf(lowerer.typeOf(args[1]));
+        if (fillT?.kind === "string") {
+            const encName = args[2] ? bufEncoding(lowerer, "Buffer.alloc", args[2]) : "utf8";
+            const s = lowerer.lowerExprExpecting(args[1], STRING);
+            const enc = { kind: "strLit", value: encName, type: STRING, loc };
+            return { kind: "bytesIntrinsic", method: "fillStr", receiver: fresh, args: [s, enc], type: BYTES_U8, loc };
+        }
+        if (args.length > 2) {
+            lowerer.noLowering("Buffer.alloc with an encoding on a non-string fill", args[2]);
+        }
+        if (fillT?.kind === "f64") {
+            const v = lowerer.lowerExprExpecting(args[1], F64);
+            return { kind: "bytesIntrinsic", method: "fillNum", receiver: fresh, args: [v], type: BYTES_U8, loc };
+        }
+        if (fillT?.kind === "bytes" && fillT.elem === "u8") {
+            const pattern = lowerer.lowerExpr(args[1]);
+            return { kind: "bytesIntrinsic", method: "fill", receiver: fresh, args: [pattern], type: BYTES_U8, loc };
+        }
+        lowerer.noLowering(`Buffer.alloc with a '${lowerer.checker.typeToString(lowerer.typeOf(args[1]))}' fill`, args[1], "number, string, and Buffer/Uint8Array fills are the lowered shapes");
+    }
+    if (member === "concat") {
+        if (args.length < 1 || args.length > 2 || args.some(ts.isSpreadElement)) {
+            lowerer.noLowering(`Buffer.concat with ${args.length} arguments`, call);
+        }
+        const argNode = args[0];
+        let list;
+        if (ts.isArrayLiteralExpression(argNode) && !argNode.elements.some(ts.isSpreadElement)) {
+            const elems = argNode.elements.map((el) => lowerer.lowerExprExpecting(el, BYTES_U8));
+            list = { kind: "arrayLit", elems, type: arrayOf(BYTES_U8), loc };
+        }
+        else {
+            list = lowerer.lowerExpr(argNode);
+            if (!typeEquals(list.type, arrayOf(BYTES_U8))) {
+                lowerer.noLowering(`Buffer.concat of '${lowerer.fmt(list.type)}' values`, argNode, "one Uint8Array[]/Buffer[] value (or literal) is the lowered list shape");
+            }
+        }
+        if (args.length === 2) {
+            // The totalLength form truncates or zero-pads (and THROWS Node's
+            // 'length' RangeError on bad totals).
+            const total = lowerer.lowerExprExpecting(args[1], F64);
+            return { kind: "libCall", fn: "buffer.concatLen", args: [list, total], type: BYTES_U8, loc };
+        }
+        return { kind: "libCall", fn: "buffer.concat", args: [list], type: BYTES_U8, loc };
+    }
+    if (member === "compare") {
+        // The static form: Buffer.compare(a, b) IS a.compare(b).
+        if (args.length !== 2 || args.some(ts.isSpreadElement)) {
+            lowerer.noLowering(`Buffer.compare with ${args.length} arguments`, call);
+        }
+        const sides = args.map((a) => lowerer.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" || lowerer.dynConvertible(v.type)) {
+                return { kind: "dynFrom", value: v, type: DYN, loc: v.loc };
+            }
+            lowerer.noLowering(`Buffer.compare of '${lowerer.fmt(v.type)}' values`, args[i], "Buffer/Uint8Array values compare (narrow unions first)");
+        });
+        return { kind: "libCall", fn: "buffer.compareChk", args: dyns, type: F64, loc };
+    }
+    if (member === "isBuffer") {
+        // The type-predicate narrowing test. Lowered where it DECIDES
+        // something: a union-typed argument with a Buffer arm becomes a
+        // runtime tag test (tsc's narrowing then types the branches, the
+        // discriminated-union machinery). Statically-decided arguments are
+        // fenced — the answer is a constant, and the operand's evaluation
+        // would have to be discarded.
+        if (args.length === 1 && !ts.isSpreadElement(args[0])) {
+            const v = lowerer.lowerExpr(args[0]);
+            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;
+                if (tag >= 0) {
+                    return { kind: "unionIsTag", unionId: v.type.unionId, tag, negated: false, value: v, type: BOOL, loc };
+                }
+            }
+            lowerer.noLowering(`Buffer.isBuffer of '${lowerer.fmt(v.type)}' values`, args[0], "the check lowers as a runtime tag test on unions with a Buffer arm — here the answer is static");
+        }
+        lowerer.noLowering("Buffer.isBuffer with this argument shape", call);
+    }
+    if (member === "byteLength") {
+        // Buffer.byteLength(string, enc?) — the UTF-16-aware per-encoding
+        // count — or of a typed array/Buffer (its byte length, a property
+        // read at heart).
+        if (args.length >= 1 && args.length <= 2 && !ts.isSpreadElement(args[0])) {
+            const srcIr = lowerer.mapTypeOf(lowerer.typeOf(args[0]));
+            if (srcIr?.kind === "string") {
+                const encName = args[1] ? bufEncoding(lowerer, "Buffer.byteLength", args[1]) : "utf8";
+                const s = lowerer.lowerExprExpecting(args[0], STRING);
+                const enc = { kind: "strLit", value: encName, type: STRING, loc };
+                return { kind: "libCall", fn: "buffer.byteLenStr", args: [s, enc], 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 };
+            }
+        }
+        lowerer.noLowering("Buffer.byteLength with this argument shape", call, "supported: Buffer.byteLength(string, literalEncoding?) or Buffer.byteLength(typedArray)");
+    }
+    if (member === "isEncoding") {
+        // The runtime alias-set test — a plain bool over any string value
+        // (Node's case-insensitive normalizeEncoding check).
+        if (args.length === 1 && !ts.isSpreadElement(args[0]) && lowerer.mapTypeOf(lowerer.typeOf(args[0]))?.kind === "string") {
+            const s = lowerer.lowerExprExpecting(args[0], STRING);
+            return { kind: "libCall", fn: "buffer.isEncoding", args: [s], type: BOOL, loc };
+        }
+        lowerer.noLowering("Buffer.isEncoding with this argument shape", call, "one string-typed argument is the lowered form");
+    }
+    return null; // of, copyBytesFrom, ... → the SC2020 member fence
+}
+//# sourceMappingURL=bytes.js.map