@scriptc/compiler 0.1.1 → 0.1.3

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

@@ -1,20 +1,25 @@
+import { InternalCompilerError } from "../../errors.js";
 /* Call lowering: the lowerCall dispatch chain, parameter-shape analysis and
  * argument completion (optional/default/rest, explicit-undefined ≡ omission),
  * function/lambda lowering and signature collection, and monomorphizing
  * 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 { isGenericCallableMemberType, typeKey } from "../type-mapper.js";
+import { genResultRecord, isGenericCallableMemberType, typeKey } from "../type-mapper.js";
 import { PoisonError, dynFallbackType, dynUndefinedExpr, importCallHandleType, jsFuncNameOf, newFnCtx, nodeThrowExpr } 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";
 import { mixinFnShapeOf } from "./lower-mixins.js";
-import { bufEncoding, dynStringReceiver, lowerArrayFromCall, lowerDynArrayFilterCall, lowerDynArrayFlatMapCall, lowerGroupByStaticCall, lowerIteratorHelperCall, lowerObjectAssignIndexShape, lowerObjectFromEntriesCall, lowerObjectIterOverIndexShape, lowerRegexMethodCall, lowerStringMethodCall, lowerTupleReadMethodCall } from "./lower-containers.js";
-import { lowerChildStreamMethodCall, lowerCreateRequireCall, lowerDirentMethodCall, lowerFileHandleMethodCall, lowerPerfHooksCall, lowerProcStreamMethodCall, lowerReflectApplyCall, lowerWatcherMethodCall } from "./lower-builtins.js";
-import { droppableStatic, lowerAbsenceProbe, lowerPromiseAllTupleCall, lowerPromiseRejectCall, probeLower, templateRawTextOf } from "./lower-exprs.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 { isSafeToDiscard } from "./expressions/evaluation-safety.js";
+import { tryLowerExpression } from "./expressions/try-lower-expression.js";
 import { httpClientFnBindingOf, isStreamUndefCallExpr, lowerCompatReqStreamOptionalCall, lowerHttpClientFnCall } from "./lower-server.js";
 import { EMITTER_API_MEMBERS, exactInstanceClassOf, findGenericMethodOn, lowerClassGenericMethodCall, lowerStaticMethodCall } from "./lower-classes.js";
 import { emitterRooted, lowerEmitterMethodCall } from "./lower-event-emitter.js";
@@ -26,6 +31,14 @@ import { expandoMemberRead } from "./lower-expando.js";
 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";
+export function generatorMeta(lowerer, type) {
+    const resultType = genResultRecord(type.yieldT, type.retT, lowerer.shapes, lowerer.unions);
+    if (resultType === null) {
+        throw new InternalCompilerError("lowerer bug: mapped generator without an IteratorResult record");
+    }
+    return { yieldT: type.yieldT, nextT: type.nextT, resultType };
+}
 /** Instantiation cap per generic function: same-key recursion (`len<T>`
  * calling itself) converges, but POLYMORPHIC recursion (`f<T>` calling
  * `f<T[]>`) would request new instances forever — the cap turns that into a
@@ -585,6 +598,16 @@ export function appendImplicitUndefinedReturn(lowerer, body, bodyReturn, loc) {
 /** A declaration's checker-derived IR return type. The unmappable-type
    * diagnostic points at `blame` (the name for top-level declarations, the
    * whole node for lambda-likes — preserving each caller's historical loc). */
+function hasExplicitJsDocReturn(decl) {
+    const sourceFile = decl.getSourceFile();
+    return /@returns?\b/.test(sourceFile.text.slice(decl.pos, decl.getStart(sourceFile)));
+}
+function promiseCarriesDyn(lowerer, type) {
+    if (type.kind === "promise")
+        return type.inner.kind === "dyn";
+    return type.kind === "union" &&
+        (lowerer.unions.get(type.unionId)?.arms.some((arm) => promiseCarriesDyn(lowerer, arm)) ?? false);
+}
 export function declaredReturnType(lowerer, decl, blame) {
     const sig = lowerer.checker.getSignatureFromDeclaration(decl);
     if (!sig)
@@ -596,6 +619,17 @@ export function declaredReturnType(lowerer, decl, blame) {
     // (`.action(() => { throw ... })`). `never` VALUES stay unmapped.
     if (retTsType.flags & ts.TypeFlags.Never)
         return VOID;
+    const mappedReturn = lowerer.mapTypeOf(retTsType);
+    if (isJsSourceFile(decl.getSourceFile()) &&
+        !hasExplicitJsDocReturn(decl) &&
+        mappedReturn !== null &&
+        promiseCarriesDyn(lowerer, mappedReturn) &&
+        decl.parameters.some((param) => {
+            const mapped = lowerer.mapTypeOf(lowerer.typeOf(param.name));
+            return mapped === null || mapped.kind === "dyn";
+        })) {
+        return DYN;
+    }
     // A JS function whose UNANNOTATED return infers a FUNCTION type
     // (test/common's mustCall — tsc infers `() => any` from the wrapper
     // it returns): the inferred arity is the wrapper's spelling, not a
@@ -691,9 +725,6 @@ export function collectSignatureInner(lowerer, decl) {
         return;
     const isAsync = decl.modifiers?.some((m) => m.kind === ts.SyntaxKind.AsyncKeyword) === true;
     const isGenerator = decl.asteriskToken !== undefined;
-    if (isGenerator && isAsync) {
-        lowerer.unsupported("SC1071", decl, "async generators (async function*)");
-    }
     if (decl.typeParameters) {
         // Generic async composes: each monomorphized instance is an async
         // IrFunction like any other — its own spawn wrapper, its body
@@ -742,10 +773,11 @@ export function collectSignatureInner(lowerer, decl) {
     }
     const nameBlame = decl.name ?? decl;
     const returnType = lowerer.declaredReturnType(decl, nameBlame);
-    if (isAsync && returnType.kind !== "promise") {
+    if (isAsync && !isGenerator && returnType.kind !== "promise") {
         lowerer.badType(nameBlame, lowerer.typeOf(nameBlame));
     }
-    if (isGenerator && returnType.kind !== "generator") {
+    if (isGenerator &&
+        (returnType.kind !== "generator" || (returnType.async === true) !== isAsync)) {
         lowerer.badType(nameBlame, lowerer.typeOf(nameBlame));
     }
     const symbol = declSymbolOf(lowerer, decl);
@@ -761,7 +793,7 @@ export function collectSignatureInner(lowerer, decl) {
         returnType,
         isAsync,
         ...(isGenerator && returnType.kind === "generator"
-            ? { generator: { yieldT: returnType.yieldT, nextT: returnType.nextT } }
+            ? { generator: generatorMeta(lowerer, returnType) }
             : {}),
     });
 }
@@ -1172,17 +1204,15 @@ export function lowerGenericInstance(lowerer, info, inst) {
     // and awaits park this instance's fibers.
     const isAsync = decl.modifiers?.some((m) => m.kind === ts.SyntaxKind.AsyncKeyword) === true;
     const nameBlame = (ts.isArrowFunction(decl) ? undefined : decl.name) ?? decl;
-    if (isAsync && inst.returnType.kind !== "promise") {
+    const isGenerator = decl.asteriskToken !== undefined;
+    if (isAsync && !isGenerator && inst.returnType.kind !== "promise") {
         lowerer.badType(nameBlame, lowerer.checker.getTypeAtLocation(nameBlame));
     }
     // A generic GENERATOR instance mirrors async: the body returns the
     // resolved TReturn channel, calls enter through the instance's own
     // gen-spawn wrapper (the emitter routes by fn.generator).
-    const isGenerator = decl.asteriskToken !== undefined;
-    if (isGenerator && isAsync) {
-        lowerer.unsupported("SC1071", decl, "async generators (async function*)");
-    }
-    if (isGenerator && inst.returnType.kind !== "generator") {
+    if (isGenerator &&
+        (inst.returnType.kind !== "generator" || (inst.returnType.async === true) !== isAsync)) {
         lowerer.badType(nameBlame, lowerer.checker.getTypeAtLocation(nameBlame));
     }
     let bodyReturn = isGenerator
@@ -1198,7 +1228,7 @@ export function lowerGenericInstance(lowerer, info, inst) {
     if (cls && info.member.kind === "method")
         lowerer.currentClass = cls;
     if (isGenerator && inst.returnType.kind === "generator") {
-        fnCtx.generator = { yieldT: inst.returnType.yieldT, nextT: inst.returnType.nextT };
+        fnCtx.generator = generatorMeta(lowerer, inst.returnType);
     }
     lowerer.fnStack.push(fnCtx);
     try {
@@ -1623,6 +1653,15 @@ function paramWrittenInBody(lowerer, body, sym, name) {
     walk(body);
     return written;
 }
+function broadPromiseParam(lowerer, type) {
+    const mapped = lowerer.mapTypeOf(type);
+    const arms = mapped?.kind === "union"
+        ? lowerer.unions.get(mapped.unionId)?.arms
+        : mapped === null ? undefined : [mapped];
+    return !!arms &&
+        arms.some((arm) => arm.kind === "promise" && arm.inner.kind === "dyn") &&
+        arms.every((arm) => isUnitType(arm) || (arm.kind === "promise" && arm.inner.kind === "dyn"));
+}
 /** The implicit-type-parameter slots of a JS function-like: parallel to
    * decl.parameters, the param SYMBOL where the slot is a bindable
    * implicit-any param (identifier-named, no annotation/JSDoc type, not
@@ -1651,7 +1690,10 @@ export function implicitAnyParamSymbolsOf(lowerer, decl) {
         if (param.name.text === "this")
             return null;
         const t = lowerer.typeOf(param.name);
-        if ((t.flags & ts.TypeFlags.Any) === 0)
+        const broadFunction = lowerer.checker.typeToString(t) === "Function";
+        const broadArray = lowerer.checkerAnyArrayType(t);
+        const broadPromise = broadPromiseParam(lowerer, t);
+        if ((t.flags & ts.TypeFlags.Any) === 0 && !broadFunction && !broadArray && !broadPromise)
             return null;
         const sym = lowerer.checker.getSymbolAtLocation(param.name);
         if (!sym)
@@ -1670,13 +1712,54 @@ export function implicitAnyParamSymbolsOf(lowerer, decl) {
    * selects return INFERENCE with DYN as the recursion pin. */
 function implicitDeclaredReturn(lowerer, info) {
     try {
+        const broadCallbackSymbols = new Set(info.decl.parameters.flatMap((param, index) => {
+            const symbol = info.implicitParams?.[index];
+            return symbol !== null && symbol !== undefined &&
+                lowerer.checker.typeToString(lowerer.typeOf(param.name)) === "Function"
+                ? [symbol]
+                : [];
+        }));
+        let returnsBroadCallback = false;
+        if (broadCallbackSymbols.size > 0 && info.decl.body !== undefined) {
+            ts.walkPreorder(info.decl.body, (node) => {
+                if (node !== info.decl.body && ts.isFunctionLike(node))
+                    return "skip";
+                if (!ts.isReturnStatement(node) || node.expression === undefined)
+                    return undefined;
+                let expression = node.expression;
+                while (ts.isParenthesizedExpression(expression))
+                    expression = expression.expression;
+                if (ts.isCallExpression(expression) &&
+                    ts.isIdentifier(expression.expression) &&
+                    broadCallbackSymbols.has(lowerer.checker.getSymbolAtLocation(expression.expression) ?? {})) {
+                    returnsBroadCallback = true;
+                    return "stop";
+                }
+                return undefined;
+            });
+        }
+        if (returnsBroadCallback)
+            return null;
         const declSig = lowerer.checker.getSignatureFromDeclaration(info.decl);
         if (!declSig)
             return null;
         const retTs = lowerer.checker.getReturnTypeOfSignature(declSig);
         if (retTs.flags & ts.TypeFlags.Any)
             return null;
-        return lowerer.mapTypeOf(retTs);
+        if (lowerer.checker.isArrayType(retTs)) {
+            const elem = lowerer.checker.getTypeArguments(retTs)[0];
+            // An implicit-any parameter poisons an inferred array result to
+            // any[] even when this instance's body produces one concrete
+            // element type (`knownBy(cmd)` in commander). Let the existing
+            // lowered-return unifier recover that type. Explicit unknown[]
+            // remains a declared checked-dynamic contract and stays pinned.
+            if (elem && (elem.flags & ts.TypeFlags.Any) !== 0)
+                return null;
+        }
+        const mapped = lowerer.mapTypeOf(retTs);
+        if (mapped !== null && promiseCarriesDyn(lowerer, mapped) && !hasExplicitJsDocReturn(info.decl))
+            return null;
+        return mapped;
     }
     catch (e) {
         if (!(e instanceof PoisonError))
@@ -1684,6 +1767,19 @@ function implicitDeclaredReturn(lowerer, info) {
         return null;
     }
 }
+/** True when a `this.method(...)` call targets an implicit npm-static
+ * method whose result is settled from its lowered body rather than the
+ * checker declaration. Uninitialized-local inference uses this to avoid
+ * freezing an evolving `any` slot to stale JSDoc. */
+export function implicitMethodCallInfersReturn(lowerer, call) {
+    if (!ts.isPropertyAccessExpression(call.expression) ||
+        call.expression.expression.kind !== ts.SyntaxKind.ThisKeyword ||
+        lowerer.currentClass === null) {
+        return false;
+    }
+    const found = findGenericMethodOn(lowerer, lowerer.currentClass, call.expression.name.text);
+    return found?.info.implicitParams !== undefined && implicitDeclaredReturn(lowerer, found.info) === null;
+}
 /** True when an IR type may BIND an implicit param (a concrete static
    * type — the checked-dynamic kinds keep the dyn slot, units have no
    * standalone representation). */
@@ -1709,15 +1805,37 @@ export function implicitCallInstance(lowerer, call, info) {
             return;
         }
         let bound = DYN;
+        const declared = lowerer.paramShape(param);
+        if ((lowerer.typeOf(param.name).flags & ts.TypeFlags.Any) === 0)
+            bound = declared.type;
         const arg = call.arguments[i];
         if (arg && !ts.isSpreadElement(arg)) {
+            const runtimeLocal = ts.isIdentifier(arg) ? lowerer.peekLocal(arg) : null;
+            if (runtimeLocal?.type.kind === "dyn") {
+                bound = DYN;
+                argTypes.set(sym, lowerer.checker.getUnknownType());
+                shapes.push({ type: bound, mode: "required" });
+                return;
+            }
             // The argument's own checker type, literal-widened ('add' binds
             // string) — typeOf consults the ACTIVE instance's bindings, so a
             // bound param forwarded into another implicit call transitively
             // instantiates it (this._initCommandGroup(command)).
             const t = lowerer.checker.getBaseTypeOfLiteralType(lowerer.typeOf(arg));
-            const mapped = lowerer.mapTypeOf(t);
-            if (bindableImplicitIr(mapped)) {
+            const mapped = lowerer.mapTypeOf(t) ?? dynFallbackType(lowerer, arg, t);
+            if (ts.isArrowFunction(arg) &&
+                arg.type === undefined &&
+                mapped?.kind === "func" &&
+                promiseCarriesDyn(lowerer, mapped.ret)) {
+                bound = { ...mapped, ret: DYN };
+                lowerer.runtimeOptionalFunctionReturns.set(arg, DYN);
+                argTypes.set(sym, t);
+            }
+            else if (mapped?.kind === "dyn") {
+                bound = DYN;
+                argTypes.set(sym, t);
+            }
+            else if (bindableImplicitIr(mapped)) {
                 bound = mapped;
                 argTypes.set(sym, t);
             }
@@ -1743,7 +1861,11 @@ function internImplicitInstance(lowerer, blame, info, shapes, argTypes) {
             `${MAX_GENERIC_INSTANCES} instances — polymorphic recursion?)`);
     }
     const rendered = shapes.map((s) => lowerer.fmt(s.type)).join(", ");
-    const declared = implicitDeclaredReturn(lowerer, info);
+    const dynamicBroadPromise = info.decl.parameters.some((param, index) => info.implicitParams?.[index] !== null &&
+        info.implicitParams?.[index] !== undefined &&
+        shapes[index]?.type.kind === "dyn" &&
+        broadPromiseParam(lowerer, lowerer.typeOf(param.name)));
+    const declared = dynamicBroadPromise ? null : implicitDeclaredReturn(lowerer, info);
     inst = {
         name: `${info.qualifiedName}%${info.instances.size}`,
         ordinal: info.instances.size,
@@ -2712,6 +2834,11 @@ export function lowerCall(lowerer, expr) {
         if (crServed)
             return crServed;
     }
+    {
+        const resolved = lowerImportMetaResolveCall(lowerer, expr) ?? lowerRequireResolveCall(lowerer, expr);
+        if (resolved)
+            return resolved;
+    }
     // `process.getuid?.()` — intercepted BEFORE the optional-chain
     // machinery (the member always exists on a POSIX target, so the
     // optional call IS the call; `process.getuid` itself has no value
@@ -3022,6 +3149,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" ||
@@ -3057,6 +3212,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") {
@@ -3141,7 +3299,7 @@ export function lowerCall(lowerer, expr) {
             !expr.expression.questionDotToken &&
             !expr.questionDotToken &&
             !expr.arguments.some((a) => ts.isSpreadElement(a))) {
-            const recvProbe = probeLower(lowerer, expr.expression.expression);
+            const recvProbe = tryLowerExpression(lowerer, expr.expression.expression);
             if (recvProbe?.type.kind === "dyn") {
                 const args = expr.arguments.map((a) => lowerer.lowerExprExpecting(a, DYN));
                 return {
@@ -3287,6 +3445,9 @@ export function lowerCall(lowerer, expr) {
             const cryptoServed = lowerer.lowerCryptoModuleCall(expr, bi, loc);
             if (cryptoServed)
                 return cryptoServed;
+            const timersInterval = lowerer.lowerTimersPromisesSetInterval(expr, bi, loc);
+            if (timersInterval)
+                return timersInterval;
             const builtinFn = builtinModuleFnOf(lowerer, bi.module, bi.member);
             if (!builtinFn) {
                 // Typed by @types/node (the fallback declarations only declare
@@ -3442,7 +3603,7 @@ export function lowerCall(lowerer, expr) {
                         return parsed;
                 }
             }
-            const probed = probeLower(lowerer, expr.arguments[0]);
+            const probed = tryLowerExpression(lowerer, expr.arguments[0]);
             if (name === "parseFloat" && probed?.type.kind === "string") {
                 return { kind: "libCall", fn: "num.parseFloat", args: [probed], type: F64, loc };
             }
@@ -3756,12 +3917,12 @@ export function lowerCall(lowerer, expr) {
         return { kind: "callValue", callee, args, type: callee.type.ret, loc };
     }
     if (ts.isPropertyAccessExpression(expr.expression)) {
-        const intrinsic = 
-        // Builtin namespace imports first (`fs.readFileSync(...)` where fs
-        // is `import * as fs from "node:fs"`): the same tables and fences
-        // as named builtin imports — before anything below tries to lower
-        // the namespace object itself as a receiver.
-        lowerer.lowerNamespaceBuiltinCall(expr, expr.expression) ??
+        const intrinsic = fenceNodeModuleMutationCall(lowerer, expr, expr.expression) ??
+            // Builtin namespace imports first (`fs.readFileSync(...)` where fs
+            // is `import * as fs from "node:fs"`): the same tables and fences
+            // as named builtin imports — before anything below tries to lower
+            // the namespace object itself as a receiver.
+            lowerer.lowerNamespaceBuiltinCall(expr, expr.expression) ??
             // The node:perf_hooks spoke: performance.now() and its
             // .bind(performance) function value over the runtime's
             // process-start-anchored monotonic clock.
@@ -3792,10 +3953,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).
@@ -3878,6 +4041,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) ??
@@ -4379,7 +4544,7 @@ function lowerDynReceiverMethodCall(lowerer, call, access) {
         // evolving `let h = {}` object flowing back out of a JS helper —
         // tsc types the return by the evolved shape, the binding lowered
         // dyn): probe the lowering and claim exactly the dyn results.
-        const probed = probeLower(lowerer, access.expression);
+        const probed = tryLowerExpression(lowerer, access.expression);
         if (probed?.type.kind !== "dyn")
             return null;
         recv = probed;
@@ -4572,6 +4737,71 @@ export function lowerDynDispatchMethodCall(lowerer, call, access, recv, arrayRec
     if (arrayReceiver && predicate?.type.kind === "func" && predicate.type.ret.kind === "void") {
         lowerer.unsupported("SC1090", call.arguments[0], "'.filter()' with a void-returning predicate (the callback return value is erased before its truthiness can be tested)");
     }
+    // A dynamic argument array consumed immediately by the fixed-arity arrow
+    // apply lowering below never exposes its surplus tail. Keep a pushed
+    // static-only value's evaluation and the array length mutation, but store
+    // undefined in that unobserved slot so no impossible dyn conversion is
+    // invented. If the slot falls inside the typed prefix, its dynCheck fails
+    // at the callback boundary; valid callers preserve the original prefix.
+    if (method === "push" &&
+        call.arguments.length === 1 &&
+        ts.isIdentifier(access.expression) &&
+        ts.isExpressionStatement(call.parent) &&
+        ts.isBlock(call.parent.parent)) {
+        const receiverSymbol = lowerer.checker.getSymbolAtLocation(access.expression);
+        const block = call.parent.parent;
+        const statementIndex = block.statements.indexOf(call.parent);
+        const next = statementIndex >= 0 ? block.statements[statementIndex + 1] : undefined;
+        let returned = next && ts.isReturnStatement(next) ? next.expression : undefined;
+        while (returned && ts.isParenthesizedExpression(returned))
+            returned = returned.expression;
+        const apply = returned && ts.isCallExpression(returned) &&
+            ts.isPropertyAccessExpression(returned.expression) &&
+            returned.expression.name.text === "apply"
+            ? returned
+            : null;
+        const argsNode = apply?.arguments[1];
+        const sameArgs = receiverSymbol !== undefined &&
+            argsNode !== undefined &&
+            ts.isIdentifier(argsNode) &&
+            lowerer.checker.getSymbolAtLocation(argsNode) === receiverSymbol;
+        const applyAccess = apply && ts.isPropertyAccessExpression(apply.expression)
+            ? apply.expression
+            : null;
+        const applyTarget = applyAccess?.expression;
+        const arrow = applyTarget ? arrowSignatureOf(lowerer, applyTarget) : null;
+        const target = applyTarget && ts.isIdentifier(applyTarget)
+            ? lowerer.peekLocal(applyTarget)
+            : null;
+        const targetParams = target?.type.kind === "func" && target.type.rest !== true
+            ? target.type.params
+            : null;
+        if (sameArgs && arrow !== null && targetParams !== null &&
+            targetParams.every((param) => canDynCheckTo(param, (id) => lowerer.shapes.get(id), (id) => lowerer.unions.get(id)))) {
+            const value = lowerer.lowerExpr(call.arguments[0]);
+            if (value.type.kind !== "dyn" && !lowerer.dynConvertible(value.type)) {
+                const saved = lowerer.declareHiddenLocal("%applyTail", DYN);
+                return {
+                    kind: "seqExpr",
+                    stmts: [
+                        { kind: "varDecl", localId: saved.id, init: recv, loc: locOf(access.expression) },
+                        { kind: "exprStmt", expr: value, loc: value.loc },
+                    ],
+                    result: {
+                        kind: "dynInvoke",
+                        recv: { kind: "varRef", localId: saved.id, type: DYN, loc: locOf(access.expression) },
+                        method,
+                        calleeName: access.getText(),
+                        args: [dynUndefinedExpr(locOf(call.arguments[0]))],
+                        type: DYN,
+                        loc: locOf(call),
+                    },
+                    type: DYN,
+                    loc: locOf(call),
+                };
+            }
+        }
+    }
     const args = call.arguments.map((arg, i) => i === 0 && predicate ? lowerer.coerceInto(arg, predicate, DYN) : lowerer.lowerExprExpecting(arg, DYN));
     return {
         kind: "dynInvoke",
@@ -4924,7 +5154,7 @@ function lowerPrimitiveProtoCall(lowerer, call, recv, name, memberSym) {
         // optional number selects 0 at runtime through the same narrowed
         // nullish IR used by `digits ?? 0`.
         const zero = { kind: "numLit", value: 0, type: F64, loc: digits.loc };
-        const defaultUnitDigits = (value) => droppableStatic(value)
+        const defaultUnitDigits = (value) => isSafeToDiscard(value)
             ? zero
             : {
                 kind: "seqExpr",
@@ -5010,6 +5240,46 @@ function lowerPrimitiveProtoCall(lowerer, call, recv, name, memberSym) {
         return null;
     return { kind: "boolLit", value: false, type: BOOL, loc };
 }
+/** The uniquely arity-selected overload on an implicit-any receiver whose
+   * active monomorphization supplies a concrete type. The checker resolved
+   * the original call through `any`, so getResolvedSignature cannot name
+   * the declaration-authored overload; typeOf carries the instance's real
+   * receiver type. Restricting the fallback to exactly one bodyless
+   * signature at this arity avoids recreating TypeScript's overload
+   * resolution for same-arity type distinctions. */
+function implicitReceiverOverloadReturn(lowerer, expr) {
+    if (!ts.isCallExpression(expr) ||
+        !ts.isPropertyAccessExpression(expr.expression) ||
+        expr.arguments.some(ts.isSpreadElement)) {
+        return null;
+    }
+    const access = expr.expression;
+    const original = lowerer.checker.getTypeAtLocation(access.expression);
+    if ((original.flags & ts.TypeFlags.Any) === 0)
+        return null;
+    const effective = lowerer.typeOf(access.expression);
+    if ((effective.flags & ts.TypeFlags.Any) !== 0)
+        return null;
+    const member = lowerer.checker.getPropertyOfType(effective, access.name.text);
+    if (!member)
+        return null;
+    const signatures = lowerer.checker.getCallSignatures(lowerer.checker.getTypeOfSymbol(member));
+    const matches = signatures.filter((signature) => {
+        const decl = lowerer.checker.signatureDeclaration(signature);
+        if (!decl ||
+            !(ts.isFunctionDeclaration(decl) || ts.isMethodDeclaration(decl)) ||
+            decl.body) {
+            return false;
+        }
+        const params = decl.parameters.filter((param) => !isThisParameter(param));
+        const required = params.filter((param) => !param.questionToken && !param.initializer && !param.dotDotDotToken).length;
+        const maximum = params.some((param) => param.dotDotDotToken) ? Infinity : params.length;
+        return expr.arguments.length >= required && expr.arguments.length <= maximum;
+    });
+    if (matches.length !== 1)
+        return null;
+    return lowerer.mapTypeOf(lowerer.checker.getReturnTypeOfSignature(matches[0]));
+}
 /** Reconciles a direct call's recorded type with the checker's answer at
    * the site when the callee is OVERLOADED: tsc resolved the call against
    * one overload SIGNATURE, so every downstream lowering sees that
@@ -5029,10 +5299,12 @@ function lowerPrimitiveProtoCall(lowerer, call, recv, name, memberSym) {
 function reconcileOverloadReturn(lowerer, expr, call) {
     const rsig = lowerer.checker.getResolvedSignature(expr);
     const rdecl = rsig ? lowerer.checker.signatureDeclaration(rsig) : undefined;
-    if (!rsig || !rdecl || !(ts.isFunctionDeclaration(rdecl) || ts.isMethodDeclaration(rdecl)) || rdecl.body) {
-        return call;
-    }
-    const rt = lowerer.mapTypeOf(lowerer.checker.getReturnTypeOfSignature(rsig));
+    const resolvedOverload = rsig && rdecl &&
+        (ts.isFunctionDeclaration(rdecl) || ts.isMethodDeclaration(rdecl)) &&
+        !rdecl.body
+        ? lowerer.mapTypeOf(lowerer.checker.getReturnTypeOfSignature(rsig))
+        : null;
+    const rt = resolvedOverload ?? implicitReceiverOverloadReturn(lowerer, expr);
     // Unmappable, void, or unit resolved returns keep the implementation's
     // type: a discarded result never looks, a USED one meets its use
     // site's own mapping (and that site's honest fences). Unit narrowing
@@ -5290,19 +5562,38 @@ export function isTopLevelFnSymbol(lowerer, ident) {
         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
@@ -5312,10 +5603,6 @@ export function lowerNestedFunctionDecl(lowerer, stmt) {
 export function lambdaSignature(lowerer, node) {
     if (!node.body)
         lowerer.unsupported("SC1090", node, "function overload signatures");
-    if (node.asteriskToken &&
-        node.modifiers?.some((m) => m.kind === ts.SyntaxKind.AsyncKeyword)) {
-        lowerer.unsupported("SC1071", node, "async generators (async function*)");
-    }
     if (node.typeParameters) {
         // Generic function-like forms monomorphize only where a static home
         // exists: top-level generic function declarations, generic methods
@@ -5486,13 +5773,14 @@ export function lowerLambda(lowerer, node) {
     // the lifted body returns the inner T (a `return v` fulfills with v).
     const isAsync = !ts.isAccessor(node) &&
         node.modifiers?.some((m) => m.kind === ts.SyntaxKind.AsyncKeyword) === true;
-    if (isAsync && funcType.ret.kind !== "promise")
+    const isGenerator = node.asteriskToken !== undefined;
+    if (isAsync && !isGenerator && funcType.ret.kind !== "promise")
         lowerer.badType(node, lowerer.typeOf(node));
     // Generator lambdas (function* expressions and object-literal
     // *methods): the VALUE's type returns the generator; the lifted body
     // returns the TReturn channel (a `return v` is the done-value).
-    const isGenerator = node.asteriskToken !== undefined;
-    if (isGenerator && funcType.ret.kind !== "generator")
+    if (isGenerator &&
+        (funcType.ret.kind !== "generator" || (funcType.ret.async === true) !== isAsync))
         lowerer.badType(node, lowerer.typeOf(node));
     const bodyReturn = isGenerator
         ? lowerer.genBodyReturnType(funcType.ret)
@@ -5500,7 +5788,7 @@ export function lowerLambda(lowerer, node) {
     const fnCtx = newFnCtx(true, selfSymbol, funcType, bodyReturn);
     fnCtx.isAsync = isAsync;
     if (isGenerator && funcType.ret.kind === "generator") {
-        fnCtx.generator = { yieldT: funcType.ret.yieldT, nextT: funcType.ret.nextT };
+        fnCtx.generator = generatorMeta(lowerer, funcType.ret);
     }
     const diagsBefore = lowerer.diags.length;
     lowerer.fnStack.push(fnCtx);
@@ -5531,11 +5819,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 {
@@ -6535,6 +6825,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;
@@ -6842,7 +7174,7 @@ function lowerIntlNumberFormatCall(lowerer, call, access) {
 function objectIsDisjointFalse(left, right, loc) {
     const stmts = [];
     for (const e of [left, right]) {
-        if (!droppableStatic(e))
+        if (!isSafeToDiscard(e))
             stmts.push({ kind: "exprStmt", expr: e, loc });
     }
     const answer = { kind: "boolLit", value: false, type: BOOL, loc };
@@ -6856,6 +7188,9 @@ function lowerObjectStaticCall(lowerer, call, access) {
     if (!lowerer.isStdlibGlobal(access.expression, "Object"))
         return null;
     const member = access.name.text;
+    const cacheKeys = lowerRequireCacheKeys(lowerer, call, member);
+    if (cacheKeys)
+        return cacheKeys;
     // Object.is — the spec's SameValue over the static kinds. Number
     // pairs take the runtime SameValue (NaN equals NaN, +0 differs from
     // -0 — the two divergences from ===); every other supported pair
@@ -7046,8 +7381,8 @@ function lowerObjectStaticCall(lowerer, call, access) {
         // the explicit-undefined-is-absent stance). Everything else keeps
         // the spread hint.
         if (call.arguments.length === 2 && !call.arguments.some((a) => ts.isSpreadElement(a))) {
-            const tProbe = probeLower(lowerer, call.arguments[0]);
-            const sProbe = probeLower(lowerer, call.arguments[1]);
+            const tProbe = tryLowerExpression(lowerer, call.arguments[0]);
+            const sProbe = tryLowerExpression(lowerer, call.arguments[1]);
             // CHECKED-DYNAMIC target and source (the JS file-scope
             // object-literal identity story): the runtime dyn copy — own
             // members of the source land on the target, which returns.
@@ -7105,7 +7440,7 @@ function lowerObjectStaticCall(lowerer, call, access) {
             while (ts.isParenthesizedExpression(targetNode))
                 targetNode = targetNode.expression;
             const freshLiteralTarget = ts.isObjectLiteralExpression(targetNode);
-            const tProbe = freshLiteralTarget ? null : probeLower(lowerer, call.arguments[0]);
+            const tProbe = freshLiteralTarget ? null : tryLowerExpression(lowerer, call.arguments[0]);
             const tKind = tProbe?.type.kind;
             if (freshLiteralTarget || tKind === "dyn" || tKind === "nullT" || tKind === "undefinedT") {
                 const loc = locOf(call);
@@ -7177,7 +7512,7 @@ function lowerObjectStaticCall(lowerer, call, access) {
     // static shapes have no property table to extend.
     if (member === "defineProperties" && call.arguments.length === 2 &&
         !call.arguments.some((a) => ts.isSpreadElement(a))) {
-        let target = probeLower(lowerer, call.arguments[0]);
+        let target = tryLowerExpression(lowerer, call.arguments[0]);
         // A FUNCTION-typed target boxes through the dyn boundary: the
         // property table lives on the CLOSURE (shared by every box of this
         // function value), so defining through a fresh box sticks — the
@@ -7232,7 +7567,7 @@ function lowerObjectStaticCall(lowerer, call, access) {
     if (member === "hasOwn" && call.arguments.length === 2 && !call.arguments.some((a) => ts.isSpreadElement(a))) {
         const recvNode = call.arguments[0];
         const keyNode = call.arguments[1];
-        const probed = probeLower(lowerer, recvNode);
+        const probed = tryLowerExpression(lowerer, recvNode);
         // A CHECKED-DYNAMIC receiver (the JS file-scope object-literal
         // identity story): the runtime dyn probe — OBJ member presence, ARR
         // index bounds, Node's ToObject TypeError on nullish.
@@ -7278,7 +7613,7 @@ function lowerObjectStaticCall(lowerer, call, access) {
     // runtime walks the dyn node's own keys (integer-like keys first,
     // JS's own-key order) and answers a dyn array.
     {
-        const probed = probeLower(lowerer, argNode);
+        const probed = tryLowerExpression(lowerer, argNode);
         const isDyn = probed?.type.kind === "dyn";
         // Unit-typed arguments (Object.keys(null)) ride the same runtime
         // walk: it throws Node's catchable TypeError.
@@ -7296,7 +7631,7 @@ function lowerObjectStaticCall(lowerer, call, access) {
     // record (the narrowed export-table literal) — the lowered value's
     // shape is the honest dispatch key, exactly the identity-Set stance.
     if (argIr === null && isJsSourceFile(argNode.getSourceFile())) {
-        const probed = probeLower(lowerer, argNode);
+        const probed = tryLowerExpression(lowerer, argNode);
         if (probed?.type.kind === "record")
             argIr = probed.type;
     }
@@ -8337,6 +8672,69 @@ const SP_BRAND_METHODS = new Set([
     "append", "delete", "get", "getAll", "has", "set", "sort",
     "forEach", "keys", "values", "entries", "toString",
 ]);
+function arrowSignatureOf(lowerer, node) {
+    const signatures = lowerer.checker.getCallSignatures(lowerer.typeOf(node));
+    if (signatures.length !== 1)
+        return null;
+    const declaration = lowerer.checker.signatureDeclaration(signatures[0]);
+    return declaration !== undefined && ts.isArrowFunction(declaration) ? signatures[0] : null;
+}
+/** `arrow.apply(thisArg, dynArgs)` for a fixed-arity compiled arrow. Arrows
+ * ignore `thisArg` and surplus arguments by language definition; declared
+ * parameters validate from the dynamic array in order. */
+function lowerArrowFunctionApply(lowerer, call, access) {
+    if (access.name.text !== "apply" ||
+        call.arguments.length !== 2 ||
+        call.arguments.some(ts.isSpreadElement) ||
+        arrowSignatureOf(lowerer, access.expression) === null) {
+        return null;
+    }
+    const callee = lowerer.lowerExpr(access.expression);
+    if (callee.type.kind !== "func" || callee.type.rest === true)
+        return null;
+    if (!callee.type.params.every((param) => canDynCheckTo(param, (id) => lowerer.shapes.get(id), (id) => lowerer.unions.get(id)))) {
+        return null;
+    }
+    const argsList = lowerer.lowerExpr(call.arguments[1]);
+    if (argsList.type.kind !== "dyn")
+        return null;
+    const loc = locOf(call);
+    const savedCallee = lowerer.declareHiddenLocal("%applyFn", callee.type);
+    const savedArgs = lowerer.declareHiddenLocal("%applyArgs", DYN);
+    const stmts = [
+        { kind: "varDecl", localId: savedCallee.id, init: callee, loc },
+        { kind: "exprStmt", expr: lowerer.lowerExpr(call.arguments[0]), loc },
+        { kind: "varDecl", localId: savedArgs.id, init: argsList, loc },
+    ];
+    const args = callee.type.params.map((param, index) => {
+        const read = {
+            kind: "dynKeyGet",
+            key: { kind: "strLit", value: String(index), type: STRING, loc },
+            value: { kind: "varRef", localId: savedArgs.id, type: DYN, loc },
+            type: DYN,
+            loc,
+        };
+        return lowerer.coerceInto(call.arguments[1], read, param);
+    });
+    const invoked = {
+        kind: "callValue",
+        callee: { kind: "varRef", localId: savedCallee.id, type: callee.type, loc },
+        args,
+        type: callee.type.ret,
+        loc,
+    };
+    let result;
+    if (invoked.type.kind === "void") {
+        stmts.push({ kind: "exprStmt", expr: invoked, loc });
+        result = dynUndefinedExpr(loc);
+    }
+    else {
+        result = lowerer.coerceInto(call, invoked, DYN);
+        if (result.type.kind !== "dyn")
+            return null;
+    }
+    return { kind: "seqExpr", stmts, result, type: DYN, loc };
+}
 function lowerObjLitGenericMethodCall(lowerer, call, access) {
     if (lowerer.chainBlocked(access, call))
         return null;
@@ -8398,6 +8796,9 @@ function lowerObjLitGenericMethodCall(lowerer, call, access) {
     }
     const found = objLitGenericFnNodeOf(lowerer, propSym);
     if (!found) {
+        const arrowApply = lowerArrowFunctionApply(lowerer, call, access);
+        if (arrowApply !== null)
+            return arrowApply;
         // Function.prototype.apply/call/bind spelled through a FUNCTION
         // receiver: compiled functions are direct calls with no runtime
         // `this`/arguments object to re-route — name the working spelling
@@ -8444,9 +8845,32 @@ function lowerObjLitGenericMethodCall(lowerer, call, access) {
 export function lowerObjectMethodCall(lowerer, call, access) {
     if (lowerer.chainBlocked(access, call))
         return null;
-    const receiverIr = lowerer.mapTypeOf(lowerer.typeOf(access.expression));
-    if (receiverIr?.kind !== "object")
+    const mappedReceiver = lowerer.mapTypeOf(lowerer.typeOf(access.expression));
+    const receiverIr = mappedReceiver?.kind === "object"
+        ? mappedReceiver
+        : mappedReceiver?.kind === "union"
+            ? (() => {
+                const arms = lowerer.unions.get(mappedReceiver.unionId)?.arms ?? [];
+                const objects = arms.filter((arm) => arm.kind === "object");
+                return objects.length === 1 && arms.every((arm) => arm.kind === "object" || isUnitType(arm))
+                    ? objects[0]
+                    : null;
+            })()
+            : null;
+    if (receiverIr === null)
         return null;
+    const lowerReceiver = () => {
+        const receiver = lowerer.lowerExpr(access.expression);
+        const optional = lowerer.runtimeOptionalPropertyReceiver(access.expression, receiver, receiverIr, access.name.text);
+        if (optional !== null)
+            return optional;
+        if (receiver.type.kind === "union") {
+            const helper = lowerer.narrowedArmHelper(receiver.type.unionId, receiverIr, locOf(access.expression));
+            if (helper !== null)
+                return { kind: "call", callee: helper, args: [receiver], type: receiverIr, loc: locOf(access.expression) };
+        }
+        return receiver;
+    };
     const info = lowerer.classes.get(receiverIr.className);
     if (!info)
         lowerer.flushDeferredClass(receiverIr.className);
@@ -8474,17 +8898,34 @@ export function lowerObjectMethodCall(lowerer, call, access) {
         if (gfound)
             return lowerClassGenericMethodCall(lowerer, call, access, info, gfound);
     }
-    // A FUNC- or DYN-typed FIELD in call position: `this.cb()` — the
-    // ctor-assigned callback field (countdown.js's shape). The call is an
-    // ordinary call through the field's VALUE — read the field, then
-    // callValue (func fields) or the dynCall boundary (checked-dynamic
-    // fields: implicit-any ctor params, validated at the call like every
-    // dyn callee). Every other field type falls through to the fences.
+    // A FUNC-, nullable-FUNC-, or DYN-typed FIELD in call position:
+    // `this.cb()` — the ctor-assigned callback field (countdown.js's
+    // shape). The call is an ordinary call through the field's VALUE —
+    // read and, when necessary, check-narrow the callable arm, then
+    // callValue; checked-dynamic fields use the dynCall boundary. Every
+    // other field type falls through to the fences.
     if (info && !found) {
         const fieldType = info.fields.get(access.name.text);
-        if (fieldType && (fieldType.kind === "func" || fieldType.kind === "dyn")) {
+        const callableType = fieldType?.kind === "func"
+            ? fieldType
+            : fieldType?.kind === "union"
+                ? (() => {
+                    const arms = lowerer.unions.get(fieldType.unionId)?.arms ?? [];
+                    const funcs = arms.filter((arm) => arm.kind === "func");
+                    return funcs.length === 1 && arms.every((arm) => arm.kind === "func" || isUnitType(arm))
+                        ? funcs[0]
+                        : null;
+                })()
+                : null;
+        if (fieldType && (callableType !== null || fieldType.kind === "dyn")) {
             const target = lowerer.fieldTarget(access);
-            const callee = target ? lowerer.fieldGetExpr(target, locOf(access), access) : null;
+            let callee = target ? lowerer.fieldGetExpr(target, locOf(access), access) : null;
+            if (callee?.type.kind === "union" && callableType !== null) {
+                const helper = lowerer.narrowedArmHelper(callee.type.unionId, callableType, locOf(access));
+                if (helper !== null) {
+                    callee = { kind: "call", callee: helper, args: [callee], type: callableType, loc: locOf(access) };
+                }
+            }
             if (callee?.type.kind === "func") {
                 const params = callee.type.params;
                 const args = call.arguments.map((a, i) => lowerer.lowerExprExpecting(a, params[i]));
@@ -8514,7 +8955,7 @@ export function lowerObjectMethodCall(lowerer, call, access) {
         // The one builtin method: Error.prototype.toString, a runtime
         // implementation called directly (overriding it is fenced, so no
         // dispatch can ever be needed). Receiver BORROWED by the libCall.
-        const receiver = lowerer.lowerExpr(access.expression);
+        const receiver = lowerReceiver();
         return {
             kind: "libCall",
             fn: "error.toString",
@@ -8536,7 +8977,7 @@ export function lowerObjectMethodCall(lowerer, call, access) {
         lowerer.noteVirtualEdge(info, method);
     else
         lowerer.noteEdge(`%${found.declarer.def.name}.${method}`);
-    const receiver = lowerer.lowerExpr(access.expression);
+    const receiver = lowerReceiver();
     const args = lowerer.completeArgs(call.arguments, found.sig.params, locOf(call), call);
     if (lowerer.overrideBelow(info, method)) {
         return reconcileOverloadReturn(lowerer, call, {