@scriptc/compiler 0.4.3 → 0.4.5

package/dist/frontend/program.js

@@ -49,7 +49,7 @@ import { isPrunedNpmReexport, planNpmStaticReexports } from "./npm-static-prune.
 import { npmStaticTypeExportPlan } from "./npm-static-type-exports-host.js";
 import { isNpmStaticSubclassArgument } from "./npm-static-subtyping.js";
 import { npmStaticDeclarationReexports, npmStaticRuntimeClassTargets, parseNpmStaticDeclarationOverloads, parseNpmStaticDeclarationProperties, } from "./npm-static-declaration-syntax.js";
-import { configurePackageShims, isPackageShimFile, isPackageShimName, isShimmedImport, } from "./package-shims.js";
+import { configurePackageShims, isPackageShimFile, isShimmedImport, npmStaticOmitsPackage, } from "./package-shims.js";
 import { provenanceEntryFor, provenancePaths } from "./provenance-registry.js";
 import { cjsLexedExportsOfFile, cjsVisibleNames } from "./cjs-syntax.js";
 import { ambientDtsPath, fallbackDtsPath, isNodeTypesPath, overridesDtsPath, tsgoPath, } from "./dts-paths.js";
@@ -62,6 +62,7 @@ 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 { reportShapes } from "./shape-inference/index.js";
 import { inferredJsDiagnosticSuppressed } from "./inferred-js-diagnostics.js";
 import { containsJsx, firstJsx, jsxEmitName, jsxEmitPlan, jsxPragmas, lowerJsx, } from "./jsx-source.js";
 const BASE_OPTIONS = {
@@ -303,33 +304,31 @@ function visitNpmStaticDeclarationClosure(services, entryPath, onSource) {
     };
     visit(entryPath);
 }
-function npmStaticDeclarationOverloadsOf(services, entryPath) {
-    const classes = new Map();
+/** The overloads and properties of the classes a package's declaration
+ * closure declares, read from one parse of each declaration file. */
+function npmStaticDeclarationMetadataOf(services, entryPath) {
+    const overloads = new Map();
+    const properties = new Map();
     visitNpmStaticDeclarationClosure(services, entryPath, (path, source) => {
-        for (const [className, methods] of parseNpmStaticDeclarationOverloads(services.parse(path, source, "ts"))) {
-            const target = classes.get(className) ?? new Map();
-            classes.set(className, target);
+        const sourceFile = services.parse(path, source, "ts");
+        for (const [className, methods] of parseNpmStaticDeclarationOverloads(sourceFile)) {
+            const target = overloads.get(className) ?? new Map();
+            overloads.set(className, target);
             for (const [methodName, signatures] of methods) {
                 if (!target.has(methodName))
                     target.set(methodName, signatures);
             }
         }
-    });
-    return classes;
-}
-function npmStaticDeclarationPropertiesOf(services, entryPath) {
-    const classes = new Map();
-    visitNpmStaticDeclarationClosure(services, entryPath, (path, source) => {
-        for (const [className, properties] of parseNpmStaticDeclarationProperties(services.parse(path, source, "ts"))) {
-            const target = classes.get(className) ?? new Map();
-            classes.set(className, target);
-            for (const [propertyName, type] of properties) {
+        for (const [className, fields] of parseNpmStaticDeclarationProperties(sourceFile)) {
+            const target = properties.get(className) ?? new Map();
+            properties.set(className, target);
+            for (const [propertyName, type] of fields) {
                 if (!target.has(propertyName))
                     target.set(propertyName, type);
             }
         }
     });
-    return classes;
+    return { overloads, properties };
 }
 /** True when a coverage mapping names one exact bare host module. TypeScript
  * gives `paths` keys containing `*` pattern semantics, so accepting one here
@@ -808,11 +807,12 @@ export function loadProgram(entryPath, services, opts) {
         }
         externalTypes.set(specifier, declarationPath);
     }
-    // Packages scriptc implements itself or the project marks never loaded
-    // (package-shims.ts) never compile their published JavaScript, even when
-    // named.
+    // Packages scriptc implements itself, and packages the project marks
+    // never loaded (package-shims.ts), never compile their published
+    // JavaScript, even when named. A registry entry's `sourceVersions`
+    // (chalk 6) compile from their own source.
     configurePackageShims(entryPath);
-    const npmStaticPackages = [...new Set(opts?.npmStatic ?? [])].filter((name) => !isPackageShimName(name));
+    const npmStaticPackages = [...new Set(opts?.npmStatic ?? [])].filter((name) => !npmStaticOmitsPackage(entryPath, name));
     // Resolve authored declaration entries before enabling the JS-only
     // package resolver. Safe overload metadata binds through the runtime
     // entry to one exact implementation file; it never contributes values
@@ -827,8 +827,7 @@ export function loadProgram(entryPath, services, opts) {
             !/\.d\.(?:ts|mts|cts)$/.test(resolved.typesFile)) {
             continue;
         }
-        const overloads = npmStaticDeclarationOverloadsOf(services, resolved.typesFile);
-        const properties = npmStaticDeclarationPropertiesOf(services, resolved.typesFile);
+        const { overloads, properties } = npmStaticDeclarationMetadataOf(services, resolved.typesFile);
         const classNames = new Set([...overloads.keys(), ...properties.keys()]);
         if (classNames.size === 0)
             continue;
@@ -976,6 +975,10 @@ export function loadProgram(entryPath, services, opts) {
         };
     try {
         const load = loadProgram7(host, entryPath, externalTypes, npmStaticPackages.length > 0, projector);
+        // Shape inference, stage S1: a report only (SCRIPTC_DEBUG_SHAPES).
+        const shapes = process.env["SCRIPTC_DEBUG_SHAPES"];
+        if (shapes !== undefined && shapes !== "" && shapes !== "0" && npmStaticPackages.length > 0)
+            reportShapes(load.program, shapes);
         return {
             ...load,
             services,
@@ -1013,9 +1016,9 @@ export function loadProgram(entryPath, services, opts) {
  * packages whose declarations the boundary projects from. */
 function declBoundaryUserFiles(program, packages) {
     const out = [];
-    for (const sf of program.getSourceFiles()) {
+    for (const sf of program.getImplementationSourceFiles()) {
         const name = sf.fileName.split("\\").join("/");
-        if (sf.isDeclarationFile || name.includes("/node_modules/") || !/\.[mc]?tsx?$/.test(name))
+        if (name.includes("/node_modules/") || !/\.[mc]?tsx?$/.test(name))
             continue;
         if (name.endsWith(".tsx"))
             continue; // JSX files: not projected yet
@@ -1087,6 +1090,16 @@ 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), and fs.ReadStream(...)
+    // and fs.WriteStream(...), which construct their stream
+    // (builtins/fs-streams.ts).
+    if (d.code === 2348) {
+        const text = ts.flattenDiagnosticMessageText(d, "\n");
+        return (text.includes("'BufferConstructor'") ||
+            text.includes("'typeof ReadStream'") ||
+            text.includes("'typeof WriteStream'"));
+    }
     return false;
 }
 /** The specifier of a `require("...")` call: the callee is the bare
@@ -1126,9 +1139,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 }] : [];
     }
@@ -1142,6 +1161,158 @@ 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 ||
@@ -1269,7 +1440,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)) {
@@ -1393,12 +1564,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);
@@ -1446,6 +1623,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) => {
@@ -1690,7 +1873,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";
@@ -2023,18 +2206,30 @@ export function isCreateRequireBinding7(program, callee) {
         ((decl.parent.flags & ts.NodeFlags.Const) !== 0 ||
             stableCreateRequireBindingReason7(program, decl) === null));
 }
-/** Only literal calls and literal resolution queries can erase the loader
- * value. In particular, assignments, exported aliases, shorthand properties,
- * optional calls, and passing the loader to user code cannot pass this test. */
-function staticCreateRequireUse7(expr) {
+/** How a use of a createRequire loader lowers:
+ * - "static": a literal call or a literal resolution query, which erases
+ *   the loader value.
+ * - "deferred": a call with a computed specifier or another argument shape,
+ *   or `resolve` / `resolve.paths` read as a value, inside the try block
+ *   of a try statement in the same function. The call throws a runtime
+ *   fence, and the resolve value is a function that throws one when called
+ *   (module-resolution.ts), so the statement's catch clause handles them
+ *   (packages that look for optional native addons).
+ * - "computed": the same shapes outside a try block.
+ * - "escaping": the loader itself as a value, writes, optional calls, and
+ *   other members. */
+const COMPUTED_CREATE_REQUIRE_REASON = "its createRequire result is used with a computed specifier, or its resolve as a value, outside a try block (static requires need literal specifiers)";
+function createRequireUse7(expr) {
     let use = expr;
     while (ts.isParenthesizedExpression(use.parent))
         use = use.parent;
+    let member = false;
     if (ts.isPropertyAccessExpression(use.parent) &&
         use.parent.expression === use &&
         use.parent.name.text === "resolve" &&
         !use.parent.questionDotToken) {
         use = use.parent;
+        member = true;
         if (ts.isPropertyAccessExpression(use.parent) &&
             use.parent.expression === use &&
             use.parent.name.text === "paths" &&
@@ -2042,11 +2237,37 @@ function staticCreateRequireUse7(expr) {
             use = use.parent;
     }
     const call = use.parent;
-    return (ts.isCallExpression(call) &&
-        call.expression === use &&
-        !call.questionDotToken &&
-        call.arguments.nodes.length === 1 &&
-        ts.isStringLiteralLike(call.arguments.nodes[0]));
+    if (ts.isCallExpression(call) && call.expression === use) {
+        if (call.questionDotToken)
+            return "escaping";
+        if (call.arguments.nodes.length === 1 && ts.isStringLiteralLike(call.arguments.nodes[0]))
+            return "static";
+    }
+    else if (!member || isAssignmentTarget7(use)) {
+        return "escaping";
+    }
+    return insideTryBlock7(use) ? "deferred" : "computed";
+}
+function isAssignmentTarget7(node) {
+    const parent = node.parent;
+    return (ts.isBinaryExpression(parent) &&
+        parent.left === node &&
+        parent.operatorToken.kind >= ts.SyntaxKind.FirstAssignment &&
+        parent.operatorToken.kind <= ts.SyntaxKind.LastAssignment);
+}
+/** True when `node` is inside the try block of a try statement in the same
+ * function (a catch clause or finally block does not count). A class field
+ * initializer runs when the class is instantiated, so it is a boundary too. */
+function insideTryBlock7(node) {
+    for (let child = node, parent = node.parent; parent; child = parent, parent = parent.parent) {
+        if (ts.isTryStatement(parent) && parent.tryBlock === child)
+            return true;
+        if (ts.isFunctionLike(parent) ||
+            ts.isClassStaticBlockDeclaration(parent) ||
+            ts.isPropertyDeclaration(parent))
+            return false;
+    }
+    return false;
 }
 function stableCreateRequireBindingReason7(program, decl) {
     const cache = program.analysis.createRequireReasons;
@@ -2077,9 +2298,13 @@ function stableCreateRequireBindingReason7(program, decl) {
                 : checker.getSymbolAtLocation(ref);
             if (target && (target.flags & ts.SymbolFlags.Alias) !== 0)
                 target = checker.getAliasedSymbol(target);
-            if (target === symbol && !staticCreateRequireUse7(ref)) {
-                return "its createRequire binding is reassigned, escapes, or uses a computed specifier";
-            }
+            if (target !== symbol)
+                continue;
+            const use = createRequireUse7(ref);
+            if (use === "computed")
+                return COMPUTED_CREATE_REQUIRE_REASON;
+            if (use === "escaping")
+                return "its createRequire binding is reassigned or escapes";
         }
         const preceding = stmt.declarationList.declarations.nodes.slice(0, stmt.declarationList.declarations.nodes.indexOf(decl));
         if (bindingEarlyUse7(program, sf, sf.statements.nodes.indexOf(stmt), decl, preceding) !== null) {
@@ -2133,10 +2358,11 @@ function npmStaticModuleImportReason7(program, stmt) {
         checker.prefetchSymbolNodesExact(identifierOccurrences7(sf, specifier.name.text));
         let reason = null;
         const checkUse = (expr) => {
-            if (!staticCreateRequireUse7(expr)) {
-                reason =
-                    "its createRequire result escapes or is used with a computed specifier (static requires need literal specifiers)";
-            }
+            const use = createRequireUse7(expr);
+            if (use === "computed")
+                reason = COMPUTED_CREATE_REQUIRE_REASON;
+            else if (use === "escaping")
+                reason = "its createRequire result escapes (static requires need literal specifiers)";
         };
         ts.walkPreorder(sf, (node) => {
             if (reason ||
@@ -3091,7 +3317,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");
@@ -3314,9 +3540,13 @@ function exactCycleRefusal7(program, comp, lineOf) {
             if (ts.isExportAssignment(stmt) && !stmt.isExportEquals) {
                 return `the default export expression at ${lineOf(stmt)} has no initialization state inside the cycle`;
             }
+            // `export * from` binds each name to the declaring member's own
+            // binding, like a named re-export, so only `export * as ns` (a
+            // namespace object of a member) has state of its own.
             if (ts.isExportDeclaration(stmt) &&
                 !stmt.isTypeOnly &&
-                (stmt.exportClause === undefined || ts.isNamespaceExport(stmt.exportClause))) {
+                stmt.exportClause !== undefined &&
+                ts.isNamespaceExport(stmt.exportClause)) {
                 const dep = targetOf(stmt);
                 if (dep !== null && members.has(dep)) {
                     return `the namespace re-export at ${lineOf(stmt)} names a module of the cycle`;
@@ -4701,6 +4931,15 @@ function preflight7(load) {
             return false;
         return new RegExp(`\\btypeof\\s*\\(?\\s*${name.replace(/\$/g, "\\$")}(?![\\w$])`).test(sf.text);
     };
+    // A `return` at the top level of a CommonJS module (TS1108): Node runs
+    // the module as a function body, so the return ends the module's
+    // evaluation. ES modules and TypeScript keep the error.
+    const cjsTopLevelReturnSuppressed = (p, d) => {
+        if (d.code !== 1108 || d.fileName === undefined || !isJsSourceFileName(d.fileName))
+            return false;
+        const sf = p.getSourceFile(d.fileName);
+        return sf !== undefined && isCjsJsFile7(sf, p);
+    };
     const workspaceImplicitAnySuppressed = (p, d) => {
         if (d.code !== 7016 || d.fileName === undefined || d.pos === undefined || d.end === undefined)
             return false;
@@ -4748,6 +4987,7 @@ function preflight7(load) {
             !isNpmStaticSubclassArgument(p, d) &&
             !workspaceImplicitAnySuppressed(p, d) &&
             !typeofTestedNameSuppressed(p, d) &&
+            !cjsTopLevelReturnSuppressed(p, d) &&
             !jsdocTypeSuppressed(p, d, commentDup));
     };
     // The tsc gate, with a second chance: the LOWERING world's checker
@@ -5191,9 +5431,13 @@ function preflight7(load) {
                         // to Node's no-op, the module still evaluates through its
                         // ordinary init edge, and no member is ever read through the
                         // lexer facade (self-imports of a CJS module included — the
-                        // partially-built exports are never observed). Any OTHER use
-                        // keeps the fence.
-                        if (!nsBindingUsesAreBareStatements7(program, sf, clause.namedBindings.name)) {
+                        // partially-built exports are never observed). In JavaScript
+                        // sources every use passes here: member reads lower through the
+                        // names Node's lexer detects, and the other reads refuse at
+                        // their site (lower-namespaces.ts, cjsNamespaceImportDep). Any
+                        // OTHER use in TypeScript keeps the fence.
+                        if (!isJsSourceFileName(sf.fileName) &&
+                            !nsBindingUsesAreBareStatements7(program, sf, clause.namedBindings.name)) {
                             diags.push(unsupportedDiag("SC1013", locOf7(clause.namedBindings), "namespace imports of CommonJS modules"));
                         }
                     }
@@ -5221,17 +5465,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),
@@ -5260,8 +5507,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");
                             });
@@ -5423,9 +5670,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;
@@ -5576,6 +5828,111 @@ function preflight7(load) {
         moduleEdges: edges,
     };
 }
+/* ── the CJS named-import link check ─────────────────────────────────────
+ * Node builds a CommonJS module's ESM facade from its LEXER (cjs-lexer.ts
+ * mirrors it), never from execution — so a named import the checker binds
+ * happily can still fail Node's instantiate phase with a SyntaxError,
+ * thrown before ANY module in the graph evaluates. The checker's word is
+ * NOT Node's word exactly here, and shipping the checker's answer would
+ * diverge from Node without a diagnostic (`module.exports = { a: 7 }` served `a` where
+ * Node refuses the program). This walk asks Node's question at compile
+ * time, in Node's exact ORDER, and answers with Node's exact message. */
+/** The CommonJS program file a re-export (`module.exports = require(spec)`)
+ * of `from` resolves to, or null: reexport targets union in only when they
+ * resolve to CommonJS program files (Node's cjsPreparseModuleExports rule). */
+function cjsReexportDep7(program) {
+    return (from, spec) => {
+        const dep = resolveImport7(program, from, spec, "require") ??
+            npmStaticDepSf7(program, from, spec, "require");
+        return dep !== null && isCjsJsFile7(dep, program) ? dep : null;
+    };
+}
+/** Node's lexer analysis of a CommonJS file. A bundler rewrite spells some
+ * lexer-visible names as accessors. */
+function lexWithAccessorNames(sf) {
+    const lexed = cjsLexedExportsOfFile(sf);
+    for (const name of npmStaticLexerVisibleNames(sf.fileName))
+        lexed.exports.add(name);
+    return lexed;
+}
+/** The property names of Node's namespace object for the CommonJS module
+ * `dep`: the names its lexer detects, CommonJS re-exports included (the
+ * rule of the named-import link check), plus `default` and
+ * `module.exports`. */
+/** `dep` and every CommonJS module it re-exports, transitively (the modules
+ * whose exports its namespace object shows). */
+export function cjsReexportedModules(program, dep) {
+    const resolveDep = cjsReexportDep7(program);
+    const seen = new Set([dep]);
+    const order = [dep];
+    for (let i = 0; i < order.length; i++) {
+        const mod = order[i];
+        for (const spec of lexWithAccessorNames(mod).reexports) {
+            const next = resolveDep(mod, spec);
+            if (next !== null && !seen.has(next)) {
+                seen.add(next);
+                order.push(next);
+            }
+        }
+    }
+    return order;
+}
+export function cjsNamespaceExportNames(program, dep) {
+    const names = cjsVisibleNames(dep, lexWithAccessorNames, cjsReexportDep7(program), new Map());
+    return new Set([...names, "default", "module.exports"]);
+}
+/** The export names a CommonJS module assigns inside functions
+ * (`exports.current = value` in a function body), or "all" when such code
+ * writes a computed name, replaces module.exports or redefines exports
+ * through Object.defineProperty. Node's namespace object of the module
+ * holds the values the exports had when the module finished evaluating,
+ * so it does not see those writes. */
+export function cjsExportsAssignedInFunctions(sf) {
+    const names = new Set();
+    let all = false;
+    const exportsObject = (e) => (ts.isIdentifier(e) && e.text === "exports") || isModuleExportsAccess(e);
+    const target = (e) => {
+        while (ts.isParenthesizedExpression(e))
+            e = e.expression;
+        if (isModuleExportsAccess(e))
+            all = true;
+        else if (ts.isPropertyAccessExpression(e) && exportsObject(e.expression))
+            names.add(e.name.text);
+        else if (ts.isElementAccessExpression(e) && exportsObject(e.expression)) {
+            if (ts.isStringLiteralLike(e.argumentExpression))
+                names.add(e.argumentExpression.text);
+            else
+                all = true;
+        }
+    };
+    const visit = (node, inFunction) => {
+        if (all)
+            return;
+        const nested = inFunction || ts.isFunctionLike(node);
+        if (nested) {
+            if (ts.isBinaryExpression(node) &&
+                node.operatorToken.kind >= ts.SyntaxKind.FirstAssignment &&
+                node.operatorToken.kind <= ts.SyntaxKind.LastAssignment)
+                target(node.left);
+            else if ((ts.isPrefixUnaryExpression(node) || ts.isPostfixUnaryExpression(node)) &&
+                (node.operator === ts.SyntaxKind.PlusPlusToken ||
+                    node.operator === ts.SyntaxKind.MinusMinusToken))
+                target(node.operand);
+            else if (ts.isDeleteExpression(node))
+                target(node.expression);
+            else if (ts.isCallExpression(node) &&
+                ts.isPropertyAccessExpression(node.expression) &&
+                ts.isIdentifier(node.expression.expression) &&
+                node.expression.expression.text === "Object" &&
+                node.arguments.nodes[0] !== undefined &&
+                exportsObject(node.arguments.nodes[0]))
+                all = true;
+        }
+        ts.forEachChild(node, (child) => visit(child, nested));
+    };
+    visit(sf, false);
+    return all ? "all" : names;
+}
 /** Walks the entry's ESM instantiate graph exactly as V8 does — children
  * in request order, each module's own imports checked AFTER its children
  * (postorder), regular imports sorted by LOCAL name (code units), then
@@ -5601,25 +5958,14 @@ function cjsNamedImportLinkCheck(program, entry, moduleOrder, diags) {
         const npmStatic = npmStaticDepSf7(program, from, spec);
         return npmStatic;
     };
-    // Reexport targets union in only when they resolve to CommonJS program
-    // files (Node's cjsPreparseModuleExports rule).
-    const resolveCjsDep = (from, spec) => {
-        const dep = resolveImport7(program, from, spec, "require") ??
-            npmStaticDepSf7(program, from, spec, "require");
-        return dep !== null && isCjsJsFile7(dep, program) ? dep : null;
-    };
-    // A bundler rewrite spells some lexer-visible names as accessors.
-    const lexWithAccessorNames = (sf) => {
-        const lexed = cjsLexedExportsOfFile(sf);
-        for (const name of npmStaticLexerVisibleNames(sf.fileName))
-            lexed.exports.add(name);
-        return lexed;
-    };
+    const resolveCjsDep = cjsReexportDep7(program);
     const visible = (dep, name) => 
-    // `default` is the module.exports binding itself — always provided.
-    // The program already owns native source ASTs; reuse them without
-    // starting another syntax session or reparsing their source text.
+    // `default` and `module.exports` are the module.exports binding itself
+    // — always provided. The program already owns native source ASTs;
+    // reuse them without starting another syntax session or reparsing
+    // their source text.
     name === "default" ||
+        name === "module.exports" ||
         cjsVisibleNames(dep, lexWithAccessorNames, resolveCjsDep, lexMemo).has(name);
     /** The statement's resolved LOCAL CommonJS dependency, when it is an
      * import/re-export from one. */
@@ -5798,7 +6144,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();
@@ -6076,7 +6422,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. */