@scriptc/compiler 0.4.2 → 0.4.4

package/dist/frontend/program.js

@@ -61,6 +61,7 @@ import { forkTargetPaths } from "./fork-target.js";
 import { workerTargetPaths } from "./worker-target.js";
 import { erasedTypeOnlyImport, typeOnlyNamedImport, typeOnlyReachedFiles, } from "./type-only-imports.js";
 import { moduleSourceCandidates } from "./module-source-candidates.js";
+import { planDeclProjection } from "./decl-projection.js";
 import { inferredJsDiagnosticSuppressed } from "./inferred-js-diagnostics.js";
 import { containsJsx, firstJsx, jsxEmitName, jsxEmitPlan, jsxPragmas, lowerJsx, } from "./jsx-source.js";
 const BASE_OPTIONS = {
@@ -600,7 +601,10 @@ function lowerProgramJsx7(program, options) {
 }
 function loadProgram7(host, entryPath, externalTypes = new Map(), 
 /** The --npm-static lowering world: root opted-in packages' deep edges. */
-rootNpmStaticEdges = false) {
+rootNpmStaticEdges = false, 
+/** The declaration-typed boundary's projection (decl-projection.ts):
+ * answers rewritten user files for the lowering world, or null. */
+projector) {
     const config = adoptProjectConfig7(host, entryPath);
     const configuredPaths = config.options["paths"];
     setProjectPathMappings(configuredPaths !== undefined && typeof configuredPaths === "object" && configuredPaths !== null
@@ -678,6 +682,7 @@ rootNpmStaticEdges = false) {
         // lowering compiles holds them with their JSX lowered.
         const jsx = lowerProgramJsx7(program, options);
         let tscWorld;
+        const declBoundaryNotes = [];
         if (jsx.refusal !== null) {
             config.diags.push(jsx.refusal);
         }
@@ -696,6 +701,57 @@ rootNpmStaticEdges = false) {
                 host.addVirtualFile(file, lowered.text);
             program = host.createProgram([...programRoots, overridesDtsPath()], options);
         }
+        else if (projector !== undefined) {
+            // The declaration-typed boundary: user files typed from package
+            // declarations (decl-projection.ts). The tsc gate reads the original
+            // text; the lowering compiles the rewritten files.
+            const projection = projector(program);
+            if (projection !== null) {
+                const original = program;
+                const baseline = new Map();
+                for (const file of projection.files.keys()) {
+                    const sf = original.getSourceFile(file);
+                    if (sf !== undefined)
+                        baseline.set(file, original.getSemanticDiagnostics(sf).length);
+                }
+                for (const [file, text] of projection.files)
+                    host.addVirtualFile(file, text);
+                host.addVirtualFile(projection.declFile, projection.declText);
+                programRoots.push(projection.declFile);
+                program = host.createProgram([...programRoots, overridesDtsPath()], options);
+                // A rewrite the lowering world disagrees with (new errors) is
+                // dropped for that file: the file lowers as it would without it.
+                const dropped = [];
+                for (const file of projection.files.keys()) {
+                    const sf = program.getSourceFile(file);
+                    if (sf === undefined)
+                        continue;
+                    if (program.getSemanticDiagnostics(sf).length > (baseline.get(file) ?? 0)) {
+                        dropped.push(file);
+                        host.addVirtualFile(file, original.getSourceFile(file).text);
+                    }
+                }
+                if (dropped.length > 0) {
+                    program.dispose();
+                    program = host.createProgram([...programRoots, overridesDtsPath()], options);
+                    for (const file of dropped)
+                        declBoundaryNotes.push(declBoundaryDroppedDiag(file));
+                }
+                if (dropped.length === projection.files.size) {
+                    program.dispose();
+                    programRoots.pop();
+                    program = original;
+                }
+                else {
+                    tscWorld = {
+                        program: original,
+                        diagnostics: ts.getPreEmitDiagnostics(original),
+                        projectWorld: null,
+                        declWorldFallback: true,
+                    };
+                }
+            }
+        }
         const entry = program.getSourceFile(entryPath);
         if (!entry)
             throw new Error(`could not load ${entryPath}`);
@@ -706,6 +762,7 @@ rootNpmStaticEdges = false) {
             entry,
             moduleOrder: [],
             configDiags: config.diags,
+            ...(declBoundaryNotes.length > 0 ? { declBoundaryNotes } : {}),
             typeWorld: {
                 nodeFallback: nodeTypes === null,
                 projectLib: config.projectLib ?? null,
@@ -877,25 +934,58 @@ export function loadProgram(entryPath, services, opts) {
         hideFile: (path) => (npmShadow?.hideFile(path) ?? false) || projectDtsRuntimeSibling(path) !== null,
     };
     const host = services.createProgramHost({ cwd: dirname(entryPath), fsShadow });
+    let authoredHost = null;
+    let authoredLoad = null;
+    const authored = () => {
+        if (!authoredLoad) {
+            authoredHost = services.createProgramHost({ cwd: dirname(entryPath) });
+            authoredLoad = loadProgram7(authoredHost, entryPath, externalTypes);
+        }
+        return authoredLoad;
+    };
+    const declPackages = npmStaticPackages.filter((pkg) => {
+        const resolved = resolveBareModule(entryPath, pkg, "types-only");
+        return resolved !== null && /\.d\.(?:ts|mts|cts)$/.test(resolved.typesFile);
+    });
+    const projector = declPackages.length === 0
+        ? undefined
+        : (program) => {
+            const userFiles = declBoundaryUserFiles(program, declPackages);
+            if (userFiles.length === 0)
+                return null;
+            let projection;
+            try {
+                projection = planDeclProjection({
+                    jsProgram: program,
+                    declProgram: authored().program,
+                    userFiles,
+                    outDir: dirname(entryPath),
+                });
+            }
+            catch (error) {
+                if (process.env["SCRIPTC_DEBUG_DECL_BOUNDARY"] === "1")
+                    throw error;
+                return null;
+            }
+            if (process.env["SCRIPTC_DEBUG_DECL_BOUNDARY"] === "1") {
+                process.stderr.write(`[decl-boundary] ${projection === null ? "no projection" : projection.plan.join("\n[decl-boundary] ")}\n`);
+                if (projection !== null)
+                    process.stderr.write(projection.declText);
+            }
+            return projection;
+        };
     try {
-        const load = loadProgram7(host, entryPath, externalTypes, npmStaticPackages.length > 0);
-        let authoredHost = null;
-        let authoredLoad = null;
+        const load = loadProgram7(host, entryPath, externalTypes, npmStaticPackages.length > 0, projector);
         return {
             ...load,
             services,
             projectWorld: npmStaticPackages.length === 0
                 ? load.projectWorld
-                : () => {
-                    // Check authored code against the package's published declarations.
-                    // Runtime bodies still lower from JavaScript in the original world;
-                    // inference there must not manufacture errors in valid user code.
-                    if (!authoredLoad) {
-                        authoredHost = services.createProgramHost({ cwd: dirname(entryPath) });
-                        authoredLoad = loadProgram7(authoredHost, entryPath, externalTypes);
-                    }
-                    return authoredLoad.projectWorld();
-                },
+                : () => 
+                // Check authored code against the package's published declarations.
+                // Runtime bodies still lower from JavaScript in the original world;
+                // inference there must not manufacture errors in valid user code.
+                authored().projectWorld(),
             dispose: () => {
                 try {
                     authoredLoad?.disposeAll();
@@ -913,10 +1003,39 @@ export function loadProgram(entryPath, services, opts) {
         };
     }
     catch (error) {
+        authoredLoad?.disposeAll();
+        authoredHost?.close();
         host.close();
         throw error;
     }
 }
+/** User TypeScript files (outside node_modules) that import one of the
+ * packages whose declarations the boundary projects from. */
+function declBoundaryUserFiles(program, packages) {
+    const out = [];
+    for (const sf of program.getSourceFiles()) {
+        const name = sf.fileName.split("\\").join("/");
+        if (sf.isDeclarationFile || name.includes("/node_modules/") || !/\.[mc]?tsx?$/.test(name))
+            continue;
+        if (name.endsWith(".tsx"))
+            continue; // JSX files: not projected yet
+        const text = sf.text;
+        if (packages.some((pkg) => text.includes(`"${pkg}"`) ||
+            text.includes(`'${pkg}'`) ||
+            text.includes(`"${pkg}/`) ||
+            text.includes(`'${pkg}/`)))
+            out.push(sf.fileName);
+    }
+    return out;
+}
+/** SC6102 — a projected file the lowering world disagreed with. */
+function declBoundaryDroppedDiag(file) {
+    return {
+        code: "SC6102",
+        message: "values from npm packages stay checked-dynamic in this file: the types projected from the packages' declarations do not type-check against their JavaScript",
+        loc: { file, start: 0, end: 0 },
+    };
+}
 /** tsc diagnostics (syntax + types), the supported-import fence, and the
  * module evaluation order: fills load.moduleOrder (the SourceFiles
  * themselves — the lowering consumes them directly) and returns the
@@ -968,6 +1087,11 @@ function suppressedJsStrictness7(d) {
     if (JS_ANY_OPERATOR_CODES.has(d.code)) {
         return ts.flattenDiagnosticMessageText(d, "\n").includes("'any'");
     }
+    // The deprecated Buffer(...) call without `new`, which Node's Buffer
+    // function accepts (containers/bytes.ts lowers it).
+    if (d.code === 2348) {
+        return ts.flattenDiagnosticMessageText(d, "\n").includes("'BufferConstructor'");
+    }
     return false;
 }
 /** The specifier of a `require("...")` call: the callee is the bare
@@ -1007,9 +1131,15 @@ function isRequireStatement7(stmt) {
         decls.every((d) => d.initializer !== undefined && requireSpecOf7(d.initializer) !== null));
 }
 /** The require() occurrences of one top-level statement: the declaration
- * forms and the bare side-effect call. Empty for everything else. */
-function requiresOf7(stmt) {
+ * forms, the bare side-effect call, and the assignment of a split require
+ * binding. Empty for everything else. */
+function requiresOf7(stmt, program) {
     if (ts.isExpressionStatement(stmt)) {
+        const split = splitRequireOfStatement7(program, stmt);
+        if (split !== null)
+            return [
+                { spec: requireSpecOf7(split.call), node: split.call, decl: split.decl, split: true },
+            ];
         const spec = requireSpecOf7(stmt.expression);
         return spec !== null ? [{ spec, node: stmt.expression, decl: null }] : [];
     }
@@ -1023,8 +1153,169 @@ function requiresOf7(stmt) {
     }
     return out;
 }
+/** CommonJS require bindings split into a declaration and one later
+ * assignment (`var m; m = require("./x")`): a top-level `var` or `let`
+ * declaration without initializer in a CommonJS file, assigned by exactly one
+ * top-level `m = require("<literal>")` statement of the require global over
+ * a compiled program module, and written nowhere else. The binding holds the
+ * module's exports from the assignment on, as `const m = require("./x")`
+ * does, so preflight treats the assignment as that require: its module edge,
+ * its cycle admission and its early-read fence. The lowering's recognizer
+ * (splitRequireBindingOf in cjs-inline-require.ts) accepts only these
+ * bindings. Keyed by declaration, with the assignment's require call. */
+function splitRequireBindings7(program, sf) {
+    const memo = program.analysis.splitRequireBindings;
+    const cached = memo.get(sf);
+    if (cached !== undefined)
+        return cached;
+    const out = new Map();
+    memo.set(sf, out);
+    if (sf.isDeclarationFile || !isCjsJsFile7(sf, program) || !sf.text.includes("require"))
+        return out;
+    const checker = program.getTypeChecker();
+    const stmts = sf.statements.nodes;
+    const candidates = new Map();
+    for (const stmt of stmts) {
+        if (!ts.isVariableStatement(stmt))
+            continue;
+        if ((stmt.declarationList.flags & (ts.NodeFlags.Const | ts.NodeFlags.Using)) !== 0)
+            continue;
+        for (const decl of stmt.declarationList.declarations.nodes) {
+            if (!ts.isIdentifier(decl.name) || decl.initializer !== undefined)
+                continue;
+            const symbol = checker.getSymbolAtLocation(decl.name);
+            if (symbol === undefined || symbol.declarations.length !== 1)
+                continue;
+            candidates.set(symbol, { decl, call: null, assigns: 0 });
+        }
+    }
+    if (candidates.size === 0)
+        return out;
+    // The one top-level `m = ...` statement, whose right side is the require.
+    for (const stmt of stmts) {
+        if (!ts.isExpressionStatement(stmt) || !ts.isBinaryExpression(stmt.expression))
+            continue;
+        const assign = stmt.expression;
+        if (assign.operatorToken.kind !== ts.SyntaxKind.EqualsToken || !ts.isIdentifier(assign.left))
+            continue;
+        const symbol = checker.getSymbolAtLocation(assign.left);
+        const candidate = symbol !== undefined ? candidates.get(symbol) : undefined;
+        if (candidate === undefined)
+            continue;
+        candidate.assigns++;
+        let right = assign.right;
+        while (ts.isParenthesizedExpression(right))
+            right = right.expression;
+        if (ts.isCallExpression(right) && splitRequireTarget7(program, sf, right))
+            candidate.call = right;
+    }
+    const names = new Set();
+    for (const candidate of candidates.values()) {
+        if (candidate.assigns === 1 && candidate.call !== null)
+            names.add(candidate.decl.name.text);
+    }
+    if (names.size === 0)
+        return out;
+    // Exactly one write in the whole file: the assignment itself.
+    const writes = new Map();
+    ts.walkPreorder(sf, (node) => {
+        if (!ts.isIdentifier(node) || !names.has(node.text))
+            return undefined;
+        const parent = node.parent;
+        const symbol = parent !== undefined && ts.isShorthandPropertyAssignment(parent) && parent.name === node
+            ? (checker.getShorthandAssignmentValueSymbol(parent) ?? checker.getSymbolAtLocation(node))
+            : checker.getSymbolAtLocation(node);
+        if (symbol === undefined || !candidates.has(symbol) || !isWriteReference7(node))
+            return undefined;
+        writes.set(symbol, (writes.get(symbol) ?? 0) + 1);
+        return undefined;
+    });
+    for (const [symbol, candidate] of candidates) {
+        if (candidate.assigns === 1 && candidate.call !== null && writes.get(symbol) === 1)
+            out.set(candidate.decl, candidate.call);
+    }
+    return out;
+}
+/** True when `call` is a require of the CommonJS global over a compiled
+ * program module: not a builtin, a JSON document or a declaration file. */
+function splitRequireTarget7(program, sf, call) {
+    const spec = requireSpecOf7(call);
+    if (spec === null || canonicalBuiltinModule(spec) !== null)
+        return false;
+    if (requireCallBindingKind7(program, call) !== "ambient")
+        return false;
+    const dep = resolveImport7(program, sf, spec, "require") ?? npmStaticDepSf7(program, sf, spec, "require");
+    return dep !== null && !dep.isDeclarationFile && !dep.fileName.endsWith(".json");
+}
+/** The split require binding a top-level statement assigns, or null. */
+function splitRequireOfStatement7(program, stmt) {
+    if (!ts.isExpressionStatement(stmt) ||
+        !ts.isBinaryExpression(stmt.expression) ||
+        !ts.isSourceFile(stmt.parent))
+        return null;
+    let right = stmt.expression.right;
+    while (ts.isParenthesizedExpression(right))
+        right = right.expression;
+    for (const [decl, call] of splitRequireBindings7(program, stmt.parent))
+        if (call === right)
+            return { decl, call };
+    return null;
+}
+/** The top-level statement of a split require binding's assignment, from
+ * its require call (`m = require("./x")` or `m = (require("./x"))`). */
+function splitRequireStatementOf7(call) {
+    let node = call;
+    while (node.parent !== undefined && ts.isParenthesizedExpression(node.parent))
+        node = node.parent;
+    return node.parent?.parent;
+}
+/** The require call of a split require binding's declaration, or null. */
+function splitRequireCallOf7(program, decl) {
+    return splitRequireBindings7(program, ts.getSourceFileOfNode(decl)).get(decl) ?? null;
+}
+/** True when `id` is written: an assignment target (compound and
+ * destructuring included), an update operand, or a for-in/of target. */
+function isWriteReference7(id) {
+    let n = id;
+    for (;;) {
+        const p = n.parent;
+        if (p === undefined)
+            return false;
+        if (ts.isBinaryExpression(p)) {
+            const k = p.operatorToken.kind;
+            return (p.left === n && k >= ts.SyntaxKind.FirstAssignment && k <= ts.SyntaxKind.LastAssignment);
+        }
+        if (ts.isPostfixUnaryExpression(p) || ts.isPrefixUnaryExpression(p)) {
+            return ((p.operator === ts.SyntaxKind.PlusPlusToken ||
+                p.operator === ts.SyntaxKind.MinusMinusToken) &&
+                p.operand === n);
+        }
+        if (ts.isForOfStatement(p) || ts.isForInStatement(p))
+            return p.initializer === n;
+        if (ts.isParenthesizedExpression(p) ||
+            ts.isArrayLiteralExpression(p) ||
+            ts.isSpreadElement(p) ||
+            ts.isSpreadAssignment(p) ||
+            ts.isShorthandPropertyAssignment(p) ||
+            ts.isObjectLiteralExpression(p) ||
+            (ts.isPropertyAssignment(p) && p.initializer === n)) {
+            n = p;
+            continue;
+        }
+        return false;
+    }
+}
+/** `true`, or `!0`, its minified spelling. */
+function isTrueLiteral(expr) {
+    return (expr.kind === ts.SyntaxKind.TrueKeyword ||
+        (ts.isPrefixUnaryExpression(expr) &&
+            expr.operator === ts.SyntaxKind.ExclamationToken &&
+            ts.isNumericLiteral(expr.operand) &&
+            expr.operand.text === "0"));
+}
 /** The exact `Object.defineProperty(exports|module.exports, "__esModule",
- * { value: true })` interop stamp (shared by preflight and the no-op lowering). */
+ * { value: true })` interop stamp (shared by preflight and the no-op lowering);
+ * `{ value: !0 }` is the same stamp. */
 export function isEsModuleStamp(expr) {
     if (!ts.isCallExpression(expr) || expr.questionDotToken !== undefined)
         return false;
@@ -1055,7 +1346,7 @@ export function isEsModuleStamp(expr) {
     return (ts.isPropertyAssignment(p) &&
         ts.isIdentifier(p.name) &&
         p.name.text === "value" &&
-        p.initializer.kind === ts.SyntaxKind.TrueKeyword);
+        isTrueLiteral(p.initializer));
 }
 /** Plain CommonJS prologue writes only publish values; in particular,
  * publishing a hoisted function does not invoke its body. Later runnable
@@ -1141,7 +1432,7 @@ function purePrefixStmt7(program, s) {
         return true;
     if (ts.isExpressionStatement(s) && ts.isStringLiteral(s.expression))
         return true; // directive
-    if (isRequireStatement7(s))
+    if (isRequireStatement7(s) || splitRequireOfStatement7(program, s) !== null)
         return true;
     if (isCjsJsFile7(ts.getSourceFileOfNode(s), program)) {
         if (ts.isExpressionStatement(s) && isEsModuleStamp(s.expression)) {
@@ -1265,12 +1556,18 @@ function requireEarlyReference7(program, decl) {
     if (cached !== undefined)
         return cached;
     let found = null;
-    const stmt = decl.parent?.parent;
     const sf = ts.getSourceFileOfNode(decl);
-    if (stmt !== undefined && ts.isVariableStatement(stmt) && ts.isSourceFile(stmt.parent)) {
+    // A split require binding is bound at its assignment statement.
+    const splitCall = splitRequireCallOf7(program, decl);
+    const stmt = splitCall !== null ? splitRequireStatementOf7(splitCall) : decl.parent?.parent;
+    if (stmt !== undefined &&
+        (ts.isVariableStatement(stmt) || splitCall !== null) &&
+        ts.isSourceFile(stmt.parent)) {
         const stmts = sf.statements.nodes;
         const k = stmts.indexOf(stmt);
-        const declarations = stmt.declarationList.declarations.nodes;
+        const declarations = ts.isVariableStatement(stmt)
+            ? stmt.declarationList.declarations.nodes
+            : [];
         // Earlier declarators run too: `const x = read(), dep = require('./dep')`.
         const precedingDecls = declarations.slice(0, declarations.indexOf(decl));
         let firstRunnable = program.analysis.requireFirstRunnable.get(sf);
@@ -1318,6 +1615,12 @@ exactEarlyRead) {
     }
     if (bindings.size === 0)
         return null;
+    // A split require binding's assignment writes the binding; it reads nothing.
+    let splitWrite = splitRequireCallOf7(program, decl);
+    while (splitWrite !== null && ts.isParenthesizedExpression(splitWrite.parent))
+        splitWrite = splitWrite.parent;
+    splitWrite =
+        splitWrite !== null && ts.isBinaryExpression(splitWrite.parent) ? splitWrite.parent.left : null;
     const stmts = sf.statements.nodes;
     const cjs = isCjsJsFile7(sf, program);
     const symbolOf = (id) => {
@@ -1562,7 +1865,7 @@ exactEarlyRead) {
             if (sym === undefined)
                 return undefined;
             if (bindings.has(sym)) {
-                if (exactEarlyRead?.(n) === true)
+                if (n === splitWrite || exactEarlyRead?.(n) === true)
                     return undefined;
                 hit = n;
                 return "stop";
@@ -2963,7 +3266,7 @@ function cjsCycleRefusal7(program, comp, lineOf) {
         }
         // Bindings of other members must stay unreachable from top-level code.
         for (const st of stmts) {
-            for (const req of requiresOf7(st)) {
+            for (const req of requiresOf7(st, program)) {
                 if (req.decl === null)
                     continue;
                 const dep = resolveImport7(program, m, req.spec, "require");
@@ -3362,6 +3665,7 @@ function computeCycleEarlyBindings7(program, entry, order, singleRoot, exact) {
                         start: ts.tokenStartOfNode(stmt),
                         end: stmt.end,
                         reference: null,
+                        deferredReference: null,
                         folded: null,
                         localNames: new Map(),
                     });
@@ -3438,10 +3742,13 @@ function computeCycleEarlyBindings7(program, entry, order, singleRoot, exact) {
                     ts.tokenStartOfNode(ref) >= c.start &&
                     ref.end <= c.end)
                     continue;
+                if (inDeferredPosition7(ref)) {
+                    if (c.exposed && c.deferredReference === null)
+                        c.deferredReference = ref;
+                    continue;
+                }
                 let early;
-                if (inDeferredPosition7(ref))
-                    early = c.exposed;
-                else if (sf === c.module)
+                if (sf === c.module)
                     early = ts.tokenStartOfNode(ref) < c.start;
                 else if (!memberSet.has(sf) || !rankOf.has(sf))
                     early = false;
@@ -3451,7 +3758,15 @@ function computeCycleEarlyBindings7(program, entry, order, singleRoot, exact) {
                     c.reference = ref;
             }
         }
+        // With a static evaluation order, a deferred reference only runs early
+        // when the code that runs before the declaration completes can reach
+        // the function holding it.
+        const reached = known && [...candidates.values()].some((c) => c.reference === null && c.deferredReference)
+            ? cycleReachedDeferredReferences7(program, evaluation, candidates)
+            : null;
         for (const c of candidates.values()) {
+            if (c.reference === null && c.deferredReference !== null)
+                c.reference = reached === null ? c.deferredReference : (reached.get(c.symbol) ?? null);
             if (c.reference === null)
                 continue;
             const settled = new Set(order.filter((sf) => !rankOf.has(sf)));
@@ -3472,6 +3787,292 @@ function computeCycleEarlyBindings7(program, entry, order, singleRoot, exact) {
     }
     return out;
 }
+/** Collects into `units` the callables an initializer expression stores
+ * (see moduleEarlyBindingsOf7), recording in `immediate` the parts of a
+ * stored node that run where it is evaluated. */
+function storedCallables7(checker, e, units, immediate) {
+    while (ts.isParenthesizedExpression(e) ||
+        ts.isAsExpression(e) ||
+        ts.isSatisfiesExpression(e) ||
+        ts.isNonNullExpression(e))
+        e = e.expression;
+    if (ts.isArrowFunction(e) || ts.isFunctionExpression(e)) {
+        units.push(e);
+    }
+    else if (ts.isClassExpression(e)) {
+        units.push(e);
+        immediate.set(e, classSyncParts7(e));
+    }
+    else if (ts.isObjectLiteralExpression(e)) {
+        for (const p of e.properties.nodes) {
+            if (ts.isMethodDeclaration(p) ||
+                ts.isGetAccessorDeclaration(p) ||
+                ts.isSetAccessorDeclaration(p)) {
+                // A computed key evaluates where the literal does; a plain
+                // member-chain key (`[Equal.symbol]`) runs no user code.
+                if (!ts.isComputedPropertyName(p.name))
+                    units.push(p);
+                else if (memberChainKey7(p.name.expression)) {
+                    units.push(p);
+                    immediate.set(p, [p.name]);
+                }
+            }
+            else if (ts.isPropertyAssignment(p))
+                storedCallables7(checker, p.initializer, units, immediate);
+        }
+    }
+    else if (ts.isArrayLiteralExpression(e)) {
+        for (const el of e.elements.nodes)
+            if (!ts.isSpreadElement(el))
+                storedCallables7(checker, el, units, immediate);
+    }
+    else if (ts.isCallExpression(e)) {
+        // `const f = wrap(callback)` where wrap only returns closures over
+        // the callback: it runs when the stored result is called.
+        e.arguments.nodes.forEach((arg, index) => {
+            let fn = arg;
+            while (ts.isParenthesizedExpression(fn))
+                fn = fn.expression;
+            if ((ts.isArrowFunction(fn) || ts.isFunctionExpression(fn)) &&
+                returnsOnlyClosuresOver7(checker, e.expression, index))
+                units.push(fn);
+        });
+    }
+}
+/** For one import cycle with a static evaluation order: the first deferred
+ * reference to each candidate that code running before the candidate's
+ * declaration completes can reach, or null when the walk cannot be precise
+ * (top-level await, a default-exported function or class declaration).
+ *
+ * The cycle's top-level code runs in evaluation order. A stored callable
+ * (a function or class declaration, or a function, class or object-literal
+ * method stored by a variable initializer) becomes reachable once
+ * reachable code names its binding, through an import alias or a
+ * namespace member too; every other function-like in reachable code counts
+ * as reachable, since it may be handed to a callee. A namespace import of
+ * a cycle member used other than for a member read makes every stored
+ * callable reachable. moduleEarlyBindingsOf7 is the single-module form. */
+function cycleReachedDeferredReferences7(program, evaluation, candidates) {
+    const checker = program.getTypeChecker();
+    const members = new Set(evaluation);
+    for (const sf of evaluation) {
+        if (hasTopLevelAwait7(sf))
+            return null;
+        for (const stmt of sf.statements.nodes) {
+            if ((ts.isFunctionDeclaration(stmt) || ts.isClassDeclaration(stmt)) &&
+                (ts.getCombinedModifierFlags(stmt) &
+                    ts.ModifierFlags.Default) !==
+                    0)
+                return null;
+        }
+    }
+    const stored = new Set();
+    const immediate = new Map();
+    const storedNames = [];
+    const unitsOfName = new Map();
+    const store = (name, units) => {
+        if (units.length === 0)
+            return;
+        for (const u of units)
+            stored.add(u);
+        storedNames.push(name);
+        unitsOfName.set(name, units);
+    };
+    for (const sf of evaluation) {
+        for (const stmt of sf.statements.nodes) {
+            if ((ts.getCombinedModifierFlags(stmt) &
+                ts.ModifierFlags.Ambient) !==
+                0)
+                continue;
+            if (ts.isFunctionDeclaration(stmt) && stmt.name !== undefined && stmt.body !== undefined) {
+                store(stmt.name, [stmt]);
+            }
+            else if (ts.isClassDeclaration(stmt) && stmt.name !== undefined) {
+                store(stmt.name, [stmt]);
+            }
+            else if (ts.isVariableStatement(stmt)) {
+                for (const d of stmt.declarationList.declarations.nodes) {
+                    if (ts.isIdentifier(d.name) && d.initializer !== undefined) {
+                        const units = [];
+                        storedCallables7(checker, d.initializer, units, immediate);
+                        store(d.name, units);
+                    }
+                }
+            }
+        }
+    }
+    const unitsBySymbol = new Map();
+    const allUnits = [];
+    for (const name of storedNames) {
+        const symbol = checker.getSymbolAtLocation(name);
+        if (symbol === undefined)
+            continue;
+        const units = unitsOfName.get(name);
+        unitsBySymbol.set(symbol, [...(unitsBySymbol.get(symbol) ?? []), ...units]);
+        allUnits.push(...units);
+    }
+    // A named class expression's inner name (`class Impl { static x =
+    // Impl.m(); }`) names the class inside its own body, as the binding it
+    // is stored in names it outside.
+    const innerNames = [];
+    for (const unit of allUnits) {
+        if (!ts.isClassExpression(unit) || unit.name === undefined)
+            continue;
+        const symbol = checker.getSymbolAtLocation(unit.name);
+        if (symbol === undefined)
+            continue;
+        innerNames.push(unit.name);
+        unitsBySymbol.set(symbol, [...(unitsBySymbol.get(symbol) ?? []), unit]);
+    }
+    // The identifier texts worth resolving: declared names, and the local
+    // names of imports (named, default and namespace) in cycle members.
+    const names = new Set();
+    for (const c of candidates.values())
+        names.add(c.name.text);
+    for (const name of storedNames)
+        names.add(name.text);
+    for (const name of innerNames)
+        names.add(name.text);
+    for (const sf of evaluation) {
+        for (const stmt of sf.statements.nodes) {
+            if (!ts.isImportDeclaration(stmt) || stmt.importClause === undefined)
+                continue;
+            const clause = stmt.importClause;
+            if (clause.name !== undefined)
+                names.add(clause.name.text);
+            const bindings = clause.namedBindings;
+            if (bindings === undefined)
+                continue;
+            if (ts.isNamedImports(bindings))
+                for (const element of bindings.elements.nodes)
+                    names.add(element.name.text);
+            else
+                names.add(bindings.name.text);
+        }
+    }
+    const idents = [];
+    for (const sf of evaluation) {
+        ts.walkPreorder(sf, (node) => {
+            if (ts.isImportDeclaration(node))
+                return "skip";
+            if (ts.isIdentifier(node) && names.has(node.text))
+                idents.push(node);
+            return undefined;
+        });
+    }
+    checker.prefetchSymbolNodesExact(idents);
+    const symbolOf = (id) => {
+        const parent = id.parent;
+        let symbol = checker.getSymbolAtLocation(id);
+        if (parent !== undefined && ts.isShorthandPropertyAssignment(parent) && parent.name === id) {
+            symbol = checker.getShorthandAssignmentValueSymbol(parent) ?? symbol;
+        }
+        if (symbol !== undefined && symbol.flags & ts.SymbolFlags.Alias) {
+            symbol = checker.getAliasedSymbol(symbol);
+        }
+        return symbol;
+    };
+    const isMemberNamespace = (symbol) => (symbol.flags & ts.SymbolFlags.ValueModule) !== 0 &&
+        symbol.declarations.some((d) => ts.isSourceFile(d) && members.has(d));
+    const declared = new Set();
+    const reachedUnits = new Set();
+    const out = new Map();
+    const work = [];
+    const reach = (unit) => {
+        if (reachedUnits.has(unit))
+            return;
+        reachedUnits.add(unit);
+        work.push(unit);
+    };
+    const visit = (root) => {
+        ts.walkPreorder(root, (node) => {
+            if (node !== root && stored.has(node)) {
+                for (const part of immediate.get(node) ?? [])
+                    visit(part);
+                return "skip";
+            }
+            if (ts.isImportDeclaration(node))
+                return "skip";
+            if (node.kind === ts.SyntaxKind.ThisKeyword) {
+                // `this` in a static initializer or block names the class, so it
+                // reaches the class's methods as naming the class does.
+                const owner = staticThisClass7(node);
+                if (owner !== undefined && stored.has(owner))
+                    reach(owner);
+                return undefined;
+            }
+            if (!ts.isIdentifier(node) || !names.has(node.text))
+                return undefined;
+            if (inTypePosition7(node))
+                return undefined;
+            const parent = node.parent;
+            if (parent !== undefined && ts.isExportSpecifier(parent))
+                return undefined;
+            if (parent !== undefined && declaredName7(parent) === node)
+                return undefined;
+            const symbol = symbolOf(node);
+            if (symbol === undefined)
+                return undefined;
+            if (isMemberNamespace(symbol)) {
+                // `ns.member` resolves through the member's own identifier; any
+                // other use can reach every export.
+                if (!(parent !== undefined &&
+                    ts.isPropertyAccessExpression(parent) &&
+                    parent.expression === node))
+                    for (const unit of allUnits)
+                        reach(unit);
+                return undefined;
+            }
+            const c = candidates.get(symbol);
+            if (c !== undefined &&
+                node !== c.name &&
+                !declared.has(symbol) &&
+                !out.has(symbol) &&
+                inDeferredPosition7(node) &&
+                !(c.kind === "class" &&
+                    ts.getSourceFileOfNode(node) === c.module &&
+                    ts.tokenStartOfNode(node) >= c.start &&
+                    node.end <= c.end))
+                out.set(symbol, node);
+            for (const unit of unitsBySymbol.get(symbol) ?? [])
+                reach(unit);
+            return undefined;
+        });
+    };
+    const drain = () => {
+        while (work.length > 0)
+            visit(work.pop());
+    };
+    const declare = (name) => {
+        for (const id of boundNames7(name)) {
+            const symbol = checker.getSymbolAtLocation(id);
+            if (symbol !== undefined)
+                declared.add(symbol);
+        }
+    };
+    for (const sf of evaluation) {
+        for (const stmt of sf.statements.nodes) {
+            if (ts.isClassDeclaration(stmt)) {
+                for (const part of classSyncParts7(stmt))
+                    visit(part);
+                drain();
+                if (stmt.name !== undefined)
+                    declare(stmt.name);
+            }
+            else if (ts.isVariableStatement(stmt)) {
+                for (const d of stmt.declarationList.declarations.nodes) {
+                    visit(d);
+                    drain();
+                    declare(d.name);
+                }
+            }
+            else if (!ts.isFunctionDeclaration(stmt))
+                visit(stmt);
+            drain();
+        }
+    }
+    return out;
+}
 /** Top-level let/const and class bindings, in modules outside the
  * exactly-initialized cycles, that code running before their declaration
  * completes can read.
@@ -3523,55 +4124,7 @@ function moduleEarlyBindingsOf7(program, sf, order) {
         storedBy.set(name.text, list);
     };
     const checker = program.getTypeChecker();
-    const storedIn = (e, units) => {
-        while (ts.isParenthesizedExpression(e) ||
-            ts.isAsExpression(e) ||
-            ts.isSatisfiesExpression(e) ||
-            ts.isNonNullExpression(e))
-            e = e.expression;
-        if (ts.isArrowFunction(e) || ts.isFunctionExpression(e)) {
-            units.push(e);
-        }
-        else if (ts.isClassExpression(e)) {
-            units.push(e);
-            immediate.set(e, classSyncParts7(e));
-        }
-        else if (ts.isObjectLiteralExpression(e)) {
-            for (const p of e.properties.nodes) {
-                if (ts.isMethodDeclaration(p) ||
-                    ts.isGetAccessorDeclaration(p) ||
-                    ts.isSetAccessorDeclaration(p)) {
-                    // A computed key evaluates where the literal does; a plain
-                    // member-chain key (`[Equal.symbol]`) runs no user code.
-                    if (!ts.isComputedPropertyName(p.name))
-                        units.push(p);
-                    else if (memberChainKey7(p.name.expression)) {
-                        units.push(p);
-                        immediate.set(p, [p.name]);
-                    }
-                }
-                else if (ts.isPropertyAssignment(p))
-                    storedIn(p.initializer, units);
-            }
-        }
-        else if (ts.isArrayLiteralExpression(e)) {
-            for (const el of e.elements.nodes)
-                if (!ts.isSpreadElement(el))
-                    storedIn(el, units);
-        }
-        else if (ts.isCallExpression(e)) {
-            // `const f = wrap(callback)` where wrap only returns closures over
-            // the callback: it runs when the stored result is called.
-            e.arguments.nodes.forEach((arg, index) => {
-                let fn = arg;
-                while (ts.isParenthesizedExpression(fn))
-                    fn = fn.expression;
-                if ((ts.isArrowFunction(fn) || ts.isFunctionExpression(fn)) &&
-                    returnsOnlyClosuresOver7(checker, e.expression, index))
-                    units.push(fn);
-            });
-        }
-    };
+    const storedIn = (e, units) => storedCallables7(checker, e, units, immediate);
     sf.statements.nodes.forEach((stmt, index) => {
         if (ambient(stmt))
             return;
@@ -3853,6 +4406,41 @@ function returnsOnlyClosuresOver7(checker, callee, index) {
  * expressions, decorators, computed member keys, static field
  * initializers and static blocks. Methods and instance fields wait for a
  * call or a construction. */
+/** The class whose static field initializer or static block evaluates `this`
+ * (through arrow functions, which keep the enclosing `this`), or undefined
+ * when another function or a class's instance side binds it. */
+function staticThisClass7(node) {
+    let child = node;
+    for (let n = node.parent; n !== undefined; child = n, n = n.parent) {
+        if (ts.isArrowFunction(n))
+            continue;
+        if (ts.isClassStaticBlockDeclaration(n))
+            return n.parent;
+        if (ts.isPropertyDeclaration(n)) {
+            if (n.initializer !== child)
+                return undefined;
+            return (ts.getCombinedModifierFlags(n) & ts.ModifierFlags.Static) !== 0
+                ? n.parent
+                : undefined;
+        }
+        if (ts.isComputedPropertyName(n)) {
+            // A computed key evaluates in the scope around the class.
+            const member = n.parent;
+            const cls = member?.parent;
+            if (cls === undefined)
+                return undefined;
+            child = cls;
+            n = cls;
+            continue;
+        }
+        if (ts.isFunctionLike(n) ||
+            ts.isClassDeclaration(n) ||
+            ts.isClassExpression(n) ||
+            ts.isSourceFile(n))
+            return undefined;
+    }
+    return undefined;
+}
 function classSyncParts7(c) {
     const decorators = (n) => (n.modifiers?.nodes ?? []).filter((m) => m.kind === ts.SyntaxKind.Decorator);
     const parts = [...decorators(c), ...(c.heritageClauses?.nodes ?? [])];
@@ -4356,7 +4944,9 @@ function preflight7(load) {
     const tscWorld = load.tscWorld;
     const tscErrors = tscWorld === undefined ? errorsOf(program) : keptErrors(tscWorld.program, tscWorld.diagnostics);
     if (tscErrors.length > 0) {
-        const world = tscWorld === undefined ? load.projectWorld() : (tscWorld.projectWorld ?? tscWorld.program);
+        const world = tscWorld === undefined || tscWorld.declWorldFallback === true
+            ? load.projectWorld()
+            : (tscWorld.projectWorld ?? tscWorld.program);
         for (const d of errorsOf(world)) {
             const diag = toPassthrough(d);
             const lowered = tscWorld === undefined ? undefined : load.jsxSources?.get(diag.loc.file);
@@ -4806,17 +5396,20 @@ function preflight7(load) {
                 const early = req.decl !== null ? requireEarlyReference7(program, req.decl) : null;
                 if (early === null ||
                     (bindingKind !== "createRequire" &&
+                        req.split === undefined &&
                         ((req.decl.parent?.flags ?? 0) & (ts.NodeFlags.Const | ts.NodeFlags.Let)) !== 0)) {
                     return false;
                 }
                 diags.push(unsupportedDiag("SC1013", loc, bindingKind === "createRequire"
                     ? `createRequire() binding '${early.text}' below code that can reach it (Node throws ReferenceError on any earlier access, which is not modeled — move the require above the code that can run first)`
-                    : `var require() binding '${early.text}' below code that can reach it (Node reads undefined before the require runs, which is not modeled — declare it with const or let, or move the require above the code that can run first)`));
+                    : req.split !== undefined
+                        ? `require() binding '${early.text}' assigned below code that can reach it (Node reads undefined before the assignment runs, which is not modeled — move the assignment above the code that can run first)`
+                        : `var require() binding '${early.text}' below code that can reach it (Node reads undefined before the require runs, which is not modeled — declare it with const or let, or move the require above the code that can run first)`));
                 return true;
             };
             for (let k = 0; k < stmts.length; k++) {
                 const stmt = stmts[k];
-                for (const req of requiresOf7(stmt)) {
+                for (const req of requiresOf7(stmt, program)) {
                     const loc = {
                         file: sf.fileName,
                         start: ts.tokenStartOfNode(req.node),
@@ -4845,8 +5438,8 @@ function preflight7(load) {
                     if (jsonDep !== null && jsonDep.fileName.endsWith(".json")) {
                         if (bindingKind === "createRequire")
                             continue;
-                        if (ts.isVariableStatement(stmt) && requiresOf7(stmt).length > 1) {
-                            const others = requiresOf7(stmt).some((r) => {
+                        if (ts.isVariableStatement(stmt) && requiresOf7(stmt, program).length > 1) {
+                            const others = requiresOf7(stmt, program).some((r) => {
                                 const d = resolveImport7(program, sf, r.spec, "require");
                                 return d === null || !d.fileName.endsWith(".json");
                             });
@@ -5008,9 +5601,14 @@ function preflight7(load) {
             // counts, and targets outside the compiled graph add nothing here:
             // their use sites keep their existing lowering fences.
             if (jsRequireFile && !isNodeEsmFile7(sf, program)) {
+                // A split require binding's assignment is a statement-level require
+                // edge (requiresOf7 above), parenthesized or not.
+                const splitCalls = new Set(splitRequireBindings7(program, sf).values());
                 for (const call of inlineRequiresOf7(sf)) {
                     if (requireCallBindingKind7(program, call) !== "ambient")
                         continue;
+                    if (splitCalls.has(call))
+                        continue;
                     const spec = requireSpecOf7(call);
                     if (load.externalTypes.has(spec) || canonicalBuiltinModule(spec) !== null)
                         continue;
@@ -5383,7 +5981,7 @@ function analyzeEsmNamedImportLinks(program, entry) {
         const nextSeen = new Set(seenModules);
         nextSeen.add(dep);
         const module = checker.getSymbolAtLocation(dep);
-        const exported = module?.getExports().get(name);
+        const exported = module?.getExports().get(ts.escapedSymbolName(name));
         if (exported !== undefined) {
             let resolved = exported;
             const seenSymbols = new Set();
@@ -5661,7 +6259,7 @@ const nodeBuiltinNames = new Set(builtinModules);
 export { ambientDtsPath, fallbackDtsPath, isNodeTypesPath, overridesDtsPath } from "./dts-paths.js";
 export { builtinDefaultImportModule, canonicalBuiltinModule, npmBuiltinAliasOf, SUPPORTED_BUILTIN_MODULES, } from "./builtin-modules.js";
 export { npmPackageNameOf, workspacePackageOfPath } from "./workspace-registry.js";
-export { requireSpecOf7 as requireSpecOf, isRequireStatement7 as isRequireStatement, requiresOf7 as requiresOf, isNodeEsmFile7 as isNodeEsmFile, resolveImport7 as resolveImport, resolveNpmImport7 as resolveNpmImport, locOf7 as locOf, requireEarlyReference7 as requireEarlyReference, inDeferredPosition7 as inDeferredPosition, };
+export { requireSpecOf7 as requireSpecOf, isRequireStatement7 as isRequireStatement, requiresOf7 as requiresOf, splitRequireCallOf7 as splitRequireCallOf, isNodeEsmFile7 as isNodeEsmFile, resolveImport7 as resolveImport, resolveNpmImport7 as resolveNpmImport, locOf7 as locOf, requireEarlyReference7 as requireEarlyReference, inDeferredPosition7 as inDeferredPosition, };
 /** True for JavaScript source files (.js/.mjs/.cjs) — the files whose
  * types come entirely from inference (checkJs + JSDoc) and whose classes
  * declare fields by constructor assignment. */