@scriptc/compiler 0.1.1 → 0.1.3

package/dist/frontend/lowering/lowerer.js

@@ -15,22 +15,24 @@ import { InternalCompilerError } from "../../errors.js";
  */
 import { resolve } from "node:path";
 import { tsgoPath } from "../dts-paths.js";
-import { isRelativeSpecifier } from "../workspace-registry.js";
 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, F64, isJsonSafeType, isJsonStringifySafeType, isUndefinedArmedUnion, isUnitType, JSVAL, RUNTIME_ERROR_CLASSES, STRING, typeEquals, UNDEFINED_T, VOID } from "../../ir/ir.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 { 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 { 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 { lowerArrayMethodCall, lowerBufferStaticCall, lowerBytesMethodCall, lowerBytesNew, lowerMapMethodCall, lowerMapForEachCall, buildMapForEachFn, lowerRecordOvfCaptureHelper, lowerEnvToPairsHelper, lowerSetMethodCall, lowerSetForEachCall, buildSetForEachFn, lowerRegexMethodCall, lowerStringMethodCall } from "./lower-containers.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, 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, 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 { 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";
@@ -38,11 +40,14 @@ import { lowerNodeTestModuleCall, lowerTestDirectCall, lowerTestMethodCall, lowe
 import { lowerAssertModuleCall, lowerAssertDirectCall } from "./lower-assert.js";
 import { lowerUtilModuleCall } from "./lower-inspect.js";
 import { lowerComptime, comptimeBakeable, rejectComptimeCaptures, comptimeValueToIr } from "./lower-comptime.js";
-import { lowerStmts, noteBlockedBindings, isBlockedBinding, lowerScopedBlock, predeclareForwardCapture, predeclareForwardFnDecl, predeclareForwardVar, rejectJumpCrossingFinally, lowerStmt, lowerVarStatement, lowerDestructuringDecl, lowerDestructuringAssignParts, lowerBindingPattern, lowerJsvalBindingPattern, checkBindingElement, bindPatternTarget, isParseArgsDynCheckerType, lowerVarDeclList, lowerVarDecl, lowerSwitch, lowerTry, lowerExprStatement, lowerForOf, lowerForStatement } from "./lower-stmts.js";
-import { lowerDynObjectLiteral, lowerExpr, maybeNarrow, lowerUnitComparison, lowerNullishCoalesce, lowerOptionalChain, finishOptionalChain, lowerCondition, ensureBool, requireTruthyUnion, eqComparableUnion, lowerIntrinsicProperty, lowerArrayLiteral, lowerObjectLiteral, lowerShorthandValue, rejectThisInObjectMethod, lowerElementAccess, lowerElementWrite, lowerRecordKeyRead, ensureString, lowerTemplate, lowerAsExpression, lowerPrefixUnary, lowerBinary, lowerCaughtTypeofTest, caughtRead, caughtLocalOf, caughtToString, lowerInstanceOf, lowerRegexLiteral, lowerFieldRead, lowerUnionProperty, fieldTarget, fieldGetExpr, fieldSetStmt, lowerFieldCompound, uniqueSymbolKeyOf, foldedStringKeyOf } from "./lower-exprs.js";
+import { lowerStmts, noteBlockedBindings, isBlockedBinding, lowerScopedBlock, predeclareForwardCapture, predeclareForwardFnDecl, predeclareForwardVar, lowerStmt, lowerVarStatement, lowerDestructuringDecl, lowerDestructuringAssignParts, lowerBindingPattern, lowerJsvalBindingPattern, checkBindingElement, bindPatternTarget, isParseArgsDynCheckerType, lowerVarDeclList, lowerVarDecl, lowerSwitch, lowerTry, lowerExprStatement, lowerForOf, lowerForStatement } from "./lower-stmts.js";
+import { lowerExpr, maybeNarrow, lowerUnitComparison, lowerNullishCoalesce, lowerCondition, ensureBool, requireTruthyUnion, eqComparableUnion, lowerIntrinsicProperty, lowerArrayLiteral, lowerElementAccess, lowerElementWrite, lowerRecordKeyRead, ensureString, lowerTemplate, lowerAsExpression, lowerPrefixUnary, lowerBinary, lowerCaughtTypeofTest, caughtRead, caughtLocalOf, caughtToString, lowerInstanceOf, lowerRegexLiteral, lowerFieldRead, lowerUnionProperty, fieldTarget, fieldGetExpr, fieldSetStmt, lowerFieldCompound, uniqueSymbolKeyOf } from "./lower-exprs.js";
+import { finishOptionalChain, lowerOptionalChain } from "./expressions/optional-chains.js";
+import { foldedStringKeyOf, lowerDynObjectLiteral, lowerObjectLiteral, lowerShorthandValue, rejectThisInObjectMethod } from "./expressions/object-literals.js";
 import { lowerRecordFieldCall, lowerObjectMethodCall } from "./lower-calls.js";
 import { fenceCrossBlockNsRef, nsPathPrefix } from "./lower-namespaces.js";
 import { numLit, varRef } from "../../ir/build.js";
+import { isSafeToRepeat } from "./expressions/evaluation-safety.js";
 /** Entry function name. '%' cannot appear in a TS identifier, so a user
  * function can never collide with it (mangling is injective per prefix). */
 export const ENTRY_NAME = "%main";
@@ -464,6 +469,41 @@ export function dynFallbackType(lowerer, node, t) {
         // the whole type's own fence.
         return anyPiecedFuncType(lowerer, node, t);
     }
+    // JS inference commonly spells a callback field initialized to null as
+    // `((value: any) => any) | null`. Preserve the callable arm and its
+    // checked-dynamic pieces instead of collapsing the whole slot to dyn.
+    // Besides keeping direct calls static, this leaves closure captures
+    // visible to the native cycle collector (a dyn-boxed closure edge is
+    // intentionally opaque to it).
+    if (t.isUnionType()) {
+        const arms = [];
+        let functions = 0;
+        for (const part of ts.constituentTypes(t)) {
+            if (part.flags & ts.TypeFlags.Null) {
+                arms.push(NULL_T);
+                continue;
+            }
+            if (part.flags & (ts.TypeFlags.Undefined | ts.TypeFlags.Void)) {
+                arms.push(UNDEFINED_T);
+                continue;
+            }
+            const mapped = lowerer.mapTypeOf(part) ?? jsFallbackFunctionType(lowerer, node, part);
+            if (mapped?.kind !== "func") {
+                functions = -1;
+                break;
+            }
+            functions++;
+            arms.push(mapped);
+        }
+        if (functions === 1 && arms.length > 1) {
+            const canonical = [...new Map(arms.map((arm) => [typeKey(arm), arm])).entries()]
+                .sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0)
+                .map(([, arm]) => arm);
+            return canonical.length === 1
+                ? canonical[0]
+                : { kind: "union", unionId: lowerer.unions.intern(canonical) };
+        }
+    }
     if (lowerer.checker.isArrayType(t)) {
         const elem = lowerer.checker.getTypeArguments(t)[0];
         const elemTainted = elem !== undefined &&
@@ -485,18 +525,23 @@ export function dynFallbackType(lowerer, node, t) {
     // construct signatures, overloads, and function-with-properties shapes
     // stay out (the whole value falls to dyn below, where every reached
     // use meets its own fence or boxes as-is).
-    const sig = pureSingleCallSignatureOf(lowerer, t);
-    if (sig) {
-        const params = sig.getParameters().map((p) => {
-            const pt = lowerer.checker.getTypeOfSymbolAtLocation(p, node);
-            return lowerer.mapTypeOf(pt) ?? DYN;
-        });
-        const retT = lowerer.checker.getReturnTypeOfSignature(sig);
-        const ret = retT.flags & ts.TypeFlags.Void ? VOID : lowerer.mapTypeOf(retT) ?? DYN;
-        return { kind: "func", params, ret };
-    }
+    const fallbackFunction = jsFallbackFunctionType(lowerer, node, t);
+    if (fallbackFunction !== null)
+        return fallbackFunction;
     return DYN;
 }
+function jsFallbackFunctionType(lowerer, node, t) {
+    const sig = pureSingleCallSignatureOf(lowerer, t);
+    if (!sig)
+        return null;
+    const params = sig.getParameters().map((p) => {
+        const pt = lowerer.checker.getTypeOfSymbolAtLocation(p, node);
+        return lowerer.mapTypeOf(pt) ?? DYN;
+    });
+    const retT = lowerer.checker.getReturnTypeOfSignature(sig);
+    const ret = retT.flags & ts.TypeFlags.Void ? VOID : lowerer.mapTypeOf(retT) ?? DYN;
+    return { kind: "func", params, 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
@@ -935,8 +980,9 @@ export class Lowerer {
             : null;
     }
     /** A strict property or method receiver over an array-derived optional
-     * value. Stabilize the receiver once, throw Node's member-read TypeError
-     * for a unit arm, and extract the expected present arm otherwise. */
+     * value. Reuse a plain read directly or stabilize an effectful receiver
+     * once, throw Node's member-read TypeError for a unit arm, and extract the
+     * expected present arm otherwise. */
     runtimeOptionalPropertyReceiver(node, value, expected, member) {
         const source = this.runtimeOptionalSourceValue(node, value);
         if (source?.type.kind !== "union")
@@ -948,8 +994,9 @@ export class Lowerer {
             !def.arms.every((arm) => typeEquals(arm, expected) || isUnitType(arm)))
             return null;
         const loc = locOf(node);
-        const stable = this.declareHiddenLocal("%propertyRecv", source.type);
-        const stableRef = () => varRef(stable.id, source.type, loc);
+        const repeatSource = isSafeToRepeat(source);
+        const stable = repeatSource ? null : this.declareHiddenLocal("%propertyRecv", source.type);
+        const stableRef = () => repeatSource ? source : varRef(stable.id, source.type, loc);
         let result = {
             kind: "unionNarrow",
             unionId: source.type.unionId,
@@ -980,6 +1027,8 @@ export class Lowerer {
                 loc,
             };
         }
+        if (stable === null)
+            return result;
         return {
             kind: "seqExpr",
             stmts: [{ kind: "varDecl", localId: stable.id, init: source, loc }],
@@ -1265,6 +1314,12 @@ export class Lowerer {
      * any body lowers: import headers and inline require statements call
      * dependency inits by these names. */
     initNameOf = new Map();
+    /** CommonJS module objects are scalar handles into the runtime registry.
+     * IDs are assigned in deterministic module order before any body lowers;
+     * the feature gate stays false for programs that never inspect the graph. */
+    cjsModuleIdOf = new Map();
+    cjsModuleFiles = [];
+    cjsModuleGraphEnabled = false;
     /** File → the id of its run-once guard global (a bool module global,
      * false at program start). Every non-entry module gets one: its %init
      * may be called from several importers/requirers, and the guard is what
@@ -1330,10 +1385,10 @@ export class Lowerer {
     liftedFns = [];
     lambdaCounter = 0;
     /** Statement lists currently mid-lowering, innermost last: the forward-
-     * capture machinery (predeclareForwardCapture) needs to know which later
-     * statements of an OPEN list a symbol's declaration sits in, which scope
-     * frame list-level declarations register into, and where to insert the
-     * scope-entry TDZ varDecl (before the statement being lowered). */
+     * capture machinery needs to know which later statements of an OPEN list
+     * a symbol's declaration sits in, which scope frame list-level declarations
+     * register into, and where to insert predeclarations before closures or
+     * earlier source statements need them. */
     activeStmtLists = [];
     /** Forward-captured consts pre-declared as TDZ boxes, keyed by symbol:
      * lowerVarDecl consumes the entry when the source declaration arrives and
@@ -1549,9 +1604,8 @@ export class Lowerer {
                     const spec = requireSpecOf(recvDecl.initializer);
                     const dep = spec === null
                         ? null
-                        : isRelativeSpecifier(spec)
-                            ? resolveImport(this.program, recvDecl.getSourceFile(), spec)
-                            : npmStaticDepSf7(this.program, recvDecl.getSourceFile(), spec);
+                        : resolveImport(this.program, recvDecl.getSourceFile(), spec) ??
+                            npmStaticDepSf7(this.program, recvDecl.getSourceFile(), spec);
                     if (dep)
                         symbol = this.cjsModuleExportSymbol(dep, ident.text);
                 }
@@ -1687,15 +1741,15 @@ export class Lowerer {
         return this.externalTypeSpecifierOfSymbol(this.checker.getSymbolAtLocation(value));
     }
     /** The source file a checker-resolved module-specifier node names. The
-     * checker path covers package.json aliases as well as relative imports;
-     * resolveImport is the fallback for the latter. */
+     * checker path is preferred; resolveImport is the canonical fallback for
+     * every project-module spelling. */
     moduleSourceFileOf(from, spec) {
         const moduleSymbol = this.checker.getSymbolAtLocation(spec);
         for (const decl of moduleSymbol ? this.checker.declarationsOf(moduleSymbol) : []) {
             if (ts.isSourceFile(decl))
                 return decl;
         }
-        return isRelativeSpecifier(spec.text) ? resolveImport(this.program, from, spec.text) : null;
+        return resolveImport(this.program, from, spec.text);
     }
     /** Follow one project-module export through the checker's resolved export
      * table, then recover its exact external route where alias declarations
@@ -1937,22 +1991,19 @@ export class Lowerer {
             return null;
         }
         const spec = importDecl.moduleSpecifier.text;
-        // Bare specifiers resolve only for opted-in --npm-static packages —
-        // their CJS entries take the same default-binding interop as a
-        // relative require; every other bare import answers null and keeps
-        // its own machinery.
-        const dep = isRelativeSpecifier(spec)
-            ? resolveImport(this.program, importDecl.getSourceFile(), spec)
-            : npmStaticDepSf7(this.program, importDecl.getSourceFile(), spec);
+        // Project aliases/self-references resolve through the same entry point as
+        // relative imports; an opted-in --npm-static package is the fallback.
+        const dep = resolveImport(this.program, importDecl.getSourceFile(), spec) ??
+            npmStaticDepSf7(this.program, importDecl.getSourceFile(), spec);
         if (!dep || !isJsSourceFile(dep) || isNodeEsmFile(dep))
             return null;
         return dep;
     }
     /** True when `expr` is an identifier bound by a top-level
-     * `const x = require("./local")` of a RELATIVE module — the CommonJS
-     * namespace binding — or of a bare specifier naming an opted-in
-     * --npm-static package (its CJS entry is a program module, so the
-     * binding is the same namespace over the same export table), or by a
+     * `const x = require("./local")` of a project module — relative,
+     * tsconfig-aliased, or package.json-mediated — or of a bare specifier
+     * naming an opted-in --npm-static package (its CJS entry is a program
+     * module, so the binding is the same namespace over the same export table), or by a
      * DEFAULT import of a CommonJS JS module (`import d from "./lib.cjs"`:
      * Node binds d to module.exports, the same value require answers).
      * Member accesses on it resolve through the export table (property
@@ -1977,7 +2028,7 @@ export class Lowerer {
             const spec = requireSpecOf(decl.initializer);
             if (spec === null)
                 return false;
-            if (!isRelativeSpecifier(spec) &&
+            if (resolveImport(this.program, decl.getSourceFile(), spec) === null &&
                 npmStaticDepSf7(this.program, decl.getSourceFile(), spec) === null) {
                 return false;
             }
@@ -2197,16 +2248,15 @@ export class Lowerer {
      * their external dependencies by name). Null for everything else
      * (builtins load nothing; the rest kept its preflight fence). */
     requireInitStmt(spec, node) {
-        // Relative requires resolve within the program; a BARE require can be
-        // a program-module edge too when it names an opted-in --npm-static
-        // package (one package requiring another — the resolution answered
-        // its shipped JS, the file is in the module order, and the reads
-        // alias its globals). Without the guarded %init call at this position
+        // Project requires resolve within the program; another bare require can
+        // be a program-module edge when it names an opted-in --npm-static package
+        // (one package requiring another — the resolution answered its shipped
+        // JS, the file is in the module order, and the reads alias its globals).
+        // Without the guarded %init call at this position
         // those globals stay uninitialized: the dep's module body would never
         // run.
-        const dep = isRelativeSpecifier(spec)
-            ? resolveImport(this.program, node.getSourceFile(), spec)
-            : npmStaticDepSf7(this.program, node.getSourceFile(), spec);
+        const dep = resolveImport(this.program, node.getSourceFile(), spec) ??
+            npmStaticDepSf7(this.program, node.getSourceFile(), spec);
         if (!dep || dep.fileName.endsWith(".json"))
             return null;
         if (this.asyncInitFiles.has(dep)) {
@@ -2216,11 +2266,33 @@ export class Lowerer {
         if (initName === undefined)
             return null;
         const loc = locOf(node);
-        return {
+        const init = {
             kind: "exprStmt",
             expr: { kind: "call", callee: initName, args: [], type: VOID, loc },
             loc,
         };
+        const parentModule = this.cjsModuleIdOf.get(node.getSourceFile());
+        const childModule = this.cjsModuleIdOf.get(dep);
+        if (parentModule === undefined || childModule === undefined)
+            return init;
+        return {
+            kind: "block",
+            body: [
+                {
+                    kind: "exprStmt",
+                    expr: {
+                        kind: "libCall",
+                        fn: "module.link",
+                        args: [numLit(parentModule, loc), numLit(childModule, loc)],
+                        type: VOID,
+                        loc,
+                    },
+                    loc,
+                },
+                init,
+            ],
+            loc,
+        };
     }
     /** True when this body should lower: everything with no reachable set,
      * the marked bodies in an externally-gated pass, and exactly the
@@ -2971,6 +3043,7 @@ export class Lowerer {
         for (const info of this.classes.values())
             analyzeClassDecoration(this, info);
         this.prepareModuleInits(parts);
+        prepareCjsModuleGraph(this, parts);
         const functions = [];
         for (const fp of parts) {
             for (const decl of fp.fnDecls) {
@@ -3192,7 +3265,7 @@ export class Lowerer {
         const module = this.diags.length > 0
             ? null
             : {
-                irVersion: 8,
+                irVersion: 9,
                 sourceFile: this.entry.fileName,
                 functions,
                 classes: artifacts.classes,
@@ -3342,6 +3415,7 @@ export class Lowerer {
         for (const info of this.classes.values())
             analyzeClassDecoration(this, info);
         this.prepareModuleInits(parts);
+        prepareCjsModuleGraph(this, parts);
         // Every lowerable body, by emitted-function name. The names double as
         // retained-function keys and are deterministic by construction
         // (qualified declaration names).
@@ -4507,10 +4581,18 @@ export class Lowerer {
             const undefArmedOk = expected.kind === "union" &&
                 (this.unions
                     .get(expected.unionId)
-                    ?.arms.every((a) => a.kind === "undefinedT" || this.jsonSafe(a)) ??
+                    ?.arms.every((a) => a.kind === "undefinedT" ||
+                    this.jsonSafe(a) ||
+                    isDynTypedRefType(a) ||
+                    DYN_HANDLE_KINDS.has(a.kind)) ??
                     false);
             const bytesOk = expected.kind === "bytes" && expected.elem === "u8";
             const errorOk = expected.kind === "object" && expected.className === "%Error";
+            // Program and runtime class instances can return only from a
+            // compiler-owned typed-reference capsule. A parsed/plain dyn object
+            // fails the runtime check; an exact capsule unwraps the original
+            // instance and preserves identity.
+            const classOk = isDynTypedRefType(expected);
             // ADAPTABLE function targets (the checked-dynamic function
             // boundary's OUT direction — `const wrapped: F = mustCall(fn)`):
             // check callable-kind, then unwrap an identical boxed signature
@@ -4518,7 +4600,8 @@ export class Lowerer {
             // arguments/results per F.
             const funcOk = expected.kind === "func" &&
                 canAdaptDynFuncTo(expected, (id) => this.shapes.get(id), (id) => this.unions.get(id));
-            if (this.jsonSafe(expected) || undefArmedOk || bytesOk || errorOk || funcOk) {
+            const handleOk = DYN_HANDLE_KINDS.has(expected.kind);
+            if (this.jsonSafe(expected) || undefArmedOk || bytesOk || errorOk || classOk || funcOk || handleOk) {
                 return { kind: "dynCheck", value: expr, type: expected, loc: expr.loc };
             }
             return expr;
@@ -8268,11 +8351,8 @@ export class Lowerer {
     lowerScopedBlock(stmt) {
         return lowerScopedBlock(this, stmt);
     }
-    /** Lowers inside a control-construct marker (loop/switch/labeled block/
-     * try-with-finally/finally block) so the jump fences below know what a
-     * break/continue/return crosses. `labels` carries the construct's JS
-     * label names when the source statement was labeled — labeled jumps
-     * resolve against them. */
+    /** Lowers inside a jump-target marker. `labels` carries the construct's
+     * source label names so labeled jumps resolve against them. */
     inCtl(kind, fn, labels) {
         this.ctx.ctl.push(labels !== undefined && labels.length > 0 ? { kind, labels } : { kind });
         try {
@@ -8293,9 +8373,6 @@ export class Lowerer {
         this.pendingLabels = null;
         return labels ?? undefined;
     }
-    rejectJumpCrossingFinally(kw, stmt, label) {
-        return rejectJumpCrossingFinally(this, kw, stmt, label);
-    }
     lowerStmt(stmt) {
         return lowerStmt(this, stmt);
     }
@@ -8588,6 +8665,12 @@ export class Lowerer {
         return rejectThisInObjectMethod(this, node);
     }
     lowerElementAccess(expr) {
+        if (ts.isPropertyAccessExpression(expr.expression) &&
+            ts.isIdentifier(expr.expression.expression) &&
+            expr.expression.expression.text === "require" &&
+            expr.expression.name.text === "cache") {
+            return lowerElementAccess(this, expr);
+        }
         const receiver = this.runtimeOptionalIdentifierValue(expr.expression);
         const receiverValue = receiver && (receiver.present.kind === "array" || receiver.present.kind === "record")
             ? (() => {
@@ -9202,6 +9285,9 @@ export class Lowerer {
     lowerBuiltinModuleCall(expr, bi, fn, loc) {
         return lowerBuiltinModuleCall(this, expr, bi, fn, loc);
     }
+    lowerTimersPromisesSetInterval(expr, bi, loc) {
+        return lowerTimersPromisesSetInterval(this, expr, bi, loc);
+    }
     lowerFsToUnixTimestampCall(expr, bi, loc) {
         return lowerFsToUnixTimestampCall(this, expr, bi, loc);
     }