@scriptc/compiler 0.2.7 → 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)),
@@ -2013,11 +2031,7 @@ export function makeCycleAdmission(program, edgesOf) {
             const reason = exactCycleRefusal7(program, comp, lineOf);
             exactVerdict.set(comp, reason);
             if (reason === null) {
-                let members = exactCycleMembers7.get(program);
-                if (members === undefined) {
-                    members = new Set();
-                    exactCycleMembers7.set(program, members);
-                }
+                const members = program.analysis.exactCycleMembers;
                 for (const m of comp)
                     members.add(m);
             }
@@ -2037,12 +2051,10 @@ export function makeCycleAdmission(program, edgesOf) {
  * 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. */
-/** Program → the modules of every cycle the exact rule admitted. */
-const exactCycleMembers7 = new WeakMap();
 /** The modules of `program` whose import cycles were admitted by the
  * exact initialization rule (not the declaration-only rule). */
 export function exactCycleMembers(program) {
-    return exactCycleMembers7.get(program) ?? new Set();
+    return program.analysis.exactCycleMembers;
 }
 /** True when the module's top level (outside every function-like body)
  * contains `await` or `for await`. */
@@ -2137,19 +2149,18 @@ function exactCycleRefusal7(program, comp, lineOf) {
  * Otherwise every deferred reference and every top-level reference from
  * another member counts. */
 export function cycleEarlyBindings(program, entry, order, singleRoot) {
-    const exact = exactCycleMembers7.get(program);
-    if (exact === undefined || exact.size === 0)
+    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 = earlyBindingsMemo7.get(program);
-    if (memo !== undefined && memo.key === key)
+    const memo = program.analysis.cycleEarlyBindings;
+    if (memo !== null && memo.key === key)
         return memo.bindings;
     const bindings = computeCycleEarlyBindings7(program, entry, order, singleRoot, exact);
-    earlyBindingsMemo7.set(program, { key, bindings });
+    program.analysis.cycleEarlyBindings = { key, bindings };
     return bindings;
 }
-const earlyBindingsMemo7 = new WeakMap();
 function computeCycleEarlyBindings7(program, entry, order, singleRoot, exact) {
     const inOrder = new Set(order);
     const members = [...exact].filter((m) => inOrder.has(m));
@@ -2347,6 +2358,468 @@ function computeCycleEarlyBindings7(program, entry, order, singleRoot, exact) {
     }
     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);
+            });
+        }
+    };
+    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,
@@ -2568,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
@@ -4149,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