@scriptc/compiler 0.1.3 → 0.1.5

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

@@ -6,18 +6,18 @@ import { InternalCompilerError } from "../../errors.js";
 import * as ts from "../ts7/adapter.js";
 import { lowerGenMethodCall } from "./lower-generators.js";
 import { BIGINT_T, BOOL, CAUGHT, DYN, F64, JSVAL, STRING, SYMBOL_T, UNDEFINED_T, VOID, arrayOf, canBoxFuncIntoDyn, canConvertToDyn, canDynCheckTo, canMarshalTypedFuncIntoIsland, ffiClassType, ffiSourceParamTypes, funcOf, isFfiCallbackParam, isFfiContextParam, isFfiReleaseParam, isUnitType, shapeHasAccessorSlots, typeEquals } from "../../ir/ir.js";
-import { isJsSourceFile, locOf } from "../program.js";
+import { isJsSourceFile, isNodeEsmFile, locOf } from "../program.js";
 import { genResultRecord, isGenericCallableMemberType, typeKey } from "../type-mapper.js";
-import { PoisonError, dynFallbackType, dynUndefinedExpr, importCallHandleType, jsFuncNameOf, newFnCtx, nodeThrowExpr } from "./lowerer.js";
+import { PoisonError, dynFallbackType, dynUndefinedExpr, importCallHandleType, jsFuncNameOf, newFnCtx, nodeThrowExpr, staticImportNamespaceType } from "./lowerer.js";
 import { enforceLibBoundary } from "./lib-boundary.js";
-import { NARROW_FIRST, builtinFenceHintOf, builtinModuleFnOf } from "./surfaces.js";
+import { NARROW_FIRST, STR_METHODS, builtinFenceHintOf, builtinModuleFnOf } from "./surfaces.js";
 import { ffiBindingDiag, ffiSignatureDiag, libCallbackDiag, requiresDynamicDiag } from "../../diagnostics/diagnostic.js";
 import { mixinFnShapeOf } from "./lower-mixins.js";
 import { dynStringReceiver, lowerArrayFromCall, lowerDynArrayFilterCall, lowerDynArrayFlatMapCall, lowerGroupByStaticCall, lowerIteratorHelperCall, lowerObjectAssignIndexShape, lowerObjectFromEntriesCall, lowerObjectIterOverIndexShape, lowerTupleReadMethodCall } from "./lower-containers.js";
 import { bufEncoding } from "./containers/bytes.js";
-import { lowerRegexMethodCall, lowerStringMethodCall } from "./containers/string-and-regexp.js";
-import { lowerChildStreamMethodCall, lowerChildWriterMethodCall, lowerCreateRequireCall, lowerCryptoHashMethodCall, lowerDirentMethodCall, lowerFileHandleMethodCall, lowerImportMetaResolveCall, lowerPerfHooksCall, lowerProcStreamMethodCall, lowerReflectApplyCall, lowerRequireResolveCall, lowerWatcherMethodCall } from "./lower-builtins.js";
-import { lowerAbsenceProbe, lowerPromiseAllTupleCall, lowerPromiseRejectCall, templateRawTextOf } from "./lower-exprs.js";
+import { lowerRegexMethodCall, lowerStringMethodCall, lowerStringPaddingCall } from "./containers/string-and-regexp.js";
+import { lowerChildStreamMethodCall, lowerChildWriterMethodCall, lowerCreateRequireCall, lowerCryptoHashMethodCall, lowerDirentMethodCall, lowerFileHandleMethodCall, lowerImportMetaResolveCall, lowerNodeModuleCall, lowerPerfHooksCall, lowerProcStreamMethodCall, lowerReflectApplyCall, lowerRequireResolveCall, lowerWatcherMethodCall } from "./lower-builtins.js";
+import { lowerAbsenceProbe, lowerPromiseAllTupleCall, lowerPromiseRejectCall, stringWrapperToString, templateRawTextOf } from "./lower-exprs.js";
 import { isSafeToDiscard } from "./expressions/evaluation-safety.js";
 import { tryLowerExpression } from "./expressions/try-lower-expression.js";
 import { httpClientFnBindingOf, isStreamUndefCallExpr, lowerCompatReqStreamOptionalCall, lowerHttpClientFnCall } from "./lower-server.js";
@@ -32,6 +32,61 @@ import { npmStaticPackageOfPath } from "../npm-static.js";
 import { countedFor, varRef } from "../../ir/build.js";
 import { rejectStaticThis } from "./static-this.js";
 import { fenceNodeModuleMutationCall, lowerRequireCacheKeys } from "./lower-node-module.js";
+import { defaultAfterUndefined, lowerOptionalArgument, lowerStaticallyUndefinedArgument, positionNumber } from "./optional-arguments.js";
+/** The one func-type projection of completed parameter shapes. Typed rest
+ * parameters keep their packed array as the trailing native ABI slot and
+ * mark the value variadic so indirect call sites run completeArgs before
+ * callValue. Dynamic rest remains the historical hidden ScrDyn slot, while
+ * island rest spells its engine-array slot directly. */
+export function funcTypeFromParamShapes(shapes, ret) {
+    const typedRest = shapes.some((shape) => shape.mode === "rest");
+    const dynRest = shapes.some((shape) => shape.mode === "dynRest");
+    const argumentsAll = shapes.some((shape) => shape.mode === "arguments");
+    const islandRest = shapes.some((shape) => shape.mode === "islandRest");
+    return {
+        kind: "func",
+        params: shapes.filter((shape) => shape.mode !== "dynRest" && shape.mode !== "arguments").map((shape) => shape.type),
+        ret,
+        ...(typedRest || dynRest || islandRest || argumentsAll ? { rest: true } : {}),
+        ...(argumentsAll ? { argumentsAll: true } : {}),
+        ...(typedRest
+            ? { restAbi: "typed" }
+            : islandRest
+                ? { restAbi: "jsval" }
+                : {}),
+    };
+}
+/** Registers `const alias = overloadedDeclaration` as a compile-time
+ * callable projection. The source function's one implementation ABI is
+ * already collected in fnSigsBySymbol; each direct call still uses the
+ * TS7-resolved overload result bridge. The alias owns no storage, and a
+ * value read materializes the source function's interned closure, so JS
+ * identity (`alias === source`) is preserved. */
+export function registerOverloadedCallableAlias(lowerer, decl) {
+    if (!ts.isIdentifier(decl.name) || !decl.initializer)
+        return false;
+    let init = decl.initializer;
+    while (ts.isParenthesizedExpression(init))
+        init = init.expression;
+    if (!ts.isIdentifier(init))
+        return false;
+    const aliasType = lowerer.typeOf(decl.name);
+    if (lowerer.checker.getCallSignatures(aliasType).length < 2)
+        return false;
+    const sourceSymbol = lowerer.resolveValueSymbol(init);
+    if (!sourceSymbol)
+        return false;
+    const sourceProjection = lowerer.staticCallables.get(sourceSymbol);
+    const signature = lowerer.fnSigsBySymbol.get(sourceSymbol) ??
+        (sourceProjection?.kind === "declared-function" ? sourceProjection.signature : undefined);
+    if (!signature)
+        return false;
+    const aliasSymbol = lowerer.checker.getSymbolAtLocation(decl.name);
+    if (!aliasSymbol)
+        return false;
+    lowerer.staticCallables.set(aliasSymbol, { kind: "declared-function", signature });
+    return true;
+}
 export function generatorMeta(lowerer, type) {
     const resultType = genResultRecord(type.yieldT, type.retT, lowerer.shapes, lowerer.unions);
     if (resultType === null) {
@@ -61,6 +116,10 @@ export const MAX_GENERIC_INSTANCES = 100;
    * - `...xs: T[]`: the ABI type is the array; call sites pack the surplus.
    */
 export function paramShape(lowerer, param) {
+    const moduleNs = lowerer.moduleNsParamOverrides.get(param);
+    if (moduleNs !== undefined) {
+        return { type: moduleNs, mode: param.questionToken ? "omittable" : "required" };
+    }
     // Island-handle params (a then-handler receiving a dynamic import's
     // namespace handle — markJsvalHandlerParams): jsval, whatever the
     // contextual type spelled.
@@ -256,6 +315,18 @@ export function checkDefaultParamBodyType(lowerer, param, bodyType) {
    * explicitly-passed `undefined` wraps to — both trigger a default, JS-
    * exact); a rest param packs the surplus args (possibly zero) into one
    * array literal, evaluated in source order at the call site. */
+function fixedTupleSpreadInfo(lowerer, node) {
+    const type = lowerer.mapTypeOf(lowerer.typeOf(node));
+    if (type?.kind !== "record")
+        return null;
+    const shape = lowerer.shapes.get(type.shapeId);
+    if (!shape?.tuple || shape.fields.length === 0)
+        return null;
+    return {
+        type,
+        fields: [...shape.fields].sort((a, b) => Number(a.name) - Number(b.name)),
+    };
+}
 export function completeArgs(lowerer, argNodes, shapes, loc, blame, 
 /** Pre-lowered values virtually PREPENDED to the argument list — the
  * tagged-template strings object, which has no ts.Expression to lower
@@ -264,9 +335,92 @@ export function completeArgs(lowerer, argNodes, shapes, loc, blame,
  * DYN conversion in a dyn rest, element coercion in a typed rest). */
 leading) {
     const isIr = (s) => s !== undefined && !("kind" in s);
-    const sources = leading && leading.length > 0 ? [...leading.map((ir) => ({ ir })), ...argNodes] : argNodes;
-    const restAt = shapes.findIndex((s) => s.mode === "rest" || s.mode === "dynRest" || s.mode === "islandRest");
+    const sources = leading?.map((ir) => ({ ir })) ?? [];
+    for (const arg of argNodes) {
+        if (!ts.isSpreadElement(arg)) {
+            sources.push(arg);
+            continue;
+        }
+        const tuple = fixedTupleSpreadInfo(lowerer, arg.expression);
+        if (!tuple) {
+            sources.push(arg);
+            continue;
+        }
+        // A fixed tuple has a compile-time argument count, so flatten it into
+        // the callee's ordinary positional ABI. The operand itself still
+        // evaluates exactly once and at the spread's source-order position:
+        // the first extracted field carries a seqExpr that initializes one
+        // hidden tuple local, and every later field reads that same local.
+        // Tuple fields are owned reads, so the call receives the same +1
+        // values as separately written arguments while the saved tuple stays
+        // alive through the call.
+        const spreadLoc = locOf(arg);
+        const value = lowerer.coerceInto(arg.expression, lowerer.lowerExpr(arg.expression), tuple.type);
+        const saved = lowerer.declareHiddenLocal("%callSpread", tuple.type);
+        const savedRef = () => ({
+            kind: "varRef",
+            localId: saved.id,
+            type: tuple.type,
+            loc: spreadLoc,
+        });
+        tuple.fields.forEach((field, i) => {
+            const read = {
+                kind: "recordGet",
+                obj: savedRef(),
+                shapeId: tuple.type.shapeId,
+                field: field.name,
+                type: field.type,
+                loc: spreadLoc,
+            };
+            sources.push({
+                ir: i === 0
+                    ? {
+                        kind: "seqExpr",
+                        stmts: [{ kind: "varDecl", localId: saved.id, init: value, loc: spreadLoc }],
+                        result: read,
+                        type: field.type,
+                        loc: spreadLoc,
+                    }
+                    : read,
+            });
+        });
+    }
+    const restAt = shapes.findIndex((s) => s.mode === "rest" || s.mode === "dynRest" || s.mode === "islandRest" || s.mode === "arguments");
     const positional = restAt >= 0 ? shapes.slice(0, restAt) : [...shapes];
+    if (restAt >= 0 && shapes[restAt].mode === "arguments") {
+        // JS `arguments` contains every supplied value, including fixed
+        // parameters. Store each call expression once, in source order, so
+        // both the native parameter slots and the full array read it.
+        const stmts = [];
+        const passed = sources.map((source, i) => {
+            if (!isIr(source) && ts.isSpreadElement(source)) {
+                lowerer.unsupported("SC1090", source, "spread arguments into fixed parameter positions (a spread can only fill a rest parameter)");
+            }
+            const slotType = i < restAt ? positional[i].type : DYN;
+            const value = isIr(source)
+                ? lowerer.coerceInto(blame, source.ir, slotType)
+                : lowerer.lowerExprExpecting(source, slotType);
+            const saved = lowerer.declareHiddenLocal("%callArg", slotType);
+            stmts.push({ kind: "varDecl", localId: saved.id, init: value, loc: value.loc });
+            return { kind: "varRef", localId: saved.id, type: slotType, loc: value.loc };
+        });
+        const fixed = positional.map((shape, i) => {
+            if (i < passed.length)
+                return passed[i];
+            if (shape.mode === "omittable")
+                return shape.callDefault ?? lowerer.undefinedArgFor(shape.type, loc, blame);
+            if (shape.type.kind === "dyn")
+                return { kind: "dynFrom", value: { kind: "unitLit", unit: "undefined", type: UNDEFINED_T, loc }, type: DYN, loc };
+            lowerer.unsupported("SC1090", blame, "this call form");
+        });
+        const elems = passed.map((value) => lowerer.coerceInto(blame, value, DYN));
+        const full = { kind: "dynArrLit", elems, type: DYN, loc };
+        const out = [...fixed, full];
+        if (stmts.length > 0) {
+            out[0] = { kind: "seqExpr", stmts, result: out[0], type: out[0].type, loc };
+        }
+        return out;
+    }
     const out = positional.map((shape, i) => {
         const src = sources[i];
         if (isIr(src))
@@ -293,6 +447,8 @@ leading) {
             // reaching here means a call form we don't model — defensive.
             lowerer.unsupported("SC1090", blame, "this call form");
         }
+        if (shape.callDefault)
+            return shape.callDefault;
         return lowerer.undefinedArgFor(shape.type, loc, blame);
     });
     if (restAt >= 0 && shapes[restAt].mode === "islandRest") {
@@ -439,6 +595,34 @@ export function omittedArgFor(lowerer, type, loc) {
         return { kind: "jsOp", op: "undefLit", args: [], type: JSVAL, loc };
     return lowerer.wrappedUndefined(type, loc);
 }
+/** Complete an indirect static call against its func value ABI. Ordinary
+ * fixed-width values retain the historical optional-suffix completion.
+ * Typed-rest values reinterpret their final array slot as a rest ParamShape
+ * and reuse completeArgs, including fixed-tuple and same-element array
+ * spreads with source-order/evaluate-once semantics. */
+function completeFuncValueArgs(lowerer, call, funcType, loc) {
+    if (funcType.rest === true && funcType.restAbi === "typed") {
+        const rest = funcType.params[funcType.params.length - 1];
+        if (!rest || rest.kind !== "array") {
+            throw new InternalCompilerError("typed-rest function value has no trailing array ABI slot");
+        }
+        const shapes = funcType.params.slice(0, -1).map((type) => ({
+            type,
+            mode: omittedArgFor(lowerer, type, loc) ? "omittable" : "required",
+        }));
+        shapes.push({ type: rest, mode: "rest" });
+        return completeArgs(lowerer, call.arguments, shapes, loc, call);
+    }
+    const args = call.arguments.map((arg, index) => lowerer.lowerExprExpecting(arg, funcType.params[index]));
+    for (let i = args.length; i < funcType.params.length; i++) {
+        const absent = omittedArgFor(lowerer, funcType.params[i], loc);
+        if (!absent) {
+            lowerer.unsupported("SC1090", call, "calls omitting a non-optional parameter of the callee's type");
+        }
+        args.push(absent);
+    }
+    return args;
+}
 export function undefinedArgFor(lowerer, type, loc, blame) {
     if (type.kind === "dyn")
         return dynUndefinedExpr(loc);
@@ -454,13 +638,12 @@ export function undefinedArgFor(lowerer, type, loc, blame) {
     }
     return wrapped;
 }
-/** DECISION (docs/ir.md): function VALUES keep exact-arity semantics — a
-   * func-typed IrType spells one completed signature, so a function whose
-   * declaration has optional/default/rest parameters can become a value only
-   * where the target type spells that exact signature with required
-   * parameters (`x?: T` / `x: T = e` params appear as literal `T | undefined`
-   * unions; a rest signature is never spellable without `...`, which func
-   * types reject). Direct calls get the full feature. */
+/** DECISION (docs/ir.md): function VALUES carry one completed native ABI.
+   * Optional/default parameters appear as literal `T | undefined` slots;
+   * typed rest parameters appear as one trailing typed-array slot plus the
+   * typed-rest marker that makes indirect call sites pack source arguments.
+   * A value is admitted only where its target type projects to that same
+   * completed signature. */
 export function requireExactArityValue(lowerer, blame, contextual, shapes, funcType) {
     // dynRest params ride the boxed thunk (JS arity — no completed-ABI
     // spelling exists or is needed); they don't gate the value form.
@@ -471,13 +654,11 @@ export function requireExactArityValue(lowerer, blame, contextual, shapes, funcT
     // tier's undefined (omittedArgFor).
     if (shapes.every((s) => s.mode === "required" ||
         s.mode === "dynRest" ||
+        s.mode === "arguments" ||
         s.mode === "islandRest" ||
         (s.mode === "omittable" && (s.type.kind === "dyn" || s.type.kind === "jsval")))) {
         return;
     }
-    if (shapes.some((s) => s.mode === "rest")) {
-        lowerer.unsupported("SC1090", blame, "functions with rest parameters as values (call them directly)");
-    }
     // The type the value FLOWS under must spell the completed ABI: the
     // contextual (target) type when one exists, otherwise the expression's
     // OWN inferred type — the unannotated-const case (`const f = (x = 5) =>
@@ -520,6 +701,20 @@ export function requireExactArityValue(lowerer, blame, contextual, shapes, funcT
         lowerer.spawnResFnAdapterPlan(funcType, mappedFn) !== null) {
         return;
     }
+    // An uncontextualized npm-static implementation function can still
+    // have a declaration-backed completed ABI: the package's .d.ts
+    // projection supplies the body-facing parameter/return types while
+    // the shipped JavaScript's own inferred type remains wider (`any`
+    // callback fields are the common case). lambdaSignature has already
+    // constructed and validated that concrete ABI, and every eventual
+    // storage/call site independently checks it. Admit the value at birth;
+    // do not make the unprojected JS inference veto its authored surface.
+    if (target === undefined &&
+        contextual !== null &&
+        (ts.isArrowFunction(contextual) || ts.isFunctionExpression(contextual)) &&
+        npmStaticPackageOfPath(contextual.getSourceFile().fileName) !== null) {
+        return;
+    }
     // An 'any'-typed slot is the ISLAND boundary: the host-function
     // trampoline already implements JS call semantics over the completed
     // signature — a missing engine argument arrives as undefined and takes
@@ -758,18 +953,16 @@ export function collectSignatureInner(lowerer, decl) {
         }
     }
     const params = lowerer.paramShapes(decl.parameters);
-    // The VARIADIC `arguments` form on a DECLARED function: same rule as
-    // lambdas (lambdaSignature) — zero declared params, the body reads
-    // `arguments`, a synthetic trailing dynRest shape carries the call's
-    // arguments (completeArgs packs direct calls; the boxed thunk packs
-    // indirect ones; lowerFunction declares the `arguments` local).
-    if (!params.some((sh) => sh.mode === "dynRest") &&
+    // A declared function reading `arguments` receives a hidden dyn array.
+    // The zero-parameter form uses the existing rest pack; named parameters
+    // use the full argument pack for both direct and boxed calls.
+    if (!params.some((sh) => sh.mode === "rest" || sh.mode === "dynRest" || sh.mode === "islandRest") &&
         isJsSourceFile(decl.getSourceFile()) &&
         bodyReadsArguments(decl)) {
-        if (decl.parameters.length > 0) {
-            lowerer.unsupported("SC1090", decl, "'arguments' in functions with declared parameters (use a rest parameter: (...args))");
+        if (decl.parameters.length > 0 && !isNodeEsmFile(decl.getSourceFile())) {
+            lowerer.unsupported("SC1090", decl, "parameterized 'arguments' outside an ES module (sloppy-mode parameter aliases)");
         }
-        params.push({ type: DYN, mode: "dynRest" });
+        params.push({ type: DYN, mode: decl.parameters.length > 0 ? "arguments" : "dynRest" });
     }
     const nameBlame = decl.name ?? decl;
     const returnType = lowerer.declaredReturnType(decl, nameBlame);
@@ -1426,12 +1619,7 @@ export function lowerGenericFnValue(lowerer, ref, info) {
     // closure per function, so `f === f` holds like any declaration).
     if (info.implicitParams) {
         const inst = implicitDefaultInstance(lowerer, ref, info);
-        const funcType = {
-            kind: "func",
-            params: inst.params.filter((p) => p.mode !== "dynRest").map((p) => p.type),
-            ret: inst.returnType,
-            ...(inst.params.some((p) => p.mode === "dynRest") ? { rest: true } : {}),
-        };
+        const funcType = funcTypeFromParamShapes(inst.params, inst.returnType);
         lowerer.requireExactArityValue(ref, ref, inst.params, funcType);
         lowerer.noteEdge(inst.name);
         return { kind: "closure", fnName: inst.name, captures: [], type: funcType, loc };
@@ -1477,15 +1665,9 @@ export function lowerGenericFnValue(lowerer, ref, info) {
     if (info.typeParams.some((tp) => !bindings.get(tp)))
         fenceUnpinned();
     const inst = genericValueInstance(lowerer, ref, info, bindings);
-    // The value's type is the completed ABI signature — exact-arity, the
-    // declared-function value rule (dynRest slots stay out of the param
-    // list; the rest marker carries the trailing dyn-array ABI).
-    const funcType = {
-        kind: "func",
-        params: inst.params.filter((p) => p.mode !== "dynRest").map((p) => p.type),
-        ret: inst.returnType,
-        ...(inst.params.some((p) => p.mode === "dynRest") ? { rest: true } : {}),
-    };
+    // The value's type is the completed ABI signature. Typed rest keeps its
+    // packed-array slot; dynRest stays hidden behind the rest marker.
+    const funcType = funcTypeFromParamShapes(inst.params, inst.returnType);
     lowerer.requireExactArityValue(ref, ref, inst.params, funcType);
     lowerer.noteEdge(inst.name);
     return { kind: "closure", fnName: inst.name, captures: [], type: funcType, loc };
@@ -2780,6 +2962,57 @@ export function lowerFfiCall(lowerer, expr) {
         loc,
     };
 }
+/** Full builtin dispatch for compile-time callable projections. A projected
+ * alias must traverse the same spoke/validation ladder as its direct import;
+ * jumping to the table tail would bypass checked-dynamic argument errors. */
+function lowerProjectedBuiltinCall(lowerer, expr, bi, loc) {
+    if (bi.module === "child_process" && bi.member === "execFile") {
+        return lowerer.lowerExecFileCall(expr, loc);
+    }
+    if (bi.module === "timers") {
+        const timersServed = lowerTimersMemberCall(lowerer, expr, bi.member, loc);
+        if (timersServed)
+            return timersServed;
+    }
+    const served = lowerer.lowerNetModuleCall(expr, bi, loc);
+    if (served)
+        return served;
+    const dgramServed = lowerer.lowerDgramDnsModuleCall(expr, bi, loc);
+    if (dgramServed)
+        return dgramServed;
+    const assertServed = lowerer.lowerAssertModuleCall(expr, bi, loc);
+    if (assertServed)
+        return assertServed;
+    const testServed = lowerer.lowerNodeTestModuleCall(expr, bi, loc);
+    if (testServed)
+        return testServed;
+    const utilServed = lowerer.lowerUtilModuleCall(expr, bi, loc);
+    if (utilServed)
+        return utilServed;
+    const streamServed = lowerStreamModuleCall(lowerer, expr, bi, loc);
+    if (streamServed)
+        return streamServed;
+    const fsTs = lowerer.lowerFsToUnixTimestampCall(expr, bi, loc);
+    if (fsTs)
+        return fsTs;
+    const fsLadder = lowerer.lowerFsLadderCall(expr, bi, loc);
+    if (fsLadder)
+        return fsLadder;
+    const cryptoServed = lowerer.lowerCryptoModuleCall(expr, bi, loc);
+    if (cryptoServed)
+        return cryptoServed;
+    const timersInterval = lowerer.lowerTimersPromisesSetInterval(expr, bi, loc);
+    if (timersInterval)
+        return timersInterval;
+    const nodeModuleServed = lowerNodeModuleCall(lowerer, expr, bi, loc);
+    if (nodeModuleServed)
+        return nodeModuleServed;
+    const builtinFn = builtinModuleFnOf(lowerer, bi.module, bi.member);
+    if (!builtinFn) {
+        lowerer.noLowering(`${bi.module}.${bi.member}`, expr, builtinFenceHintOf(bi.module, bi.member), ts.isIdentifier(expr.expression) ? lowerer.resolveValueSymbol(expr.expression) : undefined);
+    }
+    return lowerer.lowerBuiltinModuleCall(expr, bi, builtinFn, loc);
+}
 export function lowerCall(lowerer, expr) {
     const loc = locOf(expr);
     // A call whose chain ROOTS at an ambient-undefined name (`declare
@@ -3142,13 +3375,12 @@ export function lowerCall(lowerer, expr) {
     // String(x) is exactly the template-literal ToString, Boolean(x) is
     // exactly the condition ToBoolean (union arms included), Number(x) is
     // ToNumber where it lowers exactly: numbers pass through, booleans
-    // become 1/0, and strings run the runtime's ECMA-exact
-    // StringToNumber (num.fromString — the full StringNumericLiteral
-    // grammar, scr_string.c). Other argument types (unions included —
-    // narrow first) keep the fence.
+    // become 1/0, null becomes 0, and undefined becomes NaN. Strings use
+    // the runtime's StringToNumber parser (num.fromString — the full
+    // StringNumericLiteral grammar in scr_string.c).
     // Provenance-checked like setTimeout; zero-arg forms are the JS
-    // constants ("", false, 0). `new String(...)` (wrapper objects) stays
-    // on the SC2020 fence.
+    // constants ("", false, 0). Wrapper objects stay fenced except where
+    // the receiver is immediately converted by a direct String method call.
     if (ts.isIdentifier(expr.expression) &&
         expr.expression.text === "BigInt" &&
         lowerer.isStdlibSymbol(lowerer.resolveValueSymbol(expr.expression) ?? undefined)) {
@@ -3209,33 +3441,11 @@ export function lowerCall(lowerer, expr) {
         // bool) that a value lowering of the `&&` would fence on.
         if (name === "Boolean")
             return lowerer.lowerCondition(argNode);
+        if (name === "Number")
+            return lowerNumberConstructorValue(lowerer, argNode, loc);
         const arg = lowerer.lowerExpr(argNode);
         if (name === "String")
             return lowerer.ensureString(arg, argNode);
-        if (name === "Number" && arg.type.kind === "bigint") {
-            return { kind: "libCall", fn: "bigint.toF64", args: [arg], type: F64, loc };
-        }
-        if (arg.type.kind === "f64")
-            return arg;
-        if (arg.type.kind === "bool") {
-            return {
-                kind: "ternary",
-                cond: arg,
-                then: { kind: "numLit", value: 1, type: F64, loc },
-                else_: { kind: "numLit", value: 0, type: F64, loc },
-                type: F64,
-                loc,
-            };
-        }
-        if (arg.type.kind === "string") {
-            return { kind: "libCall", fn: "num.fromString", args: [arg], type: F64, loc };
-        }
-        const optionalNumber = lowerOptionalStringNumber(lowerer, arg, loc);
-        if (optionalNumber)
-            return optionalNumber;
-        lowerer.noLowering(`Number of ${lowerer.fmt(arg.type)} values`, argNode, arg.type.kind === "union"
-            ? "numbers, booleans, and strings lower (the full ToNumber string grammar included) — narrow the union first"
-            : undefined);
     }
     // __island_eval: the internal island testing hook (eval in the embedded
     // engine, String(result) back). Provenance-checked like setTimeout.
@@ -3371,15 +3581,21 @@ export function lowerCall(lowerer, expr) {
     // supported form is fenced here per site. Members with no lowering at
     // all (fs.watch, os.cpus, ...) fence with the module-qualified name.
     if (ts.isIdentifier(expr.expression)) {
-        // A call through a `const execFileAsync = promisify(execFile)`
-        // binding — the one lowered util.promisify shape: the interned
-        // async-exec helper (Node's promisified execFile behind an
-        // already-settled promise).
+        // A call through a compile-time util.promisify projection. execFile
+        // keeps its custom result helper; ordinary builtins route through
+        // their existing promise-module lowering.
         {
             const sym = lowerer.resolveValueSymbol(expr.expression);
-            if (sym && lowerer.promisifiedExecFile.has(sym)) {
+            const projection = sym ? lowerer.staticCallables.get(sym) : undefined;
+            if (projection?.kind === "promisified-exec-file") {
                 return lowerer.lowerExecFileAsyncCall(expr, loc);
             }
+            if (projection?.kind === "promisified-builtin") {
+                return lowerProjectedBuiltinCall(lowerer, expr, { module: projection.module, member: projection.member }, loc);
+            }
+            if (projection?.kind === "builtin-function") {
+                return lowerProjectedBuiltinCall(lowerer, expr, { module: projection.module, member: projection.member }, loc);
+            }
             // A call through a `const requestFn = tls ? https.request :
             // http.request` binding (the client-function ternary): the http
             // client lowering with the RUNTIME-secure dial.
@@ -3389,6 +3605,9 @@ export function lowerCall(lowerer, expr) {
         }
         const bi = lowerer.builtinImportOf(expr.expression);
         if (bi) {
+            if (bi.module === "child_process" && bi.member === "execFile") {
+                return lowerer.lowerExecFileCall(expr, loc);
+            }
             // The timers spoke: the node:timers module's exports ARE the
             // timer globals (Node re-exports them), so a named/destructured
             // import lands on the same shared lowering. Unknown members fall
@@ -3448,6 +3667,9 @@ export function lowerCall(lowerer, expr) {
             const timersInterval = lowerer.lowerTimersPromisesSetInterval(expr, bi, loc);
             if (timersInterval)
                 return timersInterval;
+            const nodeModuleServed = lowerNodeModuleCall(lowerer, expr, bi, loc);
+            if (nodeModuleServed)
+                return nodeModuleServed;
             const builtinFn = builtinModuleFnOf(lowerer, bi.module, bi.member);
             if (!builtinFn) {
                 // Typed by @types/node (the fallback declarations only declare
@@ -3754,7 +3976,7 @@ export function lowerCall(lowerer, expr) {
             if (generic && !(jsSpreadArgs && generic.implicitParams))
                 return lowerer.lowerGenericCall(expr, generic);
             const sig = generic ? null : lowerer.fnSigOf(expr.expression);
-            if (sig && !(jsSpreadArgs && spreadNeedsRuntimeArity(sig.params, expr.arguments))) {
+            if (sig && !(jsSpreadArgs && spreadNeedsRuntimeArity(lowerer, sig.params, expr.arguments))) {
                 lowerer.noteEdge(sig.name);
                 const args = lowerer.completeArgs(expr.arguments, sig.params, loc, expr);
                 return reconcileOverloadReturn(lowerer, expr, { kind: "call", callee: sig.name, args, type: sig.returnType, loc });
@@ -3796,15 +4018,7 @@ export function lowerCall(lowerer, expr) {
         if (callee) {
             if (callee.type.kind !== "func")
                 lowerer.badType(expr.expression, lowerer.typeOf(expr.expression));
-            const params = callee.type.params;
-            const args = expr.arguments.map((a, i) => lowerer.lowerExprExpecting(a, params[i]));
-            for (let i = args.length; i < params.length; i++) {
-                const absent = omittedArgFor(lowerer, params[i], loc);
-                if (!absent) {
-                    lowerer.unsupported("SC1090", expr, "calls omitting a non-optional parameter of the callee's type");
-                }
-                args.push(absent);
-            }
+            const args = completeFuncValueArgs(lowerer, expr, callee.type, loc);
             return { kind: "callValue", callee, args, type: callee.type.ret, loc };
         }
     }
@@ -3844,15 +4058,7 @@ export function lowerCall(lowerer, expr) {
                 callee = lowerer.hybridCallUnwrap(callee);
             if (callee.type.kind !== "func")
                 lowerer.badType(expr.expression, lowerer.typeOf(expr.expression));
-            const params = callee.type.params;
-            const args = expr.arguments.map((a, i) => lowerer.lowerExprExpecting(a, params[i]));
-            for (let i = args.length; i < params.length; i++) {
-                const absent = omittedArgFor(lowerer, params[i], loc);
-                if (!absent) {
-                    lowerer.unsupported("SC1090", expr, "calls omitting a non-optional parameter of the callee's type");
-                }
-                args.push(absent);
-            }
+            const args = completeFuncValueArgs(lowerer, expr, callee.type, loc);
             return { kind: "callValue", callee, args, type: callee.type.ret, loc };
         }
         // An AMBIENT namespace callee (`M.f()` where only `declare
@@ -3905,15 +4111,7 @@ export function lowerCall(lowerer, expr) {
             callee = lowerer.hybridCallUnwrap(callee);
         if (callee.type.kind !== "func")
             lowerer.badType(expr.expression, lowerer.typeOf(expr.expression));
-        const params = callee.type.params;
-        const args = expr.arguments.map((a, i) => lowerer.lowerExprExpecting(a, params[i]));
-        for (let i = args.length; i < params.length; i++) {
-            const absent = omittedArgFor(lowerer, params[i], loc);
-            if (!absent) {
-                lowerer.unsupported("SC1090", expr, "calls omitting a non-optional parameter of the callee's type");
-            }
-            args.push(absent);
-        }
+        const args = completeFuncValueArgs(lowerer, expr, callee.type, loc);
         return { kind: "callValue", callee, args, type: callee.type.ret, loc };
     }
     if (ts.isPropertyAccessExpression(expr.expression)) {
@@ -3990,11 +4188,12 @@ export function lowerCall(lowerer, expr) {
             // TestContext surface (t.test/t.skip/t.diagnostic), t.assert.*.
             lowerer.lowerTestMethodCall(expr, expr.expression) ??
             lowerer.lowerTimeoutMethodCall(expr, expr.expression) ??
+            lowerStringPrototypeCall(lowerer, expr, expr.expression) ??
             lowerStringMethodCallWithOptionalArgs(lowerer, expr, expr.expression) ??
             // Typed-array/Buffer receivers and the Buffer statics — before the
             // island path (bytes never cross the boundary).
             lowerer.lowerBytesMethodCall(expr, expr.expression) ??
-            lowerBufferStaticCallWithOptionalArg(lowerer, expr, expr.expression) ??
+            lowerBufferStaticCallWithNarrowedArg(lowerer, expr, expr.expression) ??
             // URL.revokeObjectURL's zero-argument contract (the one-argument
             // form keeps the fence — createObjectURL does too).
             lowerUrlStaticCall(lowerer, expr, expr.expression) ??
@@ -4187,6 +4386,14 @@ export function lowerCall(lowerer, expr) {
     if (callee.type.kind !== "func") {
         lowerer.badType(expr.expression, lowerer.typeOf(expr.expression));
     }
+    // Typed-rest closures already have a fixed native ABI: complete the
+    // source-level variadic call into their trailing typed-array slot.
+    // Claim before the runtime-arity spread lane; completeArgs handles
+    // typed spreads without boxing the function.
+    if (callee.type.rest === true && callee.type.restAbi === "typed") {
+        const args = completeFuncValueArgs(lowerer, expr, callee.type, loc);
+        return { kind: "callValue", callee, args, type: callee.type.ret, loc };
+    }
     // A SPREAD argument on a func-typed callee — the rest-forwarding
     // idiom (`(...args) => from(...args)`): the runtime-arity lane boxes
     // or marshals the callee and applies through a runtime-built argument
@@ -4238,26 +4445,7 @@ export function lowerCall(lowerer, expr) {
         const boxed = { kind: "dynFrom", value: callee, type: DYN, loc };
         return { kind: "dynCall", callee: boxed, calleeName, args, type: DYN, loc };
     }
-    const params = callee.type.params;
-    const args = expr.arguments.map((a, i) => lowerer.lowerExprExpecting(a, params[i]));
-    // Optional-param func TYPES map their `x?: T` slots as `T | undefined`
-    // ABI unions, and tsc admits calls that omit the optional suffix —
-    // complete the missing trailing args with the interned undefined arm,
-    // exactly what completeArgs does for direct calls (the ABI stays
-    // count-exact). A missing arg whose param has no undefined arm means
-    // the callee value's type spelled a required param tsc let the caller
-    // skip — not a shape this surface models; fence.
-    for (let i = args.length; i < params.length; i++) {
-        // A missing argument completes with the slot's absent value — the
-        // interned undefined arm, the dyn undefined for checked-dynamic
-        // slots (a JS-inferred wrapper like mustCall's, called short), or
-        // the engine undefined for island slots.
-        const absent = omittedArgFor(lowerer, params[i], loc);
-        if (!absent) {
-            lowerer.unsupported("SC1090", expr, "calls omitting a non-optional parameter of the callee's type");
-        }
-        args.push(absent);
-    }
+    const args = completeFuncValueArgs(lowerer, expr, callee.type, loc);
     return { kind: "callValue", callee, args, type: callee.type.ret, loc };
 }
 function lowerRegexMethodCallWithOptionalArg(lowerer, call, access) {
@@ -4280,22 +4468,29 @@ function lowerRegexMethodCallWithOptionalArg(lowerer, call, access) {
 function optionalCallValue(lowerer, node) {
     return lowerer.runtimeOptionalIdentifierValue(node)?.value ?? lowerAbsenceProbe(lowerer, node);
 }
-function lowerBufferStaticCallWithOptionalArg(lowerer, call, access) {
+function lowerBufferStaticCallWithNarrowedArg(lowerer, call, access) {
     const lowered = lowerer.lowerBufferStaticCall(call, access);
     if (lowered?.kind !== "bytesNew" || !lowered.source || lowered.source.type.kind !== "union")
         return lowered;
-    const present = lowerer.stripUndefinedArm(lowered.source.type);
-    const validSource = (present.kind === "array" && present.elem.kind === "f64") ||
-        (present.kind === "bytes" && present.elem === "u8");
-    if (!validSource)
-        return lowered;
-    const helper = lowerer.narrowedArmHelper(lowered.source.type.unionId, present, lowered.source.loc);
-    return helper
-        ? {
-            ...lowered,
-            source: { kind: "call", callee: helper, args: [lowered.source], type: present, loc: lowered.source.loc },
-        }
-        : lowered;
+    // A callback can store a wider union than the checker sees at this use
+    // (including an added undefined arm). Extract the exact arm proven by
+    // control-flow narrowing, not merely the union with undefined removed.
+    const narrowed = lowerer.mapTypeOf(lowerer.typeOf(call.arguments[0]));
+    if (!narrowed ||
+        !(narrowed.kind === "f64" ||
+            (narrowed.kind === "array" && narrowed.elem.kind === "f64") ||
+            (narrowed.kind === "bytes" && narrowed.elem === "u8")) ||
+        lowerer.armTag(lowered.source.type.unionId, narrowed) < 0) {
+        lowerer.unsupported("SC1090", call.arguments[0], "a Buffer constructor argument whose narrowed type is not a stored source arm");
+    }
+    const helper = lowerer.narrowedArmHelper(lowered.source.type.unionId, narrowed, lowered.source.loc);
+    if (!helper) {
+        lowerer.unsupported("SC1090", call.arguments[0], "a Buffer constructor argument whose narrowed type is not a stored source arm");
+    }
+    return {
+        ...lowered,
+        source: { kind: "call", callee: helper, args: [lowered.source], type: narrowed, loc: lowered.source.loc },
+    };
 }
 function lowerOptionalNumberDefault(lowerer, value, dflt, loc) {
     const widened = lowerer.runtimeOptionalWidening(value.type, F64);
@@ -4335,14 +4530,14 @@ function lowerOptionalNumberDefault(lowerer, value, dflt, loc) {
     }
     return { kind: "call", callee: helper, args: [value], type: F64, loc };
 }
-function lowerStringMethodCallWithOptionalArgs(lowerer, call, access) {
-    const lowered = lowerer.lowerStringMethodCall(call, access);
+function lowerStringMethodCallWithOptionalArgs(lowerer, call, access, receiver, argumentNodes = call.arguments) {
+    const lowered = lowerStringMethodCall(lowerer, call, access, receiver, argumentNodes);
     if (lowered?.kind !== "strIntrinsic")
         return lowered;
     const args = [...lowered.args];
     let changed = false;
     const zeroDefaultArgs = lowered.method === "charCodeAt" || lowered.method === "charAt" ||
-        lowered.method === "repeat" || lowered.method === "padStart" || lowered.method === "padEnd"
+        lowered.method === "repeat"
         ? [0]
         : lowered.method === "slice" || lowered.method === "substring"
             ? [0]
@@ -4363,11 +4558,170 @@ function lowerStringMethodCallWithOptionalArgs(lowerer, call, access) {
         lowered.method === "startsWith" || lowered.method === "endsWith") &&
         args[0]?.type.kind === "union" &&
         lowerer.runtimeOptionalWidening(args[0].type, STRING) !== null) {
-        args[0] = lowerer.ensureString(args[0], call.arguments[0]);
+        args[0] = lowerer.ensureString(args[0], argumentNodes[0]);
         changed = true;
     }
     return changed ? { ...lowered, args } : lowered;
 }
+function lowerNumberConstructorValue(lowerer, argNode, loc) {
+    const undefinedArg = lowerStaticallyUndefinedArgument(lowerer, argNode);
+    if (undefinedArg) {
+        return defaultAfterUndefined(undefinedArg, {
+            kind: "bin", op: "/", left: { kind: "numLit", value: 0, type: F64, loc },
+            right: { kind: "numLit", value: 0, type: F64, loc }, type: F64, loc,
+        });
+    }
+    const arg = lowerer.lowerExpr(argNode);
+    if (arg.type.kind === "nullT")
+        return defaultAfterUndefined(arg, { kind: "numLit", value: 0, type: F64, loc });
+    if (arg.type.kind === "bigint")
+        return { kind: "libCall", fn: "bigint.toF64", args: [arg], type: F64, loc };
+    if (arg.type.kind === "f64")
+        return arg;
+    if (arg.type.kind === "bool") {
+        return {
+            kind: "ternary",
+            cond: arg,
+            then: { kind: "numLit", value: 1, type: F64, loc },
+            else_: { kind: "numLit", value: 0, type: F64, loc },
+            type: F64,
+            loc,
+        };
+    }
+    if (arg.type.kind === "string")
+        return { kind: "libCall", fn: "num.fromString", args: [arg], type: F64, loc };
+    const optionalNumber = lowerOptionalStringNumber(lowerer, arg, loc);
+    if (optionalNumber)
+        return optionalNumber;
+    const scalarUnionNumber = lowerScalarUnionNumber(lowerer, arg, argNode, loc);
+    if (scalarUnionNumber)
+        return scalarUnionNumber;
+    return lowerer.noLowering(`Number of ${lowerer.fmt(arg.type)} values`, argNode, arg.type.kind === "union"
+        ? "unions of numbers, booleans, strings, null, and undefined lower — narrow other arms first"
+        : undefined);
+}
+function immediatePrimitiveWrapperToString(lowerer, node) {
+    const stringValue = stringWrapperToString(lowerer, node);
+    if (stringValue)
+        return stringValue;
+    let wrapped = node;
+    while (ts.isParenthesizedExpression(wrapped))
+        wrapped = wrapped.expression;
+    if (!ts.isNewExpression(wrapped) || !ts.isIdentifier(wrapped.expression))
+        return null;
+    const name = wrapped.expression.text;
+    if ((name !== "Boolean" && name !== "Number") ||
+        !lowerer.isStdlibSymbol(lowerer.resolveValueSymbol(wrapped.expression) ?? undefined))
+        return null;
+    const args = wrapped.arguments ?? [];
+    if (args.length > 1 || args.some(ts.isSpreadElement))
+        return null;
+    const loc = locOf(wrapped);
+    const primitive = name === "Boolean"
+        ? args.length ? lowerer.lowerCondition(args[0]) : { kind: "boolLit", value: false, type: BOOL, loc }
+        : args.length ? lowerNumberConstructorValue(lowerer, args[0], loc) : { kind: "numLit", value: 0, type: F64, loc };
+    return lowerer.ensureString(primitive, wrapped);
+}
+function plainObjectCoercionReceiver(lowerer, node) {
+    const plainLiteral = (literal) => literal.properties.every((prop) => ts.isPropertyAssignment(prop) &&
+        (ts.isIdentifier(prop.name) || ts.isStringLiteral(prop.name) || ts.isNumericLiteral(prop.name)) &&
+        prop.name.text !== "__proto__");
+    let value = node;
+    while (ts.isParenthesizedExpression(value))
+        value = value.expression;
+    if (ts.isObjectLiteralExpression(value))
+        return plainLiteral(value);
+    if (!ts.isIdentifier(value))
+        return false;
+    const symbol = lowerer.resolveValueSymbol(value);
+    const decl = symbol ? lowerer.checker.valueDeclarationOf(symbol) : undefined;
+    if (!symbol || !decl || !ts.isVariableDeclaration(decl) || !decl.initializer ||
+        !ts.isObjectLiteralExpression(decl.initializer) || !plainLiteral(decl.initializer))
+        return false;
+    return bindingNeverReassigned(lowerer, symbol, decl);
+}
+function lowerStringPrototypeCall(lowerer, call, access) {
+    if (access.name.text !== "call" || !ts.isPropertyAccessExpression(access.expression))
+        return null;
+    const methodAccess = access.expression;
+    const prototypeAccess = methodAccess.expression;
+    if (!ts.isPropertyAccessExpression(prototypeAccess) || prototypeAccess.name.text !== "prototype" ||
+        !ts.isIdentifier(prototypeAccess.expression) || prototypeAccess.expression.text !== "String" ||
+        !Object.hasOwn(STR_METHODS, methodAccess.name.text) || !lowerer.isStdlibMember(methodAccess))
+        return null;
+    if (call.arguments.some(ts.isSpreadElement))
+        return null;
+    const entry = STR_METHODS[methodAccess.name.text];
+    const method = methodAccess.name.text === "trimStart" ? "trimLeft" :
+        methodAccess.name.text === "trimEnd" ? "trimRight" : methodAccess.name.text;
+    const loc = locOf(call);
+    const nullishError = nodeThrowExpr(1, "", `String.prototype.${method} called on null or undefined`, entry.result, loc);
+    const receiverNode = call.arguments[0];
+    if (!receiverNode)
+        return nullishError;
+    // Receiver coercion runs after .call has evaluated its arguments; keep
+    // contextual wrapper lowering on forms without later method arguments.
+    const immediateWrapper = entry.maxArgs === 0 && call.arguments.length === 1
+        ? immediatePrimitiveWrapperToString(lowerer, receiverNode) : null;
+    const receiverValue = immediateWrapper ?? lowerer.lowerExpr(receiverNode);
+    const receiverType = receiverValue.type;
+    const nullish = isUnitType(receiverType) || receiverType.kind === "void" ||
+        (receiverType.kind === "union" && (lowerer.unions.get(receiverType.unionId)?.arms.every((arm) => isUnitType(arm) || arm.kind === "void") ?? false));
+    if (nullish) {
+        const values = [receiverValue, ...call.arguments.slice(1).map((arg) => lowerer.lowerExpr(arg))];
+        return {
+            kind: "seqExpr",
+            stmts: values.filter((value) => !isSafeToDiscard(value)).map((value) => ({ kind: "exprStmt", expr: value, loc: value.loc })),
+            result: nullishError,
+            type: entry.result,
+            loc,
+        };
+    }
+    const padding = entry.method === "padStart" || entry.method === "padEnd";
+    const scalar = receiverType.kind === "string" || receiverType.kind === "f64" ||
+        receiverType.kind === "bool" || receiverType.kind === "bigint" ||
+        (receiverType.kind === "union" && (lowerer.unions.get(receiverType.unionId)?.arms.every((arm) => arm.kind === "string" || arm.kind === "f64" || arm.kind === "bool" || arm.kind === "bigint") ?? false));
+    // Other methods convert object receivers before lowering their arguments;
+    // padding uses a helper that delays conversion until every argument is ready.
+    const objectWithoutMethodArgs = entry.maxArgs === 0 && call.arguments.length === 1 &&
+        (receiverType.kind === "record" || receiverType.kind === "array" || receiverType.kind === "object");
+    const dynObjectWithoutMethodArgs = entry.maxArgs === 0 && call.arguments.length === 1 &&
+        receiverType.kind === "dyn" && plainObjectCoercionReceiver(lowerer, receiverNode);
+    if (!scalar && !objectWithoutMethodArgs && !dynObjectWithoutMethodArgs && !(padding && receiverType.kind === "dyn")) {
+        return lowerer.noLowering(`String.prototype.${methodAccess.name.text}.call with ${lowerer.fmt(receiverType)} receivers`, call);
+    }
+    if (padding) {
+        return lowerStringPaddingCall(lowerer, call, entry.method, receiverValue, receiverNode, call.arguments.slice(1));
+    }
+    const receiver = dynObjectWithoutMethodArgs
+        ? { kind: "libCall", fn: "dyn.toStringCoerce", args: [receiverValue], type: STRING, loc }
+        : lowerer.ensureString(receiverValue, receiverNode);
+    return lowerStringMethodCallWithOptionalArgs(lowerer, call, methodAccess, () => receiver, call.arguments.slice(1));
+}
+function lowerScalarUnionNumber(lowerer, arg, node, loc) {
+    if (arg.type.kind !== "union" || !lowerer.unions.get(arg.type.unionId)?.arms.every((arm) => arm.kind === "f64" || arm.kind === "string" || arm.kind === "bool" || isUnitType(arm)))
+        return null;
+    const key = `number.scalar:${arg.type.unionId}`;
+    let helper = lowerer.widthHelpers.get(key);
+    if (!helper) {
+        helper = `%number.scalar.${lowerer.widthHelpers.size}`;
+        lowerer.widthHelpers.set(key, helper);
+        const value = varRef("value.0", arg.type, loc);
+        const nan = {
+            kind: "bin", op: "/", left: { kind: "numLit", value: 0, type: F64, loc },
+            right: { kind: "numLit", value: 0, type: F64, loc }, type: F64, loc,
+        };
+        lowerer.liftedFns.push({
+            name: helper,
+            params: [{ localId: "value.0", name: "value", type: arg.type }],
+            returnType: F64,
+            locals: [{ id: "value.0", name: "value", type: arg.type, mutable: false }],
+            body: [{ kind: "return", value: positionNumber(lowerer, value, nan, node, "Number argument"), loc }],
+            loc,
+        });
+    }
+    return { kind: "call", callee: helper, args: [arg], type: F64, loc };
+}
 function lowerOptionalStringNumber(lowerer, arg, loc, fn = "num.fromString", label = "number") {
     if (arg.type.kind !== "union")
         return null;
@@ -4505,9 +4859,22 @@ function lowerSpreadArgsCall(lowerer, expr, callee, loc) {
    * (dynRest/islandRest, whose packs are built per-argument): the shapes
    * the runtime-arity lane (lowerSpreadArgsCall) serves. Typed `rest`
    * slots keep completeArgs' same-element spread packing. */
-function spreadNeedsRuntimeArity(shapes, argNodes) {
+function spreadNeedsRuntimeArity(lowerer, shapes, argNodes) {
     const restAt = shapes.findIndex((s) => s.mode === "rest" || s.mode === "dynRest" || s.mode === "islandRest");
-    return argNodes.some((a, i) => ts.isSpreadElement(a) && (restAt < 0 || i < restAt || shapes[restAt].mode !== "rest"));
+    let position = 0;
+    for (const arg of argNodes) {
+        if (ts.isSpreadElement(arg)) {
+            const tuple = fixedTupleSpreadInfo(lowerer, arg.expression);
+            if (tuple) {
+                position += tuple.fields.length;
+                continue;
+            }
+            if (restAt < 0 || position < restAt || shapes[restAt].mode !== "rest")
+                return true;
+        }
+        position++;
+    }
+    return false;
 }
 /** METHOD calls on dyn receivers (`pkg.name.replace(...)`, `rawName.split`,
  * `ws.packages.filter(...)` — JSON.parse-derived values): validate the
@@ -4535,8 +4902,9 @@ function lowerDynReceiverMethodCall(lowerer, call, access) {
     const anyArray = arrayReceiver &&
         ((lowerer.checker.getTypeArguments(recvTs)[0]?.flags ?? 0) &
             (ts.TypeFlags.Any | ts.TypeFlags.Unknown)) !== 0;
+    const checkerUntyped = (recvTs.flags & (ts.TypeFlags.Any | ts.TypeFlags.Unknown)) !== 0 || anyArray;
     let recv;
-    if (recvTs.flags & (ts.TypeFlags.Any | ts.TypeFlags.Unknown) || anyArray) {
+    if (checkerUntyped) {
         recv = lowerer.lowerExpr(access.expression);
     }
     else {
@@ -4625,7 +4993,23 @@ function lowerDynReceiverMethodCall(lowerer, call, access) {
     // member models. Order note: JS reads the callee before evaluating
     // arguments — dynKeyGet's undefined-receiver TypeError fires first,
     // exactly Node.
-    if (DYN_PROTO_METHOD_NAMES.has(access.name.text))
+    // A checker-typed object whose represented value remains dyn still
+    // has an authored own-member contract. Let that member win even when
+    // its name overlaps a primitive prototype (`colors.bold(...)`): the
+    // source value was compiled from that object shape, while genuinely
+    // untyped/any receivers retain the runtime-kind ambiguity and fence.
+    const ownCallable = !checkerUntyped && (() => {
+        const prop = lowerer.checker.getPropertyOfType(recvTs, access.name.text);
+        if (prop === undefined)
+            return false;
+        // getPropertyOfType includes inherited Object.prototype members.
+        // Those are not stored members of a checked-dynamic object, so
+        // dynKeyGet cannot stand in for JavaScript's prototype lookup. Only
+        // an authored declaration can justify the own-member path.
+        const authored = lowerer.checker.declarationsOf(prop).some((decl) => !lowerer.isStdlibFile(decl.getSourceFile()));
+        return authored && lowerer.checker.getCallSignatures(lowerer.checker.getTypeOfSymbol(prop)).length > 0;
+    })();
+    if (DYN_PROTO_METHOD_NAMES.has(access.name.text) && !ownCallable)
         return null;
     // Optional forms (`obj.cb?.()`, `obj?.cb()`) belong to the chain
     // machinery's short-circuit semantics — not modeled here yet.
@@ -5557,6 +5941,8 @@ function loweredTemplateStrings(lowerer, expr, cooked, loc) {
    * same collection lists top-level declarations ride. */
 export function isTopLevelFnSymbol(lowerer, ident) {
     const symbol = lowerer.resolveValueSymbol(ident);
+    if (symbol && lowerer.staticCallables.get(symbol)?.kind === "declared-function")
+        return true;
     const decl = symbol ? lowerer.checker.declarationsOf(symbol)[0] : undefined;
     return (!!decl &&
         ts.isFunctionDeclaration(decl) &&
@@ -5596,10 +5982,9 @@ export function lowerNestedFunctionDecl(lowerer, stmt) {
     return { kind: "assign", localId: local.id, value: init, loc: locOf(stmt) };
 }
 /** Signature checks + param shapes + IR func type for any lambda-like
-   * node. The func type's params are the ABI types, so a lambda with
-   * optional/default params has the same IR type as one spelling the
-   * `T | undefined` unions with required params — exactly the exact-arity
-   * value rule (requireExactArityValue decides who may become a value). */
+   * node. The func type's params are the ABI types: optional/default params
+   * become `T | undefined`, and typed rest becomes one packed-array slot.
+   * requireExactArityValue decides whether that completed ABI may escape. */
 export function lambdaSignature(lowerer, node) {
     if (!node.body)
         lowerer.unsupported("SC1090", node, "function overload signatures");
@@ -5688,39 +6073,25 @@ export function lambdaSignature(lowerer, node) {
             ret = VOID;
         }
     }
-    // VARIADIC JS functions: a dynRest param (above), or a plain function
-    // whose body reads `arguments` (test/common's mustCall wrapper —
-    // `function() { ...; return fn.apply(this, arguments); }`). Both mark
-    // the func type `rest`: the lifted body takes one trailing dyn-array
-    // param, filled by the boxed call thunk with the call's arguments
-    // from index params.length on. `arguments` is only claimed in
-    // ZERO-param functions (there it IS the surplus array); alongside
-    // declared params the alias story has no model — the fence says to
-    // use a rest parameter. Arrows never claim it (JS: an arrow's
-    // `arguments` is the enclosing function's).
-    const hasDynRest = shapes.some((s) => s.mode === "dynRest");
-    const hasIslandRest = shapes.some((s) => s.mode === "islandRest");
-    const usesArguments = !hasDynRest &&
-        !ts.isArrowFunction(node) &&
+    // A plain JS function reading `arguments` receives one hidden dyn
+    // array. With named parameters, the array contains every actual
+    // argument and only ES modules are admitted: sloppy-mode arguments
+    // alias named parameters. Arrows inherit the enclosing `arguments`.
+    const hasRest = shapes.some((s) => s.mode === "rest" || s.mode === "dynRest" || s.mode === "islandRest");
+    const usesArguments = !hasRest &&
+        (ts.isFunctionExpression(node) || ts.isFunctionDeclaration(node)) &&
         isJsSourceFile(node.getSourceFile()) &&
         bodyReadsArguments(node);
     if (usesArguments && node.parameters.length > 0) {
-        lowerer.unsupported("SC1090", node, "'arguments' in functions with declared parameters (use a rest parameter: (...args))");
+        if (!isNodeEsmFile(node.getSourceFile())) {
+            lowerer.unsupported("SC1090", node, "parameterized 'arguments' outside an ES module (sloppy-mode parameter aliases)");
+        }
+        shapes.push({ type: DYN, mode: "arguments" });
     }
-    return {
-        shapes,
-        funcType: {
-            kind: "func",
-            // dynRest is EXCLUDED (the boxed thunk fills the trailing dyn
-            // array — no spelled slot); islandRest is INCLUDED (the trailing
-            // jsval param IS the engine arguments array, the REST host-call
-            // adapter's one uniform shape).
-            params: shapes.filter((s) => s.mode !== "dynRest").map((s) => s.type),
-            ret,
-            ...(hasDynRest || usesArguments || hasIslandRest ? { rest: true } : {}),
-            ...(hasIslandRest ? { restAbi: "jsval" } : {}),
-        },
-    };
+    const funcType = funcTypeFromParamShapes(shapes, ret);
+    if (usesArguments)
+        funcType.rest = true;
+    return { shapes, funcType };
 }
 /** Does this function's OWN body read `arguments`? Nested plain functions
    * and methods have their own `arguments` (the walk skips them); arrows
@@ -5753,7 +6124,7 @@ export function bodyReadsArguments(fn) {
 export function lowerLambda(lowerer, node) {
     const loc = locOf(node);
     const { shapes, funcType } = lowerer.lambdaSignature(node);
-    // A lambda IS a value: the exact-arity rule applies at birth. The
+    // A lambda IS a value: the completed-ABI rule applies at birth. The
     // contextual (target) type decides — `(x?: number) => void` may flow
     // into a slot annotated `(x: number | undefined) => void` (same ABI
     // signature), anything else is fenced. Nested function declarations and
@@ -5794,9 +6165,9 @@ export function lowerLambda(lowerer, node) {
     lowerer.fnStack.push(fnCtx);
     try {
         const { params, prologue } = lowerer.declareParams(node.parameters, shapes);
-        // The VARIADIC `arguments` form (rest-marked with no declared rest
-        // param): a synthetic trailing dyn-array param carries the call's
-        // arguments; `arguments` reads resolve to it (identifier lowering).
+        // The synthetic trailing dyn-array param carries `arguments`.
+        // Parameterized functions receive all actual arguments; zero-param
+        // functions receive the same array through their rest ABI.
         if (funcType.rest && !shapes.some((s) => s.mode === "dynRest" || s.mode === "islandRest")) {
             const argsLocal = lowerer.declareHiddenLocal("%arguments", DYN);
             params.push({ localId: argsLocal.id, name: "%arguments", type: DYN });
@@ -5900,7 +6271,7 @@ export function lowerLambda(lowerer, node) {
         // closure-signature check trips (SC9001). Island rest types SPELL
         // their trailing engine-array param, so funcType.params already
         // covers those.
-        if (funcType.rest === true && funcType.restAbi !== "jsval") {
+        if (funcType.rest === true && funcType.restAbi === undefined) {
             params.push({ localId: "%pfrest", name: "%pfrest", type: DYN });
         }
         const fence = lowerer.deferToRuntimeFence(diagsBefore, node, {
@@ -5955,13 +6326,16 @@ export function lowerLambda(lowerer, node) {
  * to a promise-of-jsval local or module global answers the binding's
  * type. Null everywhere else. */
 function islandPromiseStorageTypeOf(lowerer, e) {
-    const direct = importCallHandleType(e);
+    const direct = lowerer.dynamic
+        ? importCallHandleType(e)
+        : staticImportNamespaceType(lowerer, e);
     if (direct?.kind === "promise")
         return direct;
     if (!ts.isIdentifier(e))
         return null;
     const local = lowerer.resolveLocal(e);
-    if (local?.type.kind === "promise" && local.type.inner.kind === "jsval")
+    if (local?.type.kind === "promise" &&
+        (local.type.inner.kind === "jsval" || local.type.inner.kind === "moduleNs"))
         return local.type;
     if (local)
         return null;
@@ -5969,7 +6343,8 @@ function islandPromiseStorageTypeOf(lowerer, e) {
     if (sym && sym.flags & ts.SymbolFlags.Alias)
         sym = lowerer.checker.getAliasedSymbol(sym);
     const g = sym ? lowerer.globalsBySymbol.get(sym) : undefined;
-    if (g?.type.kind === "promise" && g.type.inner.kind === "jsval")
+    if (g?.type.kind === "promise" &&
+        (g.type.inner.kind === "jsval" || g.type.inner.kind === "moduleNs"))
         return g.type;
     return null;
 }
@@ -5989,6 +6364,18 @@ function markJsvalHandlerParams(lowerer, handler) {
         }
     }
 }
+function markModuleNsHandlerParams(lowerer, handler, type) {
+    let e = handler;
+    while (ts.isParenthesizedExpression(e))
+        e = e.expression;
+    if (!ts.isArrowFunction(e) && !ts.isFunctionExpression(e))
+        return;
+    for (const p of e.parameters) {
+        if (ts.isIdentifier(p.name) && !p.dotDotDotToken && !p.initializer) {
+            lowerer.moduleNsParamOverrides.set(p, type);
+        }
+    }
+}
 export function lowerPromiseMethodCall(lowerer, call, access) {
     if (call.questionDotToken || access.questionDotToken)
         return null;
@@ -6002,7 +6389,7 @@ export function lowerPromiseMethodCall(lowerer, call, access) {
     // (importCallHandleType / the island-HANDLE var rules), so the storage
     // type is the receiver's truth. Direct `import("./m").then(...)`
     // spells the same promise with no binding at all.
-    if (!recvT && lowerer.dynamic)
+    if (!recvT)
         recvT = islandPromiseStorageTypeOf(lowerer, access.expression);
     if (recvT?.kind !== "promise")
         return null;
@@ -6107,6 +6494,8 @@ export function lowerPromiseMethodCall(lowerer, call, access) {
         // the handle is the value's only story, isIslandExpr's local rule).
         if (inner.kind === "jsval")
             markJsvalHandlerParams(lowerer, call.arguments[0]);
+        if (inner.kind === "moduleNs")
+            markModuleNsHandlerParams(lowerer, call.arguments[0], inner);
         let cb = lowerer.lowerExpr(call.arguments[0]);
         // A TYPED handler on a DYN-settling promise (the tracePromise
         // result's `.then((value) => ...)` — the checker's generic
@@ -6860,9 +7249,10 @@ function lowerBigIntMethodCall(lowerer, call, access) {
     if (name === "valueOf" && call.arguments.length === 0)
         return receiver;
     if (name === "toString" && call.arguments.length <= 1) {
+        const defaultRadix = { kind: "numLit", value: 10, type: F64, loc };
         const radix = call.arguments[0]
-            ? lowerer.lowerExprExpecting(call.arguments[0], F64)
-            : { kind: "numLit", value: 10, type: F64, loc };
+            ? lowerOptionalArgument(lowerer, call.arguments[0], F64, defaultRadix)
+            : defaultRadix;
         return { kind: "libCall", fn: "bigint.toString", args: [receiver, radix], type: STRING, loc };
     }
     return null;
@@ -7607,6 +7997,48 @@ function lowerObjectStaticCall(lowerer, call, access) {
     if (call.arguments.length !== 1 || ts.isSpreadElement(call.arguments[0]))
         return null;
     const argNode = call.arguments[0];
+    // A compiled PROGRAM module namespace is a nominal token whose members
+    // remain live bindings, but its enumerable key set is static and Node
+    // sorts it in code-unit order. Materialize exactly those value-export
+    // names for Object.keys; values/entries would need a heterogeneous live
+    // view and stay explicitly fenced. Builtin namespaces also stay fenced:
+    // their exact runtime export set is Node-owned, not the ambient subset.
+    {
+        const probed = tryLowerExpression(lowerer, argNode);
+        if (probed?.type.kind === "moduleNs") {
+            if (member !== "keys") {
+                lowerer.noLowering(`Object.${member} over a module namespace`, call, "read the named exports directly (module namespace values are live and may have heterogeneous representations)");
+            }
+            const source = lowerer.sourceFileOfModuleNamespace(probed.type);
+            if (source === null) {
+                lowerer.noLowering("Object.keys over a builtin module namespace", call, "access the builtin's named exports directly (the exact runtime key census is Node-owned)");
+            }
+            const moduleSymbol = source ? lowerer.checker.getSymbolAtLocation(source) : undefined;
+            const names = [];
+            moduleSymbol?.getExports().forEach((symbol, key) => {
+                const name = String(key);
+                if (name.startsWith("__") || name === "export=")
+                    return;
+                const target = symbol.flags & ts.SymbolFlags.Alias
+                    ? lowerer.checker.getAliasedSymbol(symbol)
+                    : symbol;
+                if (target.flags & ts.SymbolFlags.Value)
+                    names.push(name);
+            });
+            names.sort();
+            const loc = locOf(call);
+            const result = {
+                kind: "arrayLit",
+                elems: names.map((name) => ({ kind: "strLit", value: name, type: STRING, loc })),
+                type: arrayOf(STRING),
+                loc,
+            };
+            const receiver = lowerer.lowerExpr(argNode);
+            return isSafeToDiscard(receiver)
+                ? result
+                : { kind: "seqExpr", stmts: [{ kind: "exprStmt", expr: receiver, loc }], result, type: result.type, loc };
+        }
+    }
     // A CHECKED-DYNAMIC argument — the checker may still spell a record
     // type (the JS file-scope object-literal identity story stores the
     // dyn object), so the LOWERED value's kind is the dispatch: the
@@ -7838,10 +8270,9 @@ export function lowerFunction(lowerer, decl) {
     lowerer.fnStack.push(ctx);
     try {
         const { params, prologue } = lowerer.declareParams(decl.parameters, sig.params);
-        // The synthetic `arguments` slot (a dynRest shape BEYOND the declared
-        // parameters — collectSignatureInner appended it): one trailing
-        // dyn-array param, resolved by `arguments` reads.
-        if (sig.params.length > decl.parameters.length && sig.params[sig.params.length - 1].mode === "dynRest") {
+        // The synthetic `arguments` slot follows the declared parameters;
+        // reads resolve to this dyn array.
+        if (sig.params.length > decl.parameters.length && (sig.params[sig.params.length - 1].mode === "dynRest" || sig.params[sig.params.length - 1].mode === "arguments")) {
             const argsLocal = lowerer.declareHiddenLocal("%arguments", DYN);
             params.push({ localId: argsLocal.id, name: "%arguments", type: DYN });
             ctx.argumentsLocal = argsLocal;
@@ -7991,8 +8422,7 @@ export function lowerRecordFieldCall(lowerer, call, access) {
         callee = lowerer.hybridCallUnwrap(callee);
     if (callee.type.kind !== "func")
         lowerer.badType(access, lowerer.typeOf(access));
-    const params = callee.type.params;
-    const args = call.arguments.map((a, i) => lowerer.lowerExprExpecting(a, params[i]));
+    const args = completeFuncValueArgs(lowerer, call, callee.type, locOf(call));
     return { kind: "callValue", callee, args, type: callee.type.ret, loc: locOf(call) };
 }
 /** The function-like node behind an object-literal generic-method member:
@@ -8846,6 +9276,12 @@ export function lowerObjectMethodCall(lowerer, call, access) {
     if (lowerer.chainBlocked(access, call))
         return null;
     const mappedReceiver = lowerer.mapTypeOf(lowerer.typeOf(access.expression));
+    if (mappedReceiver?.kind === "union") {
+        const dispatched = lowerUnionObjectMethodCall(lowerer, call, access, mappedReceiver) ??
+            lowerUnionObjectDynFieldCall(lowerer, call, access, mappedReceiver);
+        if (dispatched)
+            return dispatched;
+    }
     const receiverIr = mappedReceiver?.kind === "object"
         ? mappedReceiver
         : mappedReceiver?.kind === "union"
@@ -8927,15 +9363,7 @@ export function lowerObjectMethodCall(lowerer, call, access) {
                 }
             }
             if (callee?.type.kind === "func") {
-                const params = callee.type.params;
-                const args = call.arguments.map((a, i) => lowerer.lowerExprExpecting(a, params[i]));
-                for (let i = args.length; i < params.length; i++) {
-                    const absent = omittedArgFor(lowerer, params[i], locOf(call));
-                    if (!absent) {
-                        lowerer.unsupported("SC1090", call, "calls omitting a non-optional parameter of the callee's type");
-                    }
-                    args.push(absent);
-                }
+                const args = completeFuncValueArgs(lowerer, call, callee.type, locOf(call));
                 return { kind: "callValue", callee, args, type: callee.type.ret, loc: locOf(call) };
             }
             if (callee?.type.kind === "dyn") {
@@ -8997,4 +9425,205 @@ export function lowerObjectMethodCall(lowerer, call, access) {
         loc: locOf(call),
     });
 }
+/** A method TypeScript proves callable on every arm of an unrelated class
+ * union. Each runtime tag keeps its own direct/virtual dispatch; only the
+ * completed argument ABI must agree. Results flow into the checker-selected
+ * call type through the ordinary wrap/retag/width machinery. */
+function lowerUnionObjectMethodCall(lowerer, call, access, receiverT) {
+    const def = lowerer.unions.get(receiverT.unionId);
+    if (!def || def.arms.length < 2 || !def.arms.every((arm) => arm.kind === "object"))
+        return null;
+    const method = access.name.text;
+    const plans = [];
+    for (const arm of def.arms) {
+        const info = lowerer.classes.get(arm.className);
+        if (!info) {
+            lowerer.flushDeferredClass(arm.className);
+            return null;
+        }
+        const found = lowerer.findMethodOn(info, method);
+        if (!found)
+            return null;
+        if (found.sig.abstract === true && !lowerer.overrideBelow(info, method))
+            return null;
+        plans.push({ arm, info, found });
+    }
+    const shapes = plans[0].found.sig.params;
+    if (!plans.every((plan) => paramAbisEqual(shapes, plan.found.sig.params)))
+        return null;
+    const resultT = lowerer.mapTypeOf(lowerer.typeOf(call));
+    if (!resultT || isUnitType(resultT))
+        return null;
+    const loc = locOf(call);
+    const receiver = lowerer.coerceInto(access.expression, lowerer.lowerExpr(access.expression), receiverT);
+    const args = lowerer.completeArgs(call.arguments, shapes, loc, call);
+    const helper = unionObjectMethodHelper(lowerer, call, receiverT, method, plans, shapes, resultT, loc);
+    return { kind: "call", callee: helper, args: [receiver, ...args], type: resultT, loc };
+}
+function paramAbisEqual(left, right) {
+    return left.length === right.length && left.every((shape, i) => {
+        const other = right[i];
+        return other !== undefined && shape.mode === other.mode && typeEquals(shape.type, other.type);
+    });
+}
+/** The JS-class sibling of union method dispatch: every arm stores the
+ * named callable in a checked-dynamic field. A helper selects and retains
+ * the field value before the dynCall evaluates its source arguments, so an
+ * argument that overwrites the field cannot change this invocation. */
+function lowerUnionObjectDynFieldCall(lowerer, call, access, receiverT) {
+    const def = lowerer.unions.get(receiverT.unionId);
+    if (!def || def.arms.length < 2 || !def.arms.every((arm) => arm.kind === "object"))
+        return null;
+    const field = access.name.text;
+    const plans = [];
+    for (const arm of def.arms) {
+        const info = lowerer.classes.get(arm.className);
+        if (!info || info.fields.get(field)?.kind !== "dyn")
+            return null;
+        plans.push({ arm, info });
+    }
+    if (call.arguments.some(ts.isSpreadElement)) {
+        lowerer.unsupported("SC1090", call, "spread arguments in calls through 'unknown' values");
+    }
+    const loc = locOf(call);
+    const receiver = lowerer.coerceInto(access.expression, lowerer.lowerExpr(access.expression), receiverT);
+    const key = `${receiverT.unionId}:dyn-field:${field}`;
+    let helper = lowerer.unionCallHelpers.get(key);
+    if (!helper) {
+        helper = `%union.call.${lowerer.unionCallHelpers.size}`;
+        lowerer.unionCallHelpers.set(key, helper);
+        const receiverRef = varRef("this.0", receiverT, loc);
+        const branch = (plan) => {
+            const concrete = {
+                kind: "unionNarrow",
+                unionId: receiverT.unionId,
+                tag: lowerer.armTag(receiverT.unionId, plan.arm),
+                value: receiverRef,
+                type: plan.arm,
+                loc,
+            };
+            return [{
+                    kind: "return",
+                    value: {
+                        kind: "fieldGet",
+                        obj: concrete,
+                        className: plan.info.def.name,
+                        field,
+                        type: DYN,
+                        loc,
+                    },
+                    loc,
+                }];
+        };
+        let body = branch(plans[plans.length - 1]);
+        for (let i = plans.length - 2; i >= 0; i--) {
+            const plan = plans[i];
+            body = [{
+                    kind: "if",
+                    cond: {
+                        kind: "unionIsTag",
+                        unionId: receiverT.unionId,
+                        tag: lowerer.armTag(receiverT.unionId, plan.arm),
+                        negated: false,
+                        value: receiverRef,
+                        type: BOOL,
+                        loc,
+                    },
+                    then: branch(plan),
+                    else_: body,
+                    loc,
+                }];
+        }
+        const params = [
+            { localId: "this.0", name: "this", type: receiverT },
+        ];
+        const locals = params.map((param) => ({ id: param.localId, name: param.name, type: param.type, mutable: false }));
+        lowerer.liftedFns.push({ name: helper, params, returnType: DYN, locals, body, loc });
+    }
+    const callee = { kind: "call", callee: helper, args: [receiver], type: DYN, loc };
+    const args = call.arguments.map((arg) => lowerer.lowerExprExpecting(arg, DYN));
+    return { kind: "dynCall", callee, calleeName: access.getText(), args, type: DYN, loc };
+}
+function unionObjectMethodHelper(lowerer, sourceCall, receiverT, method, plans, shapes, resultT, loc) {
+    const key = `${receiverT.unionId}:${method}:${shapes.map((shape) => `${shape.mode}:${typeKey(shape.type)}`).join(",")}:${typeKey(resultT)}`;
+    const existing = lowerer.unionCallHelpers.get(key);
+    if (existing)
+        return existing;
+    const name = `%union.call.${lowerer.unionCallHelpers.size}`;
+    lowerer.unionCallHelpers.set(key, name);
+    const receiver = varRef("this.0", receiverT, loc);
+    const argRefs = shapes.map((shape, i) => varRef(`a.${i}`, shape.type, loc));
+    const branch = (plan) => {
+        const concrete = {
+            kind: "unionNarrow",
+            unionId: receiverT.unionId,
+            tag: lowerer.armTag(receiverT.unionId, plan.arm),
+            value: receiver,
+            type: plan.arm,
+            loc,
+        };
+        let invoke;
+        if (plan.found.declarer.builtinError) {
+            invoke = {
+                kind: "libCall",
+                fn: "error.toString",
+                args: [lowerer.upcastTo(concrete, plan.found.declarer.def.name)],
+                type: STRING,
+                loc,
+            };
+        }
+        else if (lowerer.overrideBelow(plan.info, method)) {
+            lowerer.noteVirtualEdge(plan.info, method);
+            invoke = {
+                kind: "virtualCall",
+                className: plan.info.def.name,
+                method,
+                args: [lowerer.upcastTo(concrete, plan.info.def.name), ...argRefs],
+                type: plan.found.sig.ret,
+                loc,
+            };
+        }
+        else {
+            lowerer.noteEdge(`%${plan.found.declarer.def.name}.${method}`);
+            invoke = {
+                kind: "call",
+                callee: `%${plan.found.declarer.def.name}.${method}`,
+                args: [lowerer.upcastTo(concrete, plan.found.declarer.def.name), ...argRefs],
+                type: plan.found.sig.ret,
+                loc,
+            };
+        }
+        invoke = reconcileOverloadReturn(lowerer, sourceCall, invoke);
+        const result = lowerer.coerceInto(sourceCall, invoke, resultT);
+        return resultT.kind === "void"
+            ? [{ kind: "exprStmt", expr: result, loc }, { kind: "return", value: null, loc }]
+            : [{ kind: "return", value: result, loc }];
+    };
+    let body = branch(plans[plans.length - 1]);
+    for (let i = plans.length - 2; i >= 0; i--) {
+        const plan = plans[i];
+        body = [{
+                kind: "if",
+                cond: {
+                    kind: "unionIsTag",
+                    unionId: receiverT.unionId,
+                    tag: lowerer.armTag(receiverT.unionId, plan.arm),
+                    negated: false,
+                    value: receiver,
+                    type: BOOL,
+                    loc,
+                },
+                then: branch(plan),
+                else_: body,
+                loc,
+            }];
+    }
+    const params = [
+        { localId: "this.0", name: "this", type: receiverT },
+        ...shapes.map((shape, i) => ({ localId: `a.${i}`, name: `a${i}`, type: shape.type })),
+    ];
+    const locals = params.map((param) => ({ id: param.localId, name: param.name, type: param.type, mutable: false }));
+    lowerer.liftedFns.push({ name, params, returnType: resultT, locals, body, loc });
+    return name;
+}
 //# sourceMappingURL=lower-calls.js.map