@scriptc/compiler 0.1.3 → 0.1.5

package/dist/frontend/lowering/lowerer.js

@@ -19,20 +19,20 @@ import * as ts from "../ts7/adapter.js";
 import { anyOpRequiresDynamicDiag, blockedBindingUseDiag, checkerPanicDiag, componentTypeDiag, isCheckerPanic, genericSignatureTypeDiag, indexSignatureTypeDiag, intersectionTypeDiag, noLoweringDiag, overloadedSignatureTypeDiag, recordShapeMismatchDiag, requiresDynamicApiDiag, requiresDynamicPackageDiag, requiresDynamicTypeDiag, unionMismatchDiag, unsupportedDiag, unsupportedTypeDiag, } from "../../diagnostics/diagnostic.js";
 import { arrayOf, BOOL, canAdaptDynFuncTo, canConvertToDyn, canCrossIslandBoundary, canExitIslandToType, canMarshalTypedFuncIntoIsland, DYN, DYN_HANDLE_KINDS, F64, isDynTypedRefType, isJsonSafeType, isJsonStringifySafeType, isUndefinedArmedUnion, isUnitType, JSVAL, NULL_T, RUNTIME_ERROR_CLASSES, STRING, typeEquals, UNDEFINED_T, VOID } from "../../ir/ir.js";
 import { provenanceActive } from "../provenance-registry.js";
-import { ambientDtsPath, canonicalBuiltinModule, cjsExportAssignmentOf, cjsExportDiscardReason, fallbackDtsPath, isCjsExportTableLiteral, isJsSourceFile, isNodeEsmFile, isNodeTypesPath, locOf, orderedImportsOf, overridesDtsPath, npmStaticDepSf7, requireSpecOf, resolveImport, workspacePackageOfPath, } from "../program.js";
+import { ambientDtsPath, canonicalBuiltinModule, cjsExportAssignmentOf, cjsExportDiscardReason, fallbackDtsPath, isCjsExportTableLiteral, isCjsJsFile, isJsSourceFile, isNodeEsmFile, isNodeTypesPath, locOf, orderedImportsOf, overridesDtsPath, npmStaticDepSf7, requireSpecOf, resolveImport, workspacePackageOfPath, } from "../program.js";
 import { containsRecord, containsUnion, describeComponentBlocker, describeRecordMemberBlocker, formatIrType, ISLAND_AMBIENT_TYPES, isUnitOnlyTsType, mapType, ShapeRegistry, typeKey, UnionRegistry, withUndefinedArm as withUndefinedArmCanonical, } from "../type-mapper.js";
 import { boundaryIntoIslandMsg, boundaryOutOfIslandMsg, builtinConstLit, builtinModuleConstOf, builtinModulesArrayLit, builtinFenceHintOf, builtinModuleFnOf, stdlibMemberFence, isStdlibMember, isStdlibSymbol, isStdlibGlobal, stdlibGlobalMember, nodeTypesOnlySymbol } from "./surfaces.js";
-import { splitFiles, collectProgram, collectNpmImports, collectJsonImports, moduleArtifacts, collectGlobals, declSymbolOf, defaultExportSymbolOf, lowerFileInit, lowerDefaultExport, buildMain, appendDynamicImportModules } from "./lower-modules.js";
+import { splitFiles, collectProgram, collectNpmImports, collectJsonImports, moduleArtifacts, collectGlobals, declSymbolOf, defaultExportSymbolOf, lowerFileInit, lowerDefaultExport, buildMain, appendDynamicImportModules, appendForkModules } from "./lower-modules.js";
 import { prepareCjsModuleGraph } from "./lower-node-module.js";
 import { registerBuiltinErrorClasses, registerBuiltinEmitterClass, registerBuiltinStreamClasses, builtinErrorInfoOf, builtinEmitterInfoOf, builtinStreamInfoOf, analyzeClassDecoration, classIteratorDrainCall, classIteratorNextCall, classIteratorOf, classIteratorOpenCall, classIteratorRestDrainCall, classMemberNameOf, classValueRef, collectClassShape, exactClassOfReceiver, collectClassShapeInner, ctorAbiEquals, findMethodOn, findStaticOn, findGenericMethodOn, findGenericStaticOn, genericClassInstanceType, isSubclassOf, inHierarchy, overrideBelow, staticShadowBelow, upcastTo, lowerClassMembers, lowerClassCtor, lowerClassExpression, lowerClassExpressionInfo, lowerClassMethodMember, lowerClassValueProperty, lowerStaticMethod, throwingSetterFn, fieldInitStmts, lowerStaticFieldInits, lowerStaticFieldRead, lowerDerivedCtorBody, superCallStmt, lowerSuperMethodCall, superThisRef, lowerSuperAccessorRead, lowerSuperAccessorWrite, inheritsBuiltinErrorCtor, inheritsBuiltinEmitterCtor, errorMessageArg, lowerNew, accessorCall } from "./lower-classes.js";
 import { mixinCallClassInfoOf, mixinIntersectionInstanceType } from "./lower-mixins.js";
-import { bindingNeverReassigned, bodyReadsArguments, implicitMonoFile, isThisParameter, paramShape, paramShapes, checkDefaultParamBodyType, completeArgs, wrappedUndefined, undefinedArgFor, requireExactArityValue, bodyReturnType, declaredReturnType, collectSignature, collectSignatureInner, collectGenericSignature, genericFnOf, lowerGenericCall, lowerGenericFnValue, inferTypeParamBindings, lowerGenericInstance, lowerCall, lowerFfiCall, lowerTimersMemberCall, lowerPromiseMethodCall, lowerFilterNarrowCall, isTopLevelFnSymbol, lowerNestedFunctionDecl, lambdaSignature, lowerLambda, lowerFunction, validateFfiImports } from "./lower-calls.js";
+import { bindingNeverReassigned, bodyReadsArguments, funcTypeFromParamShapes, implicitMonoFile, isThisParameter, paramShape, paramShapes, checkDefaultParamBodyType, completeArgs, wrappedUndefined, undefinedArgFor, requireExactArityValue, bodyReturnType, declaredReturnType, collectSignature, collectSignatureInner, collectGenericSignature, genericFnOf, lowerGenericCall, lowerGenericFnValue, inferTypeParamBindings, lowerGenericInstance, lowerCall, lowerFfiCall, lowerTimersMemberCall, lowerPromiseMethodCall, lowerFilterNarrowCall, isTopLevelFnSymbol, lowerNestedFunctionDecl, lambdaSignature, lowerLambda, lowerFunction, validateFfiImports } from "./lower-calls.js";
 import { lowerArrayMethodCall, lowerMapMethodCall, lowerMapForEachCall, buildMapForEachFn, lowerRecordOvfCaptureHelper, lowerEnvToPairsHelper, lowerSetMethodCall, lowerSetForEachCall, buildSetForEachFn } from "./lower-containers.js";
 import { lowerBufferStaticCall, lowerBytesMethodCall, lowerBytesNew } from "./containers/bytes.js";
 import { lowerRegexMethodCall, lowerStringMethodCall } from "./containers/string-and-regexp.js";
 import { lowerStreamModuleCall } from "./lower-stream.js";
 import { lowerEmitOverrideSpec } from "./lower-event-emitter.js";
-import { builtinImportOf, createRequireBindingDecl, createRequireNamespaceDecl, createRequireSpecOf, stripTypeCasts, lowerBuiltinModuleCall, lowerTimersPromisesSetInterval, lowerFsToUnixTimestampCall, lowerFsLadderCall, lowerChildArgsArg, lowerSpawnSyncCall, lowerSpawnCall, lowerExecSyncCall, recordToEnvPairs, lowerJsonMethodCall, fencedBuiltinImportOf, lowerCryptoComposedCall, lowerUrlMethodCall, lowerSearchParamsMethodCall, lowerStatsMethodCall, lowerChildMethodCall, lowerAtomicsCall, lowerBuiltinExtraProperty, promisifiedExecFileDecl, lowerExecFileAsyncCall, execFileAsyncHelper, lowerStringDecoderMethodCall, strdecHelper, lowerReadlineMethodCall, lowerDcChannelMethodCall, lowerDcChannelProperty, lowerAlsMethodCall, lowerDcTracingChannelMethodCall, lowerDcTracingChannelProperty, lowerJsonProperty, lowerErrorCodeProperty, lowerProcessProperty, isProcessEnv, envValueType, lowerProcessEnvGet, lowerProcessMethodCall, lowerProcessOptionalMethodCall, lowerTimeoutMethodCall, envSnapshotHelper, isConsoleLog, consoleCallMember, lowerNumberStaticCall, lowerNumberStaticProperty, lowerDateCall, lowerTextCodecCall, lowerCryptoModuleCall, lowerFsConstantsProperty, lowerBuiltinConstantsProperty, builtinConstantBindingOf, builtinConstantsDestructureDecl, lowerProcessStreamProperty, lowerStringStaticCall, lowerStringLastIndexOfCall, lowerPromiseStaticCall, textCodecBindingClassOf } from "./lower-builtins.js";
+import { builtinImportOf, createRequireBindingDecl, createRequireNamespaceDecl, createRequireProgramModuleOf, createRequireSpecOf, stripTypeCasts, lowerBuiltinModuleCall, lowerNodeModuleCall, lowerTimersPromisesSetInterval, lowerFsToUnixTimestampCall, lowerFsLadderCall, lowerChildArgsArg, lowerSpawnSyncCall, lowerSpawnCall, lowerExecFileCall, lowerExecSyncCall, recordToEnvPairs, lowerJsonMethodCall, fencedBuiltinImportOf, lowerCryptoComposedCall, lowerUrlMethodCall, lowerSearchParamsMethodCall, lowerStatsMethodCall, lowerChildMethodCall, lowerAtomicsCall, lowerBuiltinExtraProperty, registerPromisifiedBuiltinDecl, lowerExecFileAsyncCall, execFileAsyncHelper, lowerStringDecoderMethodCall, strdecHelper, lowerReadlineMethodCall, lowerDcChannelMethodCall, lowerDcChannelProperty, lowerAlsMethodCall, lowerDcTracingChannelMethodCall, lowerDcTracingChannelProperty, lowerJsonProperty, lowerErrorCodeProperty, lowerProcessProperty, isProcessEnv, envValueType, lowerProcessEnvGet, lowerProcessMethodCall, lowerProcessOptionalMethodCall, lowerTimeoutMethodCall, envSnapshotHelper, isConsoleLog, consoleCallMember, lowerNumberStaticCall, lowerNumberStaticProperty, lowerDateCall, lowerTextCodecCall, lowerCryptoModuleCall, lowerFsConstantsProperty, lowerBuiltinConstantsProperty, builtinConstantBindingOf, builtinConstantsDestructureDecl, lowerProcessStreamProperty, lowerStringStaticCall, lowerStringLastIndexOfCall, lowerPromiseStaticCall, textCodecBindingClassOf } from "./lower-builtins.js";
 import { fenceFetchObjectAssignment, fenceFetchObjectBinding, fenceStaticAbortControllerMemberRead, fenceStaticHeadersIteration, fenceStaticHeadersMember, fenceStaticReadableStreamMember, fenceStaticResponseMember, fenceUnsupportedFetchConstructorMember, isIslandExpr, islandFuncValueFence, islandRegexpOf, jsvalIn, requireDynamicApi, islandGlobalFnOf, lowerAbortControllerNew, lowerDynamicHeadersIteratorCall, lowerDynamicHeadersSpread, lowerDynamicImportCall, lowerFetchCall, lowerFetchElementMethodCall, lowerResponseNew, lowerStaticFetchCompanionCall, lowerStaticAbortControllerCall, lowerStaticAbortSignalListenerCall, lowerStaticReadableStreamCancelCall, lowerStaticReadableStreamControllerCall, lowerStaticReadableStreamNew, lowerStaticReadableStreamReaderCall, lowerStaticResponseCall, lowerIslandMethodCall, lowerMathProperty, npmPackageOf, npmMemberFence, npmPackageOfSymbol } from "./lower-island.js";
 import { lowerHttpHeadersElement, lowerNetModuleCall, lowerServerMethodCall, lowerServerProperty, lowerTlsRootCertificates } from "./lower-server.js";
 import { lowerDgramDnsModuleCall, lowerDgramMethodCall } from "./lower-dgram.js";
@@ -183,18 +183,31 @@ export function lowerToIr(program, entry, moduleOrder, options = {}) {
     const dynamic = options.dynamic ?? false;
     const targetPlatform = options.targetPlatform ?? process.platform;
     const startupCrash = options.startupCrash ?? null;
-    // --dynamic: modules reachable only through dynamic import() of the
-    // program's own files join the compiled graph here, ONCE, before any
+    // Modules reachable only through literal import() of the program's own
+    // files join the compiled graph here, ONCE, before any
     // pass constructs (nothing calls their %init at startup — the import()
     // site's namespace builder does, on the engine microtask, Node's
     // evaluation point for them). Inadmissible static cycles inside the
     // added subgraph are minted here and handed to reachable emit after this
     // extension of the shared array; no later pass re-walks the subgraph.
-    const dynamicCycleDiags = [];
-    if (dynamic) {
-        appendDynamicImportModules(program, moduleOrder, (cycle, reason) => {
-            dynamicCycleDiags.push(unsupportedDiag("SC1016", { file: entry.fileName, start: 0, end: 0 }, `circular imports (${cycle}; ${reason})`));
-        });
+    const extraModuleCycleDiags = [];
+    const cycleKeys = new Set();
+    const forkTargets = [];
+    const onExtraCycle = (cycle, reason) => {
+        const key = `${cycle}\0${reason}`;
+        if (cycleKeys.has(key))
+            return;
+        cycleKeys.add(key);
+        extraModuleCycleDiags.push(unsupportedDiag("SC1016", { file: entry.fileName, start: 0, end: 0 }, `circular imports (${cycle}; ${reason})`));
+    };
+    for (let pass = 0; pass < 32; pass++) {
+        const before = moduleOrder.length;
+        appendDynamicImportModules(program, moduleOrder, onExtraCycle);
+        appendForkModules(program, moduleOrder, forkTargets, onExtraCycle);
+        if (moduleOrder.length === before)
+            break;
+        if (pass === 31)
+            throw new Error("dynamic import and fork module discovery did not converge");
     }
     const ffiImports = options.ffiImports ?? [];
     const libraryCallbacks = options.libraryCallbacks ?? false;
@@ -206,6 +219,7 @@ export function lowerToIr(program, entry, moduleOrder, options = {}) {
         startupCrash,
         ffiImports,
         libraryCallbacks,
+        forkTargets,
         externalTypes,
         externalTypeSpecifiersByFile,
     });
@@ -223,11 +237,12 @@ export function lowerToIr(program, entry, moduleOrder, options = {}) {
             startupCrash,
             ffiImports,
             libraryCallbacks,
+            forkTargets,
             externalTypes,
             externalTypeSpecifiersByFile,
             ffiBindingSymbols: ffiValidation.symbolsByName,
         });
-    for (const d of dynamicCycleDiags)
+    for (const d of extraModuleCycleDiags)
         reachableEmit.pushDiag(d);
     for (const d of ffiValidation.diagnostics)
         reachableEmit.pushDiag(d);
@@ -250,11 +265,12 @@ export function lowerToIr(program, entry, moduleOrder, options = {}) {
             startupCrash,
             ffiImports,
             libraryCallbacks,
+            forkTargets,
             ffiBindingSymbols: ffiValidation.symbolsByName,
             externalTypes,
             externalTypeSpecifiersByFile,
         });
-        for (const d of dynamicCycleDiags)
+        for (const d of extraModuleCycleDiags)
             emit.pushDiag(d);
         for (const d of ffiValidation.diagnostics)
             emit.pushDiag(d);
@@ -271,6 +287,7 @@ export function lowerToIr(program, entry, moduleOrder, options = {}) {
         targetPlatform,
         ffiImports,
         libraryCallbacks,
+        forkTargets,
         ffiBindingSymbols: ffiValidation.symbolsByName,
         externalTypes,
         externalTypeSpecifiersByFile,
@@ -305,6 +322,46 @@ export function importCallHandleType(expr) {
     }
     return null;
 }
+/** The native namespace type produced by a literal static import() of a
+ * compiled program module or supported Node builtin. This syntax-level
+ * fallback is used where the checker exposes an anonymous builtin-module
+ * object type with no stable module symbol (locals/globals are still
+ * represented nominally by the value they actually receive). */
+export function staticImportNamespaceType(lowerer, expr) {
+    if (!expr || lowerer.dynamic)
+        return null;
+    let e = expr;
+    let awaited = false;
+    for (;;) {
+        if (ts.isParenthesizedExpression(e))
+            e = e.expression;
+        else if (ts.isAwaitExpression(e)) {
+            awaited = true;
+            e = e.expression;
+        }
+        else
+            break;
+    }
+    if (!ts.isCallExpression(e) || e.expression.kind !== ts.SyntaxKind.ImportKeyword)
+        return null;
+    const arg = e.arguments[0];
+    if (!arg || !ts.isStringLiteralLike(arg))
+        return null;
+    const builtin = canonicalBuiltinModule(arg.text);
+    let moduleId = builtin === null ? null : `builtin:${builtin}`;
+    if (moduleId === null) {
+        const symbol = lowerer.checker.getSymbolAtLocation(arg);
+        const source = symbol && lowerer.checker.declarationsOf(symbol).find((decl) => ts.isSourceFile(decl) && !decl.isDeclarationFile);
+        if (source && !source.fileName.endsWith(".cts") && !isCjsJsFile(source) &&
+            lowerer.moduleOrder.includes(source)) {
+            moduleId = `file:${tsgoPath(resolve(source.fileName))}`;
+        }
+    }
+    if (moduleId === null)
+        return null;
+    const ns = { kind: "moduleNs", moduleId };
+    return awaited ? ns : { kind: "promise", inner: ns };
+}
 /** True when `expr` is a call that resolved to an overload SIGNATURE of a
  * source-implemented function whose implementation returns an island value
  * (`any` under --dynamic): tsc never checks overload return types against
@@ -536,12 +593,50 @@ function jsFallbackFunctionType(lowerer, node, t) {
         return null;
     const params = sig.getParameters().map((p) => {
         const pt = lowerer.checker.getTypeOfSymbolAtLocation(p, node);
-        return lowerer.mapTypeOf(pt) ?? DYN;
+        let mapped = lowerer.mapTypeOf(pt) ?? DYN;
+        // The fallback must preserve the same completed ABI as mapType and
+        // lambdaSignature: a spelled optional/defaulted parameter accepts an
+        // omitted call, represented by an undefined arm in its fixed native
+        // slot. JS inference reports the body type (`boolean` for
+        // `enabled = true`) rather than that call-site type, so recover the
+        // syntactic optionality from the parameter declaration.
+        const decl = lowerer.checker.valueDeclarationOf(p);
+        const optional = decl !== undefined &&
+            ts.isParameter(decl) &&
+            (decl.questionToken !== undefined || decl.initializer !== undefined);
+        if (optional &&
+            mapped.kind !== "dyn" &&
+            mapped.kind !== "jsval" &&
+            !lowerer.bareUndefinedArmedUnion(mapped)) {
+            mapped = lowerer.withUndefinedArm(mapped);
+        }
+        return mapped;
     });
     const retT = lowerer.checker.getReturnTypeOfSignature(sig);
     const ret = retT.flags & ts.TypeFlags.Void ? VOID : lowerer.mapTypeOf(retT) ?? DYN;
     return { kind: "func", params, ret };
 }
+/** A JavaScript `arguments` reader has the spelled parameters plus a hidden
+ * array of all supplied arguments in the native ABI. Recover that ABI from
+ * the implementation when the function flows through a value binding. */
+function jsArgumentsFunctionType(lowerer, t) {
+    if (!(t.flags & ts.TypeFlags.Object))
+        return null;
+    const sigs = lowerer.checker.getCallSignatures(t);
+    if (sigs.length !== 1 || sigs[0].getTypeParameters().length !== 0 || lowerer.checker.getConstructSignatures(t).length !== 0 || lowerer.checker.getPropertiesOfType(t).length !== 0)
+        return null;
+    const decl = lowerer.checker.signatureDeclaration(sigs[0]);
+    if (decl === undefined || !(ts.isFunctionDeclaration(decl) || ts.isFunctionExpression(decl)) ||
+        !isJsSourceFile(decl.getSourceFile()) || !isNodeEsmFile(decl.getSourceFile()) ||
+        decl.parameters.length === 0 ||
+        decl.parameters.some((p) => p.dotDotDotToken !== undefined) ||
+        !bodyReadsArguments(decl))
+        return null;
+    const shapes = paramShapes(lowerer, decl.parameters);
+    const retType = lowerer.checker.getReturnTypeOfSignature(sigs[0]);
+    const ret = retType.flags & ts.TypeFlags.Void ? VOID : lowerer.mapTypeOf(retType) ?? DYN;
+    return funcTypeFromParamShapes([...shapes, { type: DYN, mode: "arguments" }], ret);
+}
 /** The one call signature of a PURE function type — single signature, no
  * properties, no construct signatures, no type parameters, no rest params
  * (declared or synthesized from an `arguments` read). Null for every
@@ -638,6 +733,10 @@ export class Lowerer {
     checker;
     diags = [];
     fnSigsBySymbol = new Map();
+    /** Immutable callable aliases and compiler-generated adapters. The map
+     * is symbol-keyed, so shadowing and cross-module imports keep the same
+     * exact binding discipline as globals/functions. */
+    staticCallables = new Map();
     genericFnsBySymbol = new Map();
     /** Object-literal GENERIC methods (`{ m<T>(x: T) {...} }`), interned by
      * their function-like node — instances ride the same monomorphization
@@ -925,7 +1024,7 @@ export class Lowerer {
                     if (sig) {
                         return {
                             ...fallback,
-                            params: sig.params.filter((p) => p.mode !== "dynRest").map((p) => p.type),
+                            params: sig.params.filter((p) => p.mode !== "dynRest" && p.mode !== "arguments").map((p) => p.type),
                             ret: sig.returnType,
                         };
                     }
@@ -1126,6 +1225,9 @@ export class Lowerer {
     /** Synthetic array-HOF loop functions (map/filter/forEach desugar),
      * interned per method + element/callback-result type: key → fn name. */
     arrHofHelpers = new Map();
+    /** Per-arm calls through union-typed class receivers, interned by the
+     * receiver union, member, completed argument ABI, and result type. */
+    unionCallHelpers = new Map();
     /** Derived shape metadata that depends on another shape's declaration
      * order. These settle before helper bodies rebuild from that metadata. */
     shapeOrderMetadataFinalizers = [];
@@ -1175,11 +1277,6 @@ export class Lowerer {
      * adapter helper MUST add its name here, or the identity guard silently
      * reopens and the mismatch surfaces as a runtime release trap instead. */
     freshClosureAdapters = new Set();
-    /** Symbols bound by `const x = promisify(execFile)` — the one lowered
-     * util.promisify shape. Declarations register here and emit nothing;
-     * calls through the binding lower (lowerExecFileAsyncCall) and value
-     * uses fence. */
-    promisifiedExecFile = new Set();
     /** Symbols bound by `const process = globalThis.process` (and the other
      * stdlib-global snapshot spellings): pure alias plumbing — receiver
      * checks resolve through this map (stdlibGlobalNameOf), declarations
@@ -1212,10 +1309,15 @@ export class Lowerer {
     spHofHelpers = new Map();
     /** The primitive-constructor VALUES (`String`/`Number`/`Boolean` as
      * bare identifiers — CLI option tables store and compare them): one
-     * synthesized coercion function per constructor per program, interned
-     * here by name so every reference is the SAME zero-capture closure and
-     * `opt.type === String` is JS identity (see primitiveCtorClosure). */
+     * synthesized coercion function per constructor and typed/dyn ABI,
+     * interned here so references under one source-world ABI are the SAME
+     * zero-capture closure (see primitiveCtorClosure). */
     primitiveCtorFns = new Map();
+    /** Builtin-module FUNCTIONS admitted as values by their surface-table
+     * entries. The resolved runtime function plus ABI is the identity key,
+     * so named imports, namespace reads, CommonJS bindings, and alias chains
+     * all reuse one immortal zero-capture closure. */
+    builtinCallableValueFns = new Map();
     /** Optional-chain lowering state. While a chain body lowers, the guarded
      * receiver NODE reads as a chainRecv (typed by the narrowed arm) instead
      * of re-lowering, its checker type reads non-nullish (typeOf), and the
@@ -1301,8 +1403,15 @@ export class Lowerer {
      * engine handle (a dynamic import's namespace object) — paramShape's
      * early-out. */
     jsvalParamOverrides = new Set();
+    /** Inline Promise.then parameters whose contextual type is a builtin
+     * module namespace anonymous object. The settled native token is the
+     * ABI truth even when the checker type has no stable module symbol. */
+    moduleNsParamOverrides = new Map();
     /** File → qualifier prefix: "" for the entry, "%mI." otherwise. */
     fileTag = new Map();
+    /** Embedded fork roots and their private startup ids. */
+    forkTargets;
+    forkTargetIdByPath = new Map();
     /** Namespace ModuleBlocks this program lowers, filled by splitFiles:
      * "flattened" — an instantiated namespace whose body joined the file's
      * parts (members resolve statically); "typeOnly" — a skipped
@@ -1506,6 +1615,10 @@ export class Lowerer {
         this.startupCrash = mode.startupCrash ?? null;
         this.ffiImports = mode.ffiImports ?? [];
         this.libraryCallbacks = mode.libraryCallbacks ?? false;
+        this.forkTargets = mode.forkTargets ?? [];
+        this.forkTargets.forEach((sf, id) => {
+            this.forkTargetIdByPath.set(tsgoPath(resolve(sf.fileName)), id);
+        });
         this.ffiImportsByName = new Map(this.ffiImports.map((entry) => [entry.name, entry]));
         this.ffiBindingSymbols = mode.ffiBindingSymbols ?? null;
         this.externalTypes = mode.externalTypes ?? new Map();
@@ -1535,8 +1648,9 @@ export class Lowerer {
             // fileTag is filled just below; the hook is only ever CALLED during
             // lowering, long after the constructor completes.
             isProgramFile: (sf) => this.fileTag.has(sf),
+            moduleNamespaceId: (type) => this.moduleNamespaceIdOfType(type),
         };
-        // --dynamic: modules reachable only through dynamic import() joined
+        // Modules reachable only through literal import() joined
         // moduleOrder BEFORE any pass constructed — lowerToIr runs
         // appendDynamicImportModules once on the shared array (a per-pass run
         // here would repeatedly extend the graph and duplicate cycle reports).
@@ -1552,6 +1666,35 @@ export class Lowerer {
     registerBuiltinErrorClasses() {
         return registerBuiltinErrorClasses(this);
     }
+    /** The nominal identity of a checker module-namespace type. Program
+     * modules use their normalized absolute source name; supported builtins
+     * use the lowering tables' canonical bare name. */
+    moduleNamespaceIdOfType(type) {
+        let sym = type.getSymbol();
+        if (!sym)
+            return null;
+        if (sym.flags & ts.SymbolFlags.Alias)
+            sym = this.checker.getAliasedSymbol(sym);
+        for (const decl of this.checker.declarationsOf(sym)) {
+            if (ts.isSourceFile(decl) && !decl.isDeclarationFile &&
+                !decl.fileName.endsWith(".cts") && !isCjsJsFile(decl) &&
+                this.moduleOrder.includes(decl)) {
+                return `file:${tsgoPath(resolve(decl.fileName))}`;
+            }
+            if (ts.isModuleDeclaration(decl) && ts.isStringLiteral(decl.name)) {
+                const builtin = canonicalBuiltinModule(decl.name.text);
+                if (builtin !== null)
+                    return `builtin:${builtin}`;
+            }
+        }
+        return null;
+    }
+    sourceFileOfModuleNamespace(type) {
+        if (type.kind !== "moduleNs" || !type.moduleId.startsWith("file:"))
+            return null;
+        const path = type.moduleId.slice("file:".length);
+        return this.moduleOrder.find((sf) => tsgoPath(resolve(sf.fileName)) === path) ?? null;
+    }
     builtinErrorInfoOf(symbol) {
         return builtinErrorInfoOf(this, symbol);
     }
@@ -1588,34 +1731,35 @@ export class Lowerer {
         if (ident.parent && ts.isShorthandPropertyAssignment(ident.parent) && ident.parent.name === ident) {
             symbol = this.checker.getShorthandAssignmentValueSymbol(ident.parent) ?? symbol;
         }
+        // createRequire's return type is intentionally `any`, so tsgo does not
+        // make the binding an import alias. When the target replaces
+        // module.exports with one represented scalar/function/class value,
+        // reconnect the binding to that export symbol explicitly; ordinary
+        // identifier/call/new/global paths then apply unchanged.
+        const createdWhole = this.createRequireWholeExportSymbolOf(ident);
+        if (createdWhole)
+            symbol = createdWhole;
+        const createdMember = this.createRequireDestructuredExportSymbolOf(ident);
+        if (createdMember)
+            symbol = createdMember;
         // tsgo synthesizes no expando symbol at a CJS MEMBER-EXPORT use site
         // (`common.GREETING` where the exporter attached GREETING with
         // `module.exports.GREETING = ...` — 5.9.3 answered the expando
         // property symbol here), but the exporter's MODULE symbol still
         // carries the member in its exports table; resolve through it so both
         // ends of the export key one symbol identity, like 5.9.3's.
-        if (!symbol && ident.parent && ts.isPropertyAccessExpression(ident.parent) && ident.parent.name === ident) {
+        if (ident.parent && ts.isPropertyAccessExpression(ident.parent) && ident.parent.name === ident) {
             const recv = ident.parent.expression;
             if (ts.isIdentifier(recv) && this.cjsLocalModuleBindingOf(recv)) {
-                const recvSym = this.checker.getSymbolAtLocation(recv);
-                const recvDecls = recvSym ? this.checker.declarationsOf(recvSym) : [];
-                const recvDecl = recvDecls.find(ts.isImportClause) ?? recvDecls[0];
-                if (recvDecl && ts.isVariableDeclaration(recvDecl) && recvDecl.initializer) {
-                    const spec = requireSpecOf(recvDecl.initializer);
-                    const dep = spec === null
-                        ? null
-                        : resolveImport(this.program, recvDecl.getSourceFile(), spec) ??
-                            npmStaticDepSf7(this.program, recvDecl.getSourceFile(), spec);
-                    if (dep)
-                        symbol = this.cjsModuleExportSymbol(dep, ident.text);
-                }
-                else if (recvDecl && ts.isImportClause(recvDecl)) {
-                    // The DEFAULT-import spelling of the same binding: the dep is
-                    // the import declaration's resolved CJS module.
-                    const dep = this.cjsDefaultImportDepOf(recvDecl);
-                    if (dep)
-                        symbol = this.cjsModuleExportSymbol(dep, ident.text);
-                }
+                const dep = this.localModuleBindingDepOf(recv);
+                const exported = dep ? this.cjsModuleExportSymbol(dep, ident.text) : undefined;
+                // A createRequire call is typed as `any`, so tsgo can manufacture a
+                // transient property symbol with no relation to the target module.
+                // Prefer the real export-table symbol whenever the receiver is a
+                // proven static module binding; ordinary direct require aliases
+                // resolve to the same identity.
+                if (exported)
+                    symbol = exported;
             }
         }
         if (!symbol)
@@ -1911,7 +2055,17 @@ export class Lowerer {
      * property symbol exists at the attachment/use sites). */
     cjsModuleExportSymbol(sf, name) {
         const moduleSym = this.checker.getSymbolAtLocation(sf);
-        return moduleSym?.getExports().get(name);
+        const exports = moduleSym?.getExports();
+        const direct = exports?.get(name);
+        if (direct)
+            return direct;
+        // tsgo represents `module.exports = { ... }` as one `export=` symbol
+        // and does not duplicate the object literal's properties into the
+        // module export map. Resolve through that root type so createRequire's
+        // any-typed namespace can recover the same property symbols an
+        // ordinary direct require receives from checker inference.
+        const root = exports?.get("export=");
+        return root ? this.checker.getPropertyOfType(this.checker.getTypeOfSymbol(root), name) : undefined;
     }
     /** The local VALUE symbol behind a CJS export-table property symbol —
      * see resolveValueSymbol. Null when `symbol` is not such a property (or
@@ -1999,6 +2153,88 @@ export class Lowerer {
             return null;
         return dep;
     }
+    /** The compiled module behind a require-like namespace binding: an
+     * ordinary CommonJS require declaration, a canonical createRequire
+     * declaration, or an ESM default import of CommonJS. One resolver keeps
+     * member-symbol fallback and namespace classification in lockstep. */
+    localModuleBindingDepOf(expr) {
+        const sym = this.checker.getSymbolAtLocation(expr);
+        const decls = sym ? this.checker.declarationsOf(sym) : [];
+        const decl = decls.find(ts.isImportClause) ?? decls[0];
+        if (!decl)
+            return null;
+        if (ts.isImportClause(decl))
+            return this.cjsDefaultImportDepOf(decl);
+        if (!ts.isVariableDeclaration(decl) || !ts.isIdentifier(decl.name) || !decl.initializer)
+            return null;
+        const directSpec = requireSpecOf(decl.initializer);
+        if (directSpec !== null) {
+            return resolveImport(this.program, decl.getSourceFile(), directSpec) ??
+                npmStaticDepSf7(this.program, decl.getSourceFile(), directSpec);
+        }
+        return createRequireProgramModuleOf(this, decl.initializer)?.dep ?? null;
+    }
+    /** The represented single value behind a createRequire binding, or null
+     * when the target is a namespace/table module. Collection has already
+     * registered executable exports before entry-module uses lower, so the
+     * registries are the authority for whether the export= value exists in
+     * static storage or callable/class metadata. */
+    createRequireWholeExportSymbolOf(ident) {
+        const binding = this.checker.getSymbolAtLocation(ident);
+        const decl = binding ? this.checker.declarationsOf(binding).find(ts.isVariableDeclaration) : undefined;
+        if (!decl || !ts.isIdentifier(decl.name) || !decl.initializer)
+            return null;
+        const target = createRequireProgramModuleOf(this, decl.initializer);
+        if (target === null)
+            return null;
+        const moduleSym = this.checker.getSymbolAtLocation(target.dep);
+        let symbol = moduleSym?.getExports().get("export=");
+        if (!symbol)
+            return null;
+        const wholeAssignment = this.checker.declarationsOf(symbol).find((d) => {
+            if (!ts.isBinaryExpression(d) || !ts.isExpressionStatement(d.parent) || !ts.isSourceFile(d.parent.parent))
+                return false;
+            const exported = cjsExportAssignmentOf(d.parent);
+            return exported?.kind === "table" && exported.obj === null && cjsExportDiscardReason(d.parent) === null;
+        });
+        if (wholeAssignment === undefined)
+            return null;
+        let rhs = wholeAssignment.right;
+        while (ts.isParenthesizedExpression(rhs))
+            rhs = rhs.expression;
+        if (ts.isIdentifier(rhs)) {
+            const value = this.checker.getSymbolAtLocation(rhs);
+            if (value) {
+                const resolved = value.flags & ts.SymbolFlags.Alias ? this.checker.getAliasedSymbol(value) : value;
+                return resolved;
+            }
+        }
+        if (symbol.flags & ts.SymbolFlags.Alias)
+            symbol = this.checker.getAliasedSymbol(symbol);
+        symbol = this.cjsExportValueSymbol(symbol) ?? symbol;
+        return symbol;
+    }
+    /** The target export behind `const { member: local } = require("...")`
+     * through createRequire. The binding is import-style alias plumbing;
+     * plain identifiers, renames, and string-literal property names share the
+     * target module's real export symbol. */
+    createRequireDestructuredExportSymbolOf(ident) {
+        const binding = this.checker.getSymbolAtLocation(ident);
+        const element = binding ? this.checker.declarationsOf(binding).find(ts.isBindingElement) : undefined;
+        if (!element || element.name === undefined || !ts.isIdentifier(element.name) || !ts.isObjectBindingPattern(element.parent))
+            return null;
+        const declaration = element.parent.parent;
+        if (!ts.isVariableDeclaration(declaration) || !declaration.initializer)
+            return null;
+        const target = createRequireProgramModuleOf(this, declaration.initializer);
+        if (target === null)
+            return null;
+        const property = element.propertyName;
+        const name = property && (ts.isIdentifier(property) || ts.isStringLiteralLike(property))
+            ? property.text
+            : ident.text;
+        return this.cjsModuleExportSymbol(target.dep, name) ?? null;
+    }
     /** True when `expr` is an identifier bound by a top-level
      * `const x = require("./local")` of a project module — relative,
      * tsconfig-aliased, or package.json-mediated — or of a bare specifier
@@ -2013,26 +2249,10 @@ export class Lowerer {
         if (!ts.isIdentifier(expr))
             return false;
         const sym = this.checker.getSymbolAtLocation(expr);
-        const decls = sym ? this.checker.declarationsOf(sym) : [];
-        const decl = decls.find(ts.isImportClause) ?? decls[0];
-        if (!decl)
+        if (this.localModuleBindingDepOf(expr) === null)
+            return false;
+        if (this.createRequireWholeExportSymbolOf(expr) !== null)
             return false;
-        if (ts.isImportClause(decl)) {
-            if (decl.name === undefined || this.cjsDefaultImportDepOf(decl) === null)
-                return false;
-        }
-        else {
-            if (!ts.isVariableDeclaration(decl) || !ts.isIdentifier(decl.name) || !decl.initializer) {
-                return false;
-            }
-            const spec = requireSpecOf(decl.initializer);
-            if (spec === null)
-                return false;
-            if (resolveImport(this.program, decl.getSourceFile(), spec) === null &&
-                npmStaticDepSf7(this.program, decl.getSourceFile(), spec) === null) {
-                return false;
-            }
-        }
         // SINGLE-VALUE exporters (`module.exports = Countdown` / `= double` /
         // `= 42`): the requirer's binding IS the exported value, not a
         // namespace over an export table — the alias resolves straight to the
@@ -2052,10 +2272,15 @@ export class Lowerer {
                 if (!init || !ts.isObjectLiteralExpression(init))
                     return false;
             }
-            // The scalar-literal export= symbol declares AT the `module.exports
-            // =` statement itself; table/Proxy replacements share that
-            // declaration node, so only scalar RHS reads as a single value.
+            // A represented whole export declares AT the `module.exports =`
+            // statement itself. Scalar/function/factory-call roots register one
+            // snapshot global on that declaration; table/Proxy replacements do
+            // not. A binding whose declaration owns such storage is therefore a
+            // single VALUE, not a namespace whose members must appear in Node's
+            // CJS lexer export table.
             if (d && ts.isBinaryExpression(d)) {
+                if (this.globalsByDeclNode.has(d))
+                    return false;
                 let r = d.right;
                 while (ts.isParenthesizedExpression(r))
                     r = r.expression;
@@ -2086,7 +2311,11 @@ export class Lowerer {
     }
     fnSigOf(ident) {
         const symbol = this.resolveValueSymbol(ident);
-        return symbol ? (this.fnSigsBySymbol.get(symbol) ?? null) : null;
+        if (!symbol)
+            return null;
+        const projection = this.staticCallables.get(symbol);
+        return this.fnSigsBySymbol.get(symbol) ??
+            (projection?.kind === "declared-function" ? projection.signature : null);
     }
     globalOf(ident) {
         const symbol = this.resolveValueSymbol(ident);
@@ -2421,6 +2650,10 @@ export class Lowerer {
                 return true;
             if (ts.isCallExpression(e) && this.runtimeOptionalReduceTypes.has(e))
                 return true;
+            if (ts.isCallExpression(e) && e.arguments.length === 0 &&
+                ts.isPropertyAccessExpression(e.expression) &&
+                e.expression.name.text === "stringify" && this.isStdlibGlobal(e.expression.expression, "JSON"))
+                return true;
             if (ts.isCallExpression(e) &&
                 ts.isPropertyAccessExpression(e.expression) &&
                 (e.expression.name.text === "pop" || e.expression.name.text === "shift") &&
@@ -3265,7 +3498,7 @@ export class Lowerer {
         const module = this.diags.length > 0
             ? null
             : {
-                irVersion: 9,
+                irVersion: 11,
                 sourceFile: this.entry.fileName,
                 functions,
                 classes: artifacts.classes,
@@ -4156,7 +4389,8 @@ export class Lowerer {
     /** mapType with this Lowerer's registries and (while a generic instance
      * body lowers) type-parameter bindings threaded through. */
     mapTypeOf(t) {
-        return mapType(t, this.typeCtx);
+        const mapped = mapType(t, this.typeCtx);
+        return mapped?.kind === "func" ? jsArgumentsFunctionType(this, t) ?? mapped : mapped;
     }
     /** The one position where a contextual UNION must not be adopted over the
      * expression's own: the LEFT operand of `&&`, `||`, or `??`. Adopting a
@@ -4316,6 +4550,9 @@ export class Lowerer {
         // answers instead.
         const mapped = neverTaintedJsType(this, node, t) ? null : this.mapTypeOf(t);
         if (!mapped) {
+            const argumentsType = jsArgumentsFunctionType(this, t);
+            if (argumentsType !== null)
+                return argumentsType;
             // The checked-dynamic declaration fallback (dynFallbackType): a
             // JAVASCRIPT binding of any inference residue, or a TypeScript
             // binding of genuine checker-`any`, becomes the checked-dynamic
@@ -5414,8 +5651,9 @@ export class Lowerer {
         const from = this.shapes.get(fromId);
         if (!from || !from.tuple)
             return null;
+        const fields = [...from.fields].sort((a, b) => Number(a.name) - Number(b.name));
         const lifts = [];
-        for (const f of from.fields) {
+        for (const f of fields) {
             const lift = this.widthLiftPlan(f.type, toT.elem);
             if (!lift)
                 return null;
@@ -5439,7 +5677,7 @@ export class Lowerer {
                     kind: "return",
                     value: {
                         kind: "arrayLit",
-                        elems: from.fields.map((f, i) => this.applyWidthLift(lifts[i], { kind: "recordGet", obj: t, shapeId: fromId, field: f.name, type: f.type, loc }, toT.elem, loc)),
+                        elems: fields.map((f, i) => this.applyWidthLift(lifts[i], { kind: "recordGet", obj: t, shapeId: fromId, field: f.name, type: f.type, loc }, toT.elem, loc)),
                         type: toT,
                         loc,
                     },
@@ -9046,6 +9284,13 @@ export class Lowerer {
      * member access that IS a module in its own right (`fs.promises` — the
      * same object as node:fs/promises, Node's rule). Null otherwise. */
     builtinNamespaceModuleOf(expr) {
+        const stored = ts.isIdentifier(expr)
+            ? (this.peekLocal(expr)?.type ?? this.globalOf(expr)?.type)
+            : undefined;
+        const mapped = stored ?? this.mapTypeOf(this.typeOf(expr));
+        if (mapped?.kind === "moduleNs" && mapped.moduleId.startsWith("builtin:")) {
+            return mapped.moduleId.slice("builtin:".length);
+        }
         if (ts.isIdentifier(expr)) {
             const symbol = this.checker.getSymbolAtLocation(expr);
             const decl = symbol ? this.checker.declarationsOf(symbol)[0] : undefined;
@@ -9167,6 +9412,12 @@ export class Lowerer {
         const bi = this.builtinMemberOf(access);
         if (!bi)
             return null;
+        // child_process.execFile's callback forms are special-cased rather
+        // than table-backed, but namespace imports share the named-import
+        // implementation and runtime callback adapter.
+        if (bi.module === "child_process" && bi.member === "execFile") {
+            return this.lowerExecFileCall(call, locOf(access));
+        }
         // The timers spoke: `timers.setTimeout(...)` through a namespace or
         // require binding IS the global (Node's timers module re-exports
         // them) — the shared member lowering serves both spellings.
@@ -9223,6 +9474,9 @@ export class Lowerer {
         const cryptoServed = this.lowerCryptoModuleCall(call, bi, locOf(access));
         if (cryptoServed)
             return cryptoServed;
+        const nodeModuleServed = lowerNodeModuleCall(this, call, bi, locOf(access));
+        if (nodeModuleServed)
+            return nodeModuleServed;
         const builtinFn = builtinModuleFnOf(this, bi.module, bi.member);
         if (!builtinFn) {
             this.noLowering(`${bi.module}.${bi.member}`, call, builtinFenceHintOf(bi.module, bi.member), this.checker.getSymbolAtLocation(access.name));
@@ -9266,6 +9520,12 @@ export class Lowerer {
         if (bi.module === "module" && bi.member === "builtinModules") {
             return builtinModulesArrayLit(loc);
         }
+        if (bi.module === "http" && bi.member === "METHODS") {
+            return { kind: "libCall", fn: "http.methods", args: [], type: arrayOf(STRING), loc };
+        }
+        if (bi.module === "http" && bi.member === "STATUS_CODES") {
+            return { kind: "libCall", fn: "http.statusCodes", args: [], type: DYN, loc };
+        }
         // tls.rootCertificates through the namespace: the same runtime-valued
         // constant the named-import read lowers to.
         {
@@ -9273,6 +9533,14 @@ export class Lowerer {
             if (roots)
                 return roots;
         }
+        // TypeScript builtin values admitted by an explicit surface-table
+        // contract materialize as interned closures. JavaScript sources retain
+        // their established builtin identity-token/fence policy.
+        if (!isJsSourceFile(expr.getSourceFile())) {
+            const callable = this.lowerBuiltinCallableValue(bi, loc);
+            if (callable)
+                return callable;
+        }
         if (bi.member === "constants" && bi.module === "fs") {
             // A bare `fs.constants` read (not one of the baked bits above).
             this.noLowering(`fs.constants`, expr, "F_OK, R_OK, W_OK, and X_OK are the lowered constants");
@@ -9282,6 +9550,110 @@ export class Lowerer {
         }
         this.noLowering(`${bi.module}.${bi.member}`, expr, builtinFenceHintOf(bi.module, bi.member), this.checker.getSymbolAtLocation(expr.name));
     }
+    /** Materialize one explicitly value-callable table entry as an interned
+     * synthetic module function. Direct calls never use this path: they keep
+     * their existing validated libCall lowering. The value descriptor is
+     * deliberately narrower than table membership because many table rows
+     * are only dispatch sentinels for call-site-specific lowering. */
+    lowerBuiltinCallableValue(bi, loc) {
+        const fn = builtinModuleFnOf(this, bi.module, bi.member);
+        const valueParams = fn?.valueParams;
+        if (!fn || !valueParams)
+            return null;
+        const shapes = valueParams.map((param) => {
+            if (param.mode === "rest")
+                return { mode: "rest", type: arrayOf(param.type) };
+            if (param.mode === "optional") {
+                return { mode: "omittable", type: this.withUndefinedArm(param.type), bodyType: param.type };
+            }
+            return { mode: "required", type: param.type };
+        });
+        const funcType = funcTypeFromParamShapes(shapes, fn.result);
+        const adapterShape = valueParams
+            .map((param) => param.mode === "optional" ? `${param.mode}:${param.defaultValue}` : param.mode)
+            .join(",");
+        const key = `${fn.fn}:${typeKey(funcType)}:${adapterShape}`;
+        let fnName = this.builtinCallableValueFns.get(key);
+        if (!fnName) {
+            fnName = `%builtin.value.${fn.fn}.${this.builtinCallableValueFns.size}`;
+            this.builtinCallableValueFns.set(key, fnName);
+            const params = funcType.params.map((type, index) => ({
+                localId: `arg.${index}`,
+                name: `arg${index}`,
+                type,
+            }));
+            const args = params.map((param, index) => {
+                const valueParam = valueParams[index];
+                if (!valueParam) {
+                    throw new InternalCompilerError(`builtin callable value '${bi.module}.${bi.member}' has a missing value parameter`);
+                }
+                const ref = {
+                    kind: "varRef",
+                    localId: param.localId,
+                    type: param.type,
+                    loc,
+                };
+                if (valueParam.mode !== "optional")
+                    return ref;
+                if (valueParam.type.kind !== "string" || param.type.kind !== "union") {
+                    throw new InternalCompilerError(`builtin callable value '${bi.module}.${bi.member}' has an unsupported optional default`);
+                }
+                const undefTag = this.armTag(param.type.unionId, UNDEFINED_T);
+                const valueTag = this.armTag(param.type.unionId, valueParam.type);
+                if (undefTag < 0 || valueTag < 0) {
+                    throw new InternalCompilerError(`builtin callable value '${bi.module}.${bi.member}' has an invalid optional ABI`);
+                }
+                return {
+                    kind: "ternary",
+                    cond: {
+                        kind: "unionIsTag",
+                        unionId: param.type.unionId,
+                        tag: undefTag,
+                        negated: false,
+                        value: ref,
+                        type: BOOL,
+                        loc,
+                    },
+                    then: { kind: "strLit", value: valueParam.defaultValue, type: STRING, loc },
+                    else_: {
+                        kind: "unionNarrow",
+                        unionId: param.type.unionId,
+                        tag: valueTag,
+                        value: ref,
+                        type: valueParam.type,
+                        loc,
+                    },
+                    type: valueParam.type,
+                    loc,
+                };
+            });
+            const call = { kind: "libCall", fn: fn.fn, args, type: fn.result, loc };
+            const body = fn.result.kind === "void"
+                ? [
+                    { kind: "exprStmt", expr: call, loc },
+                    { kind: "return", value: null, loc },
+                ]
+                : [{ kind: "return", value: call, loc }];
+            this.liftedFns.push({
+                name: fnName,
+                params,
+                returnType: fn.result,
+                locals: params.map((param) => ({
+                    id: param.localId,
+                    name: param.name,
+                    type: param.type,
+                    mutable: false,
+                })),
+                body,
+                loc,
+            });
+        }
+        return { kind: "closure", fnName, captures: [], type: funcType, loc };
+    }
+    isBuiltinCallableValue(expr) {
+        return expr.kind === "closure" &&
+            [...this.builtinCallableValueFns.values()].some((name) => name === expr.fnName);
+    }
     lowerBuiltinModuleCall(expr, bi, fn, loc) {
         return lowerBuiltinModuleCall(this, expr, bi, fn, loc);
     }
@@ -9303,6 +9675,9 @@ export class Lowerer {
     lowerSpawnCall(expr, loc) {
         return lowerSpawnCall(this, expr, loc);
     }
+    lowerExecFileCall(expr, loc) {
+        return lowerExecFileCall(this, expr, loc);
+    }
     lowerExecSyncCall(expr, shell, loc) {
         return lowerExecSyncCall(this, expr, shell, loc);
     }
@@ -9451,8 +9826,8 @@ export class Lowerer {
     lowerTimeoutMethodCall(call, access) {
         return lowerTimeoutMethodCall(this, call, access);
     }
-    promisifiedExecFileDecl(nameNode, init) {
-        return promisifiedExecFileDecl(this, nameNode, init);
+    registerPromisifiedBuiltinDecl(nameNode, init) {
+        return registerPromisifiedBuiltinDecl(this, nameNode, init);
     }
     lowerExecFileAsyncCall(expr, loc) {
         return lowerExecFileAsyncCall(this, expr, loc);