@scriptc/compiler 0.1.2 → 0.1.4

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

@@ -5,10 +5,10 @@ import { InternalCompilerError } from "../../errors.js";
  * generic instantiation (bounded by MAX_GENERIC_INSTANCES). */
 import * as ts from "../ts7/adapter.js";
 import { lowerGenMethodCall } from "./lower-generators.js";
-import { 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 { 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 { 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 { ffiBindingDiag, ffiSignatureDiag, libCallbackDiag, requiresDynamicDiag } from "../../diagnostics/diagnostic.js";
@@ -16,7 +16,7 @@ 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, lowerCreateRequireCall, lowerDirentMethodCall, lowerFileHandleMethodCall, lowerImportMetaResolveCall, lowerPerfHooksCall, lowerProcStreamMethodCall, lowerReflectApplyCall, lowerRequireResolveCall, lowerWatcherMethodCall } from "./lower-builtins.js";
+import { lowerChildStreamMethodCall, lowerChildWriterMethodCall, lowerCreateRequireCall, lowerCryptoHashMethodCall, lowerDirentMethodCall, lowerFileHandleMethodCall, lowerImportMetaResolveCall, lowerNodeModuleCall, lowerPerfHooksCall, lowerProcStreamMethodCall, lowerReflectApplyCall, lowerRequireResolveCall, lowerWatcherMethodCall } from "./lower-builtins.js";
 import { lowerAbsenceProbe, lowerPromiseAllTupleCall, lowerPromiseRejectCall, templateRawTextOf } from "./lower-exprs.js";
 import { isSafeToDiscard } from "./expressions/evaluation-safety.js";
 import { tryLowerExpression } from "./expressions/try-lower-expression.js";
@@ -32,6 +32,58 @@ 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";
+/** 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 islandRest = shapes.some((shape) => shape.mode === "islandRest");
+    return {
+        kind: "func",
+        params: shapes.filter((shape) => shape.mode !== "dynRest").map((shape) => shape.type),
+        ret,
+        ...(typedRest || dynRest || islandRest ? { rest: 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 +113,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 +312,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,7 +332,56 @@ 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 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");
     const positional = restAt >= 0 ? shapes.slice(0, restAt) : [...shapes];
     const out = positional.map((shape, i) => {
@@ -293,6 +410,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 +558,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 +601,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.
@@ -475,9 +621,6 @@ export function requireExactArityValue(lowerer, blame, contextual, shapes, funcT
         (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 +663,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
@@ -1426,12 +1583,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 +1629,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 +2926,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
@@ -3149,6 +3346,34 @@ export function lowerCall(lowerer, expr) {
     // Provenance-checked like setTimeout; zero-arg forms are the JS
     // constants ("", false, 0). `new String(...)` (wrapper objects) stays
     // on the SC2020 fence.
+    if (ts.isIdentifier(expr.expression) &&
+        expr.expression.text === "BigInt" &&
+        lowerer.isStdlibSymbol(lowerer.resolveValueSymbol(expr.expression) ?? undefined)) {
+        if (expr.arguments.length !== 1) {
+            lowerer.noLowering(`BigInt with ${expr.arguments.length} arguments`, expr);
+        }
+        const argNode = expr.arguments[0];
+        const arg = lowerer.lowerExpr(argNode);
+        if (arg.type.kind === "bigint")
+            return arg;
+        if (arg.type.kind === "string") {
+            return { kind: "libCall", fn: "bigint.parse", args: [arg], type: BIGINT_T, loc };
+        }
+        if (arg.type.kind === "f64") {
+            return { kind: "libCall", fn: "bigint.fromF64", args: [arg], type: BIGINT_T, loc };
+        }
+        if (arg.type.kind === "bool") {
+            return {
+                kind: "ternary",
+                cond: arg,
+                then: { kind: "libCall", fn: "bigint.parse", args: [{ kind: "strLit", value: "1", type: STRING, loc }], type: BIGINT_T, loc },
+                else_: { kind: "libCall", fn: "bigint.parse", args: [{ kind: "strLit", value: "0", type: STRING, loc }], type: BIGINT_T, loc },
+                type: BIGINT_T,
+                loc,
+            };
+        }
+        lowerer.noLowering(`BigInt of ${lowerer.fmt(arg.type)} values`, argNode, "string, number, boolean, and bigint arguments are supported");
+    }
     if (ts.isIdentifier(expr.expression) &&
         (expr.expression.text === "String" ||
             expr.expression.text === "Boolean" ||
@@ -3184,6 +3409,9 @@ export function lowerCall(lowerer, expr) {
         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") {
@@ -3340,15 +3568,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.
@@ -3358,6 +3592,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
@@ -3417,6 +3654,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
@@ -3723,7 +3963,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 });
@@ -3765,15 +4005,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 };
         }
     }
@@ -3813,15 +4045,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
@@ -3874,15 +4098,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)) {
@@ -3922,10 +4138,12 @@ export function lowerCall(lowerer, expr) {
             lowerer.lowerUrlMethodCall(expr, expr.expression) ??
             lowerer.lowerSearchParamsMethodCall(expr, expr.expression) ??
             lowerer.lowerStatsMethodCall(expr, expr.expression) ??
+            lowerCryptoHashMethodCall(lowerer, expr, expr.expression) ??
             lowerFileHandleMethodCall(lowerer, expr, expr.expression) ??
             lowerer.lowerChildMethodCall(expr, expr.expression) ??
             // Piped child-output stream receivers — on/once("data" | "end").
             lowerChildStreamMethodCall(lowerer, expr, expr.expression) ??
+            lowerChildWriterMethodCall(lowerer, expr, expr.expression) ??
             // First-class process-stream receivers — write(data).
             lowerProcStreamMethodCall(lowerer, expr, expr.expression) ??
             // FSWatcher receivers — close() (fs.watch's handle).
@@ -4008,6 +4226,8 @@ export function lowerCall(lowerer, expr) {
             // by the receiver's own element.
             lowerer.lowerFilterNarrowCall(expr, expr.expression) ??
             lowerArrayIsArrayCall(lowerer, expr, expr.expression) ??
+            lowerBigIntStaticCall(lowerer, expr, expr.expression) ??
+            lowerBigIntMethodCall(lowerer, expr, expr.expression) ??
             lowerSymbolStaticCall(lowerer, expr, expr.expression) ??
             lowerSymbolMethodCall(lowerer, expr, expr.expression) ??
             lowerRegExpStaticCall(lowerer, expr, expr.expression) ??
@@ -4152,6 +4372,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
@@ -4203,26 +4431,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) {
@@ -4470,9 +4679,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
@@ -4500,8 +4722,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 {
@@ -4590,7 +4813,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.
@@ -5522,30 +5761,50 @@ 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) &&
         (ts.isSourceFile(decl.parent) || lowerer.nsBlocks.get(decl.parent) === "flattened"));
 }
-/** Nested `function name(...) {...}`: lowered as `const name = <lambda>`
-   * at the declaration's statement position (JS hoists function declarations
-   * to the top of the enclosing function — calling one before this statement
-   * is a compile error here, not a silent divergence). Self-references inside
-   * the body lower to `selfRef`, not a capture: a box holding its own
-   * closure would be an RC cycle. */
+/** Nested `function name(...) {...}`: declare the mutable function binding
+   * before lowering its body, then initialize it with the lifted closure.
+   * The early declaration is observable only when another nested closure
+   * captures the binding: its box must exist before either side of a mutual
+   * recursion cycle builds its closure. Forward source references use the
+   * same split declaration/assignment through predeclareForwardFnDecl.
+   * Self-references inside the body lower to `selfRef`, not a capture: a box
+   * holding its own closure would be an RC cycle. */
 export function lowerNestedFunctionDecl(lowerer, stmt) {
     if (!stmt.name)
         lowerer.unsupported("SC1090", stmt, "anonymous function declarations");
     const { funcType } = lowerer.lambdaSignature(stmt);
-    const local = lowerer.declareLocal(stmt.name, stmt.name.text, funcType, false);
+    // Function declaration bindings are mutable in JavaScript. More
+    // importantly, putting the empty slot into the owning statement list
+    // BEFORE lowerLambda lets a sibling lowered from that body capture this
+    // local's eventual box. The local object may become boxed while either
+    // body lowers; backends inspect its final shape when emitting varDecl.
+    const local = lowerer.declareLocal(stmt.name, stmt.name.text, funcType, true);
+    let declared = false;
+    for (let i = lowerer.activeStmtLists.length - 1; i >= 0; i--) {
+        const entry = lowerer.activeStmtLists[i];
+        if (entry.ctx !== lowerer.ctx || !entry.stmts.includes(stmt))
+            continue;
+        entry.out.push({ kind: "varDecl", localId: local.id, init: null, loc: locOf(stmt) });
+        declared = true;
+        break;
+    }
+    if (!declared) {
+        throw new InternalCompilerError("lowerer bug: nested function declaration has no active statement list");
+    }
     const init = lowerer.lowerLambda(stmt);
-    return { kind: "varDecl", localId: local.id, init, loc: locOf(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");
@@ -5645,7 +5904,6 @@ export function lambdaSignature(lowerer, node) {
     // 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) &&
         isJsSourceFile(node.getSourceFile()) &&
@@ -5653,20 +5911,10 @@ export function lambdaSignature(lowerer, node) {
     if (usesArguments && node.parameters.length > 0) {
         lowerer.unsupported("SC1090", node, "'arguments' in functions with declared parameters (use a rest parameter: (...args))");
     }
-    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 && !hasDynRest)
+        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
@@ -5699,7 +5947,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
@@ -5765,11 +6013,13 @@ export function lowerLambda(lowerer, node) {
                 // the validator's bare-unitLit rule (typeCheckReturnExpression).
                 // A `void e` body rides the statement lowering (the value is
                 // discarded here, so the operand evaluates for effect alone —
-                // `(name) => void doThing(name)`, the fire-and-forget arrow).
+                // `(name) => void doThing(name)`, the fire-and-forget arrow). A
+                // conditional body does the same so its void arms become lazy
+                // statement branches instead of a forbidden void-valued ternary.
                 let stripped = bodyExpr;
                 while (ts.isParenthesizedExpression(stripped))
                     stripped = stripped.expression;
-                if (ts.isVoidExpression(stripped)) {
+                if (ts.isVoidExpression(stripped) || ts.isConditionalExpression(stripped)) {
                     body = [lowerer.lowerExprStatement(stripped)];
                 }
                 else {
@@ -5844,7 +6094,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, {
@@ -5899,13 +6149,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;
@@ -5913,7 +6166,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;
 }
@@ -5933,6 +6187,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;
@@ -5946,7 +6212,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;
@@ -6051,6 +6317,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
@@ -6769,6 +7037,48 @@ function lowerSymbolStaticCall(lowerer, call, access) {
     }
     lowerer.unsupported("SC1090", call, `well-known symbols as values (Symbol.${member} — for-of, iteration protocols, and template literals compile through their language constructs; the reified symbol has no static lowering)`);
 }
+function lowerBigIntStaticCall(lowerer, call, access) {
+    if (call.questionDotToken || access.questionDotToken)
+        return null;
+    if (!lowerer.isStdlibGlobal(access.expression, "BigInt"))
+        return null;
+    const name = access.name.text;
+    if (name !== "asUintN" && name !== "asIntN")
+        return null;
+    if (call.arguments.length !== 2) {
+        lowerer.noLowering(`BigInt.${name} with ${call.arguments.length} arguments`, call);
+    }
+    const loc = locOf(call);
+    const bits = lowerer.lowerExprExpecting(call.arguments[0], F64);
+    const value = lowerer.lowerExprExpecting(call.arguments[1], BIGINT_T);
+    return {
+        kind: "libCall",
+        fn: name === "asUintN" ? "bigint.asUintN" : "bigint.asIntN",
+        args: [bits, value],
+        type: BIGINT_T,
+        loc,
+    };
+}
+function lowerBigIntMethodCall(lowerer, call, access) {
+    if (lowerer.mapTypeOf(lowerer.typeOf(access.expression))?.kind !== "bigint")
+        return null;
+    if (!lowerer.isStdlibMember(access))
+        return null;
+    const name = access.name.text;
+    const loc = locOf(call);
+    const receiver = lowerer.lowerExpr(access.expression);
+    if (receiver.type.kind !== "bigint")
+        return null;
+    if (name === "valueOf" && call.arguments.length === 0)
+        return receiver;
+    if (name === "toString" && call.arguments.length <= 1) {
+        const radix = call.arguments[0]
+            ? lowerer.lowerExprExpecting(call.arguments[0], F64)
+            : { kind: "numLit", value: 10, type: F64, loc };
+        return { kind: "libCall", fn: "bigint.toString", args: [receiver, radix], type: STRING, loc };
+    }
+    return null;
+}
 /** Method calls on symbol-typed receivers: `.toString()` is the
  * "Symbol(desc)" text (Node's Symbol.prototype.toString — note that
  * template literals and concatenation THROW in JS and stay fenced;
@@ -7509,6 +7819,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
@@ -7893,8 +8245,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:
@@ -8748,6 +9099,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"
@@ -8829,15 +9186,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") {
@@ -8899,4 +9248,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