@scriptc/compiler 0.1.1 → 0.1.3

package/dist/frontend/lowering/lower-containers.js

@@ -1,96 +1,21 @@
 import { InternalCompilerError } from "../../errors.js";
 /* Container-surface call lowering: array methods (including the HOF family
  * map/filter/forEach with their synthesized helper functions), Map/Set
- * methods with Node-exact forEach desugaring, and the string and regex
- * method surfaces. */
+ * methods with Node-exact forEach desugaring, iterator helpers, and indexed
+ * record operations. */
 import * as ts from "../ts7/adapter.js";
-import { BOOL, BYTES_U8, CAUGHT, DYN, F64, JSVAL, STRING, UNDEFINED_T, VOID, arrayOf, bytesOf, funcOf, isRefCounted, isSupportedArrayElem, isSupportedIndexValue, isUnitType, typeEquals } from "../../ir/ir.js";
-import { ARRAY_METHODS, MAP_METHODS, SET_COMBINE_METHODS, SET_METHODS, STR_METHODS } from "./surfaces.js";
-import { droppableStatic, isRequireMainFilename, lowerDynObjectLiteral, probeLower, pureReemittable } from "./lower-exprs.js";
+import { BOOL, CAUGHT, DYN, F64, JSVAL, STRING, UNDEFINED_T, VOID, arrayOf, funcOf, isRefCounted, isSupportedArrayElem, isSupportedIndexValue, isUnitType, typeEquals } from "../../ir/ir.js";
+import { ARRAY_METHODS, MAP_METHODS, SET_COMBINE_METHODS, SET_METHODS } from "./surfaces.js";
+import { tryLowerExpression } from "./expressions/try-lower-expression.js";
+import { isSafeToRepeat } from "./expressions/evaluation-safety.js";
 import { forOfVarTarget, lowerDestructuringAssign } from "./lower-stmts.js";
 import { isJsSourceFile, locOf } from "../program.js";
 import { islandPrimitiveExit, lowerDynDispatchMethodCall } from "./lower-calls.js";
-import { buildArraySortFn, buildBytesSortFn } from "./lower-array-sort.js";
-import { arrayValueRead, arrayValueStore, arrayValueType } from "./array-values.js";
+import { buildArraySortFn } from "./lower-array-sort.js";
+import { arrayIndexPresent, arrayValueRead, arrayValueStore, arrayValueType, currentArrayIndexPresent } from "./array-values.js";
 import { typeKey } from "../type-mapper.js";
-import { dynUndefinedExpr, own } from "./lowerer.js";
 import { boolLit, countedFor, numLit, varRef } from "../../ir/build.js";
-/** Lower an expression whose checker type is statically `undefined`/`void`.
- * Optional builtin arguments use this before their ordinary expected-type
- * coercion so every equivalent spelling (`undefined`, `void 0`, a typed
- * binding, or an effectful call returning undefined) selects the default.
- * An effectful `void e` is exact in this context: evaluate e, then produce
- * undefined, instead of hitting value-position void's general fence. */
-function lowerStaticallyUndefinedArg(lowerer, node) {
-    const peelErasableWrappers = (value) => {
-        let expr = value;
-        while (ts.isParenthesizedExpression(expr) ||
-            ts.isAsExpression(expr) ||
-            ts.isTypeAssertion(expr) ||
-            ts.isSatisfiesExpression(expr)) {
-            expr = expr.expression;
-        }
-        return expr;
-    };
-    let expr = node;
-    while (ts.isParenthesizedExpression(expr))
-        expr = expr.expression;
-    if ((lowerer.typeOf(expr).flags &
-        (ts.TypeFlags.Undefined | ts.TypeFlags.Void)) ===
-        0) {
-        return null;
-    }
-    // TypeScript erases `as`, angle-bracket assertions, and `satisfies`.
-    // Peel them only for the void recognition: a non-void assertion still
-    // lowers through the ordinary path below, preserving the checked-dynamic
-    // cast discipline. Nested voids add no effects of their own, so the one
-    // innermost operand carries the complete runtime evaluation.
-    expr = peelErasableWrappers(expr);
-    let sawVoid = false;
-    while (ts.isVoidExpression(expr)) {
-        sawVoid = true;
-        expr = peelErasableWrappers(expr.expression);
-    }
-    if (sawVoid) {
-        // The caller discards this token before producing the parameter
-        // default, so the operand itself carries exactly the required effects;
-        // no bare undefined value needs to enter the IR.
-        return lowerer.lowerExpr(expr);
-    }
-    return lowerer.lowerExpr(node);
-}
-/** Preserve a statically-undefined argument's effects, then answer the
- * optional parameter's already-lowered default value. */
-function defaultAfterUndefined(value, defaultValue) {
-    if (droppableStatic(value))
-        return defaultValue;
-    return {
-        kind: "seqExpr",
-        stmts: [{ kind: "exprStmt", expr: value, loc: value.loc }],
-        result: defaultValue,
-        type: defaultValue.type,
-        loc: value.loc,
-    };
-}
-function lowerOptionalDefaultArg(lowerer, node, expected, defaultValue) {
-    const undefinedArg = lowerStaticallyUndefinedArg(lowerer, node);
-    if (undefinedArg)
-        return defaultAfterUndefined(undefinedArg, defaultValue);
-    const value = lowerer.lowerExpr(node);
-    if (value.type.kind === "union") {
-        const def = lowerer.unions.get(value.type.unionId);
-        if (def?.arms.length === 2 &&
-            def.arms.some((arm) => arm.kind === "undefinedT") &&
-            def.arms.some((arm) => typeEquals(arm, expected))) {
-            // A runtime optional argument uses its API default only on the
-            // undefined arm. The exact two-arm gate deliberately excludes null:
-            // optional parameters do not admit it, and an asserted null must keep
-            // the ordinary checked-narrow failure instead of defaulting.
-            return { kind: "nullish", left: value, right: defaultValue, type: expected, loc: value.loc };
-        }
-    }
-    return lowerer.coerceInto(node, value, expected);
-}
+import { lowerOptionalArgument } from "./optional-arguments.js";
 /** Build the argument array for a mutating/copying operation while keeping
  * the receiver's scalar payload ABI. A missing read is represented as the
  * present UNDEFINED state in this temporary, so push/unshift and toSpliced
@@ -117,23 +42,6 @@ function lowerArrayValueItems(lowerer, values, elem, arrType, loc) {
     }
     return { kind: "seqExpr", stmts: body, result: outRef, type: arrType, loc };
 }
-function lowerSplitLimitArg(lowerer, node, loc) {
-    const defaultValue = { kind: "numLit", value: 4294967295, type: F64, loc };
-    return node ? lowerOptionalDefaultArg(lowerer, node, F64, defaultValue) : defaultValue;
-}
-/** Extract the checker-proven receiver arm from a runtime-optional array
- * read. The receiver is stabilized once before its tag is tested, and a
- * missing value throws the same property-read TypeError Node throws before
- * evaluating method arguments. */
-function lowerMethodReceiver(lowerer, node, expected, member) {
-    const lowered = lowerer.lowerExpr(node);
-    const optional = lowerer.runtimeOptionalPropertyReceiver(node, lowered, expected, member);
-    if (optional)
-        return optional;
-    if (typeEquals(lowered.type, expected))
-        return lowered;
-    return lowerer.coerceInto(node, lowered, expected);
-}
 /** Callback-driven array producers bypass mapType's ordinary T[] mapping:
  * the callback is lowered first, then the helper's result array is built
  * directly from its IR return type. Fence element kinds ScrArr cannot hold
@@ -160,6 +68,9 @@ export function lowerArrayMethodCall(lowerer, call, access) {
     if (!ARRAY_METHODS.has(name) && name !== "sort" && name !== "shift" && name !== "splice")
         return null;
     let receiverIr = lowerer.mapTypeOf(lowerer.typeOf(access.expression));
+    const checkerReceiver = lowerer.checker.getTypeAtLocation(access.expression);
+    const implicitArrayReceiver = receiverIr?.kind === "array" &&
+        (checkerReceiver.flags & (ts.TypeFlags.Any | ts.TypeFlags.Unknown) || lowerer.checkerAnyArrayType(checkerReceiver));
     // A checker-`any[]` receiver (the readonly-array Array.isArray quirk)
     // whose VALUE lowers to a real static array (maybeNarrow's isArray
     // bridge): ride the ordinary tables on the lowered element type — the
@@ -168,7 +79,10 @@ export function lowerArrayMethodCall(lowerer, call, access) {
     // the isStdlibMember gate is skipped for probed receivers (nothing
     // user-declared can shadow a method on a value the checker calls any).
     let probedUntyped = false;
-    if (!receiverIr &&
+    if (implicitArrayReceiver)
+        probedUntyped = true;
+    if ((receiverIr === null || receiverIr.kind === "dyn" ||
+        (receiverIr.kind === "array" && receiverIr.elem.kind === "dyn")) &&
         (lowerer.checkerAnyArray(access.expression) ||
             // A checker-`any` CHAIN whose value lowers to a real static array
             // (`context.stack.split('\n').slice(2)` — the dyn-receiver string
@@ -345,10 +259,10 @@ export function lowerArrayMethodCall(lowerer, call, access) {
         const deleteCount = call.arguments.length === 0
             ? { kind: "numLit", value: 0, type: F64, loc }
             : call.arguments[1]
-                ? lowerOptionalDefaultArg(lowerer, call.arguments[1], F64, deleteCountDefault)
+                ? lowerOptionalArgument(lowerer, call.arguments[1], F64, deleteCountDefault)
                 : { kind: "numLit", value: Infinity, type: F64, loc };
         const itemNodes = call.arguments.slice(2);
-        const itemProbes = itemNodes.map((arg) => probeLower(lowerer, arg));
+        const itemProbes = itemNodes.map((arg) => tryLowerExpression(lowerer, arg));
         const statefulItems = itemProbes.some((probe) => probe !== null && lowerer.runtimeOptionalWidening(probe.type, elem) !== null);
         const items = statefulItems
             ? lowerArrayValueItems(lowerer, itemNodes.map((arg) => lowerer.lowerExpr(arg)), elem, receiverIr, loc)
@@ -431,7 +345,7 @@ export function lowerArrayMethodCall(lowerer, call, access) {
                 loc,
             };
         }
-        const valueProbes = call.arguments.map((arg) => probeLower(lowerer, arg));
+        const valueProbes = call.arguments.map((arg) => tryLowerExpression(lowerer, arg));
         if (valueProbes.some((probe) => probe !== null && lowerer.runtimeOptionalWidening(probe.type, elem) !== null)) {
             const items = lowerArrayValueItems(lowerer, call.arguments.map((arg) => lowerer.lowerExpr(arg)), elem, receiverIr, loc);
             return {
@@ -494,8 +408,12 @@ export function lowerArrayMethodCall(lowerer, call, access) {
                 lowerer.unsupported("SC1090", argNode, "spread arguments to concat (pass the array itself — concat already spreads array arguments)");
             }
             const argIr = lowerer.mapTypeOf(lowerer.typeOf(argNode));
-            if (argIr !== null && argIr.kind === "array" && typeEquals(argIr.elem, elem)) {
-                if (elem.kind === "array" && typeEquals(argIr, elem)) {
+            const probedArg = probedUntyped ? tryLowerExpression(lowerer, argNode) : null;
+            const argArrayType = probedArg?.type.kind === "array"
+                ? probedArg.type
+                : argIr?.kind === "array" ? argIr : null;
+            if (argArrayType !== null && typeEquals(argArrayType.elem, elem)) {
+                if (elem.kind === "array" && typeEquals(argArrayType, elem)) {
                     // number[][].concat(inner: number[]) — TS says element, JS's
                     // IsArray says spread; no honest static answer exists.
                     lowerer.unsupported("SC1090", argNode, "concat of a bare inner array onto an array-of-arrays (JS would SPREAD it one level — wrap it: a.concat([inner]))");
@@ -596,7 +514,7 @@ export function lowerArrayMethodCall(lowerer, call, access) {
     }
     if (name === "find" || name === "findIndex" || name === "findLast" ||
         name === "findLastIndex" || name === "some" || name === "every") {
-        return lowerArrayFindLikeCall(lowerer, call, access, name, elem);
+        return lowerArrayFindLikeCall(lowerer, call, access, name, elem, probedUntyped);
     }
     if (name === "at")
         return lowerArrayAtCall(lowerer, call, access, elem);
@@ -623,7 +541,7 @@ function lowerArraySearchCall(lowerer, call, access, method, elem) {
     }
     // Preserve the existing fast path for an ordinary, non-union needle. Its
     // runtime implementation already has exact primitive/reference equality.
-    if (elem.kind !== "union" && typeEquals(needle.type, elem)) {
+    if (elem.kind !== "union" && elem.kind !== "bigint" && typeEquals(needle.type, elem)) {
         return {
             kind: "arrIntrinsic",
             method,
@@ -823,7 +741,8 @@ function arraySearchHelper(lowerer, method, elem, valueT, loc) {
    * loop passes exactly what it declares (JS passes everything; a callback
    * only sees the parameters it names). Returns the lowered callback and
    * its declared arity. */
-function hofCallbackArg(lowerer, argNode, lead, arrT) {
+function hofCallbackArg(lowerer, argNode, lead, arrT, bindUntyped = false) {
+    const full = [...lead, F64, arrT];
     // A DYN-receiver HOF's callback (`parsed.flatMap((value) => ...)`):
     // the contextual signature types the unannotated param `any` (the
     // receiver is checker-`any[]`), while the VALUE each call receives is
@@ -857,6 +776,43 @@ function hofCallbackArg(lowerer, argNode, lead, arrT) {
             lowerer.jsvalParamOverrides.add(p);
         });
     }
+    // A checker-untyped array expression whose lowered value supplies a
+    // concrete static element type still contextually types an inline HOF
+    // callback with any/unknown. Bind only unannotated parameters to the
+    // exact ABI the synthesized loop passes. The override is temporary:
+    // one callback AST may be lowered under several generic instances.
+    const contextual = [];
+    const previousImplicit = lowerer.implicitParamTypes;
+    let contextualTs = null;
+    if (bindUntyped && (ts.isArrowFunction(argNode) || ts.isFunctionExpression(argNode))) {
+        argNode.parameters.forEach((param, i) => {
+            const expected = full[i];
+            if (expected === undefined || expected.kind === "dyn" || expected.kind === "jsval" ||
+                !ts.isIdentifier(param.name) || param.type || param.initializer || param.dotDotDotToken) {
+                return;
+            }
+            const checkerType = lowerer.checker.getTypeAtLocation(param.name);
+            if ((checkerType.flags & (ts.TypeFlags.Any | ts.TypeFlags.Unknown)) === 0)
+                return;
+            const symbol = lowerer.checker.getSymbolAtLocation(param.name);
+            if (!symbol)
+                return;
+            contextual.push({ symbol, previous: lowerer.runtimeOptionalBindingTypes.get(symbol) });
+            lowerer.runtimeOptionalBindingTypes.set(symbol, expected);
+            const bodyExpected = expected.kind === "union" && lowerer.armTag(expected.unionId, UNDEFINED_T) >= 0
+                ? lowerer.stripUndefinedArm(expected)
+                : expected;
+            const expectedTs = bodyExpected.kind === "string" ? lowerer.checker.getStringType() :
+                bodyExpected.kind === "f64" ? lowerer.checker.getNumberType() :
+                    bodyExpected.kind === "bool" ? lowerer.checker.getBooleanType() : null;
+            if (expectedTs !== null) {
+                contextualTs ??= new Map(previousImplicit ?? []);
+                contextualTs.set(symbol, expectedTs);
+            }
+        });
+    }
+    if (contextualTs !== null)
+        lowerer.implicitParamTypes = contextualTs;
     let fnArg;
     try {
         fnArg = lowerer.lowerExpr(argNode);
@@ -864,8 +820,14 @@ function hofCallbackArg(lowerer, argNode, lead, arrT) {
     finally {
         for (const n of overridden)
             lowerer.chainNarrowedType.delete(n);
+        for (const { symbol, previous } of contextual) {
+            if (previous === undefined)
+                lowerer.runtimeOptionalBindingTypes.delete(symbol);
+            else
+                lowerer.runtimeOptionalBindingTypes.set(symbol, previous);
+        }
+        lowerer.implicitParamTypes = previousImplicit;
     }
-    const full = [...lead, F64, arrT];
     if (fnArg.type.kind !== "func" ||
         fnArg.type.params.length > full.length ||
         !fnArg.type.params.every((p, i) => typeEquals(p, full[i]))) {
@@ -1024,8 +986,9 @@ function truthyFilterCallback(lowerer, valueT, loc) {
 }
 /** The predicate result kinds `.filter()` accepts. JS applies ToBoolean to
  * whatever the callback answers, so a bool is not required: the scalars and
- * the reference kinds have constant or by-value answers, and a union is fine
- * when every arm does. void/dyn/jsval/caught stay out — see below. */
+ * the reference kinds have constant or by-value answers, checked-dynamic
+ * values ask their runtime kind, and a union is fine when every arm does.
+ * void/jsval/caught stay out — see below. */
 function filterPredicateOk(lowerer, ret) {
     if (ret.kind === "bool")
         return true;
@@ -1035,10 +998,13 @@ function filterPredicateOk(lowerer, ret) {
     // compiled ABI has already discarded it. Treating void as constantly
     // falsy would silently answer [] where Node answers [1]. Fenced until
     // the returned value can be preserved through the void ABI.
-    // dyn/jsval/caught stay out too: no native ToBoolean to compile against.
+    // A checked-dynamic value retains its runtime kind, so scr_dyn_truthy can
+    // apply JavaScript ToBoolean exactly. Island and caught values stay out.
     if (ret.kind === "void")
         return false;
-    if (ret.kind === "dyn" || ret.kind === "jsval" || ret.kind === "caught")
+    if (ret.kind === "dyn")
+        return true;
+    if (ret.kind === "jsval" || ret.kind === "caught")
         return false;
     if (ret.kind === "union") {
         const def = lowerer.unions.get(ret.unionId);
@@ -1058,9 +1024,9 @@ function filterCond(call, fnRet, loc) {
     // `void` returns to void and a standalone `null` return to the unit-ONLY
     // UNION, which routes through toBool below; ir/validate.ts rejects a
     // bare unit return type outright). filterPredicateOk already rejected
-    // the arms with no native ToBoolean (dyn/caught) — which is exactly what
-    // requireTruthyUnion checks — and it did so at the call site, where a
-    // real node exists for the diagnostic.
+    // unsafe union arms (dyn/caught) at the call site, where a real node
+    // exists for the diagnostic. A bare dyn value is handled directly by
+    // the runtime's kind-aware ToBoolean.
     return { kind: "toBool", operand: call, type: BOOL, loc };
 }
 /** Interned synthetic loop function for one (method, elem, fnRet, arity)
@@ -1113,7 +1079,7 @@ export function lowerTupleReadMethodCall(lowerer, call, access) {
     receiver ??= lowerer.lowerExpr(access.expression);
     if (receiver.type.kind !== "record")
         return null;
-    if (!pureReemittable(receiver)) {
+    if (!isSafeToRepeat(receiver)) {
         lowerer.noLowering(`${lowerer.checker.typeToString(lowerer.typeOf(access.expression))}.${name}`, call, "tuple receivers snapshot per position, so only effect-free receivers lower — bind the tuple to a const first");
     }
     const loc = locOf(call);
@@ -1400,14 +1366,14 @@ function buildArrayHofFn(lowerer, name, method, elem, fnRet, arity, loc, outElem
    * backwards (`i = n - 1; i >= 0; i--`), exactly the es2023 spec's
    * descending index walk. All require a bool-returning callback
    * (JS's ToBoolean of arbitrary predicate results has no lowering). */
-function lowerArrayFindLikeCall(lowerer, call, access, method, elem) {
+function lowerArrayFindLikeCall(lowerer, call, access, method, elem, bindUntyped = false) {
     const loc = locOf(call);
     const receiver = lowerer.lowerExpr(access.expression);
     const arrT = arrayOf(elem);
     const argNode = call.arguments[0];
     if (!argNode)
         lowerer.unsupported("SC1090", call, "this call form"); // tsc-guarded
-    const { fnArg, arity } = hofCallbackArg(lowerer, argNode, [arrayValueType(lowerer, elem)], arrT);
+    const { fnArg, arity } = hofCallbackArg(lowerer, argNode, [arrayValueType(lowerer, elem)], arrT, bindUntyped);
     // JS takes the ToBoolean of the predicate's result — allowed wherever
     // that ToBoolean has a static answer (bool passes through; f64/string
     // by value; a truthy-answerable union by its arm — the
@@ -1437,7 +1403,7 @@ function lowerArrayFindLikeCall(lowerer, call, access, method, elem) {
     // found element passes through untouched; otherwise it wraps into its
     // arm. A union element whose result union differs would need the
     // union-into-union re-tag that doesn't exist — fenced.
-    const resultT = lowerer.irTypeOf(call);
+    const resultT = bindUntyped ? arrayValueType(lowerer, elem) : lowerer.irTypeOf(call);
     if (resultT.kind !== "union")
         lowerer.badType(call, lowerer.typeOf(call)); // defensive: T | undefined always maps to a union
     const undefTag = lowerer.armTag(resultT.unionId, UNDEFINED_T);
@@ -1605,7 +1571,7 @@ function someEveryHelper(lowerer, method, elem, fnRet, arity, loc) {
         countedFor(loc, varRef("n.0", F64, loc), () => [
             {
                 kind: "if",
-                cond: getHasExpr(arrT, loc),
+                cond: currentArrayIndexPresent(arrT, loc),
                 then: [{
                         kind: "if",
                         cond: method === "some" ? callF : { kind: "unary", op: "!", operand: callF, type: BOOL, loc },
@@ -1703,7 +1669,7 @@ function flatMapHelper(lowerer, elem, fnRet, arity, loc) {
         body: [
             {
                 kind: "if",
-                cond: arrayHasExpr(varRef("r.0", fnRet, loc), varRef("j.0", F64, loc), loc),
+                cond: arrayIndexPresent(varRef("r.0", fnRet, loc), varRef("j.0", F64, loc), loc),
                 then: [
                     { kind: "varDecl", localId: "inner.0", init: arrayValueRead(lowerer, varRef("r.0", fnRet, loc), varRef("j.0", F64, loc), inner, loc), loc },
                     arrayValueStore(lowerer, varRef("out.0", fnRet, loc), { kind: "arrIntrinsic", method: "length", receiver: varRef("out.0", fnRet, loc), args: [], type: F64, loc }, varRef("inner.0", arrayValueType(lowerer, inner), loc), inner, loc),
@@ -1720,7 +1686,7 @@ function flatMapHelper(lowerer, elem, fnRet, arity, loc) {
         countedFor(loc, varRef("n.0", F64, loc), () => [
             {
                 kind: "if",
-                cond: getHasExpr(arrT, loc),
+                cond: currentArrayIndexPresent(arrT, loc),
                 then: [
                     {
                         kind: "varDecl",
@@ -1843,7 +1809,7 @@ function reduceHelper(lowerer, method, elem, accT, fnRet, arity, hasInit, loc) {
         ...(hasInit
             ? [{ kind: "varDecl", localId: "acc.0", init: varRef("z.0", accT, loc), loc }]
             : [
-                { kind: "while", cond: { kind: "ternary", cond: inRange, then: { kind: "unary", op: "!", operand: getHasExpr(arrT, loc), type: BOOL, loc }, else_: boolLit(false, loc), type: BOOL, loc }, body: [advance], loc },
+                { kind: "while", cond: { kind: "ternary", cond: inRange, then: { kind: "unary", op: "!", operand: currentArrayIndexPresent(arrT, loc), type: BOOL, loc }, else_: boolLit(false, loc), type: BOOL, loc }, body: [advance], loc },
                 { 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: lowerer.coerceToExpected(at(i), accT), loc },
                 advance,
@@ -1861,7 +1827,7 @@ function reduceHelper(lowerer, method, elem, accT, fnRet, arity, hasInit, loc) {
             value: { kind: "bin", op: right ? "-" : "+", left: i, right: numLit(1, loc), type: F64, loc },
             loc,
         },
-        body: [{ kind: "if", cond: getHasExpr(arrT, loc), then: [
+        body: [{ kind: "if", cond: currentArrayIndexPresent(arrT, loc), then: [
                     {
                         kind: "assign",
                         localId: "acc.0",
@@ -1997,83 +1963,6 @@ function defaultStringCmpHelper(lowerer, loc) {
     });
     return name;
 }
-/** Uint8Array.prototype.toSorted. The receiver/comparator expressions are
- * evaluated before entering the helper; the helper snapshots with
- * TypedArray.prototype.slice before its first comparison, then performs
- * the same stable merge walk as Array.toSorted. Uint8Array's default
- * comparator is numeric ascending, so its comparator-less form needs no
- * string-conversion machinery. */
-function lowerBytesToSortedCall(lowerer, call, access, bytesT) {
-    const loc = locOf(call);
-    if (call.arguments.length > 1 || call.arguments.some(ts.isSpreadElement)) {
-        lowerer.noLowering(`.toSorted with ${call.arguments.length} arguments on Uint8Array`, call);
-    }
-    const receiver = lowerer.lowerExpr(access.expression);
-    const undefinedArg = call.arguments[0]
-        ? lowerStaticallyUndefinedArg(lowerer, call.arguments[0])
-        : null;
-    if (call.arguments.length === 0 || undefinedArg) {
-        const key = "bytes.toSorted:u8:default";
-        let helper = lowerer.arrHofHelpers.get(key);
-        if (!helper) {
-            helper = `%bytes.toSorted.${lowerer.arrHofHelpers.size}`;
-            lowerer.arrHofHelpers.set(key, helper);
-            lowerer.liftedFns.push(buildBytesSortFn(helper, 0, false, loc));
-        }
-        if (!undefinedArg || droppableStatic(undefinedArg)) {
-            return { kind: "call", callee: helper, args: [receiver], type: bytesT, loc };
-        }
-        // The default helper takes no comparator argument. Snapshot the
-        // receiver into a hidden local so the discarded undefined argument
-        // still evaluates after the receiver and before the helper call.
-        const saved = lowerer.declareHiddenLocal("%bytesSortRecv", bytesT);
-        const savedRef = {
-            kind: "varRef",
-            localId: saved.id,
-            type: bytesT,
-            loc,
-        };
-        return {
-            kind: "seqExpr",
-            stmts: [
-                { kind: "varDecl", localId: saved.id, init: receiver, loc },
-                { kind: "exprStmt", expr: undefinedArg, loc: undefinedArg.loc },
-            ],
-            result: {
-                kind: "call",
-                callee: helper,
-                args: [savedRef],
-                type: bytesT,
-                loc,
-            },
-            type: bytesT,
-            loc,
-        };
-    }
-    const argNode = call.arguments[0];
-    const fnArg = lowerer.lowerExpr(argNode);
-    if (fnArg.type.kind !== "func" ||
-        fnArg.type.params.length > 2 ||
-        !fnArg.type.params.every((p) => p.kind === "f64") ||
-        fnArg.type.ret.kind !== "f64") {
-        lowerer.badType(argNode, lowerer.typeOf(argNode));
-    }
-    const arity = fnArg.type.params.length;
-    const key = `bytes.toSorted:u8:${arity}`;
-    let helper = lowerer.arrHofHelpers.get(key);
-    if (!helper) {
-        helper = `%bytes.toSorted.${lowerer.arrHofHelpers.size}`;
-        lowerer.arrHofHelpers.set(key, helper);
-        lowerer.liftedFns.push(buildBytesSortFn(helper, arity, true, loc));
-    }
-    return {
-        kind: "call",
-        callee: helper,
-        args: [receiver, fnArg],
-        type: bytesT,
-        loc,
-    };
-}
 /** `n = a.length` — the once-up-front length read every array HOF loop
    * starts with (locals a.0/n.0 by convention). */
 function readLenStmt(arrT, loc) {
@@ -2457,7 +2346,15 @@ export function lowerMapMethodCall(lowerer, call, access) {
     const name = access.name.text;
     if (!MAP_METHODS.has(name) && !MAP_ITER_METHODS.has(name))
         return null;
-    const receiverIr = lowerer.mapTypeOf(lowerer.typeOf(access.expression));
+    let receiverIr = lowerer.mapTypeOf(lowerer.typeOf(access.expression));
+    let probedUntyped = false;
+    if (receiverIr?.kind !== "map" && isJsSourceFile(access.getSourceFile())) {
+        const probed = tryLowerExpression(lowerer, access.expression);
+        if (probed?.type.kind === "map") {
+            receiverIr = probed.type;
+            probedUntyped = true;
+        }
+    }
     if (receiverIr?.kind !== "map")
         return null;
     if (!lowerer.isStdlibMember(access))
@@ -2501,7 +2398,7 @@ export function lowerMapMethodCall(lowerer, call, access) {
         return lowerMapIterDrainCall(lowerer, call, receiver, receiverIr, name);
     }
     // forEach
-    return lowerer.lowerMapForEachCall(call, receiver, receiverIr);
+    return lowerMapForEachCall(lowerer, call, receiver, receiverIr, probedUntyped);
 }
 /** The iterator methods the lowering DOES cover — in exactly one context. */
 const MAP_ITER_METHODS = new Set(["keys", "values", "entries"]);
@@ -2621,12 +2518,52 @@ function buildMapIterDrainFn(name, mapT, method, elemT, tupleT, loc) {
    * callback throws. That is JS's live-iteration contract, Node-verified
    * (SEMANTICS.md). The callback receives (value, key) like JS; declaring
    * fewer parameters — (value) or () — is ordinary TS and supported. */
-export function lowerMapForEachCall(lowerer, call, receiver, mapT) {
+export function lowerMapForEachCall(lowerer, call, receiver, mapT, bindUntyped = false) {
     const loc = locOf(call);
     const argNode = call.arguments[0];
     if (!argNode)
         lowerer.unsupported("SC1090", call, "this call form"); // tsc-guarded
-    const fnArg = lowerer.lowerExpr(argNode);
+    const previousRuntime = [];
+    const previousImplicit = lowerer.implicitParamTypes;
+    let contextualTs = null;
+    if (bindUntyped && (ts.isArrowFunction(argNode) || ts.isFunctionExpression(argNode))) {
+        const expected = [mapT.value, mapT.key];
+        argNode.parameters.slice(0, 2).forEach((param, i) => {
+            const type = expected[i];
+            if (type === undefined || !ts.isIdentifier(param.name) || param.type || param.initializer || param.dotDotDotToken)
+                return;
+            const checkerType = lowerer.checker.getTypeAtLocation(param.name);
+            if ((checkerType.flags & (ts.TypeFlags.Any | ts.TypeFlags.Unknown)) === 0)
+                return;
+            const symbol = lowerer.checker.getSymbolAtLocation(param.name);
+            if (!symbol)
+                return;
+            previousRuntime.push({ symbol, type: lowerer.runtimeOptionalBindingTypes.get(symbol) });
+            lowerer.runtimeOptionalBindingTypes.set(symbol, type);
+            const primitive = type.kind === "string" ? lowerer.checker.getStringType() :
+                type.kind === "f64" ? lowerer.checker.getNumberType() :
+                    type.kind === "bool" ? lowerer.checker.getBooleanType() : null;
+            if (primitive !== null) {
+                contextualTs ??= new Map(previousImplicit ?? []);
+                contextualTs.set(symbol, primitive);
+            }
+        });
+    }
+    if (contextualTs !== null)
+        lowerer.implicitParamTypes = contextualTs;
+    let fnArg;
+    try {
+        fnArg = lowerer.lowerExpr(argNode);
+    }
+    finally {
+        lowerer.implicitParamTypes = previousImplicit;
+        for (const { symbol, type } of previousRuntime) {
+            if (type === undefined)
+                lowerer.runtimeOptionalBindingTypes.delete(symbol);
+            else
+                lowerer.runtimeOptionalBindingTypes.set(symbol, type);
+        }
+    }
     if (fnArg.type.kind !== "func" ||
         fnArg.type.params.length > 2 ||
         (fnArg.type.params.length >= 1 && !typeEquals(fnArg.type.params[0], mapT.value)) ||
@@ -2749,8 +2686,8 @@ export function lowerSetMethodCall(lowerer, call, access) {
     // Set<union-of-signatures>, but the VALUE lowered as a real Set of
     // identity tokens (the new-Set probe) — the lowered receiver's type
     // is the honest dispatch key.
-    if (receiverIr === null && isJsSourceFile(access.getSourceFile())) {
-        const probed = probeLower(lowerer, access.expression);
+    if (receiverIr?.kind !== "set" && isJsSourceFile(access.getSourceFile())) {
+        const probed = tryLowerExpression(lowerer, access.expression);
         if (probed?.type.kind === "set")
             receiverIr = probed.type;
     }
@@ -4401,1271 +4338,6 @@ function buildMapSeedFn(mapT, name, arrT, tupleT, kT, vT, loc) {
         loc,
     };
 }
-/** Regex method calls, both directions: `re.test(s)` on a regex receiver,
-   * and `s.replace(re, tpl)` / `s.replaceAll(re, tpl)` / `s.split(re)` on a
-   * string receiver whose FIRST ARGUMENT is a regex (the string-pattern
-   * overloads keep their island lowering — the argument's mapped type is
-   * what routes here, before lowerIslandMethodCall can claim the name).
-   * Null when neither shape matches. */
-export function lowerRegexMethodCall(lowerer, call, access, dynReceiver) {
-    // chainBlocked, not a raw token test: an optional-chain re-dispatch
-    // (`rawName?.match(re)` — the receiver reads back chain-narrowed)
-    // rides the same lowering as the plain spelling.
-    if (lowerer.chainBlocked(access, call))
-        return null;
-    // A validated dyn receiver (lowerStringMethodCall's story) is a STRING
-    // by construction — the symbol gate doesn't apply to `any` receivers.
-    if (dynReceiver === undefined && !lowerer.isStdlibMember(access))
-        return null;
-    const name = access.name.text;
-    const receiverKind = dynReceiver ? "string" : lowerer.mapTypeOf(lowerer.typeOf(access.expression))?.kind;
-    const lowerReceiver = () => {
-        if (dynReceiver)
-            return dynReceiver();
-        if (receiverKind === "string")
-            return lowerMethodReceiver(lowerer, access.expression, STRING, access.name.text);
-        if (receiverKind === "regex")
-            return lowerMethodReceiver(lowerer, access.expression, { kind: "regex" }, access.name.text);
-        return lowerer.lowerExpr(access.expression);
-    };
-    const loc = locOf(call);
-    if (receiverKind === "regex" && name === "test") {
-        // The statefulness fence, at compile time where the flags are
-        // visible: a literal receiver (possibly parenthesized). Values that
-        // flow through variables hit the same fence at runtime.
-        let recv = access.expression;
-        while (ts.isParenthesizedExpression(recv))
-            recv = recv.expression;
-        if (ts.isRegularExpressionLiteral(recv)) {
-            const flags = recv.text.slice(recv.text.lastIndexOf("/") + 1);
-            if (flags.includes("g") || flags.includes("y")) {
-                lowerer.unsupported("SC1121", call);
-            }
-        }
-        const receiver = lowerReceiver();
-        const args = call.arguments.map((a) => lowerer.lowerExpr(a));
-        return { kind: "regexIntrinsic", method: "test", receiver, args, type: BOOL, loc };
-    }
-    // `re.exec(s)` for non-g/y regexes: spec-identical to `s.match(re)`
-    // (Symbol.match delegates to exec when lastIndex is out of play), so
-    // it lowers to the SAME match intrinsic with the operands swapped —
-    // the honest `string[] | null` slice, nonparticipating captures ""
-    // (match's documented rule). The g/y statefulness fence applies at
-    // compile time on literal receivers, exactly test()'s stance; values
-    // reaching the runtime with those flags abort there.
-    if (receiverKind === "regex" && name === "exec") {
-        if (call.arguments.length !== 1)
-            return null; // exec takes exactly the subject
-        let recv = access.expression;
-        while (ts.isParenthesizedExpression(recv))
-            recv = recv.expression;
-        if (ts.isRegularExpressionLiteral(recv)) {
-            const flags = recv.text.slice(recv.text.lastIndexOf("/") + 1);
-            if (flags.includes("g") || flags.includes("y")) {
-                lowerer.unsupported("SC1121", call);
-            }
-        }
-        const re = lowerReceiver();
-        const subject = lowerer.lowerExprExpecting(call.arguments[0], STRING);
-        const resultT = { kind: "union", unionId: lowerer.unions.intern([arrayOf(STRING), { kind: "nullT" }]) };
-        return { kind: "regexIntrinsic", method: "match", receiver: subject, args: [re], type: resultT, loc };
-    }
-    // `s.match(re)` for non-g/y regexes: Node's exec-shaped result reduced
-    // to the honest slice — the `string[] | null` union holding
-    // [whole match, ...captures] or the null arm. The g-flag match returns
-    // EVERY match (a different shape) and /y is stateful — both fence at
-    // compile time on literal arguments (values reaching the runtime with
-    // those flags abort, the test() stance). `.index`/`.input` reads on
-    // the result fence per member (array-typed value); `.groups` reads
-    // desugar at their access sites when the regex is statically known
-    // (lowerMatchGroupsRead).
-    // `s.match(re)` also claims a NULLABLE string receiver (string + unit
-    // arms — `process.versions.openssl.match(...)`, the Dict<string>
-    // member the node suite's crypto helper reads): the checked
-    // extraction narrows to the string arm and a unit value throws the
-    // catchable TypeError at the read, where Node's own member read
-    // throws — tsc only admits the spelling in JS sources.
-    const nullableStringRecv = receiverKind === "union" &&
-        name === "match" &&
-        (() => {
-            const t = lowerer.mapTypeOf(lowerer.typeOf(access.expression));
-            if (t?.kind !== "union")
-                return false;
-            const arms = lowerer.unions.get(t.unionId)?.arms ?? [];
-            return arms.some((a) => a.kind === "string") && arms.every((a) => a.kind === "string" || isUnitType(a));
-        })();
-    if ((receiverKind === "string" || nullableStringRecv) && name === "match") {
-        const arg0 = call.arguments[0];
-        if (!arg0 || lowerer.mapTypeOf(lowerer.typeOf(arg0))?.kind !== "regex")
-            return null; // string-pattern match: the SC2020 fence
-        if (call.arguments.length !== 1)
-            return null;
-        let reNode = arg0;
-        while (ts.isParenthesizedExpression(reNode))
-            reNode = reNode.expression;
-        if (ts.isRegularExpressionLiteral(reNode)) {
-            const flags = reNode.text.slice(reNode.text.lastIndexOf("/") + 1);
-            if (flags.includes("g") || flags.includes("y")) {
-                lowerer.unsupported("SC1120", call, "'.match()' with the 'g' or 'y' flag (an every-match array is a different shape — use replaceAll/split, or test() per position)");
-            }
-        }
-        const receiver = nullableStringRecv
-            ? lowerMethodReceiver(lowerer, access.expression, STRING, access.name.text)
-            : lowerReceiver();
-        const re = lowerer.lowerExpr(arg0);
-        // RegExpMatchArray | null maps to the string[] | null union by
-        // itself; intern it directly when the checker's spelling doesn't —
-        // or when it maps to something WIDER (an optional-chain call node
-        // types `s?.match(re)` with the chain's `| undefined`; the intrinsic
-        // itself answers string[] | null, and the chain wrapper widens).
-        const exactT = { kind: "union", unionId: lowerer.unions.intern([arrayOf(STRING), { kind: "nullT" }]) };
-        const mapped = lowerer.mapTypeOf(lowerer.typeOf(call));
-        const resultT = mapped && typeEquals(mapped, exactT) ? mapped : exactT;
-        return { kind: "regexIntrinsic", method: "match", receiver, args: [re], type: resultT, loc };
-    }
-    // `s.matchAll(re)` — the every-match iterator drained EAGERLY into a
-    // string[][] (one honest match slice per row — match's rule). Lazy vs
-    // eager is unobservable here: strings are immutable, and the spec
-    // clones the regex at the call, so nothing can perturb the drain. The
-    // eager array IS what the two lowered consumers see anyway (the
-    // immediate [...spread] and the for-of walk); a stored iterator's
-    // .next() fences as an array member like any other. Non-global
-    // regexes throw Node's exact TypeError at runtime, catchably
-    // (replaceAll's stance).
-    if (receiverKind === "string" && name === "matchAll") {
-        const arg0 = call.arguments[0];
-        if (!arg0 || lowerer.mapTypeOf(lowerer.typeOf(arg0))?.kind !== "regex")
-            return null; // string-pattern form: the SC2020 fence
-        if (call.arguments.length !== 1)
-            return null;
-        const receiver = lowerReceiver();
-        const re = lowerer.lowerExpr(arg0);
-        return {
-            kind: "regexIntrinsic",
-            method: "matchAll",
-            receiver,
-            args: [re],
-            type: arrayOf(arrayOf(STRING)),
-            loc,
-        };
-    }
-    // `s.search(re)` — the first match's UTF-16 index, or -1. No g/y fence
-    // (unlike test/match): Symbol.search neither reads nor writes lastIndex
-    // — a fresh exec from position 0, so /g is irrelevant and /y anchors at
-    // 0, exactly Node. Never throws.
-    if (receiverKind === "string" && name === "search") {
-        const arg0 = call.arguments[0];
-        if (!arg0 || lowerer.mapTypeOf(lowerer.typeOf(arg0))?.kind !== "regex")
-            return null; // string-pattern form: the SC2020 fence
-        if (call.arguments.length !== 1)
-            return null;
-        const receiver = lowerReceiver();
-        const re = lowerer.lowerExpr(arg0);
-        return { kind: "regexIntrinsic", method: "search", receiver, args: [re], type: F64, loc };
-    }
-    if (receiverKind === "string" &&
-        (name === "replace" || name === "replaceAll" || name === "split")) {
-        const arg0 = call.arguments[0];
-        if (!arg0 || lowerer.mapTypeOf(lowerer.typeOf(arg0))?.kind !== "regex")
-            return null;
-        const receiver = lowerReceiver();
-        // Split's omitted or undefined limit is 2^32-1. Complete it here so
-        // both IR backends and the runtime have one required (regex, limit)
-        // shape; an optional-number value selects the default at runtime.
-        const args = name === "split"
-            ? [lowerer.lowerExpr(arg0), lowerSplitLimitArg(lowerer, call.arguments[1], loc)]
-            : call.arguments.map((a) => lowerer.lowerExpr(a));
-        if (name !== "split" && args[1]?.type.kind !== "string") {
-            lowerer.unsupported("SC1120", call.arguments[1] ?? call, "function replacement values (replacements must be string templates)");
-        }
-        return {
-            kind: "regexIntrinsic",
-            method: name,
-            receiver,
-            args,
-            type: name === "split" ? arrayOf(STRING) : STRING,
-            loc,
-        };
-    }
-    return null;
-}
-/** `s.slice(1, 4)` and friends → strIntrinsic. Null when this isn't an
-   * ambient string method call (caller keeps its generic rejection). Missing
-   * optional arguments are omitted from `args` — the backend fills the
-   * documented defaults; the IR never encodes them (Infinity isn't
-   * JSON-safe). tsc has already checked arity and argument types against
-   * ambient/scriptc.d.ts. */
-export function lowerStringMethodCall(lowerer, call, access, dynReceiver) {
-    if (lowerer.chainBlocked(access, call))
-        return null;
-    if (dynReceiver === undefined && access.name.text === "localeCompare")
-        return lowerLocaleCompareCall(lowerer, call, access);
-    const entry = own(STR_METHODS, access.name.text);
-    if (!entry)
-        return null;
-    // A validated dyn receiver (`pkg.name.replace(...)` on a JSON.parse
-    // value) arrives pre-extracted through `dynReceiver`; its checker type
-    // is `any`, so the type/symbol gates don't apply — the dyn value's
-    // methods can only BE the string intrinsics.
-    if (dynReceiver === undefined) {
-        const receiverIr = lowerer.mapTypeOf(lowerer.typeOf(access.expression));
-        // `require.main?.filename.startsWith(...)`: the checker types the
-        // receiver `string | undefined` (the chain's short-circuit arm), but
-        // the entry-module fold lowers it to a compile-time STRING — the
-        // suite harness's skip() shape. Everything else keeps the strict
-        // string gate.
-        if (receiverIr?.kind !== "string" && !isRequireMainFilename(lowerer, access.expression))
-            return null;
-        if (!lowerer.isStdlibMember(access))
-            return null;
-    }
-    // The lib declares optional parameters beyond the lowered forms
-    // (includes/startsWith/endsWith take a position); fence the unlowered
-    // arities instead of passing arguments the runtime doesn't take.
-    if (call.arguments.length < entry.minArgs || call.arguments.length > entry.maxArgs) {
-        lowerer.noLowering(`.${access.name.text} with ${call.arguments.length} argument${call.arguments.length === 1 ? "" : "s"} on strings`, call);
-    }
-    const receiver = dynReceiver
-        ? dynReceiver()
-        : lowerMethodReceiver(lowerer, access.expression, STRING, access.name.text);
-    const args = entry.method === "split"
-        ? [lowerer.lowerExpr(call.arguments[0]), lowerSplitLimitArg(lowerer, call.arguments[1], locOf(call))]
-        : call.arguments.map((a) => lowerer.lowerExpr(a));
-    // split's separator must BE a string here (a regex argument was
-    // claimed by lowerRegexMethodCall before this path) — the lib's
-    // `string | RegExp` union has no lowering as a VALUE.
-    if (entry.method === "split" && args[0].type.kind !== "string") {
-        lowerer.unsupported("SC1090", call.arguments[0], `'.split()' on a '${lowerer.fmt(args[0].type)}' separator (pass a string, or a regex literal)`);
-    }
-    // padStart/padEnd with the fill omitted: Node pads with " " — the
-    // same call with the default made explicit.
-    if ((entry.method === "padStart" || entry.method === "padEnd") && args.length === 1) {
-        args.push({ kind: "strLit", value: " ", type: STRING, loc: locOf(call) });
-    }
-    return {
-        kind: "strIntrinsic",
-        method: entry.method,
-        receiver,
-        args,
-        type: entry.result,
-        loc: locOf(call),
-    };
-}
-/** `a.localeCompare(b)` — the one-argument form only (locales/options
-   * select ICU collations that do not exist here). Lowers to an interned
-   * synthetic function returning -1/0/1 by CODE-UNIT order — the same
-   * ordering as the string relational operators — NOT Node's ICU default
-   * collation: a documented divergence (SEMANTICS.md; e.g. Node says
-   * "a" < "B" under ICU while code units say "B" < "a"). For same-case
-   * ASCII the orders agree. Null when the receiver isn't a stdlib string
-   * (caller keeps its generic rejection). */
-function lowerLocaleCompareCall(lowerer, call, access) {
-    const receiverIr = lowerer.mapTypeOf(lowerer.typeOf(access.expression));
-    if (receiverIr?.kind !== "string")
-        return null;
-    if (!lowerer.isStdlibMember(access))
-        return null;
-    const loc = locOf(call);
-    if (call.arguments.length !== 1) {
-        lowerer.noLowering(`.localeCompare with ${call.arguments.length} arguments`, call, "the locales/options parameters select ICU collations that have no lowering — " +
-            "pass exactly the comparison string");
-    }
-    const receiver = lowerMethodReceiver(lowerer, access.expression, STRING, access.name.text);
-    const arg = lowerer.lowerExpr(call.arguments[0]);
-    if (arg.type.kind !== "string")
-        lowerer.badType(call.arguments[0], lowerer.typeOf(call.arguments[0]));
-    const key = "localeCompare";
-    let helper = lowerer.arrHofHelpers.get(key);
-    if (!helper) {
-        helper = `%str.localeCompare`;
-        lowerer.arrHofHelpers.set(key, helper);
-        lowerer.liftedFns.push(buildLocaleCompareFn(helper, loc));
-    }
-    return { kind: "call", callee: helper, args: [receiver, arg], type: F64, loc };
-}
-/** `return a < b ? -1 : a > b ? 1 : 0` over the strCmp primitive (the
-   * relational operators' exact machinery — one interned helper, no new IR
-   * or runtime surface). */
-function buildLocaleCompareFn(name, loc) {
-    const cmp = (op) => ({ kind: "strCmp", op, left: varRef("a.0", STRING, loc), right: varRef("b.0", STRING, loc), type: BOOL, loc });
-    const body = [
-        {
-            kind: "return",
-            value: {
-                kind: "ternary",
-                cond: cmp("<"),
-                then: numLit(-1, loc),
-                else_: { kind: "ternary", cond: cmp(">"), then: numLit(1, loc), else_: numLit(0, loc), type: F64, loc },
-                type: F64,
-                loc,
-            },
-            loc,
-        },
-    ];
-    return {
-        name,
-        params: [
-            { localId: "a.0", name: "a", type: STRING },
-            { localId: "b.0", name: "b", type: STRING },
-        ],
-        returnType: F64,
-        locals: [
-            { id: "a.0", name: "a", type: STRING, mutable: true },
-            { id: "b.0", name: "b", type: STRING, mutable: true },
-        ],
-        body,
-        loc,
-    };
-}
-/* ── typed arrays / Buffer ─────────────────────────────────────────────── */
-/** The typed-array constructors with a runtime representation, by lib
- * interface name. The other TypedArray flavors (Int8Array, Float64Array,
- * DataView, ...) fall through to the generic stdlib-constructor fence. */
-const BYTES_CTORS = {
-    Uint8Array: "u8",
-    Uint32Array: "u32",
-    Int32Array: "i32",
-    Float32Array: "f32",
-};
-/** `new Uint8Array(...)` / `new Uint32Array(...)` / `new Float32Array(...)`
-   * (stdlib provenance — a user's own class with the name resolves through
-   * classBySymbol). Lowered argument shapes: none (empty), a length
-   * (zero-filled; ToIndex at runtime — invalid lengths throw Node's
-   * RangeError), a same-kind typed array or Buffer (an independent COPY —
-   * the readFile chain's `new Uint8Array(await readFile(p))`), a number[]
-   * literal (element-coerced; its contextual type is the lib's
-   * ArrayLike/Iterable union, which cannot map — the Set-seed pattern), or
-   * a number[]-typed value. ArrayBuffer/view forms are fenced: scriptc
-   * typed arrays own their storage. Null when this isn't a stdlib
-   * typed-array construction. */
-export function lowerBytesNew(lowerer, expr, symbol) {
-    if (symbol && symbol.name === "DataView" && lowerer.isStdlibSymbol(symbol)) {
-        return lowerDataViewNew(lowerer, expr);
-    }
-    const elem = symbol ? own(BYTES_CTORS, symbol.name) : undefined;
-    if (!elem || !symbol || !lowerer.isStdlibSymbol(symbol))
-        return null;
-    const name = symbol.name;
-    const type = bytesOf(elem);
-    const loc = locOf(expr);
-    const args = expr.arguments ?? [];
-    if (args.length === 0)
-        return { kind: "bytesNew", source: null, type, loc };
-    if (args.length === 1 && !ts.isSpreadElement(args[0])) {
-        const argNode = args[0];
-        if (ts.isArrayLiteralExpression(argNode) && !argNode.elements.some(ts.isSpreadElement)) {
-            const elems = argNode.elements.map((el) => lowerer.lowerExprExpecting(el, F64));
-            const seed = { kind: "arrayLit", elems, type: arrayOf(F64), loc };
-            return { kind: "bytesNew", source: seed, type, loc };
-        }
-        // The SYNTACTIC `new T(new ArrayBuffer(n))` and `new T(new
-        // SharedArrayBuffer(n))` forms — fresh-buffer construction (the
-        // shared spelling is the Atomics.wait sleep idiom's). The buffer
-        // never exists as a value: n must be a byte-length LITERAL divisible
-        // by the element size (tsc would admit any number; a bad one is
-        // Node's RangeError — rejected at compile time instead of
-        // half-lowering), and the whole expression is a zero-filled typed
-        // array of n/elemSize elements. Erasing the buffer is exact: nothing
-        // else can ever reference it, so neither sharing (scriptc has no
-        // threads) nor aliasing is observable — SEMANTICS.md documents the
-        // stance. The RESIZABLE form (a maxByteLength options bag) fences by
-        // name: resize needs the buffer to exist as a value, and none does.
-        if (ts.isNewExpression(argNode) &&
-            ts.isIdentifier(argNode.expression) &&
-            (argNode.expression.text === "ArrayBuffer" ||
-                argNode.expression.text === "SharedArrayBuffer") &&
-            lowerer.isStdlibSymbol(lowerer.resolveValueSymbol(argNode.expression) ?? undefined)) {
-            const bufCtor = argNode.expression.text;
-            if ((argNode.arguments?.length ?? 0) > 1) {
-                lowerer.noLowering(`new ${name} over a resizable ${bufCtor}`, argNode, "a maxByteLength options bag makes the buffer resizable, and resizing needs the buffer " +
-                    "to exist as a runtime value — no free-standing ArrayBuffer value exists (the buffer here " +
-                    "erases into the view): drop the options bag");
-            }
-            const elemSize = elem === "u8" ? 1 : 4;
-            const lenArg = argNode.arguments?.length === 1 ? argNode.arguments[0] : undefined;
-            const lenT = lenArg ? lowerer.typeOf(lenArg) : null;
-            const byteLen = lenT?.isNumberLiteralType() ? lenT.value : null;
-            if (byteLen === null || byteLen % elemSize !== 0 || byteLen < 0) {
-                lowerer.noLowering(`new ${name} over this ${bufCtor}`, argNode, `the byte length must be a number literal divisible by ${elemSize} — new ${name}(new ${bufCtor}(${elemSize}))`);
-            }
-            const count = { kind: "numLit", value: byteLen / elemSize, type: F64, loc };
-            return { kind: "bytesNew", source: count, type, loc };
-        }
-        const src = lowerer.lowerExpr(argNode);
-        if (src.type.kind === "union" && lowerer.armTag(src.type.unionId, UNDEFINED_T) >= 0) {
-            const present = lowerer.stripUndefinedArm(src.type);
-            if (present.kind === "array" && present.elem.kind === "f64") {
-                const undefTag = lowerer.armTag(src.type.unionId, UNDEFINED_T);
-                const presentTag = lowerer.armTag(src.type.unionId, present);
-                if (undefTag >= 0 && presentTag >= 0) {
-                    const empty = { kind: "arrayLit", elems: [], type: present, loc };
-                    const source = {
-                        kind: "ternary",
-                        cond: { kind: "unionIsTag", unionId: src.type.unionId, tag: undefTag, negated: false, value: src, type: BOOL, loc },
-                        then: empty,
-                        else_: { kind: "unionNarrow", unionId: src.type.unionId, tag: presentTag, value: src, type: present, loc },
-                        type: present,
-                        loc,
-                    };
-                    return { kind: "bytesNew", source, type, loc };
-                }
-            }
-        }
-        if (src.type.kind === "f64" ||
-            typeEquals(src.type, type) ||
-            (src.type.kind === "array" && src.type.elem.kind === "f64")) {
-            return { kind: "bytesNew", source: src, type, loc };
-        }
-        if (src.type.kind === "bytes") {
-            lowerer.noLowering(`new ${name} over a '${lowerer.fmt(src.type)}'`, argNode, "cross-kind typed-array conversion has no lowering — copy element by element");
-        }
-        lowerer.noLowering(`new ${name} over '${lowerer.fmt(src.type)}' values`, argNode, `supported: new ${name}(), (length), (typedArray) — always a copy — or (number[]); ` +
-            "ArrayBuffers and views do not exist here (narrow unions first)");
-    }
-    lowerer.noLowering(`new ${name} with ${args.length} arguments`, expr, `supported: new ${name}(), (length), (typedArray), or (number[])`);
-}
-/** `new DataView(x.buffer, byteOffset?, byteLength?)` (stdlib provenance).
-   * The first argument must be the SYNTACTIC `.buffer` of a typed-array/
-   * Buffer value — `x.buffer` names x's own storage (scriptc typed arrays
-   * always own it whole, byteOffset 0), so the view construction takes x
-   * itself as the receiver and no ArrayBuffer value ever exists.
-   * byteOffset/byteLength are optional f64s (omitted args OMITTED, like
-   * slice); bad indices THROW Node's RangeErrors catchably. The result is
-   * a true borrowed view: reads and writes through it alias x. */
-function lowerDataViewNew(lowerer, expr) {
-    const loc = locOf(expr);
-    const args = expr.arguments ?? [];
-    const bufNode = args[0];
-    if (!bufNode || args.length > 3 || args.some(ts.isSpreadElement)) {
-        lowerer.noLowering(`new DataView with ${args.length} arguments`, expr, "supported: new DataView(x.buffer), (x.buffer, byteOffset), or (x.buffer, byteOffset, byteLength)");
-    }
-    // The FRESH-BUFFER form: `new DataView(new ArrayBuffer(n), ...)` — the
-    // buffer erases into the view (nothing else can ever reference it, so
-    // the aliasing a shared buffer would exhibit is unobservable): the
-    // view's storage is a fresh zero-filled n-byte allocation. n must be a
-    // non-negative integer LITERAL (tsc admits any number; a fractional
-    // one is ToIndex truncation nothing here implements). byteOffset and
-    // byteLength keep their runtime Node-RangeError story. The RESIZABLE
-    // form (a maxByteLength options bag) fences by name.
-    if (ts.isNewExpression(bufNode) &&
-        ts.isIdentifier(bufNode.expression) &&
-        bufNode.expression.text === "ArrayBuffer" &&
-        lowerer.isStdlibSymbol(lowerer.resolveValueSymbol(bufNode.expression) ?? undefined)) {
-        if ((bufNode.arguments?.length ?? 0) > 1) {
-            lowerer.noLowering("new DataView over a resizable ArrayBuffer", bufNode, "a maxByteLength options bag makes the buffer resizable, and resizing needs the buffer " +
-                "to exist as a runtime value — no free-standing ArrayBuffer value exists (the buffer here " +
-                "erases into the view): drop the options bag");
-        }
-        const lenArg = bufNode.arguments?.length === 1 ? bufNode.arguments[0] : undefined;
-        const lenT = lenArg ? lowerer.typeOf(lenArg) : null;
-        const byteLen = lenT?.isNumberLiteralType() ? lenT.value : null;
-        if (byteLen === null || !Number.isInteger(byteLen) || byteLen < 0) {
-            lowerer.noLowering("new DataView over this ArrayBuffer", bufNode, "the byte length must be a non-negative integer literal — new DataView(new ArrayBuffer(8))");
-        }
-        const count = { kind: "numLit", value: byteLen, type: F64, loc };
-        const receiver = { kind: "bytesNew", source: count, type: BYTES_U8, loc };
-        const idxArgs = args.slice(1).map((a) => lowerer.lowerExprExpecting(a, F64));
-        return { kind: "bytesIntrinsic", method: "dataViewNew", receiver, args: idxArgs, type: BYTES_U8, loc };
-    }
-    const hint = "views compile over a typed array's own storage — new DataView(x.buffer, byteOffset?, byteLength?) " +
-        "where x is a Uint8Array/Uint32Array/Float32Array/Buffer value — or a fresh buffer erased into " +
-        "the view: new DataView(new ArrayBuffer(n), ...); free-standing ArrayBuffers have no representation";
-    if (!ts.isPropertyAccessExpression(bufNode) || bufNode.name.text !== "buffer" || bufNode.questionDotToken) {
-        lowerer.noLowering("new DataView over this buffer expression", bufNode, hint);
-    }
-    const srcIr = lowerer.mapTypeOf(lowerer.typeOf(bufNode.expression));
-    if (srcIr?.kind !== "bytes" || !lowerer.isStdlibMember(bufNode)) {
-        lowerer.noLowering(`new DataView over '.buffer' of a '${lowerer.checker.typeToString(lowerer.typeOf(bufNode.expression))}'`, bufNode, hint);
-    }
-    const receiver = lowerer.lowerExpr(bufNode.expression);
-    const idxArgs = args.slice(1).map((a) => lowerer.lowerExprExpecting(a, F64));
-    return { kind: "bytesIntrinsic", method: "dataViewNew", receiver, args: idxArgs, type: BYTES_U8, loc };
-}
-/** Method calls on typed-array/Buffer receivers: slice and subarray (BOTH
-   * copy — subarray's sharing is the documented divergence), set(src,
-   * offset?), and the u8-only Buffer surface: toString(enc?) plus the
-   * whole numeric read/write family (fixed widths BE/LE and the
-   * variable-width read/writeUIntLE quartet — BUF_NUM_METHODS). Everything
-   * else the lib declares (fill, indexOf, reverse, ...) falls through to
-   * the SC2020 member fence. Null when this isn't a bytes method call. */
-export function lowerBytesMethodCall(lowerer, call, access) {
-    if (lowerer.chainBlocked(access, call))
-        return null;
-    const name = access.name.text;
-    const receiverIr = lowerer.mapTypeOf(lowerer.typeOf(access.expression));
-    if (receiverIr?.kind !== "bytes")
-        return null;
-    if (!lowerer.isStdlibMember(access))
-        return null;
-    const loc = locOf(call);
-    const nArgs = call.arguments.length;
-    if (receiverIr.elem === "u8" && name === "toSorted") {
-        return lowerBytesToSortedCall(lowerer, call, access, receiverIr);
-    }
-    if (receiverIr.elem === "u8" && name === "toReversed") {
-        if (nArgs !== 0) {
-            lowerer.noLowering(`.toReversed with ${nArgs} arguments on Uint8Array`, call);
-        }
-        return {
-            kind: "bytesIntrinsic",
-            method: "toReversed",
-            receiver: lowerer.lowerExpr(access.expression),
-            args: [],
-            type: receiverIr,
-            loc,
-        };
-    }
-    if (receiverIr.elem === "u8" && name === "with") {
-        if (nArgs !== 2 || call.arguments.some(ts.isSpreadElement)) {
-            lowerer.noLowering(`.with with ${nArgs} arguments on Uint8Array`, call);
-        }
-        return {
-            kind: "bytesIntrinsic",
-            method: "with",
-            receiver: lowerer.lowerExpr(access.expression),
-            args: [
-                lowerer.lowerExprExpecting(call.arguments[0], F64),
-                lowerer.lowerExprExpecting(call.arguments[1], F64),
-            ],
-            type: receiverIr,
-            loc,
-        };
-    }
-    if (receiverIr.elem === "u8" && name === "join") {
-        if (nArgs > 1 || call.arguments.some(ts.isSpreadElement)) {
-            lowerer.noLowering(`.join with ${nArgs} arguments on Uint8Array`, call);
-        }
-        const separatorDefault = {
-            kind: "strLit",
-            value: ",",
-            type: STRING,
-            loc,
-        };
-        const separator = call.arguments[0]
-            ? lowerOptionalDefaultArg(lowerer, call.arguments[0], STRING, separatorDefault)
-            : separatorDefault;
-        return {
-            kind: "bytesIntrinsic",
-            method: "join",
-            receiver: lowerer.lowerExpr(access.expression),
-            args: [separator],
-            type: STRING,
-            loc,
-        };
-    }
-    if (name === "slice" || name === "subarray") {
-        if (nArgs > 2) {
-            lowerer.noLowering(`.${name} with ${nArgs} arguments on typed arrays`, call);
-        }
-        const receiver = lowerer.lowerExpr(access.expression);
-        const args = call.arguments.map((a) => lowerer.lowerExprExpecting(a, F64));
-        // subarray is a VIEW (TypedArray.prototype.subarray aliases), and
-        // Buffer's slice() is subarray's deprecated Node alias — resolved by
-        // where the member is declared, the toString discipline below. Only
-        // the plain typed arrays' slice() copies (JS-exact).
-        const declaredOnBuffer = name === "slice" &&
-            (() => {
-                const nameSym = lowerer.checker.getSymbolAtLocation(access.name);
-                return nameSym !== undefined && lowerer.checker.declarationsOf(nameSym).some((d) => ts.isInterfaceDeclaration(d.parent) && d.parent.name.text === "Buffer");
-            })();
-        const method = name === "subarray" || declaredOnBuffer ? "subarray" : "slice";
-        return { kind: "bytesIntrinsic", method, receiver, args, type: receiverIr, loc };
-    }
-    if (name === "fill" && receiverIr.elem !== "u8") {
-        // TypedArray.prototype.fill on the non-u8 kinds: per-element value
-        // coercion, slice-clamped relative indices, never throws. u8
-        // receivers keep the Buffer fill family (string patterns, throwing
-        // offset validation) — lowerBufferInstanceMethod's surface.
-        if (nArgs < 1 || nArgs > 3) {
-            lowerer.noLowering(`.fill with ${nArgs} arguments on typed arrays`, call);
-        }
-        const receiver = lowerer.lowerExpr(access.expression);
-        const v = lowerer.lowerExprExpecting(call.arguments[0], F64);
-        const idx = call.arguments.slice(1).map((a) => lowerer.lowerExprExpecting(a, F64));
-        return { kind: "bytesIntrinsic", method: "fillElem", receiver, args: [v, ...idx], type: receiverIr, loc };
-    }
-    if (name === "set") {
-        if (nArgs < 1 || nArgs > 2) {
-            lowerer.noLowering(`.set with ${nArgs} arguments on typed arrays`, call);
-        }
-        const receiver = lowerer.lowerExpr(access.expression);
-        const src = lowerer.lowerExpr(call.arguments[0]);
-        if (!typeEquals(src.type, receiverIr)) {
-            lowerer.noLowering(`.set from '${lowerer.fmt(src.type)}' values`, call.arguments[0], "only a same-kind typed array copies in (number[] sources have no lowering — narrow unions first)");
-        }
-        const args = [src];
-        if (nArgs === 2)
-            args.push(lowerer.lowerExprExpecting(call.arguments[1], F64));
-        return { kind: "bytesIntrinsic", method: "setFrom", receiver, args, type: VOID, loc };
-    }
-    if (name === "toString") {
-        // Buffer's toString(encoding?) — utf8 by default. A 0-arg toString
-        // resolved against the plain Uint8Array interface is JS's
-        // Array-toString (comma join), a different operation: fenced.
-        const declaredOnBuffer = (() => {
-            const nameSym = lowerer.checker.getSymbolAtLocation(access.name);
-            return nameSym !== undefined && lowerer.checker.declarationsOf(nameSym).some((d) => ts.isInterfaceDeclaration(d.parent) && d.parent.name.text === "Buffer");
-        })();
-        if (receiverIr.elem !== "u8" || !declaredOnBuffer) {
-            lowerer.noLowering("typed-array toString", call, 'Buffer.from(x).toString("utf8" | "hex" | "base64") is the lowered string conversion');
-        }
-        if (nArgs > 3)
-            lowerer.noLowering(`.toString with ${nArgs} arguments on Buffers`, call);
-        const receiver = lowerer.lowerExpr(access.expression);
-        const encNode = call.arguments[0];
-        let method = "toString";
-        let enc = { kind: "strLit", value: "utf8", type: STRING, loc };
-        if (encNode) {
-            const encType = lowerer.typeOf(encNode);
-            const encName = encType.isStringLiteralType()
-                ? knownBufEncoding(encType.value)
-                : undefined;
-            if (encName !== undefined) {
-                // Keep literals on the canonical, non-throwing fast path.
-                enc = { kind: "strLit", value: encName, type: STRING, loc };
-            }
-            else {
-                const undefinedArg = lowerStaticallyUndefinedArg(lowerer, encNode);
-                if (undefinedArg) {
-                    // An explicit undefined is the omitted-encoding default. Keep
-                    // the canonical, non-throwing path while preserving effects
-                    // from equivalent spellings such as `void sideEffect()`.
-                    enc = defaultAfterUndefined(undefinedArg, enc);
-                }
-                else {
-                    // A BufferEncoding-typed variable selects its decoder at
-                    // runtime. Optional variables default their undefined arm to
-                    // utf8; the checked intrinsic canonicalizes every present
-                    // alias/case and raises Node's ERR_UNKNOWN_ENCODING when a cast
-                    // lets a bad value through.
-                    enc = lowerOptionalDefaultArg(lowerer, encNode, STRING, enc);
-                    method = "toStringVar";
-                }
-            }
-        }
-        // The range form toString(enc, start[, end]) decodes the clamped
-        // [start, end) byte window (Node's slice-then-decode). An omitted
-        // end stays omitted (2 intrinsic args) — the emitter supplies the
-        // receiver's length, because EXPLICIT negative ends clamp to empty
-        // in Node and no in-band sentinel can represent "omitted" safely.
-        if (nArgs > 1) {
-            const start = lowerer.lowerExprExpecting(call.arguments[1], F64);
-            if (nArgs === 3) {
-                const end = lowerer.lowerExprExpecting(call.arguments[2], F64);
-                return { kind: "bytesIntrinsic", method, receiver, args: [enc, start, end], type: STRING, loc };
-            }
-            return { kind: "bytesIntrinsic", method, receiver, args: [enc, start], type: STRING, loc };
-        }
-        return { kind: "bytesIntrinsic", method, receiver, args: [enc], type: STRING, loc };
-    }
-    // The Buffer-declared comparison/search/mutation surface. All of
-    // these resolve against the Buffer interface (the checker keeps most
-    // off plain typed arrays; where the lib DOES declare a same-named
-    // TypedArray member — indexOf, includes, fill — the semantics differ,
-    // so only Buffer-declared resolutions lower and u8 receivers gate the
-    // rest).
-    const declOnBuffer = (() => {
-        const nameSym = lowerer.checker.getSymbolAtLocation(access.name);
-        return nameSym !== undefined && lowerer.checker.declarationsOf(nameSym).some((d) => ts.isInterfaceDeclaration(d.parent) && d.parent.name.text === "Buffer");
-    })();
-    if (declOnBuffer && receiverIr.elem === "u8") {
-        const bufMethod = lowerBufferInstanceMethod(lowerer, call, access, name, loc);
-        if (bufMethod)
-            return bufMethod;
-    }
-    // The Buffer numeric read/write families — every fixed-width kind in
-    // both endiannesses ("Uint" and "UInt" alike: Node aliases both), plus
-    // the variable-width read/writeUIntLE quartet. The kind token rides as
-    // a strLit args[0]; omitted offsets complete to Node's default 0.
-    const numKind = own(BUF_NUM_METHODS, name);
-    if (numKind !== undefined) {
-        if (receiverIr.elem !== "u8") {
-            lowerer.noLowering(`.${name} on a '${lowerer.fmt(receiverIr)}'`, call, "the numeric families read/write Buffer bytes");
-        }
-        const write = name.startsWith("write");
-        const required = write ? 1 : 0; // value; offset defaults to 0
-        if (nArgs < required || nArgs > required + 1) {
-            lowerer.noLowering(`.${name} with ${nArgs} arguments`, call);
-        }
-        const receiver = lowerer.lowerExpr(access.expression);
-        const kind = { kind: "strLit", value: numKind, type: STRING, loc };
-        const args = [kind, ...call.arguments.map((a) => lowerer.lowerExprExpecting(a, F64))];
-        if (nArgs === required) {
-            args.push({ kind: "numLit", value: 0, type: F64, loc }); // Node's offset default
-        }
-        return { kind: "bytesIntrinsic", method: write ? "writeNum" : "readNum", receiver, args, type: F64, loc };
-    }
-    const varKind = own(BUF_NUM_VAR_METHODS, name);
-    if (varKind !== undefined) {
-        if (receiverIr.elem !== "u8") {
-            lowerer.noLowering(`.${name} on a '${lowerer.fmt(receiverIr)}'`, call, "the numeric families read/write Buffer bytes");
-        }
-        const write = name.startsWith("write");
-        const required = write ? 3 : 2; // Node declares offset AND byteLength required
-        if (nArgs !== required) {
-            lowerer.noLowering(`.${name} with ${nArgs} arguments`, call);
-        }
-        const receiver = lowerer.lowerExpr(access.expression);
-        const kind = { kind: "strLit", value: varKind, type: STRING, loc };
-        const args = [kind, ...call.arguments.map((a) => lowerer.lowerExprExpecting(a, F64))];
-        return { kind: "bytesIntrinsic", method: write ? "writeNumVar" : "readNumVar", receiver, args, type: F64, loc };
-    }
-    // DataView getters (DataView maps to bytes<u8>, so the receiver kind
-    // and stdlib provenance land here; the checker keeps these names off
-    // typed arrays and Buffers). The multi-byte kinds take the optional
-    // littleEndian bool (omitted = big-endian, the JS default). All THROW
-    // Node's RangeError on a bad offset (may-throw seeds).
-    const dvGetter = own(DV_GETTERS, name);
-    if (dvGetter !== undefined && receiverIr.elem === "u8") {
-        if (dvGetter.method === "dvGetBigUint64Number" || dvGetter.method === "dvGetBigInt64Number") {
-            // bigint values have no representation — only the COMPOSED
-            // `Number(view.getBigUint64/getBigInt64(...))` compiles (the
-            // randomBytesToString pattern): the 8-byte integer converts to
-            // double exactly as Number(bigint) would, and the bigint never
-            // exists as a value (the f64-typed intrinsic result IS what the
-            // identity Number(f64) lowering hands back).
-            const p = call.parent;
-            const composed = ts.isCallExpression(p) &&
-                p.arguments.length === 1 &&
-                p.arguments[0] === call &&
-                ts.isIdentifier(p.expression) &&
-                p.expression.text === "Number" &&
-                lowerer.isStdlibSymbol(lowerer.resolveValueSymbol(p.expression) ?? undefined);
-            if (!composed) {
-                lowerer.noLowering(`.${name} outside Number(...)`, call, `bigint values have no representation — Number(view.${name}(offset, littleEndian?)) is the lowered form`);
-            }
-        }
-        const maxArgs = dvGetter.le ? 2 : 1;
-        if (nArgs < 1 || nArgs > maxArgs) {
-            lowerer.noLowering(`.${name} with ${nArgs} arguments`, call);
-        }
-        const receiver = lowerer.lowerExpr(access.expression);
-        const args = [lowerer.lowerExprExpecting(call.arguments[0], F64)];
-        if (nArgs === 2)
-            args.push(lowerer.lowerExprExpecting(call.arguments[1], BOOL));
-        return { kind: "bytesIntrinsic", method: dvGetter.method, receiver, args, type: F64, loc };
-    }
-    // DataView setters — the getters' mirror: (byteOffset, value) plus the
-    // optional littleEndian bool on the multi-byte kinds. Void results;
-    // the same constant Node RangeError on a bad offset (may-throw seeds).
-    // setBigUint64/setBigInt64 never lower (bigint ARGUMENTS have no
-    // representation and no composed form exists) — they keep the member
-    // fence, as does setFloat16.
-    const dvSetter = own(DV_SETTERS, name);
-    if (dvSetter !== undefined && receiverIr.elem === "u8") {
-        const maxArgs = dvSetter.le ? 3 : 2;
-        if (nArgs < 2 || nArgs > maxArgs) {
-            lowerer.noLowering(`.${name} with ${nArgs} arguments`, call);
-        }
-        const receiver = lowerer.lowerExpr(access.expression);
-        const args = [
-            lowerer.lowerExprExpecting(call.arguments[0], F64),
-            lowerer.lowerExprExpecting(call.arguments[1], F64),
-        ];
-        if (nArgs === 3)
-            args.push(lowerer.lowerExprExpecting(call.arguments[2], BOOL));
-        return { kind: "bytesIntrinsic", method: dvSetter.method, receiver, args, type: VOID, loc };
-    }
-    return null;
-}
-/** Node's Buffer encoding names → the runtime's canonical spelling (every
- * alias folds at compile time; the runtime sees only canonical names).
- * Shared by toString, Buffer.from, and Buffer.byteLength. */
-const BUF_ENCODINGS = {
-    utf8: "utf8",
-    "utf-8": "utf8",
-    hex: "hex",
-    base64: "base64",
-    base64url: "base64url",
-    latin1: "latin1",
-    binary: "latin1",
-    ascii: "ascii",
-    utf16le: "utf16le",
-    "utf-16le": "utf16le",
-    ucs2: "utf16le",
-    "ucs-2": "utf16le",
-};
-/** A literal encoding's canonical name, or undefined for a spelling Node
- * does not know — the ladder callers (stream options) turn unknown
- * literals into Node's runtime ERR_UNKNOWN_ENCODING throw. */
-export function knownBufEncoding(name) {
-    return own(BUF_ENCODINGS, name);
-}
-/** Presence guard for a synthetic native-array loop. HOFs skip holes, while
- * the ordinary `arrayGet` remains a proven-presence operation. */
-function arrayHasExpr(arr, index, loc) {
-    return {
-        kind: "arrayHas",
-        arr,
-        index,
-        type: BOOL,
-        loc,
-    };
-}
-function getHasExpr(arrT, loc) {
-    return arrayHasExpr({ kind: "varRef", localId: "a.0", type: arrT, loc }, { kind: "varRef", localId: "i.0", type: F64, loc }, loc);
-}
-/** The literal encoding argument of a Buffer surface, normalized — or a
- * fence when it isn't a literal alias Node knows. */
-export function bufEncoding(lowerer, what, encNode) {
-    const t = lowerer.typeOf(encNode);
-    const v = t.isStringLiteralType() ? own(BUF_ENCODINGS, t.value) : undefined;
-    if (v === undefined) {
-        lowerer.noLowering(`${what} with this encoding`, encNode, 'a literal "utf8", "hex", "base64", "base64url", "latin1", "binary", "ascii", "utf16le", or "ucs2" spelling is the lowered encoding surface');
-    }
-    return v;
-}
-/** The fixed-width Buffer numeric methods by source name → the readNum/
- * writeNum kind token. Node declares BOTH capitalizations ("UInt" is the
- * original, "Uint" the aliased spelling) — the tables carry both. */
-const BUF_NUM_METHODS = (() => {
-    const out = {};
-    for (const rw of ["read", "write"]) {
-        for (const u of ["UInt", "Uint"]) {
-            out[`${rw}${u}8`] = "u8";
-            out[`${rw}${u}16BE`] = "u16be";
-            out[`${rw}${u}16LE`] = "u16le";
-            out[`${rw}${u}32BE`] = "u32be";
-            out[`${rw}${u}32LE`] = "u32le";
-        }
-        out[`${rw}Int8`] = "i8";
-        out[`${rw}Int16BE`] = "i16be";
-        out[`${rw}Int16LE`] = "i16le";
-        out[`${rw}Int32BE`] = "i32be";
-        out[`${rw}Int32LE`] = "i32le";
-        out[`${rw}FloatBE`] = "f32be";
-        out[`${rw}FloatLE`] = "f32le";
-        out[`${rw}DoubleBE`] = "f64be";
-        out[`${rw}DoubleLE`] = "f64le";
-    }
-    return out;
-})();
-/** The variable-width quartet (offset + byteLength) → sign/endian token. */
-const BUF_NUM_VAR_METHODS = {
-    readUIntBE: "ube",
-    readUintBE: "ube",
-    readUIntLE: "ule",
-    readUintLE: "ule",
-    readIntBE: "ibe",
-    readIntLE: "ile",
-    writeUIntBE: "ube",
-    writeUintBE: "ube",
-    writeUIntLE: "ule",
-    writeUintLE: "ule",
-    writeIntBE: "ibe",
-    writeIntLE: "ile",
-};
-/** The Buffer-declared comparison/search/mutation methods on a u8
- * receiver: equals, compare, indexOf/lastIndexOf/includes (number,
- * string-with-encoding, and Buffer needles), fill, copy, swap16/32/64,
- * and write. Null when `name` isn't one of them (the numeric families
- * and the generic bytes surface try next). Encodings must be literals
- * (bufEncoding's fence); a trailing string-typed argument is the
- * encoding, exactly Node's overloads. */
-function lowerBufferInstanceMethod(lowerer, call, access, name, loc) {
-    const args = call.arguments;
-    const nArgs = args.length;
-    if (args.some(ts.isSpreadElement))
-        return null;
-    const isStringArg = (i) => lowerer.mapTypeOf(lowerer.typeOf(args[i]))?.kind === "string";
-    const u8Arg = (i) => {
-        const v = lowerer.lowerExpr(args[i]);
-        if (!(v.type.kind === "bytes" && v.type.elem === "u8")) {
-            lowerer.noLowering(`.${name} of '${lowerer.fmt(v.type)}' values`, args[i], "a Buffer/Uint8Array argument is the lowered shape (narrow unions first)");
-        }
-        return v;
-    };
-    // The checked-dynamic crossing for a compare/equals argument slot: dyn
-    // passes through, convertible statics (the invalid-input probes'
-    // literals) wrap in dynFrom, `undefined` literals ride the same wrap.
-    // Fences (never returns) when the value cannot cross — an island jsval.
-    const chkArg = (i) => {
-        // Object literals take the dyn literal path directly (method members
-        // box as dyn functions — the typed record fence never applies).
-        if (ts.isObjectLiteralExpression(args[i])) {
-            return lowerDynObjectLiteral(lowerer, args[i]);
-        }
-        const v = lowerer.lowerExpr(args[i]);
-        if (v.type.kind === "dyn")
-            return v;
-        if (v.kind === "unitLit" || lowerer.dynConvertible(v.type)) {
-            return { kind: "dynFrom", value: v, type: DYN, loc: v.loc };
-        }
-        lowerer.noLowering(`.${name} of '${lowerer.fmt(v.type)}' values`, args[i], "a Buffer/Uint8Array argument is the lowered shape (narrow unions first)");
-    };
-    const argIrKind = (i) => lowerer.mapTypeOf(lowerer.typeOf(args[i]));
-    if (name === "equals") {
-        if (nArgs !== 1)
-            lowerer.noLowering(`.equals with ${nArgs} arguments`, call);
-        if (argIrKind(0)?.kind === "bytes") {
-            const other = u8Arg(0);
-            const receiver = lowerer.lowerExpr(access.expression);
-            return { kind: "bytesIntrinsic", method: "equals", receiver, args: [other], type: BOOL, loc };
-        }
-        // Not statically bytes (the invalid-input probes, untyped JS
-        // helpers): Node's "otherBuffer" argument ladder runs at runtime.
-        const receiver = lowerer.lowerExpr(access.expression);
-        return { kind: "libCall", fn: "bytes.equalsChk", args: [receiver, chkArg(0)], type: BOOL, loc };
-    }
-    if (name === "compare") {
-        if (nArgs > 5)
-            lowerer.noLowering(`.compare with ${nArgs} arguments`, call);
-        const fast = nArgs >= 1 &&
-            argIrKind(0)?.kind === "bytes" &&
-            call.arguments.slice(1).every((a) => lowerer.mapTypeOf(lowerer.typeOf(a))?.kind === "f64");
-        if (fast) {
-            const target = u8Arg(0);
-            const idx = call.arguments.slice(1).map((a) => lowerer.lowerExprExpecting(a, F64));
-            const receiver = lowerer.lowerExpr(access.expression);
-            return { kind: "bytesIntrinsic", method: "compareBuf", receiver, args: [target, ...idx], type: F64, loc };
-        }
-        // An absent/ill-typed target or offset (`a.compare()`, string
-        // offsets, explicit undefined): Node's target/targetStart/targetEnd/
-        // sourceStart/sourceEnd ladder runs at runtime; absent slots pass
-        // the undefined dyn (Node defaults apply there).
-        const receiver = lowerer.lowerExpr(access.expression);
-        const slots = [];
-        for (let i = 0; i < 5; i++)
-            slots.push(i < nArgs ? chkArg(i) : dynUndefinedExpr(loc));
-        return { kind: "libCall", fn: "bytes.compareChk", args: [receiver, ...slots], type: F64, loc };
-    }
-    if (name === "indexOf" || name === "lastIndexOf" || name === "includes") {
-        if (nArgs < 1 || nArgs > 3)
-            lowerer.noLowering(`.${name} with ${nArgs} arguments`, call);
-        // The overloads: (v), (v, byteOffset), (v, encoding), (v, byteOffset,
-        // encoding) — a trailing string-typed arg is the encoding.
-        let encName = "utf8";
-        let offNode;
-        if (nArgs === 3) {
-            offNode = args[1];
-            encName = bufEncoding(lowerer, `.${name}`, args[2]);
-        }
-        else if (nArgs === 2) {
-            if (isStringArg(1))
-                encName = bufEncoding(lowerer, `.${name}`, args[1]);
-            else
-                offNode = args[1];
-        }
-        const resultT = name === "includes" ? BOOL : F64;
-        const vT = lowerer.mapTypeOf(lowerer.typeOf(args[0]));
-        const receiver = lowerer.lowerExpr(access.expression);
-        if (vT?.kind === "f64") {
-            // A number needle wraps & 0xFF at runtime (Buffer semantics; the
-            // encoding is irrelevant, like Node).
-            const v = lowerer.lowerExprExpecting(args[0], F64);
-            const numArgs = [v, ...(offNode ? [lowerer.lowerExprExpecting(offNode, F64)] : [])];
-            const method = name === "indexOf" ? "indexOfNum" : name === "lastIndexOf" ? "lastIndexOfNum" : "includesNum";
-            return { kind: "bytesIntrinsic", method, receiver, args: numArgs, type: resultT, loc };
-        }
-        let needle;
-        let align = 1;
-        if (vT?.kind === "string") {
-            const s = lowerer.lowerExprExpecting(args[0], STRING);
-            const enc = { kind: "strLit", value: encName, type: STRING, loc };
-            needle = { kind: "libCall", fn: "buffer.fromStr", args: [s, enc], type: BYTES_U8, loc };
-            if (encName === "utf16le")
-                align = 2;
-        }
-        else if (vT?.kind === "bytes" && vT.elem === "u8") {
-            needle = lowerer.lowerExpr(args[0]);
-        }
-        else {
-            lowerer.noLowering(`.${name} of '${lowerer.checker.typeToString(lowerer.typeOf(args[0]))}' values`, args[0], "string, number, and Buffer/Uint8Array needles search (narrow unions first)");
-        }
-        const alignLit = { kind: "numLit", value: align, type: F64, loc };
-        const searchArgs = [needle, alignLit, ...(offNode ? [lowerer.lowerExprExpecting(offNode, F64)] : [])];
-        return { kind: "bytesIntrinsic", method: name, receiver, args: searchArgs, type: resultT, loc };
-    }
-    if (name === "fill") {
-        if (nArgs < 1 || nArgs > 4)
-            lowerer.noLowering(`.fill with ${nArgs} arguments`, call);
-        // A trailing string-typed arg past the value is the encoding.
-        let encNode;
-        let idxNodes = call.arguments.slice(1);
-        if (idxNodes.length > 0 && isStringArg(nArgs - 1)) {
-            encNode = idxNodes[idxNodes.length - 1];
-            idxNodes = idxNodes.slice(0, -1);
-        }
-        if (idxNodes.length > 2)
-            lowerer.noLowering(`.fill with ${nArgs} arguments`, call);
-        const idx = idxNodes.map((a) => lowerer.lowerExprExpecting(a, F64));
-        const receiverT = lowerer.mapTypeOf(lowerer.typeOf(access.expression));
-        if (receiverT?.kind !== "bytes")
-            lowerer.badType(access.expression, lowerer.typeOf(access.expression));
-        const vT = lowerer.mapTypeOf(lowerer.typeOf(args[0]));
-        const receiver = lowerer.lowerExpr(access.expression);
-        if (vT?.kind === "string") {
-            const encName = encNode ? bufEncoding(lowerer, ".fill", encNode) : "utf8";
-            const s = lowerer.lowerExprExpecting(args[0], STRING);
-            const enc = { kind: "strLit", value: encName, type: STRING, loc };
-            return { kind: "bytesIntrinsic", method: "fillStr", receiver, args: [s, enc, ...idx], type: BYTES_U8, loc };
-        }
-        if (encNode)
-            lowerer.noLowering(".fill with an encoding on a non-string value", encNode);
-        if (vT?.kind === "f64") {
-            const v = lowerer.lowerExprExpecting(args[0], F64);
-            return { kind: "bytesIntrinsic", method: "fillNum", receiver, args: [v, ...idx], type: BYTES_U8, loc };
-        }
-        const pattern = u8Arg(0);
-        return { kind: "bytesIntrinsic", method: "fill", receiver, args: [pattern, ...idx], type: BYTES_U8, loc };
-    }
-    if (name === "copy") {
-        if (nArgs < 1 || nArgs > 4)
-            lowerer.noLowering(`.copy with ${nArgs} arguments`, call);
-        const target = u8Arg(0);
-        const idx = call.arguments.slice(1).map((a) => lowerer.lowerExprExpecting(a, F64));
-        const receiver = lowerer.lowerExpr(access.expression);
-        return { kind: "bytesIntrinsic", method: "copy", receiver, args: [target, ...idx], type: F64, loc };
-    }
-    if (name === "swap16" || name === "swap32" || name === "swap64") {
-        if (nArgs !== 0)
-            lowerer.noLowering(`.${name} with ${nArgs} arguments`, call);
-        const receiver = lowerer.lowerExpr(access.expression);
-        return { kind: "bytesIntrinsic", method: name, receiver, args: [], type: BYTES_U8, loc };
-    }
-    if (name === "write") {
-        if (nArgs < 1 || nArgs > 4)
-            lowerer.noLowering(`.write with ${nArgs} arguments`, call);
-        // (str), (str, enc), (str, offset), (str, offset, enc),
-        // (str, offset, length), (str, offset, length, enc).
-        let encNode;
-        let idxNodes = call.arguments.slice(1);
-        if (idxNodes.length > 0 && isStringArg(nArgs - 1)) {
-            encNode = idxNodes[idxNodes.length - 1];
-            idxNodes = idxNodes.slice(0, -1);
-        }
-        if (idxNodes.length > 2)
-            lowerer.noLowering(`.write with ${nArgs} arguments`, call);
-        const encName = encNode ? bufEncoding(lowerer, "Buffer.write", encNode) : "utf8";
-        const s = lowerer.lowerExprExpecting(args[0], STRING);
-        const enc = { kind: "strLit", value: encName, type: STRING, loc };
-        const offset = idxNodes[0]
-            ? lowerer.lowerExprExpecting(idxNodes[0], F64)
-            : { kind: "numLit", value: 0, type: F64, loc };
-        const writeArgs = [s, enc, offset, ...(idxNodes[1] ? [lowerer.lowerExprExpecting(idxNodes[1], F64)] : [])];
-        const receiver = lowerer.lowerExpr(access.expression);
-        return { kind: "bytesIntrinsic", method: "writeStr", receiver, args: writeArgs, type: F64, loc };
-    }
-    return null;
-}
-/** The DataView getter surface by source name. `le` marks the multi-byte
- * kinds whose lib signature declares the optional littleEndian parameter
- * (the 8-bit getters take none). The Big pair only compiles composed
- * inside Number(...) — see the use site. */
-const DV_GETTERS = {
-    getUint8: { method: "dvGetUint8", le: false },
-    getInt8: { method: "dvGetInt8", le: false },
-    getUint16: { method: "dvGetUint16", le: true },
-    getInt16: { method: "dvGetInt16", le: true },
-    getUint32: { method: "dvGetUint32", le: true },
-    getInt32: { method: "dvGetInt32", le: true },
-    getFloat32: { method: "dvGetFloat32", le: true },
-    getFloat64: { method: "dvGetFloat64", le: true },
-    getBigUint64: { method: "dvGetBigUint64Number", le: true },
-    getBigInt64: { method: "dvGetBigInt64Number", le: true },
-};
-const DV_SETTERS = {
-    setUint8: { method: "dvSetUint8", le: false },
-    setInt8: { method: "dvSetInt8", le: false },
-    setUint16: { method: "dvSetUint16", le: true },
-    setInt16: { method: "dvSetInt16", le: true },
-    setUint32: { method: "dvSetUint32", le: true },
-    setInt32: { method: "dvSetInt32", le: true },
-    setFloat32: { method: "dvSetFloat32", le: true },
-    setFloat64: { method: "dvSetFloat64", le: true },
-};
-/** The Buffer statics — `Buffer.from(...)`, `Buffer.alloc(n)`,
-   * `Buffer.concat(list)`, `Buffer.isBuffer(x)` — on THE stdlib Buffer
-   * global (name + provenance; fallback and @types/node alike). Null when
-   * the callee isn't a Buffer-static access. */
-export function lowerBufferStaticCall(lowerer, call, access) {
-    if (call.questionDotToken || access.questionDotToken)
-        return null;
-    if (!lowerer.isStdlibGlobal(access.expression, "Buffer"))
-        return null;
-    const member = access.name.text;
-    const loc = locOf(call);
-    const args = call.arguments;
-    if (member === "from") {
-        // Buffer.from(x.buffer[, byteOffset[, length]]): a u8 VIEW sharing
-        // x's storage (Node shares the ArrayBuffer; length is in BYTES).
-        // The first argument must be the SYNTACTIC `.buffer` of a typed
-        // array — the DataView peel — and the construction rides the same
-        // dataViewNew intrinsic (offset/length validation throws Node's
-        // DataView-shaped RangeErrors; valid indices behave exactly).
-        if (args.length >= 1 && args.length <= 3 && !args.some(ts.isSpreadElement) &&
-            ts.isPropertyAccessExpression(args[0]) && args[0].name.text === "buffer") {
-            const srcNode = args[0].expression;
-            const srcIr = lowerer.mapTypeOf(lowerer.typeOf(srcNode));
-            if (srcIr?.kind === "bytes") {
-                const receiver = lowerer.lowerExpr(srcNode);
-                const idxArgs = args.slice(1).map((a) => lowerer.lowerExprExpecting(a, F64));
-                return { kind: "bytesIntrinsic", method: "dataViewNew", receiver, args: idxArgs, type: BYTES_U8, loc };
-            }
-        }
-        if (args.length >= 1 && args.length <= 2 && !ts.isSpreadElement(args[0])) {
-            const argNode = args[0];
-            if (ts.isArrayLiteralExpression(argNode) && !argNode.elements.some(ts.isSpreadElement)) {
-                // A number[] literal (contextually typed by the lib's readonly
-                // number[] slot — build it element-wise, the Set-seed pattern).
-                if (args.length === 1) {
-                    const elems = argNode.elements.map((el) => lowerer.lowerExprExpecting(el, F64));
-                    const seed = { kind: "arrayLit", elems, type: arrayOf(F64), loc };
-                    return { kind: "bytesNew", source: seed, type: BYTES_U8, loc };
-                }
-            }
-            else {
-                const srcIr = lowerer.mapTypeOf(lowerer.typeOf(argNode));
-                if (srcIr?.kind === "string") {
-                    const encNode = args[1];
-                    const encName = encNode ? bufEncoding(lowerer, "Buffer.from", encNode) : "utf8";
-                    const s = lowerer.lowerExprExpecting(argNode, STRING);
-                    const enc = { kind: "strLit", value: encName, type: STRING, loc };
-                    return { kind: "libCall", fn: "buffer.fromStr", args: [s, enc], type: BYTES_U8, loc };
-                }
-                if (args.length === 1 && srcIr?.kind === "bytes" && srcIr.elem === "u8") {
-                    return { kind: "bytesNew", source: lowerer.lowerExpr(argNode), type: BYTES_U8, loc };
-                }
-                if (args.length === 1 && srcIr?.kind === "array" && srcIr.elem.kind === "f64") {
-                    return { kind: "bytesNew", source: lowerer.lowerExpr(argNode), type: BYTES_U8, loc };
-                }
-            }
-        }
-        lowerer.noLowering("Buffer.from with this argument shape", call, "supported: Buffer.from(string, encoding?) with a literal encoding, Buffer.from(u8Array) — a copy — " +
-            "Buffer.from(number[]), or Buffer.from(x.buffer, byteOffset?, length?) — a view sharing x's " +
-            "storage (no free-standing ArrayBuffer value exists; narrow unions first)");
-    }
-    if (member === "alloc" || member === "allocUnsafe") {
-        const maxArgs = member === "alloc" ? 3 : 1;
-        if (args.length < 1 || args.length > maxArgs || args.some(ts.isSpreadElement)) {
-            lowerer.noLowering(`Buffer.${member} with ${args.length} arguments`, call);
-        }
-        // allocUnsafe's contents are UNSPECIFIED in Node (uninitialized pool
-        // memory); a zero-filled buffer is a valid instance of unspecified,
-        // and the deterministic choice — a program observing the difference
-        // is depending on garbage.
-        const size = lowerer.lowerExprExpecting(args[0], F64);
-        const fresh = { kind: "bytesNew", source: size, type: BYTES_U8, loc };
-        if (args.length === 1)
-            return fresh;
-        // alloc(size, fill, encoding?): the fill semantics ARE fill()'s —
-        // the fresh buffer is the receiver of a whole-range fill.
-        const fillT = lowerer.mapTypeOf(lowerer.typeOf(args[1]));
-        if (fillT?.kind === "string") {
-            const encName = args[2] ? bufEncoding(lowerer, "Buffer.alloc", args[2]) : "utf8";
-            const s = lowerer.lowerExprExpecting(args[1], STRING);
-            const enc = { kind: "strLit", value: encName, type: STRING, loc };
-            return { kind: "bytesIntrinsic", method: "fillStr", receiver: fresh, args: [s, enc], type: BYTES_U8, loc };
-        }
-        if (args.length > 2) {
-            lowerer.noLowering("Buffer.alloc with an encoding on a non-string fill", args[2]);
-        }
-        if (fillT?.kind === "f64") {
-            const v = lowerer.lowerExprExpecting(args[1], F64);
-            return { kind: "bytesIntrinsic", method: "fillNum", receiver: fresh, args: [v], type: BYTES_U8, loc };
-        }
-        if (fillT?.kind === "bytes" && fillT.elem === "u8") {
-            const pattern = lowerer.lowerExpr(args[1]);
-            return { kind: "bytesIntrinsic", method: "fill", receiver: fresh, args: [pattern], type: BYTES_U8, loc };
-        }
-        lowerer.noLowering(`Buffer.alloc with a '${lowerer.checker.typeToString(lowerer.typeOf(args[1]))}' fill`, args[1], "number, string, and Buffer/Uint8Array fills are the lowered shapes");
-    }
-    if (member === "concat") {
-        if (args.length < 1 || args.length > 2 || args.some(ts.isSpreadElement)) {
-            lowerer.noLowering(`Buffer.concat with ${args.length} arguments`, call);
-        }
-        const argNode = args[0];
-        let list;
-        if (ts.isArrayLiteralExpression(argNode) && !argNode.elements.some(ts.isSpreadElement)) {
-            const elems = argNode.elements.map((el) => lowerer.lowerExprExpecting(el, BYTES_U8));
-            list = { kind: "arrayLit", elems, type: arrayOf(BYTES_U8), loc };
-        }
-        else {
-            list = lowerer.lowerExpr(argNode);
-            if (!typeEquals(list.type, arrayOf(BYTES_U8))) {
-                lowerer.noLowering(`Buffer.concat of '${lowerer.fmt(list.type)}' values`, argNode, "one Uint8Array[]/Buffer[] value (or literal) is the lowered list shape");
-            }
-        }
-        if (args.length === 2) {
-            // The totalLength form truncates or zero-pads (and THROWS Node's
-            // 'length' RangeError on bad totals).
-            const total = lowerer.lowerExprExpecting(args[1], F64);
-            return { kind: "libCall", fn: "buffer.concatLen", args: [list, total], type: BYTES_U8, loc };
-        }
-        return { kind: "libCall", fn: "buffer.concat", args: [list], type: BYTES_U8, loc };
-    }
-    if (member === "compare") {
-        // The static form: Buffer.compare(a, b) IS a.compare(b).
-        if (args.length !== 2 || args.some(ts.isSpreadElement)) {
-            lowerer.noLowering(`Buffer.compare with ${args.length} arguments`, call);
-        }
-        const sides = args.map((a) => lowerer.lowerExpr(a));
-        if (sides.every((v) => v.type.kind === "bytes" && v.type.elem === "u8")) {
-            return { kind: "bytesIntrinsic", method: "compareBuf", receiver: sides[0], args: [sides[1]], type: F64, loc };
-        }
-        // A side that is not statically bytes (the invalid-input probes,
-        // untyped JS helpers): Node's "buf1"/"buf2" argument ladder runs
-        // at runtime — a well-typed dyn still compares.
-        const dyns = sides.map((v, i) => {
-            if (v.type.kind === "dyn")
-                return v;
-            if (v.kind === "unitLit" || lowerer.dynConvertible(v.type)) {
-                return { kind: "dynFrom", value: v, type: DYN, loc: v.loc };
-            }
-            lowerer.noLowering(`Buffer.compare of '${lowerer.fmt(v.type)}' values`, args[i], "Buffer/Uint8Array values compare (narrow unions first)");
-        });
-        return { kind: "libCall", fn: "buffer.compareChk", args: dyns, type: F64, loc };
-    }
-    if (member === "isBuffer") {
-        // The type-predicate narrowing test. Lowered where it DECIDES
-        // something: a union-typed argument with a Buffer arm becomes a
-        // runtime tag test (tsc's narrowing then types the branches, the
-        // discriminated-union machinery). Statically-decided arguments are
-        // fenced — the answer is a constant, and the operand's evaluation
-        // would have to be discarded.
-        if (args.length === 1 && !ts.isSpreadElement(args[0])) {
-            const v = lowerer.lowerExpr(args[0]);
-            if (v.type.kind === "union") {
-                const def = lowerer.unions.get(v.type.unionId);
-                const tag = def ? def.arms.findIndex((a) => a.kind === "bytes" && a.elem === "u8") : -1;
-                if (tag >= 0) {
-                    return { kind: "unionIsTag", unionId: v.type.unionId, tag, negated: false, value: v, type: BOOL, loc };
-                }
-            }
-            lowerer.noLowering(`Buffer.isBuffer of '${lowerer.fmt(v.type)}' values`, args[0], "the check lowers as a runtime tag test on unions with a Buffer arm — here the answer is static");
-        }
-        lowerer.noLowering("Buffer.isBuffer with this argument shape", call);
-    }
-    if (member === "byteLength") {
-        // Buffer.byteLength(string, enc?) — the UTF-16-aware per-encoding
-        // count — or of a typed array/Buffer (its byte length, a property
-        // read at heart).
-        if (args.length >= 1 && args.length <= 2 && !ts.isSpreadElement(args[0])) {
-            const srcIr = lowerer.mapTypeOf(lowerer.typeOf(args[0]));
-            if (srcIr?.kind === "string") {
-                const encName = args[1] ? bufEncoding(lowerer, "Buffer.byteLength", args[1]) : "utf8";
-                const s = lowerer.lowerExprExpecting(args[0], STRING);
-                const enc = { kind: "strLit", value: encName, type: STRING, loc };
-                return { kind: "libCall", fn: "buffer.byteLenStr", args: [s, enc], type: F64, loc };
-            }
-            if (srcIr?.kind === "bytes" && args.length === 1) {
-                const receiver = lowerer.lowerExpr(args[0]);
-                return { kind: "bytesIntrinsic", method: "byteLength", receiver, args: [], type: F64, loc };
-            }
-        }
-        lowerer.noLowering("Buffer.byteLength with this argument shape", call, "supported: Buffer.byteLength(string, literalEncoding?) or Buffer.byteLength(typedArray)");
-    }
-    if (member === "isEncoding") {
-        // The runtime alias-set test — a plain bool over any string value
-        // (Node's case-insensitive normalizeEncoding check).
-        if (args.length === 1 && !ts.isSpreadElement(args[0]) && lowerer.mapTypeOf(lowerer.typeOf(args[0]))?.kind === "string") {
-            const s = lowerer.lowerExprExpecting(args[0], STRING);
-            return { kind: "libCall", fn: "buffer.isEncoding", args: [s], type: BOOL, loc };
-        }
-        lowerer.noLowering("Buffer.isEncoding with this argument shape", call, "one string-typed argument is the lowered form");
-    }
-    return null; // of, copyBytesFrom, ... → the SC2020 member fence
-}
 /** `Object.keys/values/entries` over an INDEX-SIGNATURE (overflow-carrying)
    * record shape: declared fields answer first from the compile-time field
    * list (declaration order, undefined-valued fields skipped — exactly the