@scriptc/compiler 0.2.6 → 0.2.8

package/dist/frontend/program.js

@@ -201,11 +201,24 @@ function adoptProjectConfig7(host, entryPath) {
         adopted["paths"] = paths;
     }
     const nullChecks = adopted["strictNullChecks"] ?? adopted["strict"] ?? false;
-    if (nullChecks !== true) {
+    const forcedStrictNullChecks = nullChecks !== true;
+    if (forcedStrictNullChecks) {
         diags.push(strictNullChecksFloorDiag(configFile));
         adopted["strictNullChecks"] = true;
     }
-    return { configFile, options: { ...BASE_OPTIONS, ...adopted, ...FORCED_OPTIONS }, diags };
+    // The project's own library selection, kept only to explain errors: the
+    // checker always uses scriptc's fixed library set (FORCED_OPTIONS).
+    const rawLib = parsed.options["lib"];
+    const projectLib = Array.isArray(rawLib)
+        ? rawLib.filter((entry) => typeof entry === "string")
+        : undefined;
+    return {
+        configFile,
+        options: { ...BASE_OPTIONS, ...adopted, ...FORCED_OPTIONS },
+        diags,
+        ...(projectLib === undefined ? {} : { projectLib }),
+        forcedStrictNullChecks,
+    };
 }
 /** The target project's @types/node, resolved with the OWN resolver's
  * type-directive lookup anchored at the ENTRY (typeRoots-free — exactly the
@@ -538,6 +551,11 @@ function loadProgram7(host, entryPath, externalTypes = new Map()) {
             entry,
             moduleOrder: [],
             configDiags: config.diags,
+            typeWorld: {
+                nodeFallback: nodeTypes === null,
+                projectLib: config.projectLib ?? null,
+                forcedStrictNullChecks: config.forcedStrictNullChecks ?? false,
+            },
             externalTypes,
             externalTypeSpecifiersByFile,
             projectWorld: () => (projectWorld ??= host.createProgram(programRoots, options)),
@@ -1611,6 +1629,18 @@ function inTypePosition7(node) {
  * callback-invoking builtin, a getter, an iterator, or an implicit
  * coercion of a user object) disqualifies the module's cycles. */
 function nonInertTopLevel7(program, sf) {
+    const nonInert = topLevelInertness7(program);
+    for (const stmt of sf.statements) {
+        const offence = nonInert(stmt);
+        if (offence !== null)
+            return offence;
+    }
+    return null;
+}
+/** The per-statement form of nonInertTopLevel7: answers, for one
+ * top-level statement, the first construct that could execute user code
+ * while the statement runs, or null when the statement is inert. */
+function topLevelInertness7(program) {
     const checker = program.getTypeChecker();
     const PRIM = ts.TypeFlags.StringLike |
         ts.TypeFlags.NumberLike |
@@ -1779,7 +1809,7 @@ function nonInertTopLevel7(program, sf) {
         }
         return false;
     };
-    for (const stmt of sf.statements) {
+    return (stmt) => {
         if (ts.isImportDeclaration(stmt) ||
             ts.isExportDeclaration(stmt) ||
             ts.isImportEqualsDeclaration(stmt) ||
@@ -1790,20 +1820,13 @@ function nonInertTopLevel7(program, sf) {
             (ts.getCombinedModifierFlags(stmt) &
                 ts.ModifierFlags.Ambient) !==
                 0) {
-            continue;
+            return null;
         }
         if (ts.isEnumDeclaration(stmt)) {
-            const bad = stmt.members.find((m) => m.initializer !== undefined && !inert(m.initializer));
-            if (bad !== undefined)
-                return bad;
-            continue;
-        }
-        if (ts.isClassDeclaration(stmt)) {
-            const bad = inertClass(stmt);
-            if (bad !== null)
-                return bad;
-            continue;
+            return stmt.members.find((m) => m.initializer !== undefined && !inert(m.initializer)) ?? null;
         }
+        if (ts.isClassDeclaration(stmt))
+            return inertClass(stmt);
         if (ts.isVariableStatement(stmt)) {
             for (const d of stmt.declarationList.declarations) {
                 if (!ts.isIdentifier(d.name))
@@ -1811,21 +1834,15 @@ function nonInertTopLevel7(program, sf) {
                 if (d.initializer !== undefined && !inert(d.initializer))
                     return d.initializer;
             }
-            continue;
-        }
-        if (ts.isExpressionStatement(stmt)) {
-            if (!inert(stmt.expression))
-                return stmt;
-            continue;
+            return null;
         }
+        if (ts.isExpressionStatement(stmt))
+            return inert(stmt.expression) ? null : stmt;
         if (ts.isExportAssignment(stmt) && !stmt.isExportEquals) {
-            if (!inert(stmt.expression))
-                return stmt;
-            continue;
+            return inert(stmt.expression) ? null : stmt;
         }
         return stmt;
-    }
-    return null;
+    };
 }
 /** The head of a property/element-access chain. */
 function chainRoot7(e) {
@@ -1891,13 +1908,16 @@ function backEdgeUseOffence7(program, stmt, occurrences) {
  * e.dep already mid-initialization in a depth-first walk), answers null
  * to ADMIT the cycle — the guarded %init calls reproduce Node's cache-hit
  * order and nothing can observe the partial initialization — or the
- * human-readable reason it keeps the SC1016 fence. Two admission chances:
+ * human-readable reason it keeps the SC1016 fence. Three admission chances:
  *  - the CHEAP PER-EDGE rule: the closing statement binds nothing (a
  *    side-effect import) or binds only namespace objects whose every use
  *    is a bare expression statement — no read crosses the edge at all;
  *  - the DECLARATION-ONLY INIT WINDOW rule (the admission block above):
  *    every cluster member is an ES module with an inert top level, and
- *    the closing edge's bindings are used only in deferred positions.
+ *    the closing edge's bindings are used only in deferred positions;
+ *  - the EXACT INITIALIZATION rule (exactCycleRefusal7): partial
+ *    initialization is observable, but every observation is modeled —
+ *    the lowering checks each binding cycleEarlyBindings reports.
  * Tarjan SCCs (lazy, rooted at each queried importer) and cluster
  * verdicts are memoized across calls, so `edgesOf` must answer the same
  * edges for the same file every time. */
@@ -1948,10 +1968,11 @@ export function makeCycleAdmission(program, edgesOf) {
         const nsf = node.getSourceFile();
         return `${nsf.fileName}:${ts.getLineAndCharacterOfPosition(nsf, node.getStart(nsf)).line + 1}`;
     };
-    // Cluster verdict memo (keyed by the component array identity): the
-    // reason the cluster's cycles stay fenced, or null when its every
-    // member passes the inert-top-level bar.
+    // Cluster verdict memo (keyed by the component array identity): true
+    // when every member is an ES module passing the inert-top-level bar.
     const sccVerdict = new Map();
+    // The exact-initialization verdict, same keying (exactCycleRefusal7).
+    const exactVerdict = new Map();
     // A module can close many cycle edges, each importing many bindings.
     // Index its identifiers once for this admission pass. ASTs are immutable;
     // the pass owns the index so it cannot retain a disposed program.
@@ -1997,31 +2018,860 @@ export function makeCycleAdmission(program, edgesOf) {
             return "the cycle's module cluster could not be analyzed";
         }
         if (!sccVerdict.has(comp)) {
-            let reason = null;
-            for (const m of comp) {
-                if (isCjsJsFile7(m, program)) {
-                    reason = `${m.fileName} is a CommonJS module — admission covers ES-module cycles only`;
-                    break;
+            sccVerdict.set(comp, comp.every((m) => !isCjsJsFile7(m, program) && nonInertTopLevel7(program, m) === null));
+        }
+        if (sccVerdict.get(comp) === true &&
+            backEdgeUseOffence7(program, e.stmt, usesOf(importer)) === null) {
+            return null;
+        }
+        // The EXACT INITIALIZATION rule: the cycle runs in Node's evaluation
+        // order and every binding that can be observed before its declaration
+        // runs carries an initialization check (cycleEarlyBindings).
+        if (!exactVerdict.has(comp)) {
+            const reason = exactCycleRefusal7(program, comp, lineOf);
+            exactVerdict.set(comp, reason);
+            if (reason === null) {
+                const members = program.analysis.exactCycleMembers;
+                for (const m of comp)
+                    members.add(m);
+            }
+        }
+        return exactVerdict.get(comp) ?? null;
+    };
+}
+/* ── exact cyclic initialization ─────────────────────────────────────────
+ * Cycles that fail the declaration-only rule still evaluate exactly like
+ * Node when their shape is representable: the guarded %init calls already
+ * run every module body in ES evaluation order (depth-first postorder,
+ * a module mid-evaluation answered from the cache), function declarations
+ * are callable from the start, and live bindings are shared globals. What
+ * remains is the temporal dead zone: a let/const binding read before its
+ * declaration ran throws ReferenceError. cycleEarlyBindings finds every
+ * such binding whose read CAN run early; the lowering gives each one an
+ * initialization flag and checks it at every read or write that can run
+ * before the declaration. The shapes below have no such representation
+ * and keep the SC1016 fence. */
+/** The modules of `program` whose import cycles were admitted by the
+ * exact initialization rule (not the declaration-only rule). */
+export function exactCycleMembers(program) {
+    return program.analysis.exactCycleMembers;
+}
+/** True when the module's top level (outside every function-like body)
+ * contains `await` or `for await`. */
+function hasTopLevelAwait7(sf) {
+    let found = false;
+    ts.walkPreorder(sf, (node) => {
+        if (found)
+            return "stop";
+        if (node !== sf && ts.isFunctionLike(node))
+            return "skip";
+        if (ts.isAwaitExpression(node) ||
+            (ts.isForOfStatement(node) && node.awaitModifier !== undefined)) {
+            found = true;
+            return "stop";
+        }
+        return undefined;
+    });
+    return found;
+}
+/** The reason a strongly-connected module cluster cannot be initialized
+ * exactly, or null when it can. */
+function exactCycleRefusal7(program, comp, lineOf) {
+    const members = new Set(comp);
+    const targetOf = (stmt) => {
+        const spec = stmt.moduleSpecifier;
+        if (spec === undefined || !ts.isStringLiteral(spec))
+            return null;
+        const sf = stmt.getSourceFile();
+        return resolveImport7(program, sf, spec.text) ?? npmStaticDepSf7(program, sf, spec.text);
+    };
+    for (const m of comp) {
+        if (isCjsJsFile7(m, program) || /\.c[jt]s$/.test(m.fileName)) {
+            return `${m.fileName} is a CommonJS module — cyclic initialization covers ES modules only`;
+        }
+        if (hasTopLevelAwait7(m)) {
+            return `${m.fileName} uses top-level await inside the cycle`;
+        }
+        for (const stmt of m.statements) {
+            if (ts.isExportAssignment(stmt) && !stmt.isExportEquals) {
+                return `the default export expression at ${lineOf(stmt)} has no initialization state inside the cycle`;
+            }
+            if (ts.isExportDeclaration(stmt) &&
+                !stmt.isTypeOnly &&
+                (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`;
                 }
-                const off = nonInertTopLevel7(program, m);
-                if (off !== null) {
-                    reason = `top-level code at ${lineOf(off)} can run user code during the cycle's init window — only declaration-only module bodies are admitted`;
-                    break;
+            }
+            if (ts.isImportDeclaration(stmt) &&
+                stmt.importClause !== undefined &&
+                !stmt.importClause.isTypeOnly &&
+                stmt.importClause.namedBindings !== undefined &&
+                ts.isNamespaceImport(stmt.importClause.namedBindings)) {
+                const dep = targetOf(stmt);
+                const nsName = stmt.importClause.namedBindings.name;
+                if (dep !== null &&
+                    members.has(dep) &&
+                    !nsBindingUsesAreBareStatements7(program, m, nsName)) {
+                    return `the namespace import '${nsName.text}' at ${lineOf(stmt)} names a module of the cycle`;
                 }
             }
-            sccVerdict.set(comp, reason);
+            if (ts.isClassDeclaration(stmt) && stmt.name === undefined) {
+                return `the anonymous default class at ${lineOf(stmt)} has no initialization state inside the cycle`;
+            }
+            const ambient = (ts.getCombinedModifierFlags(stmt) &
+                ts.ModifierFlags.Ambient) !==
+                0;
+            if (ambient)
+                continue;
+            if (ts.isEnumDeclaration(stmt) &&
+                (ts.getCombinedModifierFlags(stmt) & ts.ModifierFlags.Const) === 0) {
+                return `the enum '${stmt.name.text}' at ${lineOf(stmt)} has no initialization state inside the cycle`;
+            }
+            if (ts.isModuleDeclaration(stmt) && !typeOnlyNamespace7(stmt)) {
+                return `the namespace at ${lineOf(stmt)} has no initialization state inside the cycle`;
+            }
         }
-        const clusterReason = sccVerdict.get(comp);
-        if (clusterReason === undefined)
-            throw new Error("missing module-cycle verdict");
-        if (clusterReason !== null)
-            return clusterReason;
-        const use = backEdgeUseOffence7(program, e.stmt, usesOf(importer));
-        if (use !== null) {
-            return `the cycle-crossing binding '${use.name}' is read at ${lineOf(use.node)}, outside any function body — a read during the init window observes the partially-initialized module (Node's TDZ ReferenceError / stale var), which is not modeled`;
+    }
+    return null;
+}
+/** Every binding of the program's exactly-initialized cycles that can be
+ * observed before its declaration executes. `order` is the compiled module
+ * order; `singleRoot` is false when more than one module graph root runs
+ * (fork or worker entries), so a cycle can be entered at different
+ * members. With one root and a purely ES-module graph the evaluation order
+ * is static and the analysis is precise up to "user code may run": a
+ * binding needs its check when its declaration completes after some
+ * top-level code that can call user functions and a deferred position
+ * (function body, parameter default, instance field) references it, or
+ * when the top level of a cycle member evaluated before it reads it.
+ * Otherwise every deferred reference and every top-level reference from
+ * another member counts. */
+export function cycleEarlyBindings(program, entry, order, singleRoot) {
+    const exact = program.analysis.exactCycleMembers;
+    if (exact.size === 0)
+        return [];
+    // Every lowering pass of one compile asks with the same inputs.
+    const key = `${entry.fileName}\0${order.map((sf) => sf.fileName).join("\0")}\0${singleRoot}`;
+    const memo = program.analysis.cycleEarlyBindings;
+    if (memo !== null && memo.key === key)
+        return memo.bindings;
+    const bindings = computeCycleEarlyBindings7(program, entry, order, singleRoot, exact);
+    program.analysis.cycleEarlyBindings = { key, bindings };
+    return bindings;
+}
+function computeCycleEarlyBindings7(program, entry, order, singleRoot, exact) {
+    const inOrder = new Set(order);
+    const members = [...exact].filter((m) => inOrder.has(m));
+    if (members.length === 0)
+        return [];
+    const memberSet = new Set(members);
+    const depsOf = (sf) => orderedImportsOf(program, sf).flatMap(({ dep }) => dep !== null && dep !== sf && inOrder.has(dep) ? [dep] : []);
+    // Strongly-connected components among the exactly-initialized members.
+    const comps = [];
+    {
+        const index = new Map();
+        const low = new Map();
+        const onStack = new Set();
+        const stack = [];
+        let next = 0;
+        const connect = (v) => {
+            index.set(v, next);
+            low.set(v, next);
+            next++;
+            stack.push(v);
+            onStack.add(v);
+            for (const w of depsOf(v)) {
+                if (!memberSet.has(w))
+                    continue;
+                if (!index.has(w)) {
+                    connect(w);
+                    low.set(v, Math.min(low.get(v), low.get(w)));
+                }
+                else if (onStack.has(w)) {
+                    low.set(v, Math.min(low.get(v), index.get(w)));
+                }
+            }
+            if (low.get(v) === index.get(v)) {
+                const comp = [];
+                for (;;) {
+                    const w = stack.pop();
+                    onStack.delete(w);
+                    comp.push(w);
+                    if (w === v)
+                        break;
+                }
+                if (comp.length > 1)
+                    comps.push(comp);
+            }
+        };
+        for (const m of members)
+            if (!index.has(m))
+                connect(m);
+    }
+    if (comps.length === 0)
+        return [];
+    // The static evaluation order: Node's depth-first postorder from the
+    // entry over ES import edges. Known only for one root and a graph with
+    // no CommonJS module (a require() evaluates its target mid-body).
+    const position = new Map();
+    if (singleRoot &&
+        !order.some((sf) => isCjsJsFile7(sf, program) || /\.c[jt]s$/.test(sf.fileName))) {
+        const seen = new Set();
+        const visit = (sf) => {
+            seen.add(sf);
+            for (const dep of depsOf(sf))
+                if (!seen.has(dep))
+                    visit(dep);
+            position.set(sf, position.size);
+        };
+        visit(entry);
+    }
+    const checker = program.getTypeChecker();
+    const nonInert = topLevelInertness7(program);
+    const out = [];
+    for (const comp of comps) {
+        const known = comp.every((m) => position.has(m));
+        const evaluation = known
+            ? comp.slice().sort((a, b) => position.get(a) - position.get(b))
+            : comp.slice();
+        const candidates = new Map();
+        const names = new Set();
+        let dirty = !known;
+        evaluation.forEach((m, rank) => {
+            for (const stmt of m.statements) {
+                const offence = nonInert(stmt);
+                const exposed = dirty || offence !== null;
+                const declared = [];
+                if (ts.isVariableStatement(stmt) &&
+                    (ts.getCombinedModifierFlags(stmt) &
+                        ts.ModifierFlags.Ambient) ===
+                        0) {
+                    const lexical = (stmt.declarationList.flags & (ts.NodeFlags.Let | ts.NodeFlags.Const)) !== 0;
+                    for (const d of stmt.declarationList.declarations) {
+                        for (const name of boundNames7(d.name)) {
+                            declared.push({ name, kind: lexical ? "lexical" : "var" });
+                        }
+                    }
+                }
+                else if (ts.isClassDeclaration(stmt) && stmt.name !== undefined) {
+                    declared.push({ name: stmt.name, kind: "class" });
+                }
+                for (const { name, kind } of declared) {
+                    const symbol = checker.getSymbolAtLocation(name);
+                    if (symbol === undefined)
+                        continue;
+                    candidates.set(symbol, {
+                        symbol,
+                        name,
+                        kind,
+                        module: m,
+                        exposed,
+                        rank,
+                        start: stmt.getStart(m),
+                        end: stmt.getEnd(),
+                        reference: null,
+                        folded: null,
+                    });
+                    names.add(name.text);
+                }
+                if (offence !== null)
+                    dirty = true;
+            }
+        });
+        if (candidates.size === 0)
+            continue;
+        const rankOf = new Map(evaluation.map((m, i) => [m, i]));
+        // References: every identifier spelled like a candidate, resolved
+        // through import aliases to the declaration's symbol.
+        for (const sf of order) {
+            const refs = [];
+            ts.walkPreorder(sf, (node) => {
+                if (ts.isImportDeclaration(node))
+                    return "skip";
+                if (ts.isIdentifier(node) && names.has(node.text))
+                    refs.push(node);
+                return undefined;
+            });
+            if (refs.length === 0)
+                continue;
+            checker.prefetchSymbolNodesExact(refs);
+            for (const ref of refs) {
+                const parent = ref.parent;
+                if (parent !== undefined && ts.isExportSpecifier(parent))
+                    continue;
+                if (inTypePosition7(ref))
+                    continue;
+                let symbol = checker.getSymbolAtLocation(ref);
+                if (parent !== undefined &&
+                    ts.isShorthandPropertyAssignment(parent) &&
+                    parent.name === ref) {
+                    symbol = checker.getShorthandAssignmentValueSymbol(parent) ?? symbol;
+                }
+                if (symbol !== undefined && symbol.flags & ts.SymbolFlags.Alias) {
+                    symbol = checker.getAliasedSymbol(symbol);
+                }
+                const c = symbol === undefined ? undefined : candidates.get(symbol);
+                if (c === undefined || ref === c.name)
+                    continue;
+                if (c.folded === null && foldablePosition7(ref))
+                    c.folded = ref;
+                if (c.reference !== null)
+                    continue;
+                // A class body names its own inner binding, initialized throughout.
+                if (c.kind === "class" &&
+                    sf === c.module &&
+                    ref.getStart(sf) >= c.start &&
+                    ref.getEnd() <= c.end)
+                    continue;
+                let early;
+                if (inDeferredPosition7(ref))
+                    early = c.exposed;
+                else if (sf === c.module)
+                    early = ref.getStart(sf) < c.start;
+                else if (!memberSet.has(sf) || !rankOf.has(sf))
+                    early = false;
+                else
+                    early = !known || rankOf.get(sf) < c.rank;
+                if (early)
+                    c.reference = ref;
+            }
+        }
+        for (const c of candidates.values()) {
+            if (c.reference === null)
+                continue;
+            const settled = new Set(order.filter((sf) => !rankOf.has(sf)));
+            if (known)
+                for (const m of evaluation.slice(c.rank + 1))
+                    settled.add(m);
+            out.push({
+                symbol: c.symbol,
+                name: c.name,
+                kind: c.kind,
+                module: c.module,
+                reference: c.reference,
+                ...(c.folded !== null ? { folded: c.folded } : {}),
+                settled,
+            });
+        }
+    }
+    return out;
+}
+/** Top-level let/const bindings, in modules outside the exactly-initialized
+ * cycles, that code running before their declaration completes can read.
+ * Function declarations are callable from the module's start, so a call
+ * made by earlier top-level code (or by the declaration's own initializer)
+ * can observe the temporal dead zone. Reachability is syntactic: 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, and every other function-like in
+ * reachable code counts as reachable because it may be handed to a callee.
+ * A binding is reported only when one of its references in a deferred
+ * position is reachable before the declaration ran, so modules that call
+ * nothing early report nothing. Bindings of exactly-initialized cycles are
+ * covered by cycleEarlyBindings. */
+export function moduleEarlyBindings(program, order) {
+    const key = order.map((sf) => sf.fileName).join("\0");
+    const memo = program.analysis.moduleEarlyBindings;
+    if (memo !== null && memo.key === key)
+        return memo.bindings;
+    const exact = program.analysis.exactCycleMembers;
+    const out = [];
+    for (const sf of order) {
+        if (sf.isDeclarationFile || exact.has(sf))
+            continue;
+        out.push(...moduleEarlyBindingsOf7(program, sf, order));
+    }
+    program.analysis.moduleEarlyBindings = { key, bindings: out };
+    return out;
+}
+function moduleEarlyBindingsOf7(program, sf, order) {
+    const ambient = (stmt) => (ts.getCombinedModifierFlags(stmt) & ts.ModifierFlags.Ambient) !==
+        0;
+    const candidates = [];
+    const candidateNames = new Set();
+    // Stored callables, by the name of the binding that stores them.
+    const stored = new Set();
+    const storedBy = new Map();
+    // Parts of a stored node that run where it is evaluated: a class's
+    // heritage, computed keys, decorators and static initializers, and a
+    // stored method's computed key.
+    const immediate = new Map();
+    const store = (name, units) => {
+        if (units.length === 0)
+            return;
+        for (const u of units)
+            stored.add(u);
+        const list = storedBy.get(name.text) ?? [];
+        list.push({ name, units });
+        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) {
+                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)
+                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.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);
+            });
         }
-        return null;
     };
+    sf.statements.forEach((stmt, index) => {
+        if (ambient(stmt))
+            return;
+        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)) {
+            const lexical = (stmt.declarationList.flags & (ts.NodeFlags.Let | ts.NodeFlags.Const)) !== 0;
+            for (const d of stmt.declarationList.declarations) {
+                if (ts.isIdentifier(d.name) && d.initializer !== undefined) {
+                    const units = [];
+                    storedIn(d.initializer, units);
+                    store(d.name, units);
+                }
+                if (!lexical)
+                    continue;
+                for (const name of boundNames7(d.name)) {
+                    candidates.push({ name, index, start: stmt.getStart(sf) });
+                    candidateNames.add(name.text);
+                }
+            }
+        }
+    });
+    if (candidates.length === 0)
+        return [];
+    // Resolve every identifier that could name a candidate or a stored
+    // callable in one batch.
+    const idents = [];
+    ts.walkPreorder(sf, (node) => {
+        if (ts.isImportDeclaration(node))
+            return "skip";
+        if (ts.isIdentifier(node) && (candidateNames.has(node.text) || storedBy.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;
+    };
+    // A callback handed to a timer, a microtask queue, a promise reaction or
+    // a host (Node) API runs as a later job or event. Without top-level await
+    // the module's body completes before any job runs, so such a callback is
+    // never early. JavaScript builtins (array callbacks, the promise
+    // executor, replacers) and the host APIs that call back synchronously
+    // keep the conservative rule.
+    if (!hasTopLevelAwait7(sf)) {
+        const callbacks = (e) => {
+            while (ts.isParenthesizedExpression(e))
+                e = e.expression;
+            if (ts.isArrowFunction(e) || ts.isFunctionExpression(e))
+                stored.add(e);
+            else if (ts.isObjectLiteralExpression(e)) {
+                for (const p of e.properties) {
+                    if (ts.isMethodDeclaration(p))
+                        stored.add(p);
+                    else if (ts.isPropertyAssignment(p))
+                        callbacks(p.initializer);
+                }
+            }
+        };
+        ts.walkPreorder(sf, (node) => {
+            if ((ts.isCallExpression(node) || ts.isNewExpression(node)) &&
+                laterJobCallee7(checker, node.expression)) {
+                for (const arg of node.arguments ?? [])
+                    callbacks(arg);
+            }
+            return undefined;
+        });
+    }
+    const unitsBySymbol = new Map();
+    for (const list of storedBy.values()) {
+        for (const { name, units } of list) {
+            const symbol = checker.getSymbolAtLocation(name);
+            if (symbol === undefined)
+                continue;
+            unitsBySymbol.set(symbol, [...(unitsBySymbol.get(symbol) ?? []), ...units]);
+        }
+    }
+    const candidateSymbols = new Map();
+    for (const c of candidates) {
+        const symbol = checker.getSymbolAtLocation(c.name);
+        if (symbol !== undefined)
+            candidateSymbols.set(symbol, c);
+    }
+    // Walk reachable code, collecting the candidate references it holds.
+    const reachedUnits = new Set();
+    const reachedRefs = new Map();
+    const work = [];
+    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 (!ts.isIdentifier(node))
+                return undefined;
+            if (!candidateNames.has(node.text) && !storedBy.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;
+            const c = candidateSymbols.get(symbol);
+            if (c !== undefined && node !== c.name && !reachedRefs.has(symbol)) {
+                if (inDeferredPosition7(node) || node.getStart(sf) < c.start)
+                    reachedRefs.set(symbol, node);
+            }
+            for (const unit of unitsBySymbol.get(symbol) ?? []) {
+                if (reachedUnits.has(unit))
+                    continue;
+                reachedUnits.add(unit);
+                work.push(unit);
+            }
+            return undefined;
+        });
+    };
+    const drain = () => {
+        while (work.length > 0)
+            visit(work.pop());
+    };
+    const out = [];
+    const settled = new Set(order.filter((m) => m !== sf));
+    let next = 0;
+    const report = (declaration) => {
+        while (next < candidates.length &&
+            candidates[next].name.getStart(sf) >= declaration.getStart(sf) &&
+            candidates[next].name.getEnd() <= declaration.getEnd()) {
+            const c = candidates[next++];
+            const symbol = checker.getSymbolAtLocation(c.name);
+            const reference = symbol === undefined ? undefined : reachedRefs.get(symbol);
+            if (symbol === undefined || reference === undefined)
+                continue;
+            out.push({ symbol, name: c.name, kind: "lexical", module: sf, reference, settled });
+        }
+    };
+    for (const stmt of sf.statements) {
+        if (ts.isClassDeclaration(stmt))
+            for (const part of classSyncParts7(stmt))
+                visit(part);
+        else if (ts.isVariableStatement(stmt)) {
+            // Declarators run in order: a later declarator's initializer cannot
+            // observe an earlier binding before it was initialized.
+            for (const d of stmt.declarationList.declarations) {
+                visit(d);
+                drain();
+                report(d);
+            }
+        }
+        else if (!ts.isFunctionDeclaration(stmt))
+            visit(stmt);
+        drain();
+    }
+    return out;
+}
+/** True when the program function `callee` names reads its parameter
+ * `index` only inside function expressions it returns directly, and never
+ * through `arguments` in its own body: calling it cannot run that argument
+ * before the returned closure is called. */
+function returnsOnlyClosuresOver7(checker, callee, index) {
+    while (ts.isParenthesizedExpression(callee))
+        callee = callee.expression;
+    const name = ts.isIdentifier(callee)
+        ? callee
+        : ts.isPropertyAccessExpression(callee) && ts.isIdentifier(callee.name)
+            ? callee.name
+            : undefined;
+    if (name === undefined)
+        return false;
+    let symbol = checker.getSymbolAtLocation(name);
+    if (symbol !== undefined && symbol.flags & ts.SymbolFlags.Alias) {
+        symbol = checker.getAliasedSymbol(symbol);
+    }
+    const decls = symbol === undefined ? [] : checker.declarationsOf(symbol);
+    if (decls.length !== 1)
+        return false;
+    const decl = decls[0];
+    if (decl.getSourceFile().isDeclarationFile)
+        return false;
+    let fn;
+    if (ts.isFunctionDeclaration(decl))
+        fn = decl;
+    else if (ts.isVariableDeclaration(decl) && decl.initializer !== undefined) {
+        let init = decl.initializer;
+        while (ts.isParenthesizedExpression(init))
+            init = init.expression;
+        if (ts.isFunctionExpression(init) || ts.isArrowFunction(init))
+            fn = init;
+    }
+    if (fn === undefined)
+        return false;
+    const like = fn;
+    const body = like.body;
+    const param = like.parameters[index];
+    if (body === undefined || !ts.isBlock(body) || param === undefined)
+        return false;
+    if (!ts.isIdentifier(param.name) || param.dotDotDotToken !== undefined)
+        return false;
+    if (like.parameters.slice(0, index).some((p) => p.dotDotDotToken !== undefined))
+        return false;
+    const paramName = param.name.text;
+    let deferred = true;
+    ts.walkPreorder(body, (node) => {
+        if (!deferred)
+            return "stop";
+        if (ts.isFunctionLike(node) || ts.isClassExpression(node) || ts.isClassDeclaration(node)) {
+            let child = node;
+            while (ts.isParenthesizedExpression(child.parent))
+                child = child.parent;
+            const returned = ts.isReturnStatement(child.parent) && child.parent.expression === child;
+            const uses = (part) => {
+                let found = false;
+                ts.walkPreorder(part, (inner) => {
+                    if (ts.isIdentifier(inner) && inner.text === paramName)
+                        found = true;
+                    return found ? "stop" : undefined;
+                });
+                return found;
+            };
+            // A returned closure may use the parameter; any other nested
+            // function could escape and run before the result is called. A
+            // returned class still evaluates its heritage, computed keys,
+            // decorators and static initializers when the callee runs.
+            if (returned) {
+                if ((ts.isClassExpression(node) || ts.isClassDeclaration(node)) &&
+                    classSyncParts7(node).some(uses))
+                    deferred = false;
+                return "skip";
+            }
+            if (uses(node))
+                deferred = false;
+            return "skip";
+        }
+        if (ts.isIdentifier(node) && (node.text === paramName || node.text === "arguments")) {
+            if (node !== param.name)
+                deferred = false;
+        }
+        return undefined;
+    });
+    return deferred;
+}
+/** The parts of a class that run where the class is evaluated: heritage
+ * expressions, decorators, computed member keys, static field
+ * initializers and static blocks. Methods and instance fields wait for a
+ * call or a construction. */
+function classSyncParts7(c) {
+    const decorators = (n) => (n.modifiers ?? []).filter((m) => m.kind === ts.SyntaxKind.Decorator);
+    const parts = [...decorators(c), ...(c.heritageClauses ?? [])];
+    for (const m of c.members) {
+        parts.push(...decorators(m));
+        const memberName = m.name;
+        if (memberName !== undefined && ts.isComputedPropertyName(memberName))
+            parts.push(memberName);
+        if (ts.isClassStaticBlockDeclaration(m))
+            parts.push(m);
+        else if (ts.isPropertyDeclaration(m) &&
+            m.initializer !== undefined &&
+            (ts.getCombinedModifierFlags(m) & ts.ModifierFlags.Static) !== 0)
+            parts.push(m.initializer);
+    }
+    return parts;
+}
+/** An identifier or a chain of plain property reads. */
+function memberChainKey7(e) {
+    while (ts.isPropertyAccessExpression(e))
+        e = e.expression;
+    return ts.isIdentifier(e);
+}
+/** The name a declaration node binds, if any. */
+function declaredName7(node) {
+    if (ts.isVariableDeclaration(node) ||
+        ts.isFunctionDeclaration(node) ||
+        ts.isFunctionExpression(node) ||
+        ts.isClassDeclaration(node) ||
+        ts.isClassExpression(node) ||
+        ts.isBindingElement(node) ||
+        ts.isParameter(node))
+        return node.name;
+    return undefined;
+}
+/** A declared builtin whose callback arguments run only as later jobs or
+ * events: the timers, queueMicrotask, promise reactions, and Node APIs
+ * other than the ones that call back before returning. */
+function laterJobCallee7(checker, callee) {
+    while (ts.isParenthesizedExpression(callee))
+        callee = callee.expression;
+    let name;
+    if (ts.isIdentifier(callee))
+        name = callee;
+    else if (ts.isPropertyAccessExpression(callee) && ts.isIdentifier(callee.name)) {
+        name = callee.name;
+    }
+    else
+        return false;
+    if (SYNC_CALLBACK_HOST_APIS7.has(name.text))
+        return false;
+    let root = callee;
+    while (ts.isPropertyAccessExpression(root))
+        root = root.expression;
+    if (ts.isIdentifier(root) && root.text === "assert")
+        return false;
+    let symbol = checker.getSymbolAtLocation(name);
+    if (symbol !== undefined && symbol.flags & ts.SymbolFlags.Alias) {
+        symbol = checker.getAliasedSymbol(symbol);
+    }
+    if (symbol === undefined)
+        return false;
+    const decls = checker.declarationsOf(symbol);
+    if (decls.length === 0 || !decls.every((d) => d.getSourceFile().isDeclarationFile))
+        return false;
+    if (LATER_JOB_BUILTINS7.has(name.text))
+        return true;
+    // The JavaScript standard library's callbacks mostly run synchronously;
+    // package declarations describe user code.
+    return decls.every((d) => {
+        const file = d.getSourceFile().fileName;
+        return isNodeTypesPath(file) || file === fallbackDtsPath();
+    });
+}
+/** Standard-library functions whose callbacks run as later jobs. */
+const LATER_JOB_BUILTINS7 = new Set([
+    "setTimeout",
+    "setInterval",
+    "setImmediate",
+    "queueMicrotask",
+    "then",
+    "catch",
+    "finally",
+]);
+/** Host APIs that can invoke a callback argument before returning. */
+const SYNC_CALLBACK_HOST_APIS7 = new Set([
+    "apply",
+    "bind",
+    "call",
+    "doesNotReject",
+    "doesNotThrow",
+    "emit",
+    "enterWith",
+    "exit",
+    "rejects",
+    "run",
+    "runInAsyncScope",
+    "throws",
+]);
+/** True for a reference whose value the lowering can take from the
+ * binding's checker type instead of its storage: a property key (element
+ * access argument, computed name, `in` operand, through parentheses,
+ * casts and template spans) or a `typeof` operand. */
+function foldablePosition7(ref) {
+    let child = ref;
+    for (let p = ref.parent; p !== undefined; p = p.parent) {
+        if (ts.isParenthesizedExpression(p) ||
+            ts.isAsExpression(p) ||
+            ts.isSatisfiesExpression(p) ||
+            ts.isNonNullExpression(p) ||
+            ts.isTemplateSpan(p) ||
+            ts.isTemplateExpression(p)) {
+            child = p;
+            continue;
+        }
+        if (ts.isTypeOfExpression(p))
+            return true;
+        if (ts.isElementAccessExpression(p))
+            return p.argumentExpression === child;
+        if (ts.isComputedPropertyName(p))
+            return true;
+        if (ts.isBinaryExpression(p))
+            return p.operatorToken.kind === ts.SyntaxKind.InKeyword && p.left === child;
+        return false;
+    }
+    return false;
+}
+/** The identifiers a binding name (identifier or destructuring pattern)
+ * declares. */
+function boundNames7(name) {
+    if (ts.isIdentifier(name))
+        return [name];
+    const out = [];
+    for (const el of name.elements) {
+        if (ts.isOmittedExpression(el) || el.name === undefined)
+            continue;
+        out.push(...boundNames7(el.name));
+    }
+    return out;
+}
+/** A namespace declaration whose body holds only types (interfaces, type
+ * aliases, nested type-only namespaces) — no runtime object exists. */
+function typeOnlyNamespace7(decl) {
+    let body = decl.body;
+    while (body !== undefined && ts.isModuleDeclaration(body))
+        body = body.body;
+    if (body === undefined || !ts.isModuleBlock(body))
+        return true;
+    return body.statements.every((s) => ts.isInterfaceDeclaration(s) ||
+        ts.isTypeAliasDeclaration(s) ||
+        (ts.isModuleDeclaration(s) && typeOnlyNamespace7(s)));
 }
 /** Resolves an import specifier from `from` to a source file of the
  * program, or null (unresolvable / outside the program). Exported (as
@@ -2191,7 +3041,13 @@ function preflight7(load) {
         const file = d.fileName ?? entry.fileName;
         const start = d.fileName !== undefined ? d.pos : 0;
         const end = d.fileName !== undefined ? d.end : 0;
-        return tscPassthroughDiag(message, { file, start, end });
+        const diag = tscPassthroughDiag(message, { file, start, end });
+        const hint = typeWorldHint(d, message, load);
+        if (hint !== null) {
+            diag.typeWorld = true;
+            diag.hint = hint;
+        }
+        return diag;
     };
     /* TS7 checker change (not finding 5, same discipline): tsgo types a
      * NAMESPACE import as the spec's non-callable module namespace object
@@ -2450,10 +3306,9 @@ function preflight7(load) {
     // benign-cycle admission block above). Node evaluates such cycles
     // benignly (the revisited module is a cache hit, and no binding read
     // can hit TDZ or a stale slot), so the guarded %init calls reproduce
-    // its order exactly. Cycles that fail both keep the SC1016 fence,
-    // because a read through them mid-cycle observes TDZ (let/const) or
-    // undefined (var) in Node — runtime evaluation-order semantics the
-    // static story does not model.
+    // its order exactly. Cycles that fail both are judged by the exact
+    // initialization rule: admitted when every early read is modeled by an
+    // initialization check, fenced with SC1016 otherwise.
     const edges = new Map();
     const refusals = new Map();
     const depPositions = new Map();
@@ -2927,9 +3782,10 @@ function preflight7(load) {
     // Node's evaluation order: depth-first postorder from the entry, each
     // module once, back-edges answered from the cache (a module already
     // evaluating is skipped) — which the guarded %init calls reproduce
-    // exactly. Cycles are admitted only where Node's partially-initialized
-    // semantics are UNOBSERVABLE (JS's partial-initialization is otherwise a
-    // silent-misbehavior trap, so SC1016 stays for the rest):
+    // exactly. Cycles are admitted where Node's partially-initialized
+    // semantics are UNOBSERVABLE or exactly modeled (JS's partial
+    // initialization is otherwise a silent-misbehavior trap, so SC1016
+    // stays for the rest):
     //  - a DIRECT SELF-IMPORT (the package self-name reference resolving to
     //    the importing module itself — Node's self-reference rule): the
     //    imported bindings alias the module's OWN top-level bindings with
@@ -2941,7 +3797,11 @@ function preflight7(load) {
     //    benign-cycle admission block: every module of the cycle's
     //    strongly-connected component has an inert top level and the
     //    closing edge's bindings are used only in deferred positions, so no
-    //    read can execute before every member initialized).
+    //    read can execute before every member initialized);
+    //  - the EXACT INITIALIZATION rule: an ES-module cluster whose early
+    //    reads are all let/const bindings with module storage — the
+    //    lowering checks each one (cycleEarlyBindings) and throws Node's
+    //    ReferenceError on a read before the declaration ran.
     const cycleAdmissionReason = makeCycleAdmission(program, (sf) => edges.get(sf) ?? []);
     const order = [];
     const state = new Map();
@@ -2957,9 +3817,9 @@ function preflight7(load) {
                 continue;
             if (s === "visiting") {
                 // A back-edge: Node answers it from the cache (the module is
-                // already evaluating) — benign exactly when nothing can observe
-                // the partial initialization through this edge's bindings, by the
-                // cheap per-edge rule or the declaration-only init window rule.
+                // already evaluating) — admitted by the cheap per-edge rule, the
+                // declaration-only init window rule, or the exact initialization
+                // rule.
                 const reason = cycleAdmissionReason(sf, e);
                 if (reason !== null) {
                     const cycleStart = stack.indexOf(e.dep.fileName);
@@ -3768,4 +4628,121 @@ export function isCjsExportTableLiteral(obj) {
     }
     return false;
 }
+/** Names other runtimes and the DOM declare that scriptc's type world
+ * (the ES2025 library plus Node types) does not. */
+const FOREIGN_RUNTIME_GLOBALS = new Set(["Deno", "Bun"]);
+const DOM_GLOBALS = new Set([
+    "window",
+    "document",
+    "navigator",
+    "location",
+    "localStorage",
+    "sessionStorage",
+    "HTMLElement",
+    "Element",
+    "Document",
+    "Window",
+    "BodyInit",
+    "HeadersInit",
+    "RequestInfo",
+    "XMLHttpRequest",
+    "requestAnimationFrame",
+]);
+/** Root identifiers whose members the bundled Node fallback declares. */
+const NODE_GLOBAL_ROOTS = new Set(["process", "Buffer", "console", "globalThis"]);
+/** A hint when a TypeScript error comes from scriptc's own type world rather
+ * than from the project: a library member newer than ES2025, a global of
+ * another runtime or of the DOM, a Node member the bundled fallback types
+ * leave out, or the strictNullChecks scriptc enforces. Null otherwise. */
+function typeWorldHint(d, message, load) {
+    const world = load.typeWorld;
+    if (world === undefined)
+        return null;
+    const quoted = /'([^']+)'/.exec(message)?.[1];
+    // TS2304/TS2552: Cannot find name; TS2580/TS2591/TS2592: missing type
+    // packages; TS2583: needs a newer library.
+    if (d.code === 2304 || d.code === 2552 || d.code === 2583) {
+        if (quoted !== undefined && FOREIGN_RUNTIME_GLOBALS.has(quoted)) {
+            return `'${quoted}' is another runtime's global; scriptc's type world declares the ES2025 library and Node only — feature-test it through globalThis instead, e.g. '(globalThis as { ${quoted}?: unknown }).${quoted}' (the native program runs as Node would, where it is undefined)`;
+        }
+        if (quoted !== undefined && DOM_GLOBALS.has(quoted)) {
+            return `'${quoted}' comes from the DOM library, which scriptc's type world does not include (it checks with the ES2025 library and Node types regardless of the project's "lib") — declare the shape you need locally, or move browser-only code out of the program`;
+        }
+        if (d.code === 2583) {
+            return `scriptc checks with the ES2025 library regardless of the project's "lib" setting, and '${quoted ?? "this name"}' comes from a newer library that does not compile yet`;
+        }
+    }
+    // TS2339/TS2550/TS2551: property does not exist (2550: on this lib).
+    if (d.code === 2339 || d.code === 2550 || d.code === 2551) {
+        const typeText = /on type '([^']+)'/.exec(message)?.[1] ?? "";
+        const newerLib = world.projectLib !== null &&
+            world.projectLib.some((lib) => /esnext|es202[6-9]|es20[3-9]\d/i.test(lib));
+        if (d.code === 2550 || (newerLib && /^[A-Z][A-Za-z0-9]*(?:Constructor)?$/.test(typeText))) {
+            return `scriptc checks with the ES2025 library regardless of the project's "lib" setting, and '${quoted ?? "this member"}' comes from a newer library that does not compile yet — use an ES2025 equivalent here`;
+        }
+        if (world.nodeFallback && d.fileName !== undefined) {
+            const root = receiverRoot(load.program.getSourceFile(d.fileName)?.text ?? "", d.pos);
+            if (root !== null &&
+                (NODE_GLOBAL_ROOTS.has(root) || importsNodeBuiltin(load, d.fileName, root))) {
+                return `the project has no @types/node, so scriptc types Node with its bundled declarations, which list only the members that compile natively — '${quoted ?? "this member"}' does not compile natively yet (https://scriptc.dev/limitations); installing @types/node turns this into a located refusal with a hint`;
+            }
+        }
+    }
+    if (world.forcedStrictNullChecks && /\b(?:null|undefined)\b/.test(message)) {
+        return `the project disables strictNullChecks, which scriptc always enables — this error appears only under strict null checks; narrow the value (or enable "strictNullChecks" in the project to see the same errors from its own tsc)`;
+    }
+    return null;
+}
+/** The root identifier of the property access whose member name starts at
+ * `pos` (`process.version` → `process`), or null. */
+function receiverRoot(text, pos) {
+    let i = pos - 1;
+    while (i >= 0 && /\s/.test(text[i]))
+        i--;
+    if (text[i] !== ".")
+        return null;
+    i--;
+    if (text[i] === "?")
+        i--;
+    let root = null;
+    for (;;) {
+        while (i >= 0 && /\s/.test(text[i]))
+            i--;
+        let j = i;
+        while (j >= 0 && /[\w$]/.test(text[j]))
+            j--;
+        if (j === i)
+            return root;
+        root = text.slice(j + 1, i + 1);
+        i = j;
+        while (i >= 0 && /\s/.test(text[i]))
+            i--;
+        if (text[i] !== ".")
+            return root;
+        i--;
+        if (text[i] === "?")
+            i--;
+    }
+}
+/** Whether `name` is bound in `fileName` by an import of a Node builtin. */
+function importsNodeBuiltin(load, fileName, name) {
+    const sf = load.program.getSourceFile(fileName);
+    for (const stmt of sf?.statements ?? []) {
+        if (!ts.isImportDeclaration(stmt) || !ts.isStringLiteral(stmt.moduleSpecifier))
+            continue;
+        if (canonicalBuiltinModule(stmt.moduleSpecifier.text) === null)
+            continue;
+        const clause = stmt.importClause;
+        if (clause?.name?.text === name)
+            return true;
+        const bindings = clause?.namedBindings;
+        if (bindings && ts.isNamespaceImport(bindings) && bindings.name.text === name)
+            return true;
+        if (bindings &&
+            ts.isNamedImports(bindings) &&
+            bindings.elements.some((e) => e.name.text === name))
+            return true;
+    }
+    return false;
+}
 //# sourceMappingURL=program.js.map