@scriptc/compiler 0.3.6 → 0.4.1

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

@@ -1,8 +1,9 @@
-import { dynUndefinedExpr, varRef } from "../../../ir/build.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, typeEquals, } from "../../../ir/ir.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";
@@ -10,6 +11,10 @@ import { lowerDynObjectLiteral } from "../expressions/object-literals.js";
 import { defaultAfterUndefined, lowerOptionalArgument, lowerStaticallyUndefinedArgument, } from "../optional-arguments.js";
 import { lowerCheckedArrayFrom } from "./array-construction.js";
 import { lowerToNumberArgument } from "../lower-exprs.js";
+import { lowerBytesIteratorValue } from "../iterator-adapters.js";
+import { lowerArrayCallback } from "./callback-arguments.js";
+import { 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
@@ -18,12 +23,12 @@ function lowerBytesSortCall(lowerer, call, access, bytesT) {
     const loc = locOf(call);
     const method = access.name.text;
     const copyFirst = method === "toSorted";
-    if (call.arguments.length > 1 || call.arguments.some(ts.isSpreadElement)) {
-        lowerer.noLowering(`.${method} with ${call.arguments.length} arguments on ${BYTES_ELEMENT_NAME[bytesT.elem]}`, call);
+    if (call.arguments.nodes.length > 1 || call.arguments.nodes.some(ts.isSpreadElement)) {
+        lowerer.noLowering(`.${method} with ${call.arguments.nodes.length} arguments on ${BYTES_ELEMENT_NAME[bytesT.elem]}`, call);
     }
     const receiver = lowerer.lowerExprExpecting(access.expression, bytesT);
-    const undefinedArg = call.arguments[0]
-        ? lowerStaticallyUndefinedArgument(lowerer, call.arguments[0])
+    const undefinedArg = call.arguments.nodes[0]
+        ? lowerStaticallyUndefinedArgument(lowerer, call.arguments.nodes[0])
         : null;
     const helperFor = (key, arity, hasComparator, order) => {
         const cacheKey = `bytes.${method}:${bytesT.elem}:${key}`;
@@ -35,7 +40,7 @@ function lowerBytesSortCall(lowerer, call, access, bytesT) {
         }
         return helper;
     };
-    if (call.arguments.length === 0 || undefinedArg) {
+    if (call.arguments.nodes.length === 0 || undefinedArg) {
         const helper = helperFor("default", 0, false, null);
         if (!undefinedArg || isSafeToDiscard(undefinedArg)) {
             return { kind: "call", callee: helper, args: [receiver], type: bytesT, loc };
@@ -67,14 +72,14 @@ function lowerBytesSortCall(lowerer, call, access, bytesT) {
             loc,
         };
     }
-    const argNode = call.arguments[0];
+    const argNode = call.arguments.nodes[0];
     let fnArg = lowerer.lowerExpr(argNode);
     // As for Array sort: adapt a comparator over checked values to the
     // element ABI; arithmetic on inferred JS values still yields a number.
     if (fnArg.type.kind === "func" &&
         fnArg.type.params.length <= 2 &&
         fnArg.type.params.every((param) => lowerer.coercibleValue(F64, param))) {
-        const result = fnArg.type.ret.kind === "dyn" && isJsSourceFile(argNode.getSourceFile())
+        const result = fnArg.type.ret.kind === "dyn" && isJsSourceFile(ts.getSourceFileOfNode(argNode))
             ? F64
             : fnArg.type.ret;
         const expected = funcOf(fnArg.type.params.map(() => F64), result);
@@ -89,7 +94,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",
@@ -99,9 +104,320 @@ 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);
+    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. */
+function bytesCallbackHelper(lowerer, method, bytesT, resultT, fnRet, arity, hasInit, loc) {
+    const key = `bytes.${method}:${bytesT.elem}:${typeKey(resultT)}:${typeKey(fnRet)}:${arity}:${hasInit ? "init" : ""}`;
+    const existing = lowerer.arrHofHelpers.get(key);
+    if (existing)
+        return existing;
+    const name = `%bytes.${method}.${lowerer.arrHofHelpers.size}`;
+    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,
+    });
+    const inRange = () => backward
+        ? { kind: "bin", op: ">=", left: i(), right: numLit(0, loc), type: BOOL, loc }
+        : { kind: "bin", op: "<", left: i(), right: n(), 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 }];
+    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 {
+                prologue.push({
+                    kind: "if",
+                    cond: { kind: "unary", op: "!", operand: inRange(), 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(i()), loc }, advance());
+            }
+            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: "i.0",
+            init: backward
+                ? { kind: "bin", op: "-", left: n(), right: numLit(1, loc), type: F64, loc }
+                : numLit(0, loc),
+            loc,
+        },
+        { kind: "varDecl", localId: "v.0", init: numLit(0, loc), loc },
+        ...prologue,
+        { kind: "for", init: null, 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 (Float16Array, BigInt64Array, ...) fall through
+ * interface name. Other flavors (BigInt64Array, BigUint64Array) fall through
  * to the generic stdlib-constructor fence. DataView is handled separately. */
 const BYTES_CTORS = {
     Uint8Array: "u8",
@@ -111,6 +427,7 @@ const BYTES_CTORS = {
     Int16Array: "i16",
     Uint32Array: "u32",
     Int32Array: "i32",
+    Float16Array: "f16",
     Float32Array: "f32",
     Float64Array: "f64",
 };
@@ -128,9 +445,9 @@ const BYTES_CTORS = {
  * typed-array construction. */
 export function lowerBytesNew(lowerer, expr, symbol) {
     if (symbol != null &&
-        (symbol.name === "ArrayBuffer" || symbol.name === "SharedArrayBuffer") &&
+        (ts.symbolName(symbol) === "ArrayBuffer" || ts.symbolName(symbol) === "SharedArrayBuffer") &&
         lowerer.isStdlibSymbol(symbol)) {
-        const args = expr.arguments ?? [];
+        const args = expr.arguments?.nodes ?? [];
         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");
         }
@@ -139,22 +456,22 @@ export function lowerBytesNew(lowerer, expr, symbol) {
             : dynUndefinedExpr(locOf(expr));
         return {
             kind: "libCall",
-            fn: symbol.name === "SharedArrayBuffer" ? "sharedArrayBuffer.new" : "arrayBuffer.new",
+            fn: ts.symbolName(symbol) === "SharedArrayBuffer" ? "sharedArrayBuffer.new" : "arrayBuffer.new",
             args: [length],
             type: DYN,
             loc: locOf(expr),
         };
     }
-    if (symbol && symbol.name === "DataView" && lowerer.isStdlibSymbol(symbol)) {
+    if (symbol && ts.symbolName(symbol) === "DataView" && lowerer.isStdlibSymbol(symbol)) {
         return lowerDataViewNew(lowerer, expr);
     }
-    const elem = symbol ? own(BYTES_CTORS, symbol.name) : undefined;
+    const elem = symbol ? own(BYTES_CTORS, ts.symbolName(symbol)) : undefined;
     if (!elem || !symbol || !lowerer.isStdlibSymbol(symbol))
         return null;
-    const name = symbol.name;
+    const name = ts.symbolName(symbol);
     const type = bytesOf(elem);
     const loc = locOf(expr);
-    const args = expr.arguments ?? [];
+    const args = expr.arguments?.nodes ?? [];
     if (args.length === 0)
         return { kind: "bytesNew", source: null, type, loc };
     if (args.length >= 2 && args.length <= 3 && !args.some(ts.isSpreadElement)) {
@@ -162,8 +479,8 @@ export function lowerBytesNew(lowerer, expr, symbol) {
     }
     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));
+        if (ts.isArrayLiteralExpression(argNode) && !argNode.elements.nodes.some(ts.isSpreadElement)) {
+            const elems = argNode.elements.nodes.map((el) => lowerer.lowerExprExpecting(el, F64));
             const seed = { kind: "arrayLit", elems, type: arrayOf(F64), loc };
             return { kind: "bytesNew", source: seed, type, loc };
         }
@@ -197,9 +514,9 @@ 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))
+        if (call.arguments.nodes.length !== 1 || call.arguments.nodes.some(ts.isSpreadElement))
             lowerer.noLowering("ArrayBuffer.isView argument count", call);
-        const arg = call.arguments[0];
+        const arg = call.arguments.nodes[0];
         return {
             kind: "libCall",
             fn: "arrayBuffer.isView",
@@ -211,17 +528,17 @@ export function lowerBytesStaticCall(lowerer, call, access) {
     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;
+    const elem = symbol ? own(BYTES_CTORS, ts.symbolName(symbol)) : undefined;
     if (!elem || !lowerer.isStdlibSymbol(symbol ?? undefined))
         return null;
-    if (call.arguments.length < 1 ||
-        call.arguments.length > 3 ||
-        call.arguments.some(ts.isSpreadElement)) {
+    if (call.arguments.nodes.length < 1 ||
+        call.arguments.nodes.length > 3 ||
+        call.arguments.nodes.some(ts.isSpreadElement)) {
         lowerer.noLowering("TypedArray.from with this argument count", call);
     }
-    const node = call.arguments[0];
+    const node = call.arguments.nodes[0];
     const source = lowerer.lowerExpr(node);
-    if (call.arguments.length > 1) {
+    if (call.arguments.nodes.length > 1) {
         if (!["string", "array", "bytes"].includes(source.type.kind))
             lowerer.noLowering("TypedArray.from mapper over this source representation", call);
         const loc = locOf(call);
@@ -268,9 +585,9 @@ export function lowerBytesStaticCall(lowerer, call, access) {
             callee: key,
             args: [
                 lowerer.coerceInto(node, source, DYN),
-                lowerer.lowerExprExpecting(call.arguments[1], DYN),
-                call.arguments[2]
-                    ? lowerer.lowerExprExpecting(call.arguments[2], DYN)
+                lowerer.lowerExprExpecting(call.arguments.nodes[1], DYN),
+                call.arguments.nodes[2]
+                    ? lowerer.lowerExprExpecting(call.arguments.nodes[2], DYN)
                     : dynUndefinedExpr(loc),
             ],
             type: bytesOf(elem),
@@ -303,6 +620,7 @@ function lowerArrayBufferView(lowerer, args, elem, loc) {
         u8: "arrayBuffer.viewU8",
         u32: "arrayBuffer.viewU32",
         i32: "arrayBuffer.viewI32",
+        f16: "arrayBuffer.viewF16",
         f32: "arrayBuffer.viewF32",
         f64: "arrayBuffer.viewF64",
         dv: "arrayBuffer.viewDV",
@@ -316,7 +634,7 @@ function lowerArrayBufferView(lowerer, args, elem, loc) {
     };
 }
 function lowerDataViewNew(lowerer, expr) {
-    const args = expr.arguments ?? [];
+    const args = expr.arguments?.nodes ?? [];
     if (!args.length || args.length > 3 || args.some(ts.isSpreadElement))
         lowerer.noLowering("DataView constructor argument count", expr);
     return lowerArrayBufferView(lowerer, args, "dv", locOf(expr));
@@ -338,10 +656,10 @@ export function lowerBytesMethodCall(lowerer, call, access) {
     if (!lowerer.isStdlibMember(access))
         return null;
     const loc = locOf(call);
-    const nArgs = call.arguments.length;
+    const nArgs = call.arguments.nodes.length;
     // Encoded stream callbacks can receive strings even when JavaScript's
     // contextual inference still describes their parameter as a Buffer.
-    if (name === "toString" && nArgs <= 1 && isJsSourceFile(call.getSourceFile())) {
+    if (name === "toString" && nArgs <= 1 && isJsSourceFile(ts.getSourceFileOfNode(call))) {
         const lowered = lowerer.lowerExpr(access.expression);
         const receiver = lowered.kind === "dynCheck" && lowered.value.type.kind === "dyn" ? lowered.value : lowered;
         if (receiver.type.kind === "dyn")
@@ -350,10 +668,10 @@ export function lowerBytesMethodCall(lowerer, call, access) {
                 fn: "dyn.toString",
                 args: [
                     receiver,
-                    call.arguments[0]
-                        ? lowerer.lowerExprExpecting(call.arguments[0], DYN)
+                    call.arguments.nodes[0]
+                        ? lowerer.lowerExprExpecting(call.arguments.nodes[0], DYN)
                         : dynUndefinedExpr(loc),
-                    { kind: "strLit", value: access.getText(), type: STRING, loc },
+                    { kind: "strLit", value: ts.getTextOfNode(access), type: STRING, loc },
                 ],
                 type: STRING,
                 loc,
@@ -362,6 +680,19 @@ 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) {
+        const type = lowerer.mapTypeOf(lowerer.typeOf(call));
+        if (type?.kind === "generator") {
+            const value = lowerBytesIteratorValue(lowerer, lowerer.lowerExpr(access.expression), name, type, loc);
+            if (value)
+                return value;
+        }
+    }
     if (name === "toReversed") {
         if (nArgs !== 0) {
             lowerer.noLowering(`.toReversed with ${nArgs} arguments on typed arrays`, call);
@@ -376,7 +707,7 @@ export function lowerBytesMethodCall(lowerer, call, access) {
         };
     }
     if (receiverIr.elem === "u8" && name === "with") {
-        if (nArgs !== 2 || call.arguments.some(ts.isSpreadElement)) {
+        if (nArgs !== 2 || call.arguments.nodes.some(ts.isSpreadElement)) {
             lowerer.noLowering(`.with with ${nArgs} arguments on Uint8Array`, call);
         }
         return {
@@ -384,15 +715,15 @@ export function lowerBytesMethodCall(lowerer, call, access) {
             method: "with",
             receiver: lowerer.lowerExprExpecting(access.expression, receiverIr),
             args: [
-                lowerer.lowerExprExpecting(call.arguments[0], F64),
-                lowerer.lowerExprExpecting(call.arguments[1], F64),
+                lowerer.lowerExprExpecting(call.arguments.nodes[0], F64),
+                lowerer.lowerExprExpecting(call.arguments.nodes[1], F64),
             ],
             type: receiverIr,
             loc,
         };
     }
     if (name === "join") {
-        if (nArgs > 1 || call.arguments.some(ts.isSpreadElement)) {
+        if (nArgs > 1 || call.arguments.nodes.some(ts.isSpreadElement)) {
             lowerer.noLowering(`.join with ${nArgs} arguments on typed arrays`, call);
         }
         const separatorDefault = {
@@ -401,8 +732,8 @@ export function lowerBytesMethodCall(lowerer, call, access) {
             type: STRING,
             loc,
         };
-        const separator = call.arguments[0]
-            ? lowerOptionalArgument(lowerer, call.arguments[0], STRING, separatorDefault)
+        const separator = call.arguments.nodes[0]
+            ? lowerOptionalArgument(lowerer, call.arguments.nodes[0], STRING, separatorDefault)
             : separatorDefault;
         return {
             kind: "bytesIntrinsic",
@@ -420,7 +751,7 @@ export function lowerBytesMethodCall(lowerer, call, access) {
         const receiver = lowerer.lowerExprExpecting(access.expression, receiverIr);
         // A missing start is 0 and a missing end is the length (+Infinity
         // clamps to it), as for omitted arguments.
-        const args = call.arguments.map((a, i) => lowerOptionalArgument(lowerer, a, F64, {
+        const args = call.arguments.nodes.map((a, i) => lowerOptionalArgument(lowerer, a, F64, {
             kind: "numLit",
             value: i === 0 ? 0 : Infinity,
             type: F64,
@@ -434,21 +765,19 @@ export function lowerBytesMethodCall(lowerer, call, access) {
             (() => {
                 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"));
+                    nameSym.declarations.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 === "copyWithin") {
-        if (nArgs > 3 || call.arguments.some(ts.isSpreadElement)) {
+        if (nArgs > 3 || call.arguments.nodes.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];
+            const node = call.arguments.nodes[i];
             return node ? lowerOptionalArgument(lowerer, node, F64, fallback) : fallback;
         });
         return { kind: "bytesIntrinsic", method: "copyWithin", receiver, args, type: receiverIr, loc };
@@ -457,22 +786,20 @@ export function lowerBytesMethodCall(lowerer, call, access) {
         !(() => {
             const symbol = lowerer.checker.getSymbolAtLocation(access.name);
             return (symbol !== undefined &&
-                lowerer.checker
-                    .declarationsOf(symbol)
-                    .some((declaration) => ts.isInterfaceDeclaration(declaration.parent) &&
+                symbol.declarations.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)) {
+        if (nArgs > 3 || call.arguments.nodes.some(ts.isSpreadElement)) {
             lowerer.noLowering(`.fill with ${nArgs} arguments on typed arrays`, call);
         }
         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)
+        const v = call.arguments.nodes[0]
+            ? lowerOptionalArgument(lowerer, call.arguments.nodes[0], F64, zero)
             : zero;
-        const idx = call.arguments.slice(1).map((a, i) => lowerOptionalArgument(lowerer, a, F64, {
+        const idx = call.arguments.nodes.slice(1).map((a, i) => lowerOptionalArgument(lowerer, a, F64, {
             kind: "numLit",
             value: i === 0 ? 0 : Infinity,
             type: F64,
@@ -492,13 +819,13 @@ export function lowerBytesMethodCall(lowerer, call, access) {
             lowerer.noLowering(`.set with ${nArgs} arguments on typed arrays`, call);
         }
         const receiver = lowerer.lowerExprExpecting(access.expression, receiverIr);
-        const src = lowerer.lowerExpr(call.arguments[0]);
+        const src = lowerer.lowerExpr(call.arguments.nodes[0]);
         const method = src.type.kind === "bytes" ? "setFrom" : "setFromDyn";
         const args = [
-            src.type.kind === "bytes" ? src : lowerer.coerceInto(call.arguments[0], src, DYN),
+            src.type.kind === "bytes" ? src : lowerer.coerceInto(call.arguments.nodes[0], src, DYN),
         ];
         if (nArgs === 2)
-            args.push(lowerOptionalArgument(lowerer, call.arguments[1], F64, {
+            args.push(lowerOptionalArgument(lowerer, call.arguments.nodes[1], F64, {
                 kind: "numLit",
                 value: 0,
                 type: F64,
@@ -513,9 +840,7 @@ export function lowerBytesMethodCall(lowerer, call, access) {
         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"));
+                nameSym.declarations.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');
@@ -523,7 +848,7 @@ export function lowerBytesMethodCall(lowerer, call, access) {
         if (nArgs > 3)
             lowerer.noLowering(`.toString with ${nArgs} arguments on Buffers`, call);
         const receiver = lowerer.lowerExprExpecting(access.expression, receiverIr);
-        const encNode = call.arguments[0];
+        const encNode = call.arguments.nodes[0];
         let method = "toString";
         let enc = { kind: "strLit", value: "utf8", type: STRING, loc };
         if (encNode) {
@@ -563,9 +888,9 @@ export function lowerBytesMethodCall(lowerer, call, access) {
         // 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);
+            const start = lowerer.lowerExprExpecting(call.arguments.nodes[1], F64);
             if (nArgs === 3) {
-                const end = lowerer.lowerExprExpecting(call.arguments[2], F64);
+                const end = lowerer.lowerExprExpecting(call.arguments.nodes[2], F64);
                 return {
                     kind: "bytesIntrinsic",
                     method,
@@ -588,9 +913,7 @@ export function lowerBytesMethodCall(lowerer, call, access) {
     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"));
+            nameSym.declarations.some((d) => ts.isInterfaceDeclaration(d.parent) && d.parent.name.text === "Buffer"));
     })();
     if (declOnBuffer && receiverIr.elem === "u8") {
         const bufMethod = lowerBufferInstanceMethod(lowerer, call, access, name, loc);
@@ -605,7 +928,7 @@ export function lowerBytesMethodCall(lowerer, call, access) {
             lowerer.noLowering(`.${name} with ${nArgs} arguments`, call);
         }
         const receiver = lowerer.lowerExprExpecting(access.expression, receiverIr);
-        const offsetNode = call.arguments[required];
+        const offsetNode = call.arguments.nodes[required];
         const offset = offsetNode
             ? lowerer.lowerExprExpecting(offsetNode, F64)
             : { kind: "numLit", value: 0, type: F64, loc };
@@ -620,7 +943,7 @@ export function lowerBytesMethodCall(lowerer, call, access) {
                 loc,
             };
         }
-        const value = lowerer.lowerExprExpecting(call.arguments[0], BIGINT_T);
+        const value = lowerer.lowerExprExpecting(call.arguments.nodes[0], BIGINT_T);
         return {
             kind: "libCall",
             fn: "bigint.bufferWrite",
@@ -645,7 +968,7 @@ export function lowerBytesMethodCall(lowerer, call, access) {
         }
         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))];
+        const args = [kind, ...call.arguments.nodes.map((a) => lowerer.lowerExprExpecting(a, F64))];
         if (nArgs === required) {
             args.push({ kind: "numLit", value: 0, type: F64, loc }); // Node's offset default
         }
@@ -670,7 +993,7 @@ export function lowerBytesMethodCall(lowerer, call, access) {
         }
         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))];
+        const args = [kind, ...call.arguments.nodes.map((a) => lowerer.lowerExprExpecting(a, F64))];
         return {
             kind: "bytesIntrinsic",
             method: write ? "writeNumVar" : "readNumVar",
@@ -690,10 +1013,10 @@ export function lowerBytesMethodCall(lowerer, call, access) {
         if (nArgs < 1 || nArgs > 2)
             lowerer.noLowering(`.${name} with ${nArgs} arguments`, call);
         const receiver = lowerer.lowerExprExpecting(access.expression, receiverIr);
-        const offset = lowerer.lowerExprExpecting(call.arguments[0], F64);
+        const offset = lowerer.lowerExprExpecting(call.arguments.nodes[0], F64);
         const sign = { kind: "boolLit", value: dvBigGetter.sign, type: BOOL, loc };
-        const le = call.arguments[1]
-            ? lowerer.lowerExprExpecting(call.arguments[1], BOOL)
+        const le = call.arguments.nodes[1]
+            ? lowerer.lowerExprExpecting(call.arguments.nodes[1], BOOL)
             : { kind: "boolLit", value: false, type: BOOL, loc };
         return {
             kind: "libCall",
@@ -711,9 +1034,9 @@ export function lowerBytesMethodCall(lowerer, call, access) {
         }
         const receiver = lowerer.lowerExprExpecting(access.expression, receiverIr);
         // ToIndex(undefined) is ToIndex(NaN): a missing offset reads offset 0.
-        const args = [lowerToNumberArgument(lowerer, call.arguments[0])];
+        const args = [lowerToNumberArgument(lowerer, call.arguments.nodes[0])];
         if (nArgs === 2)
-            args.push(lowerer.lowerExprExpecting(call.arguments[1], BOOL));
+            args.push(lowerer.lowerExprExpecting(call.arguments.nodes[1], BOOL));
         return { kind: "bytesIntrinsic", method: dvGetter.method, receiver, args, type: F64, loc };
     }
     // DataView setters — the getters' mirror: (byteOffset, value) plus the
@@ -727,10 +1050,10 @@ export function lowerBytesMethodCall(lowerer, call, access) {
         if (nArgs < 2 || nArgs > 3)
             lowerer.noLowering(`.${name} with ${nArgs} arguments`, call);
         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]
-            ? lowerer.lowerExprExpecting(call.arguments[2], BOOL)
+        const offset = lowerer.lowerExprExpecting(call.arguments.nodes[0], F64);
+        const value = lowerer.lowerExprExpecting(call.arguments.nodes[1], BIGINT_T);
+        const le = call.arguments.nodes[2]
+            ? lowerer.lowerExprExpecting(call.arguments.nodes[2], BOOL)
             : { kind: "boolLit", value: false, type: BOOL, loc };
         return {
             kind: "libCall",
@@ -749,11 +1072,11 @@ export function lowerBytesMethodCall(lowerer, call, access) {
         // The offset (ToIndex) and the value (ToNumber) treat a missing value
         // as NaN.
         const args = [
-            lowerToNumberArgument(lowerer, call.arguments[0]),
-            lowerToNumberArgument(lowerer, call.arguments[1]),
+            lowerToNumberArgument(lowerer, call.arguments.nodes[0]),
+            lowerToNumberArgument(lowerer, call.arguments.nodes[1]),
         ];
         if (nArgs === 3)
-            args.push(lowerer.lowerExprExpecting(call.arguments[2], BOOL));
+            args.push(lowerer.lowerExprExpecting(call.arguments.nodes[2], BOOL));
         return { kind: "bytesIntrinsic", method: dvSetter.method, receiver, args, type: VOID, loc };
     }
     return null;
@@ -828,7 +1151,7 @@ const BUF_NUM_VAR_METHODS = {
  * (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 args = call.arguments.nodes;
     const nArgs = args.length;
     if (args.some(ts.isSpreadElement))
         return null;
@@ -876,10 +1199,12 @@ function lowerBufferInstanceMethod(lowerer, call, access, name, loc) {
             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");
+            call.arguments.nodes
+                .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 idx = call.arguments.nodes.slice(1).map((a) => lowerer.lowerExprExpecting(a, F64));
             const receiver = lowerer.lowerExprExpecting(access.expression, BYTES_U8);
             return {
                 kind: "bytesIntrinsic",
@@ -960,7 +1285,7 @@ function lowerBufferInstanceMethod(lowerer, call, access, name, loc) {
             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);
+        let idxNodes = call.arguments.nodes.slice(1);
         if (idxNodes.length > 0 && isStringArg(nArgs - 1)) {
             encNode = idxNodes[idxNodes.length - 1];
             idxNodes = idxNodes.slice(0, -1);
@@ -1013,7 +1338,7 @@ function lowerBufferInstanceMethod(lowerer, call, access, name, loc) {
         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 idx = call.arguments.nodes.slice(1).map((a) => lowerer.lowerExprExpecting(a, F64));
         const receiver = lowerer.lowerExprExpecting(access.expression, BYTES_U8);
         return {
             kind: "bytesIntrinsic",
@@ -1036,7 +1361,7 @@ function lowerBufferInstanceMethod(lowerer, call, access, name, loc) {
         // (str), (str, enc), (str, offset), (str, offset, enc),
         // (str, offset, length), (str, offset, length, enc).
         let encNode;
-        let idxNodes = call.arguments.slice(1);
+        let idxNodes = call.arguments.nodes.slice(1);
         if (idxNodes.length > 0 && isStringArg(nArgs - 1)) {
             encNode = idxNodes[idxNodes.length - 1];
             idxNodes = idxNodes.slice(0, -1);
@@ -1081,6 +1406,7 @@ const DV_GETTERS = {
     getInt16: { method: "dvGetInt16", le: true },
     getUint32: { method: "dvGetUint32", le: true },
     getInt32: { method: "dvGetInt32", le: true },
+    getFloat16: { method: "dvGetFloat16", le: true },
     getFloat32: { method: "dvGetFloat32", le: true },
     getFloat64: { method: "dvGetFloat64", le: true },
 };
@@ -1091,6 +1417,7 @@ const DV_SETTERS = {
     setInt16: { method: "dvSetInt16", le: true },
     setUint32: { method: "dvSetUint32", le: true },
     setInt32: { method: "dvSetInt32", le: true },
+    setFloat16: { method: "dvSetFloat16", le: true },
     setFloat32: { method: "dvSetFloat32", le: true },
     setFloat64: { method: "dvSetFloat64", le: true },
 };
@@ -1107,9 +1434,7 @@ function knownBufferProducer(lowerer, source, seen = new Set()) {
         if (!symbol || seen.has(symbol))
             return false;
         seen.add(symbol);
-        return lowerer.checker
-            .declarationsOf(symbol)
-            .some((decl) => ts.isVariableDeclaration(decl) &&
+        return symbol.declarations.some((decl) => ts.isVariableDeclaration(decl) &&
             ts.isVariableDeclarationList(decl.parent) &&
             (decl.parent.flags & ts.NodeFlags.Const) !== 0 &&
             decl.initializer !== undefined &&
@@ -1132,11 +1457,163 @@ function knownBufferProducer(lowerer, source, seen = new Set()) {
         return true;
     if (!ts.isPropertyAccessExpression(callee) ||
         callee.name.text !== "digest" ||
-        node.arguments.length !== 0)
+        node.arguments.nodes.length !== 0)
         return false;
     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;
+ * other sources ignore the encoding. */
+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,
+        },
+        else_: {
+            kind: "libCall",
+            fn: "buffer.poolFromDynRef",
+            args: [source, utf8],
+            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
@@ -1152,12 +1629,13 @@ function lowerBufferStaticValue(lowerer, call, access) {
         return null;
     const member = access.name.text;
     const loc = locOf(call);
-    const args = call.arguments;
+    const args = call.arguments.nodes;
     if (member === "from") {
         if (args.length >= 1 &&
             args.length <= 3 &&
             !args.some(ts.isSpreadElement) &&
-            ((symbol) => symbol != null && (symbol.name === "ArrayBuffer" || symbol.name === "SharedArrayBuffer"))(lowerer.typeOf(args[0]).getSymbol())) {
+            ((symbol) => symbol != null &&
+                (ts.symbolName(symbol) === "ArrayBuffer" || ts.symbolName(symbol) === "SharedArrayBuffer"))(lowerer.typeOf(args[0]).getSymbol())) {
             return lowerArrayBufferView(lowerer, args, "u8", loc);
         }
         // Buffer.from(x.buffer[, byteOffset[, length]]): a u8 VIEW sharing
@@ -1188,14 +1666,19 @@ function lowerBufferStaticValue(lowerer, call, access) {
         }
         if (args.length >= 1 && args.length <= 2 && !args.some(ts.isSpreadElement)) {
             const argNode = args[0];
-            if (ts.isArrayLiteralExpression(argNode) && !argNode.elements.some(ts.isSpreadElement)) {
+            if (ts.isArrayLiteralExpression(argNode) &&
+                !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.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));
@@ -1203,6 +1686,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 {
@@ -1244,20 +1730,47 @@ function lowerBufferStaticValue(lowerer, call, access) {
                     }
                     return { kind: "libCall", fn, args: [s, enc], type: BYTES_U8, loc };
                 }
-                if (args.length === 1 && srcIr?.kind === "bytes" && srcIr.elem === "u8") {
-                    return {
+                // 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 ((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
+                // on the runtime kind exactly as for an untyped JS value, Node's
+                // TypeError for the unit arms included.
+                if (args.length === 1 &&
+                    value.type.kind === "union" &&
+                    lowerer.dynConvertible(value.type) &&
+                    lowerer.unions
+                        .get(value.type.unionId)
+                        ?.arms.every((arm) => arm.kind === "string" ||
+                        (arm.kind === "bytes" && arm.elem === "u8") ||
+                        isUnitType(arm)) === true) {
+                    return {
+                        kind: "libCall",
+                        fn: "buffer.poolFromDyn",
+                        args: [
+                            lowerer.coerceToExpected(value, DYN),
+                            { kind: "strLit", value: "utf8", type: STRING, loc },
+                        ],
                         type: BYTES_U8,
                         loc,
                     };
@@ -1333,14 +1846,29 @@ function lowerBufferStaticValue(lowerer, call, access) {
         }
         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));
+        if (ts.isArrayLiteralExpression(argNode) && !argNode.elements.nodes.some(ts.isSpreadElement)) {
+            const elems = argNode.elements.nodes.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");
+                // Any other list (JavaScript's untyped `const chunks = []`, or a
+                // union of arrays): the runtime checks it as Node does (an Array of
+                // Uint8Arrays, the ERR_INVALID_ARG_TYPE errors otherwise) before
+                // concatenating.
+                const value = list.type.kind === "dyn" ? list : { kind: "dynFrom", value: list, type: DYN, loc };
+                if (args.length === 2) {
+                    const total = lowerer.lowerExprExpecting(args[1], F64);
+                    return {
+                        kind: "libCall",
+                        fn: "buffer.concatLenDyn",
+                        args: [value, total],
+                        type: BYTES_U8,
+                        loc,
+                    };
+                }
+                return { kind: "libCall", fn: "buffer.concatDyn", args: [value], type: BYTES_U8, loc };
             }
         }
         if (args.length === 2) {
@@ -1406,7 +1934,9 @@ function lowerBufferStaticValue(lowerer, call, access) {
             // 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.
-            const checked = isJsSourceFile(call.getSourceFile()) && v.kind === "dynCheck" && v.value.type.kind === "dyn"
+            const checked = isJsSourceFile(ts.getSourceFileOfNode(call)) &&
+                v.kind === "dynCheck" &&
+                v.value.type.kind === "dyn"
                 ? v.value
                 : v;
             if (checked.type.kind === "dyn") {
@@ -1446,6 +1976,12 @@ function lowerBufferStaticValue(lowerer, call, access) {
                     };
                 }
             }
+            // A typed view of unknown provenance (a Uint8Array parameter,
+            // safe-buffer's Buffer.from result): Buffer is a brand of the view,
+            // which the runtime keeps, so the test reads it.
+            if (v.type.kind === "bytes") {
+                return { kind: "libCall", fn: "buffer.isBranded", args: [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);