@scriptc/compiler 0.4.0 → 0.4.2

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

@@ -1,16 +1,21 @@
-import { dynUndefinedExpr, varRef } from "../../../ir/build.js";
+import { keyedHelperName } from "../stable-names.js";
+import { boolLit, dynUndefinedExpr, numLit, varRef } from "../../../ir/build.js";
 import { BUF_NUM_METHODS } from "./buffer-numeric-methods.js";
 import * as ts from "../../ts7/adapter.js";
 import { BIGINT_T, BOOL, BYTES_ELEMENT_NAME, BYTES_U8, DYN, F64, STRING, UNDEFINED_T, VOID, arrayOf, bytesOf, funcOf, isUnitType, typeEquals, } from "../../../ir/ir.js";
 import { isJsSourceFile, locOf } from "../../program.js";
+import { stdlibGlobalNameOf } from "../surfaces.js";
 import { newFnCtx, own } from "../lowerer.js";
 import { buildBytesSortFn, closureKeyOrder } 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 "./array-construction.js";
+import { lowerArraySpreadItems, lowerCheckedArrayFrom } from "./array-construction.js";
 import { lowerToNumberArgument } from "../lower-exprs.js";
 import { lowerBytesIteratorValue } from "../iterator-adapters.js";
+import { lowerArrayCallback } from "./callback-arguments.js";
+import { callbackSite, findPredicateOk, predicateToBoolean } from "./array-callbacks.js";
+import { typeKey } from "../../type-mapper.js";
 /** TypedArray.prototype.sort and toSorted. The receiver and comparator
  * expressions are evaluated before entering the helper (buildBytesSortFn).
  * The default order is numeric, so the comparator-less form sorts by value
@@ -30,7 +35,7 @@ function lowerBytesSortCall(lowerer, call, access, bytesT) {
         const cacheKey = `bytes.${method}:${bytesT.elem}:${key}`;
         let helper = lowerer.arrHofHelpers.get(cacheKey);
         if (!helper) {
-            helper = `%bytes.${method}.${lowerer.arrHofHelpers.size}`;
+            helper = keyedHelperName(lowerer, `%bytes.${method}`, cacheKey);
             lowerer.arrHofHelpers.set(cacheKey, helper);
             lowerer.liftedFns.push(buildBytesSortFn(helper, bytesT, arity, hasComparator, copyFirst, order, loc));
         }
@@ -90,7 +95,7 @@ function lowerBytesSortCall(lowerer, call, access, bytesT) {
     }
     const arity = fnArg.type.params.length;
     const keyed = closureKeyOrder(lowerer.liftedFns, fnArg);
-    const order = keyed !== null && keyed.read === null ? keyed.order : null;
+    const order = keyed?.length === 1 && keyed[0].read === null ? keyed[0].order : null;
     const helper = helperFor(`${arity}${order === null ? "" : `:keyed${order}`}`, arity, true, order);
     return {
         kind: "call",
@@ -100,6 +105,355 @@ function lowerBytesSortCall(lowerer, call, access, bytesT) {
         loc,
     };
 }
+const BYTES_CALLBACK_METHODS = new Set([
+    "forEach",
+    "map",
+    "filter",
+    "some",
+    "every",
+    "find",
+    "findIndex",
+    "findLast",
+    "findLastIndex",
+    "reduce",
+    "reduceRight",
+]);
+/** The typed-array callback methods (forEach, map, filter, some, every,
+ * find, findIndex, findLast, findLastIndex, reduce, reduceRight). The
+ * receiver, the callback and reduce's initial value evaluate in order
+ * before the helper runs. The helper reads the length once (typed arrays
+ * have no holes) and each element when it visits it, so the callback's
+ * writes show in later elements. The callback receives the element, its
+ * index and the typed array (reduce's receive the accumulator first). map
+ * and filter return a new typed array of the receiver's kind; map stores
+ * each result with the element conversion of that kind. A thisArg keeps
+ * the fence, as for arrays. */
+function lowerBytesCallbackCall(lowerer, call, access, method, bytesT) {
+    const loc = locOf(call);
+    const nArgs = call.arguments.nodes.length;
+    const reduce = method === "reduce" || method === "reduceRight";
+    if (nArgs < 1 || nArgs > (reduce ? 2 : 1) || call.arguments.nodes.some(ts.isSpreadElement)) {
+        lowerer.noLowering(`.${method} with ${nArgs} arguments on ${BYTES_ELEMENT_NAME[bytesT.elem]}`, call, reduce ? undefined : "the thisArg parameter has no lowering — use an arrow function");
+    }
+    const argNode = call.arguments.nodes[0];
+    const hasInit = reduce && nArgs === 2;
+    const accT = reduce ? (hasInit ? lowerer.irTypeOf(call) : F64) : null;
+    if (accT !== null && (accT.kind === "void" || accT.kind === "func"))
+        lowerer.badType(call, lowerer.typeOf(call));
+    const receiver = lowerer.lowerExprExpecting(access.expression, bytesT);
+    const { fnArg, arity } = lowerArrayCallback(lowerer, argNode, accT !== null ? [accT, F64] : [F64], bytesT, false, accT ?? undefined);
+    const fnRet = fnArg.type.ret;
+    const predicate = method === "filter" ||
+        method === "some" ||
+        method === "every" ||
+        method === "find" ||
+        method === "findIndex" ||
+        method === "findLast" ||
+        method === "findLastIndex";
+    if (predicate && !findPredicateOk(lowerer, fnRet))
+        lowerer.badType(argNode, lowerer.typeOf(argNode));
+    if (method === "map" && !lowerer.coercibleValue(F64, fnRet))
+        lowerer.badType(argNode, lowerer.typeOf(argNode));
+    const resultT = accT ??
+        (method === "forEach"
+            ? VOID
+            : method === "map" || method === "filter"
+                ? bytesT
+                : method === "some" || method === "every"
+                    ? BOOL
+                    : method === "findIndex" || method === "findLastIndex"
+                        ? F64
+                        : lowerer.irTypeOf(call));
+    const helper = bytesCallbackHelper(lowerer, method, bytesT, resultT, fnRet, arity, hasInit, loc, callbackSite(fnArg));
+    const args = [receiver, fnArg];
+    if (hasInit)
+        args.push(lowerer.lowerExprExpecting(call.arguments.nodes[1], resultT));
+    return { kind: "call", callee: helper, args, type: resultT, loc };
+}
+/** The interned helper of one typed-array callback method shape. A literal
+ * callback gets a helper of its own (`site`), which the backend then calls
+ * directly, as for the array methods. The visit is a loop on its own
+ * counter (`for (let i = 0; i < a.length; i++)`, or down from the last
+ * index), so the counter is an integer and the element reads need no
+ * index test. */
+function bytesCallbackHelper(lowerer, method, bytesT, resultT, fnRet, arity, hasInit, loc, site) {
+    const key = `bytes.${method}:${bytesT.elem}:${typeKey(resultT)}:${typeKey(fnRet)}:${arity}:${hasInit ? "init" : ""}${site}`;
+    const existing = lowerer.arrHofHelpers.get(key);
+    if (existing)
+        return existing;
+    const name = keyedHelperName(lowerer, `%bytes.${method}`, key);
+    lowerer.arrHofHelpers.set(key, name);
+    const reduce = method === "reduce" || method === "reduceRight";
+    const backward = method === "reduceRight" || method === "findLast" || method === "findLastIndex";
+    const fnT = funcOf((reduce ? [resultT, F64, F64, bytesT] : [F64, F64, bytesT]).slice(0, arity), fnRet);
+    const keptT = arrayOf(F64);
+    const a = () => varRef("a.0", bytesT, loc);
+    const i = () => varRef("i.0", F64, loc);
+    const n = () => varRef("n.0", F64, loc);
+    const acc = () => varRef("acc.0", resultT, loc);
+    const element = () => varRef("v.0", F64, loc);
+    const at = (index) => ({
+        kind: "bytesIntrinsic",
+        method: "get",
+        receiver: a(),
+        args: [index],
+        type: F64,
+        loc,
+    });
+    const callback = () => ({
+        kind: "callValue",
+        callee: varRef("f.0", fnT, loc),
+        args: (reduce ? [acc(), element(), i(), a()] : [element(), i(), a()]).slice(0, arity),
+        type: fnRet,
+        loc,
+    });
+    // The forward bound is the receiver's length itself (fixed for a typed
+    // array, and equal to `n`), which the emitter's typed-array loops use.
+    const length = () => ({
+        kind: "bytesIntrinsic",
+        method: "length",
+        receiver: a(),
+        args: [],
+        type: F64,
+        loc,
+    });
+    const inRange = () => backward
+        ? { kind: "bin", op: ">=", left: i(), right: numLit(0, loc), type: BOOL, loc }
+        : { kind: "bin", op: "<", left: i(), right: length(), type: BOOL, loc };
+    const advance = () => ({
+        kind: "assign",
+        localId: "i.0",
+        value: {
+            kind: "bin",
+            op: backward ? "-" : "+",
+            left: i(),
+            right: numLit(1, loc),
+            type: F64,
+            loc,
+        },
+        loc,
+    });
+    const ret = (value) => ({ kind: "return", value, loc });
+    // map and filter of a Buffer return a Buffer (Node's species).
+    const copyBrand = (out) => ({
+        kind: "exprStmt",
+        expr: { kind: "libCall", fn: "bytes.copyBrand", args: [out, a()], type: VOID, loc },
+        loc,
+    });
+    const locals = [
+        { id: "a.0", name: "a", type: bytesT, mutable: true },
+        { id: "f.0", name: "f", type: fnT, mutable: true },
+        ...(hasInit ? [{ id: "z.0", name: "z", type: resultT, mutable: true }] : []),
+        ...(reduce || method === "map" || method === "filter"
+            ? [{ id: "acc.0", name: "acc", type: resultT, mutable: true }]
+            : []),
+        ...(method === "filter"
+            ? [{ id: "kept.0", name: "kept", type: keptT, mutable: true }]
+            : []),
+        { id: "n.0", name: "n", type: F64, mutable: false },
+        { id: "i.0", name: "i", type: F64, mutable: true },
+        { id: "v.0", name: "v", type: F64, mutable: true },
+    ];
+    const params = [
+        { localId: "a.0", name: "a", type: bytesT },
+        { localId: "f.0", name: "f", type: fnT },
+        ...(hasInit ? [{ localId: "z.0", name: "z", type: resultT }] : []),
+    ];
+    const visit = [{ kind: "assign", localId: "v.0", value: at(i()), loc }];
+    let seeded = false;
+    const prologue = [];
+    let epilogue;
+    switch (method) {
+        case "forEach":
+            visit.push({ kind: "exprStmt", expr: callback(), loc });
+            epilogue = [ret(null)];
+            break;
+        case "map":
+            prologue.push({
+                kind: "varDecl",
+                localId: "acc.0",
+                init: { kind: "bytesNew", source: n(), type: bytesT, loc },
+                loc,
+            });
+            visit.push({
+                kind: "bytesSet",
+                arr: acc(),
+                index: i(),
+                value: lowerer.coerceToExpected(callback(), F64),
+                loc,
+            });
+            if (bytesT.elem === "u8")
+                prologue.push(copyBrand(acc()));
+            epilogue = [ret(acc())];
+            break;
+        case "filter":
+            prologue.push({
+                kind: "varDecl",
+                localId: "kept.0",
+                init: { kind: "arrayLit", elems: [], type: keptT, loc },
+                loc,
+            });
+            visit.push({
+                kind: "if",
+                cond: predicateToBoolean(callback()),
+                then: [
+                    {
+                        kind: "exprStmt",
+                        expr: {
+                            kind: "arrIntrinsic",
+                            method: "push",
+                            receiver: varRef("kept.0", keptT, loc),
+                            args: [element()],
+                            type: F64,
+                            loc,
+                        },
+                        loc,
+                    },
+                ],
+                else_: null,
+                loc,
+            });
+            epilogue = [
+                {
+                    kind: "varDecl",
+                    localId: "acc.0",
+                    init: { kind: "bytesNew", source: varRef("kept.0", keptT, loc), type: bytesT, loc },
+                    loc,
+                },
+                ...(bytesT.elem === "u8" ? [copyBrand(acc())] : []),
+                ret(acc()),
+            ];
+            break;
+        case "some":
+        case "every": {
+            const found = method === "some";
+            const test = predicateToBoolean(callback());
+            visit.push({
+                kind: "if",
+                cond: found ? test : { kind: "unary", op: "!", operand: test, type: BOOL, loc },
+                then: [ret(boolLit(found, loc))],
+                else_: null,
+                loc,
+            });
+            epilogue = [ret(boolLit(!found, loc))];
+            break;
+        }
+        case "find":
+        case "findLast":
+            visit.push({
+                kind: "if",
+                cond: predicateToBoolean(callback()),
+                then: [ret(lowerer.coerceToExpected(element(), resultT))],
+                else_: null,
+                loc,
+            });
+            epilogue = [
+                ret(lowerer.coerceToExpected({ kind: "unitLit", unit: "undefined", type: UNDEFINED_T, loc }, resultT)),
+            ];
+            break;
+        case "findIndex":
+        case "findLastIndex":
+            visit.push({
+                kind: "if",
+                cond: predicateToBoolean(callback()),
+                then: [ret(i())],
+                else_: null,
+                loc,
+            });
+            epilogue = [ret(numLit(-1, loc))];
+            break;
+        case "reduce":
+        case "reduceRight":
+            if (hasInit) {
+                prologue.push({
+                    kind: "varDecl",
+                    localId: "acc.0",
+                    init: varRef("z.0", resultT, loc),
+                    loc,
+                });
+            }
+            else {
+                // The seed is the first visited element; the loop starts past it.
+                seeded = true;
+                prologue.push({
+                    kind: "if",
+                    cond: { kind: "bin", op: "===", left: n(), right: numLit(0, loc), type: BOOL, loc },
+                    then: [
+                        {
+                            kind: "throw",
+                            value: {
+                                kind: "libCall",
+                                fn: "error.new",
+                                args: [
+                                    {
+                                        kind: "strLit",
+                                        value: "Reduce of empty array with no initial value",
+                                        type: STRING,
+                                        loc,
+                                    },
+                                ],
+                                type: { kind: "object", className: "%TypeError" },
+                                loc,
+                            },
+                            loc,
+                        },
+                    ],
+                    else_: null,
+                    loc,
+                }, {
+                    kind: "varDecl",
+                    localId: "acc.0",
+                    init: at(backward
+                        ? { kind: "bin", op: "-", left: n(), right: numLit(1, loc), type: F64, loc }
+                        : numLit(0, loc)),
+                    loc,
+                });
+            }
+            visit.push({
+                kind: "assign",
+                localId: "acc.0",
+                value: lowerer.coerceToExpected(callback(), resultT),
+                loc,
+            });
+            epilogue = [ret(acc())];
+            break;
+    }
+    const body = [
+        {
+            kind: "varDecl",
+            localId: "n.0",
+            init: { kind: "bytesIntrinsic", method: "length", receiver: a(), args: [], type: F64, loc },
+            loc,
+        },
+        { kind: "varDecl", localId: "v.0", init: numLit(0, loc), loc },
+        ...prologue,
+        {
+            kind: "for",
+            init: {
+                kind: "varDecl",
+                localId: "i.0",
+                init: backward
+                    ? {
+                        kind: "bin",
+                        op: "-",
+                        left: n(),
+                        right: numLit(seeded ? 2 : 1, loc),
+                        type: F64,
+                        loc,
+                    }
+                    : numLit(seeded ? 1 : 0, loc),
+                loc,
+            },
+            cond: inRange(),
+            update: advance(),
+            body: visit,
+            loc,
+        },
+        ...epilogue,
+    ];
+    lowerer.liftedFns.push({ name, params, returnType: resultT, locals, body, loc });
+    return name;
+}
 /* ── typed arrays / Buffer ─────────────────────────────────────────────── */
 /** The typed-array constructors with a runtime representation, by lib
  * interface name. Other flavors (BigInt64Array, BigUint64Array) fall through
@@ -193,7 +547,7 @@ export function lowerBytesNew(lowerer, expr, symbol) {
     }
     lowerer.noLowering(`new ${name} with ${args.length} arguments`, expr, `supported: new ${name}(), (length), (typedArray), or (number[])`);
 }
-/** TypedArray.from without a mapping callback. Preserve its iterable /
+/** TypedArray.from and TypedArray.of. Preserve from's iterable /
  * array-like semantics separately from constructor length coercion. */
 export function lowerBytesStaticCall(lowerer, call, access) {
     if (lowerer.chainBlocked(call, access))
@@ -210,12 +564,15 @@ export function lowerBytesStaticCall(lowerer, call, access) {
             loc: locOf(call),
         };
     }
-    if (access.name.text !== "from" || !ts.isIdentifier(access.expression))
+    if ((access.name.text !== "from" && access.name.text !== "of") ||
+        !ts.isIdentifier(access.expression))
         return null;
     const symbol = lowerer.resolveValueSymbol(access.expression);
     const elem = symbol ? own(BYTES_CTORS, ts.symbolName(symbol)) : undefined;
     if (!elem || !lowerer.isStdlibSymbol(symbol ?? undefined))
         return null;
+    if (access.name.text === "of")
+        return lowerBytesOf(lowerer, call, elem);
     if (call.arguments.nodes.length < 1 ||
         call.arguments.nodes.length > 3 ||
         call.arguments.nodes.some(ts.isSpreadElement)) {
@@ -291,6 +648,51 @@ export function lowerBytesStaticCall(lowerer, call, access) {
         loc: locOf(call),
     };
 }
+/** TypedArray.of: a new array of the arguments, each converted with ToNumber
+ * in argument order after all of them are evaluated. Numbers copy directly;
+ * other values (and spread items) collect into an array that goes through
+ * TypedArray.from's conversion, which calls valueOf/toString the same way. */
+function lowerBytesOf(lowerer, call, elem) {
+    const loc = locOf(call);
+    const nodes = call.arguments.nodes;
+    const type = bytesOf(elem);
+    if (nodes.some(ts.isSpreadElement)) {
+        const numeric = nodes.every((node) => {
+            const mapped = lowerer.mapTypeOf(lowerer.typeOf(ts.isSpreadElement(node) ? node.expression : node));
+            return ts.isSpreadElement(node)
+                ? mapped?.kind === "array" && mapped.elem.kind === "f64"
+                : mapped?.kind === "f64";
+        });
+        const elemType = numeric ? F64 : DYN;
+        const items = lowerArraySpreadItems(lowerer, nodes, elemType, { kind: "array", elem: elemType }, loc);
+        if (numeric)
+            return { kind: "bytesNew", source: items, type, loc };
+        return {
+            kind: "bytesNew",
+            source: lowerer.coerceToExpected(items, DYN),
+            from: true,
+            type,
+            loc,
+        };
+    }
+    const values = nodes.map((node) => lowerer.lowerExpr(node));
+    if (values.every((value) => value.type.kind === "f64")) {
+        return {
+            kind: "bytesNew",
+            source: { kind: "arrayLit", elems: values, type: arrayOf(F64), loc },
+            type,
+            loc,
+        };
+    }
+    const elems = values.map((value, i) => lowerer.coerceInto(nodes[i], value, DYN));
+    return {
+        kind: "bytesNew",
+        source: lowerer.coerceToExpected({ kind: "arrayLit", elems, type: arrayOf(DYN), loc }, DYN),
+        from: true,
+        type,
+        loc,
+    };
+}
 /** Construct a view over the complete branded backing allocation. */
 function lowerArrayBufferView(lowerer, args, elem, loc) {
     const values = [0, 1, 2].map((index) => {
@@ -365,6 +767,9 @@ export function lowerBytesMethodCall(lowerer, call, access) {
     if (name === "sort" || name === "toSorted") {
         return lowerBytesSortCall(lowerer, call, access, receiverIr);
     }
+    if (BYTES_CALLBACK_METHODS.has(name)) {
+        return lowerBytesCallbackCall(lowerer, call, access, name, receiverIr);
+    }
     // values()/keys()/entries() as iterator objects (for...of heads and
     // stored numeric iterators lower before this).
     if ((name === "values" || name === "keys" || name === "entries") && nArgs === 0) {
@@ -521,8 +926,15 @@ export function lowerBytesMethodCall(lowerer, call, access) {
         // Array-toString (comma join), a different operation: fenced.
         const declaredOnBuffer = (() => {
             const nameSym = lowerer.checker.getSymbolAtLocation(access.name);
-            return (nameSym !== undefined &&
-                nameSym.declarations.some((d) => ts.isInterfaceDeclaration(d.parent) && d.parent.name.text === "Buffer"));
+            if (nameSym !== undefined &&
+                nameSym.declarations.some((d) => ts.isInterfaceDeclaration(d.parent) && d.parent.name.text === "Buffer"))
+                return true;
+            // A receiver the lowering types as a Buffer where the checker says
+            // `any` (a JavaScript pipeline stage's chunk).
+            const receiverSym = lowerer.typeOf(access.expression).getSymbol();
+            return (receiverSym !== undefined &&
+                ts.symbolName(receiverSym) === "Buffer" &&
+                receiverSym.declarations.some((d) => lowerer.isStdlibFile(ts.getSourceFileOfNode(d))));
         })();
         if (receiverIr.elem !== "u8" || !declaredOnBuffer) {
             lowerer.noLowering("typed-array toString", call, 'Buffer.from(x).toString("utf8" | "hex" | "base64") is the lowered string conversion');
@@ -950,6 +1362,9 @@ function lowerBufferInstanceMethod(lowerer, call, access, name, loc) {
         }
         else if (vT?.kind === "bytes" && vT.elem === "u8") {
             needle = lowerer.lowerExpr(args[0]);
+            // A Buffer needle under utf16le also searches whole 2-byte units.
+            if (encName === "utf16le")
+                align = 2;
         }
         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)");
@@ -1144,6 +1559,161 @@ function knownBufferProducer(lowerer, source, seen = new Set()) {
     const type = lowerer.mapTypeOf(lowerer.typeOf(callee.expression));
     return type?.kind === "cryptoHash" || type?.kind === "cryptoHmac";
 }
+/** Buffer.from over a checked-dynamic source and encoding, both already in
+ * repeatable locals: Node's fromString takes utf8 for an absent, non-string
+ * or empty encoding and throws ERR_UNKNOWN_ENCODING for an unknown name; an
+ * ArrayBuffer takes the second argument as its byte offset; other sources
+ * ignore it. */
+function dynBufferFromParts(source, encoding, loc) {
+    const utf8 = { kind: "strLit", value: "utf8", type: STRING, loc };
+    const isString = (x) => ({
+        kind: "dynTest",
+        test: "string",
+        value: x,
+        type: BOOL,
+        loc,
+    });
+    const name = {
+        kind: "ternary",
+        cond: {
+            kind: "logical",
+            op: "&&",
+            left: isString(encoding),
+            right: {
+                kind: "strEq",
+                negated: true,
+                left: { kind: "dynCheck", value: encoding, type: STRING, loc },
+                right: { kind: "strLit", value: "", type: STRING, loc },
+                type: BOOL,
+                loc,
+            },
+            type: BOOL,
+            loc,
+        },
+        then: { kind: "dynCheck", value: encoding, type: STRING, loc },
+        else_: utf8,
+        type: STRING,
+        loc,
+    };
+    return {
+        kind: "ternary",
+        cond: isString(source),
+        then: {
+            kind: "libCall",
+            fn: "buffer.poolFromStrChecked",
+            args: [{ kind: "dynCheck", value: source, type: STRING, loc }, name],
+            type: BYTES_U8,
+            loc,
+        },
+        // An ArrayBuffer takes the second argument as its byte offset
+        // (scr_buffer_from_dyn_offset_pooled); other values convert with utf8.
+        else_: {
+            kind: "libCall",
+            fn: "buffer.poolFromDynOffset",
+            args: [source, encoding],
+            type: BYTES_U8,
+            loc,
+        },
+        type: BYTES_U8,
+        loc,
+    };
+}
+/** Lowers `source` and `encNode` (or undefined) into hidden dyn locals, in
+ * source order, and builds the result from their references. */
+function withDynBufferArguments(lowerer, source, encNode, loc, build) {
+    const v = lowerer.declareHiddenLocal("%bufferValue", DYN);
+    const e = lowerer.declareHiddenLocal("%bufferEncoding", DYN);
+    const result = build(varRef(v.id, DYN, loc), varRef(e.id, DYN, loc));
+    return {
+        kind: "seqExpr",
+        stmts: [
+            { kind: "varDecl", localId: v.id, init: lowerer.coerceToExpected(source, DYN), loc },
+            {
+                kind: "varDecl",
+                localId: e.id,
+                init: encNode === undefined
+                    ? dynUndefinedExpr(loc)
+                    : lowerer.coerceToExpected(lowerer.lowerExpr(encNode), DYN),
+                loc,
+            },
+        ],
+        result,
+        type: result.type,
+        loc,
+    };
+}
+/** Buffer.from(value, encoding) over a checked-dynamic value whose encoding
+ * is not a literal: yazl forwards its `encoding` parameter, often undefined.
+ * Null when the encoding is absent or a literal. */
+function dynBufferFromRuntimeEncoding(lowerer, value, encNode, loc) {
+    if (encNode === undefined || lowerer.typeOf(encNode).isStringLiteralType())
+        return null;
+    return withDynBufferArguments(lowerer, value, encNode, loc, (source, encoding) => dynBufferFromParts(source, encoding, loc));
+}
+/** The deprecated `new Buffer(arg[, encoding])` in a dependency's
+ * JavaScript, through the global or an alias of it (buffer-crc32 and yazl
+ * keep it as the fallback for runtimes without Buffer.alloc/Buffer.from).
+ * Node never emits DEP0005 for calls from node_modules, so the construction
+ * is exactly Node's: a number allocates zero-filled bytes (and throws
+ * ERR_INVALID_ARG_TYPE beside a string second argument), anything else
+ * converts as Buffer.from does. Null elsewhere: other callers owe the
+ * deprecation warning. */
+export function lowerNodeModulesBufferConstruct(lowerer, expr) {
+    const sf = expr.getSourceFile();
+    if (!isJsSourceFile(sf) || !/[\\/]node_modules[\\/]/.test(sf.fileName))
+        return null;
+    const args = expr.arguments?.nodes ?? [];
+    if (args.length < 1 || args.length > 2 || args.some(ts.isSpreadElement))
+        return null;
+    if (stdlibGlobalNameOf(lowerer, expr.expression) !== "Buffer")
+        return null;
+    const loc = locOf(expr);
+    const value = withDynBufferArguments(lowerer, lowerer.lowerExpr(args[0]), args[1], loc, (source, encoding) => ({
+        kind: "ternary",
+        cond: { kind: "dynTest", test: "number", value: source, type: BOOL, loc },
+        then: {
+            kind: "ternary",
+            cond: { kind: "dynTest", test: "string", value: encoding, type: BOOL, loc },
+            then: { kind: "libCall", fn: "buffer.newStringFail", args: [source], type: BYTES_U8, loc },
+            else_: {
+                kind: "libCall",
+                fn: "buffer.alloc",
+                args: [{ kind: "dynCheck", value: source, type: F64, loc }],
+                type: BYTES_U8,
+                loc,
+            },
+            type: BYTES_U8,
+            loc,
+        },
+        else_: dynBufferFromParts(source, encoding, loc),
+        type: BYTES_U8,
+        loc,
+    }));
+    return { kind: "libCall", fn: "buffer.brand", args: [value], type: BYTES_U8, loc };
+}
+/** Buffer.from(array or bytes, extra): Node copies an array-like source and
+ * ignores the encoding/offset argument (yazl passes its `encoding` through
+ * unchanged), but JavaScript still evaluates it after the source. */
+function withIgnoredBufferArgument(lowerer, extraNode, source, build) {
+    if (extraNode === undefined)
+        return build(source);
+    const extra = lowerer.lowerExpr(extraNode);
+    if (isSafeToDiscard(extra))
+        return build(source);
+    const loc = source.loc;
+    const tmp = lowerer.declareHiddenLocal("%bufferSource", source.type);
+    const result = build(varRef(tmp.id, source.type, loc));
+    return {
+        kind: "seqExpr",
+        stmts: [
+            { kind: "varDecl", localId: tmp.id, init: source, loc },
+            { kind: "exprStmt", expr: extra, loc },
+        ],
+        result,
+        type: result.type,
+        loc,
+    };
+}
 export function lowerBufferStaticCall(lowerer, call, access) {
     const value = lowerBufferStaticValue(lowerer, call, access);
     // Every byte-valued Buffer factory creates a distinct view. Preserve its
@@ -1182,7 +1752,8 @@ function lowerBufferStaticValue(lowerer, call, access) {
             const srcNode = args[0].expression;
             const srcIr = lowerer.mapTypeOf(lowerer.typeOf(srcNode));
             if (srcIr?.kind === "bytes") {
-                const receiver = lowerer.lowerExpr(srcNode);
+                // A JavaScript field can hold the typed array as a dynamic value.
+                const receiver = lowerer.lowerExprExpecting(srcNode, srcIr);
                 const idxArgs = args.slice(1).map((a) => lowerer.lowerExprExpecting(a, F64));
                 return {
                     kind: "bytesIntrinsic",
@@ -1200,11 +1771,15 @@ function lowerBufferStaticValue(lowerer, call, access) {
                 !argNode.elements.nodes.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.nodes.map((el) => lowerer.lowerExprExpecting(el, F64));
-                    const seed = { kind: "arrayLit", elems, type: arrayOf(F64), loc };
-                    return { kind: "libCall", fn: "buffer.poolFromArray", args: [seed], type: BYTES_U8, loc };
-                }
+                const elems = argNode.elements.nodes.map((el) => lowerer.lowerExprExpecting(el, F64));
+                const seed = { kind: "arrayLit", elems, type: arrayOf(F64), loc };
+                return withIgnoredBufferArgument(lowerer, args[1], seed, (array) => ({
+                    kind: "libCall",
+                    fn: "buffer.poolFromArray",
+                    args: [array],
+                    type: BYTES_U8,
+                    loc,
+                }));
             }
             else {
                 const srcIr = lowerer.mapTypeOf(lowerer.typeOf(argNode));
@@ -1212,6 +1787,9 @@ function lowerBufferStaticValue(lowerer, call, access) {
                 // 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 runtimeEncoding = dynBufferFromRuntimeEncoding(lowerer, value, args[1], loc);
+                    if (runtimeEncoding)
+                        return runtimeEncoding;
                     const encName = args[1] ? bufEncoding(lowerer, "Buffer.from", args[1]) : "utf8";
                     const enc = { kind: "strLit", value: encName, type: STRING, loc };
                     return {
@@ -1256,25 +1834,24 @@ function lowerBufferStaticValue(lowerer, call, access) {
                 // A checker type with no mapping (pako's conditional `O extends
                 // { toText: true } ? string : Uint8Array` result) whose lowered
                 // value is a u8 view copies like the typed form.
-                if (args.length === 1 &&
-                    ((srcIr?.kind === "bytes" && srcIr.elem === "u8") ||
-                        (srcIr === null && value.type.kind === "bytes" && value.type.elem === "u8"))) {
-                    return {
+                if ((srcIr?.kind === "bytes" && srcIr.elem === "u8") ||
+                    (srcIr === null && value.type.kind === "bytes" && value.type.elem === "u8")) {
+                    return withIgnoredBufferArgument(lowerer, args[1], value, (bytes) => ({
                         kind: "libCall",
                         fn: "buffer.poolFromBytes",
-                        args: [value],
+                        args: [bytes],
                         type: BYTES_U8,
                         loc,
-                    };
+                    }));
                 }
-                if (args.length === 1 && srcIr?.kind === "array" && srcIr.elem.kind === "f64") {
-                    return {
+                if (srcIr?.kind === "array" && srcIr.elem.kind === "f64") {
+                    return withIgnoredBufferArgument(lowerer, args[1], value, (array) => ({
                         kind: "libCall",
                         fn: "buffer.poolFromArray",
-                        args: [value],
+                        args: [array],
                         type: BYTES_U8,
                         loc,
-                    };
+                    }));
                 }
                 // A union of strings, u8 views and undefined/null (a JS-inferred
                 // npm result such as pako's deflate): the checked form dispatches