@scriptc/compiler 0.0.36 → 0.1.2

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

@@ -1,3 +1,4 @@
+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
@@ -6,15 +7,19 @@ 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 { 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, lowerCreateRequireCall, 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
@@ -101,7 +114,7 @@ export function paramShape(lowerer, param) {
             }
             return { type: abi, mode: "omittable", bodyType };
         }
-        return { type: lowerer.irTypeOf(param.name), mode: "required" };
+        return { type: lowerer.runtimeOptionalBindingType(param.name, lowerer.irTypeOf(param.name)), mode: "required" };
     }
     if (param.dotDotDotToken) {
         // A JS rest param with no static element type (`(...args)` — any[]):
@@ -124,7 +137,7 @@ export function paramShape(lowerer, param) {
                 return { type: DYN, mode: "dynRest" };
             }
         }
-        const type = lowerer.irTypeOf(param.name);
+        const type = lowerer.runtimeOptionalBindingType(param.name, lowerer.irTypeOf(param.name));
         // Tuple-typed rest params don't map to an array; generic rest is the
         // generic path's business. Anything non-array here is unmappable.
         if (type.kind !== "array")
@@ -167,7 +180,7 @@ export function paramShape(lowerer, param) {
         }
         return { type: abi, mode: "omittable", bodyType };
     }
-    const type = lowerer.irTypeOf(param.name);
+    const type = lowerer.runtimeOptionalBindingType(param.name, lowerer.irTypeOf(param.name));
     if (param.questionToken && !lowerer.bareUndefinedArmedUnion(type) && type.kind !== "dyn" && type.kind !== "jsval") {
         // `x?: unknown` where unknown came from an annotation: undefined is
         // absorbed into the hole type, so no undefined ARM exists — but a
@@ -195,7 +208,7 @@ export function paramShapes(lowerer, params, signature, blameOf) {
     return params.map((declParam, i) => {
         const symbol = signature.getParameters()[i];
         const tsType = symbol ? lowerer.checker.getTypeOfSymbol(symbol) : lowerer.typeOf(declParam.name);
-        const mapped = lowerer.mapTypeOf(tsType);
+        const mapped = lowerer.runtimeOptionalBindingType(declParam.name, lowerer.mapTypeOf(tsType) ?? lowerer.irTypeOf(declParam.name));
         if (!mapped || mapped.kind === "void")
             lowerer.badType(blameOf?.(declParam, i) ?? declParam.name, tsType);
         if (declParam.dotDotDotToken) {
@@ -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 {
@@ -1437,6 +1467,9 @@ export function lowerGenericFnValue(lowerer, ref, info) {
         fenceUnpinned();
     const bindings = new Map();
     unifySignatureBindings(lowerer, info, target, bindings);
+    const hofBinding = runtimeOptionalHofGenericBinding(lowerer, ref, info);
+    if (hofBinding)
+        bindings.set(hofBinding.typeParam, hofBinding.type);
     bindDefaultTypeParams(lowerer, info.typeParams, info.decl.typeParameters, bindings);
     // A pinning signature that itself keeps type parameters (`let g: <T>(x:
     // T) => T = identity` — storing the generic signature as such) binds
@@ -1457,6 +1490,31 @@ export function lowerGenericFnValue(lowerer, ref, info) {
     lowerer.noteEdge(inst.name);
     return { kind: "closure", fnName: inst.name, captures: [], type: funcType, loc };
 }
+function runtimeOptionalHofGenericBinding(lowerer, ref, info) {
+    let argument = ref;
+    while (argument.parent && ts.isParenthesizedExpression(argument.parent))
+        argument = argument.parent;
+    const call = argument.parent;
+    if (!ts.isCallExpression(call) || call.arguments[0] !== argument)
+        return null;
+    if (!ts.isPropertyAccessExpression(call.expression) || call.expression.name.text !== "map")
+        return null;
+    if (!lowerer.isStdlibMember(call.expression))
+        return null;
+    const receiver = lowerer.mapTypeOf(lowerer.typeOf(call.expression.expression));
+    if (receiver?.kind !== "array")
+        return null;
+    const parameter = info.decl.parameters[0];
+    if (!parameter || !ts.isIdentifier(parameter.name))
+        return null;
+    const parameterType = lowerer.typeOf(parameter.name);
+    if ((parameterType.flags & ts.TypeFlags.TypeParameter) === 0)
+        return null;
+    const typeParam = parameterType.getSymbol();
+    if (!typeParam || !info.typeParams.includes(typeParam))
+        return null;
+    return { typeParam, type: lowerer.runtimeOptionalType(receiver.elem) };
+}
 /** The instance a pinned VALUE reference names: the declaration's modes
    * over the DECLARED types mapped under the bindings (mapType's resolver
    * substitutes — the instance-body trick), which is the same result the
@@ -1595,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
@@ -1623,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)
@@ -1642,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))
@@ -1656,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). */
@@ -1681,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);
             }
@@ -1715,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,
@@ -2684,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
@@ -3044,6 +3199,9 @@ export function lowerCall(lowerer, expr) {
         if (arg.type.kind === "string") {
             return { kind: "libCall", fn: "num.fromString", args: [arg], type: F64, loc };
         }
+        const optionalNumber = lowerOptionalStringNumber(lowerer, arg, loc);
+        if (optionalNumber)
+            return optionalNumber;
         lowerer.noLowering(`Number of ${lowerer.fmt(arg.type)} values`, argNode, arg.type.kind === "union"
             ? "numbers, booleans, and strings lower (the full ToNumber string grammar included) — narrow the union first"
             : undefined);
@@ -3110,7 +3268,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 {
@@ -3256,6 +3414,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
@@ -3335,7 +3496,7 @@ export function lowerCall(lowerer, expr) {
             const radix = expr.arguments[1]
                 ? lowerer.lowerExprExpecting(expr.arguments[1], F64)
                 : { kind: "numLit", value: 0, type: F64, loc };
-            const optional = lowerAbsenceProbe(lowerer, expr.arguments[0]);
+            const optional = optionalCallValue(lowerer, expr.arguments[0]);
             if (optional?.type.kind === "union") {
                 const def = lowerer.unions.get(optional.type.unionId);
                 const stringTag = def?.arms.findIndex((arm) => arm.kind === "string") ?? -1;
@@ -3403,7 +3564,15 @@ export function lowerCall(lowerer, expr) {
             expr.arguments.length === 1 &&
             lowerer.isStdlibSymbol(lowerer.resolveValueSymbol(expr.expression) ?? undefined)) {
             const name = expr.expression.text;
-            const probed = probeLower(lowerer, expr.arguments[0]);
+            if (name === "parseFloat") {
+                const optional = optionalCallValue(lowerer, expr.arguments[0]);
+                if (optional) {
+                    const parsed = lowerOptionalStringNumber(lowerer, optional, loc, "num.parseFloat", "parseFloat");
+                    if (parsed)
+                        return parsed;
+                }
+            }
+            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 };
             }
@@ -3433,13 +3602,12 @@ export function lowerCall(lowerer, expr) {
             const loc = locOf(expr);
             const argNode = expr.arguments[0];
             if (name === "decodeURIComponent") {
-                const d = lowerer.lowerExpr(argNode);
-                if (d.type.kind !== "string") {
-                    lowerer.noLowering(`${name} with a '${lowerer.fmt(d.type)}' argument`, argNode, "only string arguments lower (Node would ToString the value — convert it explicitly)");
-                }
-                return { kind: "libCall", fn: "str.decodeUriComponent", args: [d], type: STRING, loc };
+                const d = optionalCallValue(lowerer, argNode) ?? lowerer.lowerExpr(argNode);
+                const s = lowerer.ensureString(d, argNode);
+                return { kind: "libCall", fn: "str.decodeUriComponent", args: [s], type: STRING, loc };
             }
-            const s = lowerer.ensureString(lowerer.lowerExpr(argNode), argNode);
+            const value = optionalCallValue(lowerer, argNode) ?? lowerer.lowerExpr(argNode);
+            const s = lowerer.ensureString(value, argNode);
             return {
                 kind: "libCall",
                 fn: name === "encodeURIComponent" ? "str.encodeUriComponent" : "str.encodeUri",
@@ -3718,12 +3886,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.
@@ -3750,7 +3918,7 @@ export function lowerCall(lowerer, expr) {
             lowerPromiseRejectCall(lowerer, expr, expr.expression) ??
             // Before the island path: regex-argument replace/replaceAll/split
             // lower STATICALLY; only the string-pattern overloads are island.
-            lowerer.lowerRegexMethodCall(expr, expr.expression) ??
+            lowerRegexMethodCallWithOptionalArg(lowerer, expr, expr.expression) ??
             lowerer.lowerUrlMethodCall(expr, expr.expression) ??
             lowerer.lowerSearchParamsMethodCall(expr, expr.expression) ??
             lowerer.lowerStatsMethodCall(expr, expr.expression) ??
@@ -3789,11 +3957,11 @@ export function lowerCall(lowerer, expr) {
             // TestContext surface (t.test/t.skip/t.diagnostic), t.assert.*.
             lowerer.lowerTestMethodCall(expr, expr.expression) ??
             lowerer.lowerTimeoutMethodCall(expr, expr.expression) ??
-            lowerer.lowerStringMethodCall(expr, expr.expression) ??
+            lowerStringMethodCallWithOptionalArgs(lowerer, expr, expr.expression) ??
             // Typed-array/Buffer receivers and the Buffer statics — before the
             // island path (bytes never cross the boundary).
             lowerer.lowerBytesMethodCall(expr, expr.expression) ??
-            lowerer.lowerBufferStaticCall(expr, expr.expression) ??
+            lowerBufferStaticCallWithOptionalArg(lowerer, expr, expr.expression) ??
             // URL.revokeObjectURL's zero-argument contract (the one-argument
             // form keeps the fence — createObjectURL does too).
             lowerUrlStaticCall(lowerer, expr, expr.expression) ??
@@ -4057,6 +4225,160 @@ export function lowerCall(lowerer, expr) {
     }
     return { kind: "callValue", callee, args, type: callee.type.ret, loc };
 }
+function lowerRegexMethodCallWithOptionalArg(lowerer, call, access) {
+    const lowered = lowerer.lowerRegexMethodCall(call, access);
+    if (lowered?.kind !== "regexIntrinsic" || lowered.method !== "test" || call.arguments.length !== 1)
+        return lowered;
+    const subject = lowered.args[0];
+    if (subject?.type.kind !== "union" || lowerer.armTag(subject.type.unionId, UNDEFINED_T) < 0)
+        return lowered;
+    if (lowerer.mapTypeOf(lowerer.typeOf(call.arguments[0]))?.kind !== "string")
+        return lowered;
+    const present = lowerer.stripUndefinedArm(subject.type);
+    if (present.kind !== "string")
+        return lowered;
+    return {
+        ...lowered,
+        args: [lowerer.ensureString(subject, call.arguments[0])],
+    };
+}
+function optionalCallValue(lowerer, node) {
+    return lowerer.runtimeOptionalIdentifierValue(node)?.value ?? lowerAbsenceProbe(lowerer, node);
+}
+function lowerBufferStaticCallWithOptionalArg(lowerer, call, access) {
+    const lowered = lowerer.lowerBufferStaticCall(call, access);
+    if (lowered?.kind !== "bytesNew" || !lowered.source || lowered.source.type.kind !== "union")
+        return lowered;
+    const present = lowerer.stripUndefinedArm(lowered.source.type);
+    const validSource = (present.kind === "array" && present.elem.kind === "f64") ||
+        (present.kind === "bytes" && present.elem === "u8");
+    if (!validSource)
+        return lowered;
+    const helper = lowerer.narrowedArmHelper(lowered.source.type.unionId, present, lowered.source.loc);
+    return helper
+        ? {
+            ...lowered,
+            source: { kind: "call", callee: helper, args: [lowered.source], type: present, loc: lowered.source.loc },
+        }
+        : lowered;
+}
+function lowerOptionalNumberDefault(lowerer, value, dflt, loc) {
+    const widened = lowerer.runtimeOptionalWidening(value.type, F64);
+    if (!widened || widened.kind !== "union")
+        return null;
+    const numberTag = lowerer.armTag(widened.unionId, F64);
+    const undefinedTag = lowerer.armTag(widened.unionId, UNDEFINED_T);
+    if (numberTag < 0 || undefinedTag < 0)
+        return null;
+    const key = `number.optionalDefault:${widened.unionId}:${dflt}`;
+    let helper = lowerer.widthHelpers.get(key);
+    if (!helper) {
+        helper = `%number.optionalDefault.${lowerer.widthHelpers.size}`;
+        lowerer.widthHelpers.set(key, helper);
+        const input = varRef("value.0", widened, loc);
+        lowerer.liftedFns.push({
+            name: helper,
+            params: [{ localId: "value.0", name: "value", type: widened }],
+            returnType: F64,
+            locals: [{ id: "value.0", name: "value", type: widened, mutable: false }],
+            body: [
+                {
+                    kind: "if",
+                    cond: { kind: "unionIsTag", unionId: widened.unionId, tag: undefinedTag, negated: false, value: input, type: BOOL, loc },
+                    then: [{ kind: "return", value: { kind: "numLit", value: dflt, type: F64, loc }, loc }],
+                    else_: null,
+                    loc,
+                },
+                {
+                    kind: "return",
+                    value: { kind: "unionNarrow", unionId: widened.unionId, tag: numberTag, value: input, type: F64, loc },
+                    loc,
+                },
+            ],
+            loc,
+        });
+    }
+    return { kind: "call", callee: helper, args: [value], type: F64, loc };
+}
+function lowerStringMethodCallWithOptionalArgs(lowerer, call, access) {
+    const lowered = lowerer.lowerStringMethodCall(call, access);
+    if (lowered?.kind !== "strIntrinsic")
+        return lowered;
+    const args = [...lowered.args];
+    let changed = false;
+    const zeroDefaultArgs = lowered.method === "charCodeAt" || lowered.method === "charAt" ||
+        lowered.method === "repeat" || lowered.method === "padStart" || lowered.method === "padEnd"
+        ? [0]
+        : lowered.method === "slice" || lowered.method === "substring"
+            ? [0]
+            : lowered.method === "indexOf" || lowered.method === "includes"
+                ? [1]
+                : [];
+    for (const index of zeroDefaultArgs) {
+        const value = args[index];
+        if (!value)
+            continue;
+        const coerced = lowerOptionalNumberDefault(lowerer, value, 0, value.loc);
+        if (coerced) {
+            args[index] = coerced;
+            changed = true;
+        }
+    }
+    if ((lowered.method === "indexOf" || lowered.method === "includes" ||
+        lowered.method === "startsWith" || lowered.method === "endsWith") &&
+        args[0]?.type.kind === "union" &&
+        lowerer.runtimeOptionalWidening(args[0].type, STRING) !== null) {
+        args[0] = lowerer.ensureString(args[0], call.arguments[0]);
+        changed = true;
+    }
+    return changed ? { ...lowered, args } : lowered;
+}
+function lowerOptionalStringNumber(lowerer, arg, loc, fn = "num.fromString", label = "number") {
+    if (arg.type.kind !== "union")
+        return null;
+    const def = lowerer.unions.get(arg.type.unionId);
+    if (!def || def.arms.length !== 2)
+        return null;
+    const stringTag = lowerer.armTag(arg.type.unionId, STRING);
+    const undefinedTag = lowerer.armTag(arg.type.unionId, UNDEFINED_T);
+    if (stringTag < 0 || undefinedTag < 0)
+        return null;
+    const key = `${label}.optionalString:${arg.type.unionId}`;
+    let helper = lowerer.widthHelpers.get(key);
+    if (!helper) {
+        helper = `%${label}.optionalString.${lowerer.widthHelpers.size}`;
+        lowerer.widthHelpers.set(key, helper);
+        const value = varRef("value.0", arg.type, loc);
+        lowerer.liftedFns.push({
+            name: helper,
+            params: [{ localId: "value.0", name: "value", type: arg.type }],
+            returnType: F64,
+            locals: [{ id: "value.0", name: "value", type: arg.type, mutable: false }],
+            body: [
+                {
+                    kind: "if",
+                    cond: { kind: "unionIsTag", unionId: arg.type.unionId, tag: undefinedTag, negated: false, value, type: BOOL, loc },
+                    then: [{ kind: "return", value: { kind: "bin", op: "/", left: { kind: "numLit", value: 0, type: F64, loc }, right: { kind: "numLit", value: 0, type: F64, loc }, type: F64, loc }, loc }],
+                    else_: null,
+                    loc,
+                },
+                {
+                    kind: "return",
+                    value: {
+                        kind: "libCall",
+                        fn,
+                        args: [{ kind: "unionNarrow", unionId: arg.type.unionId, tag: stringTag, value, type: STRING, loc }],
+                        type: F64,
+                        loc,
+                    },
+                    loc,
+                },
+            ],
+            loc,
+        });
+    }
+    return { kind: "call", callee: helper, args: [arg], type: F64, loc };
+}
 /** The RUNTIME-ARITY spread call — `f(...args)`, the rest-forwarding idiom
    * (`const f = (...args) => from(...args)`): a spread whose length is a
    * runtime fact has no home in the compile-time completion, so the call
@@ -4187,7 +4509,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;
@@ -4380,6 +4702,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",
@@ -4732,7 +5119,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",
@@ -4818,6 +5205,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
@@ -4837,10 +5264,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
@@ -4920,10 +5349,9 @@ function templateEscapesValid(raw) {
     return true;
 }
 /** Tagged templates `tag\`a${x}b\`` — ES's call: tag(strings, ...values).
-   * The strings object is the per-SITE interned cooked array (the
-   * templateStrings node: one immortal string[] per occurrence, so the
-   * spec's identity contract holds — the same site evaluated twice hands
-   * the tag the SAME array; two sites never share). TemplateStringsArray
+   * The strings object is a per-SITE lazily initialized hidden array global,
+   * so the spec's identity contract holds — the same site evaluated twice
+   * hands the tag the SAME array; two sites never share. TemplateStringsArray
    * maps to string[] (type-mapper.ts), so the array rides the ordinary
    * slot-directed coercion into whatever the tag's first parameter wants
    * — string[] exactly, an `any` slot through the dyn boundary, a rest
@@ -4949,13 +5377,7 @@ export function lowerTaggedTemplate(lowerer, expr) {
             lowerer.unsupported("SC1090", p, "tagged templates with invalid escape sequences (the span cooks to undefined, which the strings array cannot carry)");
         }
     }
-    const strings = {
-        kind: "templateStrings",
-        key: `${loc.file}:${expr.template.getStart()}`,
-        cooked: pieces.map((p) => p.text),
-        type: arrayOf(STRING),
-        loc,
-    };
+    const strings = () => loweredTemplateStrings(lowerer, expr, pieces.map((piece) => piece.text), loc);
     const values = ts.isNoSubstitutionTemplateLiteral(expr.template)
         ? []
         : expr.template.templateSpans.map((s) => s.expression);
@@ -5007,7 +5429,7 @@ export function lowerTaggedTemplate(lowerer, expr) {
             const sig = lowerer.fnSigOf(expr.tag);
             if (sig) {
                 lowerer.noteEdge(sig.name);
-                const args = completeArgs(lowerer, values, sig.params, loc, expr, [strings]);
+                const args = completeArgs(lowerer, values, sig.params, loc, expr, [strings()]);
                 return reconcileOverloadReturn(lowerer, expr, { kind: "call", callee: sig.name, args, type: sig.returnType, loc });
             }
             // An ambient `declare function` nothing defines: Node throws
@@ -5034,7 +5456,7 @@ export function lowerTaggedTemplate(lowerer, expr) {
     const callee = lowerer.lowerExpr(expr.tag);
     if (callee.type.kind === "dyn") {
         const args = [
-            lowerer.coerceInto(expr.template, strings, DYN),
+            lowerer.coerceInto(expr.template, strings(), DYN),
             ...values.map((a) => lowerer.lowerExprExpecting(a, DYN)),
         ];
         const calleeName = ts.isPropertyAccessExpression(expr.tag) || ts.isElementAccessExpression(expr.tag)
@@ -5046,6 +5468,53 @@ export function lowerTaggedTemplate(lowerer, expr) {
     }
     lowerer.unsupported("SC1090", expr, "tagged templates with this tag form (top-level functions and dynamic values tag; call the function directly otherwise)");
 }
+function loweredTemplateStrings(lowerer, expr, cooked, loc) {
+    // Normal runtime construction keeps this array aligned with the current
+    // ScrArr layout in both backends. The old static-header IR node encoded the
+    // pre-sparse layout in LLVM and crashed as soon as a tag read its strings.
+    const type = arrayOf(STRING);
+    const key = `templateStringsGlobal:${loc.file}:${expr.template.getStart()}`;
+    let getter = lowerer.widthHelpers.get(key);
+    if (!getter) {
+        const site = lowerer.globalsList.length;
+        const globalId = `%g.templateStrings.${site}`;
+        const readyId = `%g.templateStringsReady.${site}`;
+        getter = `%templateStrings.get.${lowerer.widthHelpers.size}`;
+        lowerer.widthHelpers.set(key, getter);
+        lowerer.globalsList.push({ id: globalId, name: "%templateStrings", type, mutable: true }, { id: readyId, name: "%templateStringsReady", type: BOOL, mutable: true });
+        lowerer.liftedFns.push({
+            name: getter,
+            params: [],
+            returnType: type,
+            locals: [],
+            body: [
+                {
+                    kind: "if",
+                    cond: { kind: "unary", op: "!", operand: varRef(readyId, BOOL, loc), type: BOOL, loc },
+                    then: [
+                        {
+                            kind: "assign",
+                            localId: globalId,
+                            value: {
+                                kind: "arrayLit",
+                                elems: cooked.map((value) => ({ kind: "strLit", value, type: STRING, loc })),
+                                type,
+                                loc,
+                            },
+                            loc,
+                        },
+                        { kind: "assign", localId: readyId, value: { kind: "boolLit", value: true, type: BOOL, loc }, loc },
+                    ],
+                    else_: null,
+                    loc,
+                },
+                { kind: "return", value: varRef(globalId, type, loc), loc },
+            ],
+            loc,
+        });
+    }
+    return { kind: "call", callee: getter, args: [], type, loc };
+}
 /** True when the identifier resolves (through import aliases) to a
    * top-level function declaration of ANY program file (not merely a
    * same-named local shadowing one). Functions declared directly in a
@@ -5080,10 +5549,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
@@ -5107,6 +5572,7 @@ export function lambdaSignature(lowerer, node) {
     let ret = ts.isArrowFunction(node) && !ts.isBlock(node.body) && isStreamUndefCallExpr(lowerer, node.body)
         ? VOID
         : lowerer.declaredReturnType(node, node);
+    ret = lowerer.runtimeOptionalFunctionReturnType(node, ret);
     // A contextually-typed arrow/function EXPRESSION whose slot signature
     // returns a UNION the inferred return doesn't spell adopts the slot's
     // return as its ABI: `(n) => work()` (inferring Promise<void>) against
@@ -5253,13 +5719,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)
@@ -5267,7 +5734,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);
@@ -6609,7 +7076,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 };
@@ -6623,6 +7090,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
@@ -6813,8 +7283,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.
@@ -6872,7 +7342,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);
@@ -6944,7 +7414,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
@@ -6999,7 +7469,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.
@@ -7045,7 +7515,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.
@@ -7063,7 +7533,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;
     }
@@ -8104,6 +8574,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;
@@ -8165,6 +8698,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
@@ -8211,9 +8747,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);
@@ -8241,17 +8800,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]));
@@ -8281,7 +8857,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",
@@ -8303,7 +8879,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, {