@scriptc/compiler 0.2.4 → 0.2.6

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

@@ -1,14 +1,14 @@
+import { dynUndefinedExpr, varRef } from "../../../ir/build.js";
 import { BUF_NUM_METHODS } from "./buffer-numeric-methods.js";
 import * as ts from "../../ts7/adapter.js";
-import { BYTES_ELEMENT_SIZE, BIGINT_T, BOOL, BYTES_U8, DYN, F64, STRING, UNDEFINED_T, VOID, arrayOf, bytesOf, typeEquals } from "../../../ir/ir.js";
+import { BIGINT_T, BOOL, BYTES_U8, DYN, F64, STRING, UNDEFINED_T, VOID, arrayOf, bytesOf, typeEquals, } from "../../../ir/ir.js";
 import { isJsSourceFile, locOf } from "../../program.js";
-import { dynUndefinedExpr, newFnCtx, own } from "../lowerer.js";
+import { newFnCtx, own } from "../lowerer.js";
 import { buildBytesSortFn } from "../lower-array-sort.js";
 import { isSafeToDiscard } from "../expressions/evaluation-safety.js";
 import { lowerDynObjectLiteral } from "../expressions/object-literals.js";
-import { defaultAfterUndefined, lowerOptionalArgument, lowerStaticallyUndefinedArgument } from "../optional-arguments.js";
-import { lowerCheckedArrayFrom } from "../lower-containers.js";
-import { varRef } from "../../../ir/build.js";
+import { defaultAfterUndefined, lowerOptionalArgument, lowerStaticallyUndefinedArgument, } from "../optional-arguments.js";
+import { lowerCheckedArrayFrom } from "./array-construction.js";
 /** Uint8Array.prototype.toSorted. The receiver/comparator expressions are
  * evaluated before entering the helper; the helper snapshots with
  * TypedArray.prototype.slice before its first comparison, then performs
@@ -102,25 +102,35 @@ const BYTES_CTORS = {
     Float64Array: "f64",
 };
 /** Numeric typed-array constructors
-   * (stdlib provenance — a user's own class with the name resolves through
-   * classBySymbol). Lowered argument shapes: none (empty), a length
-   * (zero-filled; ToIndex at runtime — invalid lengths throw Node's
-   * RangeError), a numeric typed array or Buffer (an independent COPY —
-   * the readFile chain's `new Uint8Array(await readFile(p))`), a number[]
-   * literal (element-coerced; its contextual type is the lib's
-   * ArrayLike/Iterable union, which cannot map — the Set-seed pattern), or
-   * a number[]-typed value, or checked native input with runtime length /
-   * array-like dispatch. ArrayBuffer inputs create shared views.
-   * Null when this isn't a stdlib
-   * typed-array construction. */
+ * (stdlib provenance — a user's own class with the name resolves through
+ * classBySymbol). Lowered argument shapes: none (empty), a length
+ * (zero-filled; ToIndex at runtime — invalid lengths throw Node's
+ * RangeError), a numeric typed array or Buffer (an independent COPY —
+ * the readFile chain's `new Uint8Array(await readFile(p))`), a number[]
+ * literal (element-coerced; its contextual type is the lib's
+ * ArrayLike/Iterable union, which cannot map — the Set-seed pattern), or
+ * a number[]-typed value, or checked native input with runtime length /
+ * array-like dispatch. ArrayBuffer inputs create shared views.
+ * Null when this isn't a stdlib
+ * typed-array construction. */
 export function lowerBytesNew(lowerer, expr, symbol) {
-    if (symbol != null && symbol.name === "ArrayBuffer" && lowerer.isStdlibSymbol(symbol)) {
+    if (symbol != null &&
+        (symbol.name === "ArrayBuffer" || symbol.name === "SharedArrayBuffer") &&
+        lowerer.isStdlibSymbol(symbol)) {
         const args = expr.arguments ?? [];
         if (args.length > 1 || args.some(ts.isSpreadElement)) {
             lowerer.noLowering("resizable ArrayBuffer construction", expr, "fixed-length ArrayBuffers accept a byte length; resizable storage is not supported yet");
         }
-        const length = args[0] ? lowerer.coerceInto(args[0], lowerer.lowerExpr(args[0]), DYN) : dynUndefinedExpr(locOf(expr));
-        return { kind: "libCall", fn: "arrayBuffer.new", args: [length], type: DYN, loc: locOf(expr) };
+        const length = args[0]
+            ? lowerer.coerceInto(args[0], lowerer.lowerExpr(args[0]), DYN)
+            : dynUndefinedExpr(locOf(expr));
+        return {
+            kind: "libCall",
+            fn: symbol.name === "SharedArrayBuffer" ? "sharedArrayBuffer.new" : "arrayBuffer.new",
+            args: [length],
+            type: DYN,
+            loc: locOf(expr),
+        };
     }
     if (symbol && symbol.name === "DataView" && lowerer.isStdlibSymbol(symbol)) {
         return lowerDataViewNew(lowerer, expr);
@@ -144,41 +154,13 @@ export function lowerBytesNew(lowerer, expr, symbol) {
             const seed = { kind: "arrayLit", elems, type: arrayOf(F64), loc };
             return { kind: "bytesNew", source: seed, type, loc };
         }
-        // The SYNTACTIC `new T(new SharedArrayBuffer(n))` form — fresh-buffer construction (the
-        // shared spelling is the Atomics.wait sleep idiom's). The buffer
-        // never exists as a value: n must be a byte-length LITERAL divisible
-        // by the element size (tsc would admit any number; a bad one is
-        // Node's RangeError — rejected at compile time instead of
-        // half-lowering), and the whole expression is a zero-filled typed
-        // array of n/elemSize elements. Erasing the buffer is exact: nothing
-        // else can ever reference it, so neither sharing (scriptc has no
-        // threads) nor aliasing is observable — SEMANTICS.md documents the
-        // stance. The RESIZABLE form (a maxByteLength options bag) fences by
-        // name: this erasure has no shared or growable buffer representation.
-        if (ts.isNewExpression(argNode) &&
-            ts.isIdentifier(argNode.expression) &&
-            argNode.expression.text === "SharedArrayBuffer" &&
-            lowerer.isStdlibSymbol(lowerer.resolveValueSymbol(argNode.expression) ?? undefined)) {
-            const bufCtor = argNode.expression.text;
-            if ((argNode.arguments?.length ?? 0) > 1) {
-                lowerer.noLowering(`new ${name} over a resizable ${bufCtor}`, argNode, "a maxByteLength options bag needs growable shared storage; the fixed-length " +
-                    "SharedArrayBuffer here erases into the view: drop the options bag");
-            }
-            const elemSize = BYTES_ELEMENT_SIZE[elem];
-            const lenArg = argNode.arguments?.length === 1 ? argNode.arguments[0] : undefined;
-            const lenT = lenArg ? lowerer.typeOf(lenArg) : null;
-            const byteLen = lenT?.isNumberLiteralType() ? lenT.value : null;
-            if (byteLen === null || byteLen % elemSize !== 0 || byteLen < 0) {
-                lowerer.noLowering(`new ${name} over this ${bufCtor}`, argNode, `the byte length must be a number literal divisible by ${elemSize} — new ${name}(new ${bufCtor}(${elemSize}))`);
-            }
-            const count = { kind: "numLit", value: byteLen / elemSize, type: F64, loc };
-            return { kind: "bytesNew", source: count, type, loc };
-        }
         const src = lowerer.lowerExpr(argNode);
         if (src.type.kind === "union") {
             const arms = lowerer.unions.get(src.type.unionId)?.arms;
-            if (arms?.every((arm) => arm.kind === "f64" || arm.kind === "bytes" ||
-                typeEquals(arm, UNDEFINED_T) || (arm.kind === "array" && arm.elem.kind === "f64"))) {
+            if (arms?.every((arm) => arm.kind === "f64" ||
+                arm.kind === "bytes" ||
+                typeEquals(arm, UNDEFINED_T) ||
+                (arm.kind === "array" && arm.elem.kind === "f64"))) {
                 // The checked constructor dispatch preserves each arm's copy or
                 // length semantics, including undefined -> empty, and evaluates
                 // an effectful source expression exactly once.
@@ -186,7 +168,8 @@ export function lowerBytesNew(lowerer, expr, symbol) {
             }
         }
         if (src.type.kind === "f64" ||
-            src.type.kind === "bytes" || src.type.kind === "dyn" ||
+            src.type.kind === "bytes" ||
+            src.type.kind === "dyn" ||
             (src.type.kind === "array" && src.type.elem.kind === "f64")) {
             return { kind: "bytesNew", source: src, type, loc };
         }
@@ -204,7 +187,13 @@ export function lowerBytesStaticCall(lowerer, call, access) {
         if (call.arguments.length !== 1 || call.arguments.some(ts.isSpreadElement))
             lowerer.noLowering("ArrayBuffer.isView argument count", call);
         const arg = call.arguments[0];
-        return { kind: "libCall", fn: "arrayBuffer.isView", args: [lowerer.coerceInto(arg, lowerer.lowerExpr(arg), DYN)], type: BOOL, loc: locOf(call) };
+        return {
+            kind: "libCall",
+            fn: "arrayBuffer.isView",
+            args: [lowerer.coerceInto(arg, lowerer.lowerExpr(arg), DYN)],
+            type: BOOL,
+            loc: locOf(call),
+        };
     }
     if (access.name.text !== "from" || !ts.isIdentifier(access.expression))
         return null;
@@ -212,7 +201,9 @@ export function lowerBytesStaticCall(lowerer, call, access) {
     const elem = symbol ? own(BYTES_CTORS, symbol.name) : undefined;
     if (!elem || !lowerer.isStdlibSymbol(symbol ?? undefined))
         return null;
-    if (call.arguments.length < 1 || call.arguments.length > 3 || call.arguments.some(ts.isSpreadElement)) {
+    if (call.arguments.length < 1 ||
+        call.arguments.length > 3 ||
+        call.arguments.some(ts.isSpreadElement)) {
         lowerer.noLowering("TypedArray.from with this argument count", call);
     }
     const node = call.arguments[0];
@@ -231,24 +222,59 @@ export function lowerBytesStaticCall(lowerer, call, access) {
                 const collected = lowerCheckedArrayFrom(lowerer, input, loc);
                 const mapped = lowerCheckedArrayFrom(lowerer, collected.result, loc, mapper, receiver, true);
                 // Consume the iterable before mapping, but validate the mapper first.
-                lowerer.liftedFns.push({ name: key, params: locals.map((local) => ({ localId: local.id, name: local.name, type: DYN })),
-                    returnType: bytesOf(elem), locals: context.locals, loc, body: [
-                        mapped.stmts[0], ...collected.stmts, ...mapped.stmts.slice(1),
-                        { kind: "return", value: { kind: "bytesNew", source: mapped.result, from: true, type: bytesOf(elem), loc }, loc },
-                    ] });
+                lowerer.liftedFns.push({
+                    name: key,
+                    params: locals.map((local) => ({ localId: local.id, name: local.name, type: DYN })),
+                    returnType: bytesOf(elem),
+                    locals: context.locals,
+                    loc,
+                    body: [
+                        mapped.stmts[0],
+                        ...collected.stmts,
+                        ...mapped.stmts.slice(1),
+                        {
+                            kind: "return",
+                            value: {
+                                kind: "bytesNew",
+                                source: mapped.result,
+                                from: true,
+                                type: bytesOf(elem),
+                                loc,
+                            },
+                            loc,
+                        },
+                    ],
+                });
             }
             finally {
                 lowerer.fnStack.pop();
             }
         }
-        return { kind: "call", callee: key, args: [lowerer.coerceInto(node, source, DYN),
+        return {
+            kind: "call",
+            callee: key,
+            args: [
+                lowerer.coerceInto(node, source, DYN),
                 lowerer.lowerExprExpecting(call.arguments[1], DYN),
-                call.arguments[2] ? lowerer.lowerExprExpecting(call.arguments[2], DYN) : dynUndefinedExpr(loc)], type: bytesOf(elem), loc };
+                call.arguments[2]
+                    ? lowerer.lowerExprExpecting(call.arguments[2], DYN)
+                    : dynUndefinedExpr(loc),
+            ],
+            type: bytesOf(elem),
+            loc,
+        };
     }
-    if (source.type.kind === "bytes" || (source.type.kind === "array" && source.type.elem.kind === "f64")) {
+    if (source.type.kind === "bytes" ||
+        (source.type.kind === "array" && source.type.elem.kind === "f64")) {
         return { kind: "bytesNew", source, type: bytesOf(elem), loc: locOf(call) };
     }
-    return { kind: "bytesNew", source: lowerer.coerceInto(node, source, DYN), from: true, type: bytesOf(elem), loc: locOf(call) };
+    return {
+        kind: "bytesNew",
+        source: lowerer.coerceInto(node, source, DYN),
+        from: true,
+        type: bytesOf(elem),
+        loc: locOf(call),
+    };
 }
 /** Construct a view over the complete branded backing allocation. */
 function lowerArrayBufferView(lowerer, args, elem, loc) {
@@ -256,8 +282,25 @@ function lowerArrayBufferView(lowerer, args, elem, loc) {
         const node = args[index];
         return node ? lowerer.coerceInto(node, lowerer.lowerExpr(node), DYN) : dynUndefinedExpr(loc);
     });
-    const fn = { u8c: "arrayBuffer.viewU8C", i8: "arrayBuffer.viewI8", u16: "arrayBuffer.viewU16", i16: "arrayBuffer.viewI16", u8: "arrayBuffer.viewU8", u32: "arrayBuffer.viewU32", i32: "arrayBuffer.viewI32", f32: "arrayBuffer.viewF32", f64: "arrayBuffer.viewF64", dv: "arrayBuffer.viewDV" };
-    return { kind: "libCall", fn: fn[elem], args: values, type: elem === "dv" ? BYTES_U8 : bytesOf(elem), loc };
+    const fn = {
+        u8c: "arrayBuffer.viewU8C",
+        i8: "arrayBuffer.viewI8",
+        u16: "arrayBuffer.viewU16",
+        i16: "arrayBuffer.viewI16",
+        u8: "arrayBuffer.viewU8",
+        u32: "arrayBuffer.viewU32",
+        i32: "arrayBuffer.viewI32",
+        f32: "arrayBuffer.viewF32",
+        f64: "arrayBuffer.viewF64",
+        dv: "arrayBuffer.viewDV",
+    };
+    return {
+        kind: "libCall",
+        fn: fn[elem],
+        args: values,
+        type: elem === "dv" ? BYTES_U8 : bytesOf(elem),
+        loc,
+    };
 }
 function lowerDataViewNew(lowerer, expr) {
     const args = expr.arguments ?? [];
@@ -266,12 +309,12 @@ function lowerDataViewNew(lowerer, expr) {
     return lowerArrayBufferView(lowerer, args, "dv", locOf(expr));
 }
 /** Method calls on typed-array/Buffer receivers: slice (copy), subarray
-   * (shared view), copyWithin, set(src,
-   * offset?), and the u8-only Buffer surface: toString(enc?) plus the
-   * whole numeric read/write family (fixed widths BE/LE and the
-   * variable-width read/writeUIntLE quartet — BUF_NUM_METHODS). Everything
-   * else the lib declares (fill, indexOf, reverse, ...) falls through to
-   * the SC2020 member fence. Null when this isn't a bytes method call. */
+ * (shared view), toReversed, copyWithin, set(src,
+ * offset?), and the u8-only Buffer surface: toString(enc?) plus the
+ * whole numeric read/write family (fixed widths BE/LE and the
+ * variable-width read/writeUIntLE quartet — BUF_NUM_METHODS). Everything
+ * else the lib declares (fill, indexOf, reverse, ...) falls through to
+ * the SC2020 member fence. Null when this isn't a bytes method call. */
 export function lowerBytesMethodCall(lowerer, call, access) {
     if (lowerer.chainBlocked(access, call))
         return null;
@@ -289,16 +332,26 @@ export function lowerBytesMethodCall(lowerer, call, access) {
         const lowered = lowerer.lowerExpr(access.expression);
         const receiver = lowered.kind === "dynCheck" && lowered.value.type.kind === "dyn" ? lowered.value : lowered;
         if (receiver.type.kind === "dyn")
-            return { kind: "libCall", fn: "dyn.toString", args: [receiver,
-                    call.arguments[0] ? lowerer.lowerExprExpecting(call.arguments[0], DYN) : dynUndefinedExpr(loc),
-                    { kind: "strLit", value: access.getText(), type: STRING, loc }], type: STRING, loc };
+            return {
+                kind: "libCall",
+                fn: "dyn.toString",
+                args: [
+                    receiver,
+                    call.arguments[0]
+                        ? lowerer.lowerExprExpecting(call.arguments[0], DYN)
+                        : dynUndefinedExpr(loc),
+                    { kind: "strLit", value: access.getText(), type: STRING, loc },
+                ],
+                type: STRING,
+                loc,
+            };
     }
     if (receiverIr.elem === "u8" && name === "toSorted") {
         return lowerBytesToSortedCall(lowerer, call, access, receiverIr);
     }
-    if (receiverIr.elem === "u8" && name === "toReversed") {
+    if (name === "toReversed") {
         if (nArgs !== 0) {
-            lowerer.noLowering(`.toReversed with ${nArgs} arguments on Uint8Array`, call);
+            lowerer.noLowering(`.toReversed with ${nArgs} arguments on typed arrays`, call);
         }
         return {
             kind: "bytesIntrinsic",
@@ -360,7 +413,10 @@ export function lowerBytesMethodCall(lowerer, call, access) {
         const declaredOnBuffer = name === "slice" &&
             (() => {
                 const nameSym = lowerer.checker.getSymbolAtLocation(access.name);
-                return nameSym !== undefined && lowerer.checker.declarationsOf(nameSym).some((d) => ts.isInterfaceDeclaration(d.parent) && d.parent.name.text === "Buffer");
+                return (nameSym !== undefined &&
+                    lowerer.checker
+                        .declarationsOf(nameSym)
+                        .some((d) => ts.isInterfaceDeclaration(d.parent) && d.parent.name.text === "Buffer"));
             })();
         const method = name === "subarray" || declaredOnBuffer ? "subarray" : "slice";
         return { kind: "bytesIntrinsic", method, receiver, args, type: receiverIr, loc };
@@ -377,10 +433,15 @@ export function lowerBytesMethodCall(lowerer, call, access) {
         });
         return { kind: "bytesIntrinsic", method: "copyWithin", receiver, args, type: receiverIr, loc };
     }
-    if (name === "fill" && !(() => {
-        const symbol = lowerer.checker.getSymbolAtLocation(access.name);
-        return symbol !== undefined && lowerer.checker.declarationsOf(symbol).some((declaration) => ts.isInterfaceDeclaration(declaration.parent) && declaration.parent.name.text === "Buffer");
-    })()) {
+    if (name === "fill" &&
+        !(() => {
+            const symbol = lowerer.checker.getSymbolAtLocation(access.name);
+            return (symbol !== undefined &&
+                lowerer.checker
+                    .declarationsOf(symbol)
+                    .some((declaration) => ts.isInterfaceDeclaration(declaration.parent) &&
+                    declaration.parent.name.text === "Buffer"));
+        })()) {
         // Typed arrays use element coercion and relative, clamped indices.
         // Buffer's same-named method keeps its pattern and offset validation.
         if (nArgs > 3 || call.arguments.some(ts.isSpreadElement)) {
@@ -388,9 +449,23 @@ export function lowerBytesMethodCall(lowerer, call, access) {
         }
         const receiver = lowerer.lowerExprExpecting(access.expression, receiverIr);
         const zero = { kind: "numLit", value: 0, type: F64, loc };
-        const v = call.arguments[0] ? lowerOptionalArgument(lowerer, call.arguments[0], F64, zero) : zero;
-        const idx = call.arguments.slice(1).map((a, i) => lowerOptionalArgument(lowerer, a, F64, { kind: "numLit", value: i === 0 ? 0 : Infinity, type: F64, loc }));
-        return { kind: "bytesIntrinsic", method: "fillElem", receiver, args: [v, ...idx], type: receiverIr, loc };
+        const v = call.arguments[0]
+            ? lowerOptionalArgument(lowerer, call.arguments[0], F64, zero)
+            : zero;
+        const idx = call.arguments.slice(1).map((a, i) => lowerOptionalArgument(lowerer, a, F64, {
+            kind: "numLit",
+            value: i === 0 ? 0 : Infinity,
+            type: F64,
+            loc,
+        }));
+        return {
+            kind: "bytesIntrinsic",
+            method: "fillElem",
+            receiver,
+            args: [v, ...idx],
+            type: receiverIr,
+            loc,
+        };
     }
     if (name === "set") {
         if (nArgs < 1 || nArgs > 2) {
@@ -399,9 +474,16 @@ export function lowerBytesMethodCall(lowerer, call, access) {
         const receiver = lowerer.lowerExprExpecting(access.expression, receiverIr);
         const src = lowerer.lowerExpr(call.arguments[0]);
         const method = src.type.kind === "bytes" ? "setFrom" : "setFromDyn";
-        const args = [src.type.kind === "bytes" ? src : lowerer.coerceInto(call.arguments[0], src, DYN)];
+        const args = [
+            src.type.kind === "bytes" ? src : lowerer.coerceInto(call.arguments[0], src, DYN),
+        ];
         if (nArgs === 2)
-            args.push(lowerOptionalArgument(lowerer, call.arguments[1], F64, { kind: "numLit", value: 0, type: F64, loc }));
+            args.push(lowerOptionalArgument(lowerer, call.arguments[1], F64, {
+                kind: "numLit",
+                value: 0,
+                type: F64,
+                loc,
+            }));
         return { kind: "bytesIntrinsic", method, receiver, args, type: VOID, loc };
     }
     if (name === "toString") {
@@ -410,7 +492,10 @@ 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 && lowerer.checker.declarationsOf(nameSym).some((d) => ts.isInterfaceDeclaration(d.parent) && d.parent.name.text === "Buffer");
+            return (nameSym !== undefined &&
+                lowerer.checker
+                    .declarationsOf(nameSym)
+                    .some((d) => ts.isInterfaceDeclaration(d.parent) && d.parent.name.text === "Buffer"));
         })();
         if (receiverIr.elem !== "u8" || !declaredOnBuffer) {
             lowerer.noLowering("typed-array toString", call, 'Buffer.from(x).toString("utf8" | "hex" | "base64") is the lowered string conversion');
@@ -423,12 +508,15 @@ export function lowerBytesMethodCall(lowerer, call, access) {
         let enc = { kind: "strLit", value: "utf8", type: STRING, loc };
         if (encNode) {
             const encType = lowerer.typeOf(encNode);
-            const encName = encType.isStringLiteralType()
-                ? knownBufEncoding(encType.value)
-                : undefined;
+            const encName = encType.isStringLiteralType() ? knownBufEncoding(encType.value) : undefined;
             if (encName !== undefined) {
                 // Keep literals on the canonical, non-throwing fast path.
-                enc = { kind: "strLit", value: encName, type: STRING, loc };
+                enc = defaultAfterUndefined(lowerer.lowerExpr(encNode), {
+                    kind: "strLit",
+                    value: encName,
+                    type: STRING,
+                    loc,
+                });
             }
             else {
                 const undefinedArg = lowerStaticallyUndefinedArgument(lowerer, encNode);
@@ -458,7 +546,14 @@ export function lowerBytesMethodCall(lowerer, call, access) {
             const start = lowerer.lowerExprExpecting(call.arguments[1], F64);
             if (nArgs === 3) {
                 const end = lowerer.lowerExprExpecting(call.arguments[2], F64);
-                return { kind: "bytesIntrinsic", method, receiver, args: [enc, start, end], type: STRING, loc };
+                return {
+                    kind: "bytesIntrinsic",
+                    method,
+                    receiver,
+                    args: [enc, start, end],
+                    type: STRING,
+                    loc,
+                };
             }
             return { kind: "bytesIntrinsic", method, receiver, args: [enc, start], type: STRING, loc };
         }
@@ -472,7 +567,10 @@ export function lowerBytesMethodCall(lowerer, call, access) {
     // rest).
     const declOnBuffer = (() => {
         const nameSym = lowerer.checker.getSymbolAtLocation(access.name);
-        return nameSym !== undefined && lowerer.checker.declarationsOf(nameSym).some((d) => ts.isInterfaceDeclaration(d.parent) && d.parent.name.text === "Buffer");
+        return (nameSym !== undefined &&
+            lowerer.checker
+                .declarationsOf(nameSym)
+                .some((d) => ts.isInterfaceDeclaration(d.parent) && d.parent.name.text === "Buffer"));
     })();
     if (declOnBuffer && receiverIr.elem === "u8") {
         const bufMethod = lowerBufferInstanceMethod(lowerer, call, access, name, loc);
@@ -494,10 +592,22 @@ export function lowerBytesMethodCall(lowerer, call, access) {
         const sign = { kind: "boolLit", value: bigKind.sign, type: BOOL, loc };
         const le = { kind: "boolLit", value: bigKind.le, type: BOOL, loc };
         if (!write) {
-            return { kind: "libCall", fn: "bigint.bufferRead", args: [receiver, offset, sign, le], type: BIGINT_T, loc };
+            return {
+                kind: "libCall",
+                fn: "bigint.bufferRead",
+                args: [receiver, offset, sign, le],
+                type: BIGINT_T,
+                loc,
+            };
         }
         const value = lowerer.lowerExprExpecting(call.arguments[0], BIGINT_T);
-        return { kind: "libCall", fn: "bigint.bufferWrite", args: [receiver, value, offset, sign, le], type: F64, loc };
+        return {
+            kind: "libCall",
+            fn: "bigint.bufferWrite",
+            args: [receiver, value, offset, sign, le],
+            type: F64,
+            loc,
+        };
     }
     // The Buffer numeric read/write families — every fixed-width kind in
     // both endiannesses ("Uint" and "UInt" alike: Node aliases both), plus
@@ -519,7 +629,14 @@ export function lowerBytesMethodCall(lowerer, call, access) {
         if (nArgs === required) {
             args.push({ kind: "numLit", value: 0, type: F64, loc }); // Node's offset default
         }
-        return { kind: "bytesIntrinsic", method: write ? "writeNum" : "readNum", receiver, args, type: F64, loc };
+        return {
+            kind: "bytesIntrinsic",
+            method: write ? "writeNum" : "readNum",
+            receiver,
+            args,
+            type: F64,
+            loc,
+        };
     }
     const varKind = own(BUF_NUM_VAR_METHODS, name);
     if (varKind !== undefined) {
@@ -534,7 +651,14 @@ 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))];
-        return { kind: "bytesIntrinsic", method: write ? "writeNumVar" : "readNumVar", receiver, args, type: F64, loc };
+        return {
+            kind: "bytesIntrinsic",
+            method: write ? "writeNumVar" : "readNumVar",
+            receiver,
+            args,
+            type: F64,
+            loc,
+        };
     }
     // DataView getters (DataView maps to bytes<u8>, so the receiver kind
     // and stdlib provenance land here; the checker keeps these names off
@@ -551,7 +675,13 @@ export function lowerBytesMethodCall(lowerer, call, access) {
         const le = call.arguments[1]
             ? lowerer.lowerExprExpecting(call.arguments[1], BOOL)
             : { kind: "boolLit", value: false, type: BOOL, loc };
-        return { kind: "libCall", fn: "bigint.dataViewGet", args: [receiver, offset, sign, le], type: BIGINT_T, loc };
+        return {
+            kind: "libCall",
+            fn: "bigint.dataViewGet",
+            args: [receiver, offset, sign, le],
+            type: BIGINT_T,
+            loc,
+        };
     }
     const dvGetter = own(DV_GETTERS, name);
     if (dvGetter !== undefined && receiverIr.elem === "u8") {
@@ -581,7 +711,13 @@ export function lowerBytesMethodCall(lowerer, call, access) {
         const le = call.arguments[2]
             ? lowerer.lowerExprExpecting(call.arguments[2], BOOL)
             : { kind: "boolLit", value: false, type: BOOL, loc };
-        return { kind: "libCall", fn: "bigint.dataViewSet", args: [receiver, offset, value, le], type: VOID, loc };
+        return {
+            kind: "libCall",
+            fn: "bigint.dataViewSet",
+            args: [receiver, offset, value, le],
+            type: VOID,
+            loc,
+        };
     }
     if (dvSetter !== undefined && receiverIr.elem === "u8") {
         const maxArgs = dvSetter.le ? 3 : 2;
@@ -723,7 +859,14 @@ function lowerBufferInstanceMethod(lowerer, call, access, name, loc) {
             const target = u8Arg(0);
             const idx = call.arguments.slice(1).map((a) => lowerer.lowerExprExpecting(a, F64));
             const receiver = lowerer.lowerExprExpecting(access.expression, BYTES_U8);
-            return { kind: "bytesIntrinsic", method: "compareBuf", receiver, args: [target, ...idx], type: F64, loc };
+            return {
+                kind: "bytesIntrinsic",
+                method: "compareBuf",
+                receiver,
+                args: [target, ...idx],
+                type: F64,
+                loc,
+            };
         }
         // An absent/ill-typed target or offset (`a.compare()`, string
         // offsets, explicit undefined): Node's target/targetStart/targetEnd/
@@ -760,7 +903,11 @@ function lowerBufferInstanceMethod(lowerer, call, access, name, loc) {
             // encoding is irrelevant, like Node).
             const v = lowerer.lowerExprExpecting(args[0], F64);
             const numArgs = [v, ...(offNode ? [lowerer.lowerExprExpecting(offNode, F64)] : [])];
-            const method = name === "indexOf" ? "indexOfNum" : name === "lastIndexOf" ? "lastIndexOfNum" : "includesNum";
+            const method = name === "indexOf"
+                ? "indexOfNum"
+                : name === "lastIndexOf"
+                    ? "lastIndexOfNum"
+                    : "includesNum";
             return { kind: "bytesIntrinsic", method, receiver, args: numArgs, type: resultT, loc };
         }
         let needle;
@@ -779,7 +926,11 @@ function lowerBufferInstanceMethod(lowerer, call, access, name, loc) {
             lowerer.noLowering(`.${name} of '${lowerer.checker.typeToString(lowerer.typeOf(args[0]))}' values`, args[0], "string, number, and Buffer/Uint8Array needles search (narrow unions first)");
         }
         const alignLit = { kind: "numLit", value: align, type: F64, loc };
-        const searchArgs = [needle, alignLit, ...(offNode ? [lowerer.lowerExprExpecting(offNode, F64)] : [])];
+        const searchArgs = [
+            needle,
+            alignLit,
+            ...(offNode ? [lowerer.lowerExprExpecting(offNode, F64)] : []),
+        ];
         return { kind: "bytesIntrinsic", method: name, receiver, args: searchArgs, type: resultT, loc };
     }
     if (name === "fill") {
@@ -804,16 +955,37 @@ function lowerBufferInstanceMethod(lowerer, call, access, name, loc) {
             const encName = encNode ? bufEncoding(lowerer, ".fill", encNode) : "utf8";
             const s = lowerer.lowerExprExpecting(args[0], STRING);
             const enc = { kind: "strLit", value: encName, type: STRING, loc };
-            return { kind: "bytesIntrinsic", method: "fillStr", receiver, args: [s, enc, ...idx], type: BYTES_U8, loc };
+            return {
+                kind: "bytesIntrinsic",
+                method: "fillStr",
+                receiver,
+                args: [s, enc, ...idx],
+                type: BYTES_U8,
+                loc,
+            };
         }
         if (encNode)
             lowerer.noLowering(".fill with an encoding on a non-string value", encNode);
         if (vT?.kind === "f64") {
             const v = lowerer.lowerExprExpecting(args[0], F64);
-            return { kind: "bytesIntrinsic", method: "fillNum", receiver, args: [v, ...idx], type: BYTES_U8, loc };
+            return {
+                kind: "bytesIntrinsic",
+                method: "fillNum",
+                receiver,
+                args: [v, ...idx],
+                type: BYTES_U8,
+                loc,
+            };
         }
         const pattern = u8Arg(0);
-        return { kind: "bytesIntrinsic", method: "fill", receiver, args: [pattern, ...idx], type: BYTES_U8, loc };
+        return {
+            kind: "bytesIntrinsic",
+            method: "fill",
+            receiver,
+            args: [pattern, ...idx],
+            type: BYTES_U8,
+            loc,
+        };
     }
     if (name === "copy") {
         if (nArgs < 1 || nArgs > 4)
@@ -821,7 +993,14 @@ function lowerBufferInstanceMethod(lowerer, call, access, name, loc) {
         const target = u8Arg(0);
         const idx = call.arguments.slice(1).map((a) => lowerer.lowerExprExpecting(a, F64));
         const receiver = lowerer.lowerExprExpecting(access.expression, BYTES_U8);
-        return { kind: "bytesIntrinsic", method: "copy", receiver, args: [target, ...idx], type: F64, loc };
+        return {
+            kind: "bytesIntrinsic",
+            method: "copy",
+            receiver,
+            args: [target, ...idx],
+            type: F64,
+            loc,
+        };
     }
     if (name === "swap16" || name === "swap32" || name === "swap64") {
         if (nArgs !== 0)
@@ -848,9 +1027,21 @@ function lowerBufferInstanceMethod(lowerer, call, access, name, loc) {
         const offset = idxNodes[0]
             ? lowerer.lowerExprExpecting(idxNodes[0], F64)
             : { kind: "numLit", value: 0, type: F64, loc };
-        const writeArgs = [s, enc, offset, ...(idxNodes[1] ? [lowerer.lowerExprExpecting(idxNodes[1], F64)] : [])];
+        const writeArgs = [
+            s,
+            enc,
+            offset,
+            ...(idxNodes[1] ? [lowerer.lowerExprExpecting(idxNodes[1], F64)] : []),
+        ];
         const receiver = lowerer.lowerExprExpecting(access.expression, BYTES_U8);
-        return { kind: "bytesIntrinsic", method: "writeStr", receiver, args: writeArgs, type: F64, loc };
+        return {
+            kind: "bytesIntrinsic",
+            method: "writeStr",
+            receiver,
+            args: writeArgs,
+            type: F64,
+            loc,
+        };
     }
     return null;
 }
@@ -882,9 +1073,9 @@ const DV_SETTERS = {
     setFloat64: { method: "dvSetFloat64", le: true },
 };
 /** The Buffer statics — `Buffer.from(...)`, `Buffer.alloc(n)`,
-   * `Buffer.concat(list)`, `Buffer.isBuffer(x)` — on THE stdlib Buffer
-   * global (name + provenance; fallback and @types/node alike). Null when
-   * the callee isn't a Buffer-static access. */
+ * `Buffer.concat(list)`, `Buffer.isBuffer(x)` — on THE stdlib Buffer
+ * global (name + provenance; fallback and @types/node alike). Null when
+ * the callee isn't a Buffer-static access. */
 function knownBufferProducer(lowerer, source, seen = new Set()) {
     let node = source;
     while (ts.isParenthesizedExpression(node) || ts.isAsExpression(node) || ts.isTypeAssertion(node))
@@ -894,7 +1085,9 @@ 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 lowerer.checker
+            .declarationsOf(symbol)
+            .some((decl) => ts.isVariableDeclaration(decl) &&
             ts.isVariableDeclarationList(decl.parent) &&
             (decl.parent.flags & ts.NodeFlags.Const) !== 0 &&
             decl.initializer !== undefined &&
@@ -908,13 +1101,16 @@ function knownBufferProducer(lowerer, source, seen = new Set()) {
         : ts.isPropertyAccessExpression(callee)
             ? lowerer.builtinMemberOf(callee)
             : null;
-    if (bi?.module === "crypto" && (bi.member === "randomBytes" || bi.member === "pbkdf2Sync" || bi.member === "scryptSync"))
+    if (bi?.module === "crypto" &&
+        (bi.member === "randomBytes" || bi.member === "pbkdf2Sync" || bi.member === "scryptSync"))
         return true;
     if (bi?.module === "buffer" && bi.member === "transcode")
         return true;
     if (bi?.module === "url" && bi.member === "fileURLToPathBuffer")
         return true;
-    if (!ts.isPropertyAccessExpression(callee) || callee.name.text !== "digest" || node.arguments.length !== 0)
+    if (!ts.isPropertyAccessExpression(callee) ||
+        callee.name.text !== "digest" ||
+        node.arguments.length !== 0)
         return false;
     const type = lowerer.mapTypeOf(lowerer.typeOf(callee.expression));
     return type?.kind === "cryptoHash" || type?.kind === "cryptoHmac";
@@ -936,8 +1132,10 @@ function lowerBufferStaticValue(lowerer, call, access) {
     const loc = locOf(call);
     const args = call.arguments;
     if (member === "from") {
-        if (args.length >= 1 && args.length <= 3 && !args.some(ts.isSpreadElement) &&
-            ((symbol) => symbol != null && symbol.name === "ArrayBuffer")(lowerer.typeOf(args[0]).getSymbol())) {
+        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())) {
             return lowerArrayBufferView(lowerer, args, "u8", loc);
         }
         // Buffer.from(x.buffer[, byteOffset[, length]]): a u8 VIEW sharing
@@ -946,14 +1144,24 @@ function lowerBufferStaticValue(lowerer, call, access) {
         // array — the DataView peel — and the construction rides the same
         // dataViewNew intrinsic (offset/length validation throws Node's
         // DataView-shaped RangeErrors; valid indices behave exactly).
-        if (args.length >= 1 && args.length <= 3 && !args.some(ts.isSpreadElement) &&
-            ts.isPropertyAccessExpression(args[0]) && args[0].name.text === "buffer") {
+        if (args.length >= 1 &&
+            args.length <= 3 &&
+            !args.some(ts.isSpreadElement) &&
+            ts.isPropertyAccessExpression(args[0]) &&
+            args[0].name.text === "buffer") {
             const srcNode = args[0].expression;
             const srcIr = lowerer.mapTypeOf(lowerer.typeOf(srcNode));
             if (srcIr?.kind === "bytes") {
                 const receiver = lowerer.lowerExpr(srcNode);
                 const idxArgs = args.slice(1).map((a) => lowerer.lowerExprExpecting(a, F64));
-                return { kind: "bytesIntrinsic", method: "dataViewNew", receiver, args: idxArgs, type: BYTES_U8, loc };
+                return {
+                    kind: "bytesIntrinsic",
+                    method: "dataViewNew",
+                    receiver,
+                    args: idxArgs,
+                    type: BYTES_U8,
+                    loc,
+                };
             }
         }
         if (args.length >= 1 && args.length <= 2 && !args.some(ts.isSpreadElement)) {
@@ -978,11 +1186,35 @@ function lowerBufferStaticValue(lowerer, call, access) {
                     return { kind: "libCall", fn: "buffer.fromDyn", args: [value, enc], type: BYTES_U8, loc };
                 }
                 if (srcIr?.kind === "string") {
-                    const encNode = args[1];
-                    const encName = encNode ? bufEncoding(lowerer, "Buffer.from", encNode) : "utf8";
                     const s = lowerer.coerceInto(argNode, value, STRING);
-                    const enc = { kind: "strLit", value: encName, type: STRING, loc };
-                    return { kind: "libCall", fn: "buffer.fromStr", args: [s, enc], type: BYTES_U8, loc };
+                    const encNode = args[1];
+                    let enc = { kind: "strLit", value: "utf8", type: STRING, loc };
+                    let fn = "buffer.fromStr";
+                    if (encNode) {
+                        const encType = lowerer.typeOf(encNode);
+                        const encName = encType.isStringLiteralType()
+                            ? knownBufEncoding(encType.value)
+                            : undefined;
+                        if (encName !== undefined) {
+                            enc = defaultAfterUndefined(lowerer.lowerExpr(encNode), {
+                                kind: "strLit",
+                                value: encName,
+                                type: STRING,
+                                loc,
+                            });
+                        }
+                        else {
+                            const undefinedArg = lowerStaticallyUndefinedArgument(lowerer, encNode);
+                            if (undefinedArg) {
+                                enc = defaultAfterUndefined(undefinedArg, enc);
+                            }
+                            else {
+                                enc = lowerOptionalArgument(lowerer, encNode, STRING, enc);
+                                fn = "buffer.fromStrChecked";
+                            }
+                        }
+                    }
+                    return { kind: "libCall", fn, args: [s, enc], type: BYTES_U8, loc };
                 }
                 if (args.length === 1 && srcIr?.kind === "bytes" && srcIr.elem === "u8") {
                     return { kind: "bytesNew", source: value, type: BYTES_U8, loc };
@@ -992,7 +1224,7 @@ function lowerBufferStaticValue(lowerer, call, access) {
                 }
             }
         }
-        lowerer.noLowering("Buffer.from with this argument shape", call, "supported: Buffer.from(string, encoding?) with a literal encoding, Buffer.from(u8Array) — a copy — " +
+        lowerer.noLowering("Buffer.from with this argument shape", call, "supported: Buffer.from(string, encoding?), Buffer.from(u8Array) — a copy — " +
             "Buffer.from(number[]), or Buffer.from(arrayBuffer, byteOffset?, length?) — a view sharing " +
             "the buffer's storage; narrow unions first");
     }
@@ -1016,18 +1248,39 @@ function lowerBufferStaticValue(lowerer, call, access) {
             const encName = args[2] ? bufEncoding(lowerer, "Buffer.alloc", args[2]) : "utf8";
             const s = lowerer.lowerExprExpecting(args[1], STRING);
             const enc = { kind: "strLit", value: encName, type: STRING, loc };
-            return { kind: "bytesIntrinsic", method: "fillStr", receiver: fresh, args: [s, enc], type: BYTES_U8, loc };
+            return {
+                kind: "bytesIntrinsic",
+                method: "fillStr",
+                receiver: fresh,
+                args: [s, enc],
+                type: BYTES_U8,
+                loc,
+            };
         }
         if (args.length > 2) {
             lowerer.noLowering("Buffer.alloc with an encoding on a non-string fill", args[2]);
         }
         if (fillT?.kind === "f64") {
             const v = lowerer.lowerExprExpecting(args[1], F64);
-            return { kind: "bytesIntrinsic", method: "fillNum", receiver: fresh, args: [v], type: BYTES_U8, loc };
+            return {
+                kind: "bytesIntrinsic",
+                method: "fillNum",
+                receiver: fresh,
+                args: [v],
+                type: BYTES_U8,
+                loc,
+            };
         }
         if (fillT?.kind === "bytes" && fillT.elem === "u8") {
             const pattern = lowerer.lowerExpr(args[1]);
-            return { kind: "bytesIntrinsic", method: "fill", receiver: fresh, args: [pattern], type: BYTES_U8, loc };
+            return {
+                kind: "bytesIntrinsic",
+                method: "fill",
+                receiver: fresh,
+                args: [pattern],
+                type: BYTES_U8,
+                loc,
+            };
         }
         lowerer.noLowering(`Buffer.alloc with a '${lowerer.checker.typeToString(lowerer.typeOf(args[1]))}' fill`, args[1], "number, string, and Buffer/Uint8Array fills are the lowered shapes");
     }
@@ -1062,7 +1315,14 @@ function lowerBufferStaticValue(lowerer, call, access) {
         }
         const sides = args.map((a) => lowerer.lowerExpr(a));
         if (sides.every((v) => v.type.kind === "bytes" && v.type.elem === "u8")) {
-            return { kind: "bytesIntrinsic", method: "compareBuf", receiver: sides[0], args: [sides[1]], type: F64, loc };
+            return {
+                kind: "bytesIntrinsic",
+                method: "compareBuf",
+                receiver: sides[0],
+                args: [sides[1]],
+                type: F64,
+                loc,
+            };
         }
         // A side that is not statically bytes (the invalid-input probes,
         // untyped JS helpers): Node's "buf1"/"buf2" argument ladder runs
@@ -1103,26 +1363,44 @@ 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" ? v.value : v;
+            const checked = isJsSourceFile(call.getSourceFile()) && v.kind === "dynCheck" && v.value.type.kind === "dyn"
+                ? v.value
+                : v;
             if (checked.type.kind === "dyn") {
                 return { kind: "dynTest", test: "buffer", value: checked, type: BOOL, loc };
             }
             // Primitive storage cannot carry a Buffer. Keep argument effects
             // even when its representation makes the answer constant.
-            if (v.type.kind === "string" || v.type.kind === "f64" || v.type.kind === "bool" ||
-                v.type.kind === "symbol" || v.type.kind === "bigint" || v.type.kind === "nullT" || v.type.kind === "undefinedT") {
+            if (v.type.kind === "string" ||
+                v.type.kind === "f64" ||
+                v.type.kind === "bool" ||
+                v.type.kind === "symbol" ||
+                v.type.kind === "bigint" ||
+                v.type.kind === "nullT" ||
+                v.type.kind === "undefinedT") {
                 if (isSafeToDiscard(v))
                     return { kind: "boolLit", value: false, type: BOOL, loc };
                 return {
-                    kind: "seqExpr", stmts: [{ kind: "exprStmt", expr: v, loc: v.loc }],
-                    result: { kind: "boolLit", value: false, type: BOOL, loc }, type: BOOL, loc,
+                    kind: "seqExpr",
+                    stmts: [{ kind: "exprStmt", expr: v, loc: v.loc }],
+                    result: { kind: "boolLit", value: false, type: BOOL, loc },
+                    type: BOOL,
+                    loc,
                 };
             }
             if (v.type.kind === "union") {
                 const def = lowerer.unions.get(v.type.unionId);
                 const tag = def ? def.arms.findIndex((a) => a.kind === "bytes" && a.elem === "u8") : -1;
                 if (tag >= 0) {
-                    return { kind: "unionIsTag", unionId: v.type.unionId, tag, negated: false, value: v, type: BOOL, loc };
+                    return {
+                        kind: "unionIsTag",
+                        unionId: v.type.unionId,
+                        tag,
+                        negated: false,
+                        value: v,
+                        type: BOOL,
+                        loc,
+                    };
                 }
             }
             lowerer.noLowering(`Buffer.isBuffer of '${lowerer.fmt(v.type)}' values`, args[0], "the check lowers as a runtime tag test on unions with a Buffer arm — here the answer is static");
@@ -1141,9 +1419,21 @@ function lowerBufferStaticValue(lowerer, call, access) {
                 const enc = { kind: "strLit", value: encName, type: STRING, loc };
                 return { kind: "libCall", fn: "buffer.byteLenStr", args: [s, enc], type: F64, loc };
             }
-            if ((srcIr === null || srcIr.kind === "dyn") && (!args[1] || ts.isStringLiteralLike(args[1]))) {
-                const encoding = { kind: "strLit", value: args[1] ? bufEncoding(lowerer, "Buffer.byteLength", args[1]) : "utf8", type: STRING, loc };
-                return { kind: "libCall", fn: "buffer.byteLenDyn", args: [lowerer.lowerExprExpecting(args[0], DYN), encoding], type: F64, loc };
+            if ((srcIr === null || srcIr.kind === "dyn") &&
+                (!args[1] || ts.isStringLiteralLike(args[1]))) {
+                const encoding = {
+                    kind: "strLit",
+                    value: args[1] ? bufEncoding(lowerer, "Buffer.byteLength", args[1]) : "utf8",
+                    type: STRING,
+                    loc,
+                };
+                return {
+                    kind: "libCall",
+                    fn: "buffer.byteLenDyn",
+                    args: [lowerer.lowerExprExpecting(args[0], DYN), encoding],
+                    type: F64,
+                    loc,
+                };
             }
             if (srcIr?.kind === "bytes" && args.length === 1) {
                 const receiver = lowerer.lowerExpr(args[0]);
@@ -1155,7 +1445,9 @@ function lowerBufferStaticValue(lowerer, call, access) {
     if (member === "isEncoding") {
         // The runtime alias-set test — a plain bool over any string value
         // (Node's case-insensitive normalizeEncoding check).
-        if (args.length === 1 && !ts.isSpreadElement(args[0]) && lowerer.mapTypeOf(lowerer.typeOf(args[0]))?.kind === "string") {
+        if (args.length === 1 &&
+            !ts.isSpreadElement(args[0]) &&
+            lowerer.mapTypeOf(lowerer.typeOf(args[0]))?.kind === "string") {
             const s = lowerer.lowerExprExpecting(args[0], STRING);
             return { kind: "libCall", fn: "buffer.isEncoding", args: [s], type: BOOL, loc };
         }