@scriptc/compiler 0.1.7 → 0.2.1

package/dist/frontend/npm.js

@@ -16,7 +16,7 @@
  * ts.preProcessFile silently drops), dynamic import() of string literals,
  * and CommonJS require() calls — never a regex.
  *
- * Every reached module's SOURCE is embedded into the emitted C as a static
+ * Every reached module's SOURCE is embedded into the emitted LLVM as a static
  * string keyed by its REALPATH — one physical module embeds once, however
  * many symlink aliases reach it; scr_island.c serves the engine's module
  * loader (and a CommonJS require shim) from that map, so binaries never
@@ -86,11 +86,12 @@
  * re-export hops).
  */
 import { dirname, extname, join, resolve } from "node:path";
-import ts from "typescript5";
+import { moduleSpecifiersOfFile } from "./module-syntax.js";
 import { packageNameOfSpecifier as packageNameOf } from "./workspace-registry.js";
-import { cjsLexedExportsOf } from "./cjs-lexer.js";
+import { cjsLexedExportsOfFile } from "./cjs-syntax.js";
 import { trackedDirectoryExists, trackedFileExists, trackedReadFile, trackedRealpath } from "./input-tracker.js";
 import { resolveExports, resolvePackageImports } from "./resolve.js";
+const LAZY_CALL_FORMS = ["require", "import()", "import"];
 const NODE_IMPORT_CONDITIONS = new Set(["import", "node", "default"]);
 const NODE_REQUIRE_CONDITIONS = new Set(["require", "node", "default"]);
 function nodeExportConditions(mode) {
@@ -136,258 +137,6 @@ function cjsEsmFacadeSource(key, names) {
     parts.push(`export{m as "module.exports"${bound.join("")}};`);
     return parts.join("\n");
 }
-/** Embedded modules whose executable syntax reads Node's global fetch.
- *
- * The npm graph already owns every source string, so bind them together in a
- * no-lib TypeScript program once and ask the checker whether a `fetch`
- * identifier resolves locally. With no ambient library, an unresolved read is
- * exactly the engine global; declarations/imports/parameters retain symbols.
- * `globalThis.fetch` and `global.fetch` are recognized explicitly when their
- * receiver is likewise unshadowed, including const aliases of those global
- * objects. Parsing is recovery-capable, matching the module-specifier sweep's
- * treatment of shipped JavaScript. */
-export function embeddedModulesUsingGlobalFetch(modules) {
-    const sourceFiles = new Map();
-    for (const mod of modules) {
-        if (mod.format === "json")
-            continue;
-        sourceFiles.set(mod.key, ts.createSourceFile(mod.key, mod.source, ts.ScriptTarget.Latest, true, ts.ScriptKind.JS));
-    }
-    if (sourceFiles.size === 0)
-        return new Set();
-    const options = {
-        allowJs: true,
-        checkJs: false,
-        noLib: true,
-        target: ts.ScriptTarget.Latest,
-        module: ts.ModuleKind.ESNext,
-        moduleDetection: ts.ModuleDetectionKind.Force,
-    };
-    const canonical = (fileName) => {
-        const normalized = fileName.replace(/\\/g, "/");
-        return ts.sys.useCaseSensitiveFileNames ? normalized : normalized.toLowerCase();
-    };
-    const byCanonical = new Map([...sourceFiles].map(([fileName, sourceFile]) => [canonical(fileName), sourceFile]));
-    const originalKeyByCanonical = new Map([...sourceFiles.keys()].map((fileName) => [canonical(fileName), fileName]));
-    const host = {
-        getSourceFile: (fileName) => byCanonical.get(canonical(fileName)),
-        getDefaultLibFileName: () => "",
-        writeFile: () => { },
-        getCurrentDirectory: () => "/",
-        getDirectories: () => [],
-        fileExists: (fileName) => byCanonical.has(canonical(fileName)),
-        readFile: (fileName) => byCanonical.get(canonical(fileName))?.text,
-        getCanonicalFileName: canonical,
-        useCaseSensitiveFileNames: () => ts.sys.useCaseSensitiveFileNames,
-        getNewLine: () => "\n",
-        directoryExists: () => true,
-        realpath: (fileName) => fileName,
-    };
-    const program = ts.createProgram({ rootNames: [...sourceFiles.keys()], options, host });
-    const checker = program.getTypeChecker();
-    const found = new Set();
-    const unwrapParentheses = (node) => {
-        let current = node;
-        while (ts.isParenthesizedExpression(current))
-            current = current.expression;
-        return current;
-    };
-    const unboundGlobalObject = (candidate) => {
-        const node = unwrapParentheses(candidate);
-        if (!ts.isIdentifier(node) ||
-            (node.text !== "globalThis" && node.text !== "global")) {
-            return false;
-        }
-        const symbol = checker.getSymbolAtLocation(node);
-        // TypeScript synthesizes a declaration-less globalThis symbol even in a
-        // no-lib program. A source shadow (parameter/local/import) always carries
-        // at least one declaration; the Node `global` alias remains unresolved.
-        return (symbol === undefined ||
-            symbol.declarations === undefined ||
-            symbol.declarations.length === 0);
-    };
-    const globalObjectExpression = (candidate, aliases) => {
-        const node = unwrapParentheses(candidate);
-        if (unboundGlobalObject(node))
-            return true;
-        if (ts.isIdentifier(node)) {
-            const symbol = checker.getSymbolAtLocation(node);
-            if (symbol === undefined)
-                return false;
-            if (aliases.has(symbol))
-                return true;
-            return ((symbol.flags & ts.SymbolFlags.Alias) !== 0 &&
-                aliases.has(checker.getAliasedSymbol(symbol)));
-        }
-        if (ts.isConditionalExpression(node)) {
-            return (globalObjectExpression(node.whenTrue, aliases) ||
-                globalObjectExpression(node.whenFalse, aliases));
-        }
-        if (ts.isBinaryExpression(node)) {
-            switch (node.operatorToken.kind) {
-                case ts.SyntaxKind.BarBarToken:
-                case ts.SyntaxKind.QuestionQuestionToken:
-                case ts.SyntaxKind.AmpersandAmpersandToken:
-                    // A platform selector can yield either operand. Treat either
-                    // global-object arm as capability provenance; over-linking a
-                    // dead arm is safer than silently omitting fetch at runtime.
-                    return (globalObjectExpression(node.left, aliases) ||
-                        globalObjectExpression(node.right, aliases));
-                case ts.SyntaxKind.CommaToken:
-                    return globalObjectExpression(node.right, aliases);
-            }
-        }
-        return false;
-    };
-    const staticPropertyName = (name) => {
-        if (ts.isIdentifier(name) || ts.isStringLiteralLike(name))
-            return name.text;
-        if (ts.isComputedPropertyName(name) &&
-            ts.isStringLiteralLike(name.expression)) {
-            return name.expression.text;
-        }
-        return null;
-    };
-    /** `const { fetch } = globalThis` binds a local identifier, so the
-     * checker quite correctly resolves every later `fetch` read to that local.
-     * The capability read happens at the binding pattern itself. The same is
-     * true for aliases, computed literal keys, and defaulted parameters. */
-    const bindingReadsGlobalFetch = (node, aliases) => {
-        const pattern = node.parent;
-        if (!ts.isObjectBindingPattern(pattern))
-            return false;
-        const key = node.propertyName ?? (ts.isIdentifier(node.name) ? node.name : null);
-        if (key === null || staticPropertyName(key) !== "fetch")
-            return false;
-        const owner = pattern.parent;
-        if ((ts.isVariableDeclaration(owner) || ts.isParameter(owner) || ts.isBindingElement(owner)) &&
-            owner.name === pattern &&
-            owner.initializer !== undefined) {
-            return globalObjectExpression(owner.initializer, aliases);
-        }
-        return false;
-    };
-    /** Assignment destructuring is represented as an object-literal-shaped
-     * assignment target rather than an ObjectBindingPattern. */
-    const assignmentReadsGlobalFetch = (node, aliases) => {
-        if (node.operatorToken.kind !== ts.SyntaxKind.EqualsToken ||
-            !globalObjectExpression(node.right, aliases)) {
-            return false;
-        }
-        const target = unwrapParentheses(node.left);
-        if (!ts.isObjectLiteralExpression(target))
-            return false;
-        return target.properties.some((property) => {
-            if (ts.isShorthandPropertyAssignment(property))
-                return property.name.text === "fetch";
-            return ts.isPropertyAssignment(property) && staticPropertyName(property.name) === "fetch";
-        });
-    };
-    const bareIdentifierRead = (node) => {
-        const parent = node.parent;
-        // Binding-element names and aliases are declarations/property keys; the
-        // global-object destructuring case is handled explicitly above.
-        if (ts.isBindingElement(parent))
-            return false;
-        if ((ts.isLabeledStatement(parent) ||
-            ts.isBreakStatement(parent) ||
-            ts.isContinueStatement(parent)) &&
-            parent.label === node) {
-            return false;
-        }
-        if (ts.isQualifiedName(parent) && parent.right === node)
-            return false;
-        // Imported/exported names are module member names or declarations,
-        // never reads of Node's global binding. This matters when the custom
-        // no-lib program cannot resolve the referenced package and therefore
-        // has no checker symbol for an ImportSpecifier.propertyName.
-        if (ts.isImportSpecifier(parent) || ts.isExportSpecifier(parent))
-            return false;
-        // Named declarations and object/class property names are not reads.
-        // A shorthand property is the exception: `{ fetch }` evaluates the
-        // identifier and therefore needs the global when it is unbound.
-        const namedParent = parent;
-        if (namedParent.name === node && !ts.isShorthandPropertyAssignment(parent))
-            return false;
-        return true;
-    };
-    const bareIdentifierIsUnbound = (node) => {
-        const parent = node.parent;
-        // The binder gives `{ fetch }` a symbol for the PROPERTY it creates;
-        // the value-side symbol is the one that answers whether the shorthand
-        // reads a local binding or Node's global.
-        if (ts.isShorthandPropertyAssignment(parent) && parent.name === node) {
-            return checker.getShorthandAssignmentValueSymbol(parent) === undefined;
-        }
-        return checker.getSymbolAtLocation(node) === undefined;
-    };
-    for (const sourceFile of program.getSourceFiles()) {
-        // Package bootstraps commonly snapshot or select the global object before
-        // reading capabilities (`const root = globalThis || global; root.fetch`).
-        // Resolve alias chains by symbol, so a same-named parameter/local in
-        // another scope cannot inherit the classification. Mutable declarations
-        // are conservative: a global initializer means some executable path can
-        // retain that value. Iterate to a fixed point so declaration order does
-        // not matter.
-        const globalObjectAliases = new Set();
-        let addedAlias = true;
-        while (addedAlias) {
-            addedAlias = false;
-            const collectAliases = (node) => {
-                if (ts.isVariableDeclaration(node) &&
-                    ts.isIdentifier(node.name) &&
-                    node.initializer !== undefined &&
-                    globalObjectExpression(node.initializer, globalObjectAliases)) {
-                    const symbol = checker.getSymbolAtLocation(node.name);
-                    if (symbol !== undefined && !globalObjectAliases.has(symbol)) {
-                        globalObjectAliases.add(symbol);
-                        addedAlias = true;
-                    }
-                }
-                ts.forEachChild(node, collectAliases);
-            };
-            collectAliases(sourceFile);
-        }
-        let usesFetch = false;
-        const visit = (node) => {
-            if (usesFetch)
-                return;
-            if ((ts.isBindingElement(node) && bindingReadsGlobalFetch(node, globalObjectAliases)) ||
-                (ts.isBinaryExpression(node) && assignmentReadsGlobalFetch(node, globalObjectAliases))) {
-                usesFetch = true;
-                return;
-            }
-            if (ts.isPropertyAccessExpression(node) &&
-                node.name.text === "fetch" &&
-                globalObjectExpression(node.expression, globalObjectAliases)) {
-                usesFetch = true;
-                return;
-            }
-            if (ts.isElementAccessExpression(node) &&
-                ts.isStringLiteralLike(node.argumentExpression) &&
-                node.argumentExpression.text === "fetch" &&
-                globalObjectExpression(node.expression, globalObjectAliases)) {
-                usesFetch = true;
-                return;
-            }
-            if (ts.isIdentifier(node) && node.text === "fetch") {
-                // Every real bare read has no symbol in this no-lib program unless
-                // source syntax binds it. Syntactic names without symbols (labels,
-                // destructuring keys) are filtered separately.
-                if (bareIdentifierRead(node) && bareIdentifierIsUnbound(node)) {
-                    usesFetch = true;
-                    return;
-                }
-            }
-            ts.forEachChild(node, visit);
-        };
-        visit(sourceFile);
-        const originalKey = originalKeyByCanonical.get(canonical(sourceFile.fileName));
-        if (usesFetch && originalKey !== undefined)
-            found.add(originalKey);
-    }
-    return found;
-}
 /** Builtins the island provides shims for (scr_island.c). Both spellings
  * resolve to the canonical "node:" key. Subpath forms ("fs/promises") are
  * NOT shimmed unless listed here explicitly. */
@@ -434,101 +183,6 @@ const KNOWN_BUILTINS = new Set([
     "string_decoder", "sys", "timers", "tls", "trace_events", "tty", "url",
     "util", "v8", "vm", "wasi", "worker_threads", "zlib",
 ]);
-/** Every module specifier `source` can load at runtime, in encounter
- * order with its call-site kinds merged per specifier: import/export
- * declarations (INCLUDING `export * as ns from "x"`, which
- * ts.preProcessFile silently drops — zod v4 re-exports its util namespace
- * that way), dynamic import("literal"), and require("literal") /
- * __require("literal") (esbuild's external-require helper — collecting its
- * literal call sites gives bundled dists an honest build-time inventory).
- * A real parse, never a regex. */
-export function moduleSpecifiersOf(source, fileName) {
-    const sf = ts.createSourceFile(fileName, source, ts.ScriptTarget.Latest, false, ts.ScriptKind.JS);
-    const uses = [];
-    const bySpec = new Map();
-    let requireHelperImport = null;
-    let requireHelperReexport = null;
-    /** Uses with `__require(…)` sites — attributed local vs helper AFTER the
-     * walk, once the (hoisted) import declarations have all been seen. */
-    const viaHelperIdent = new Set();
-    const push = (spec, kind) => {
-        let use = bySpec.get(spec);
-        if (!use) {
-            use = {
-                specifier: spec,
-                static: false,
-                require: false,
-                requireLocal: false,
-                requireViaHelper: false,
-                dynamicImport: false,
-                importMetaResolve: false,
-            };
-            bySpec.set(spec, use);
-            uses.push(use);
-        }
-        if (kind !== null)
-            use[kind] = true;
-        return use;
-    };
-    const visit = (n) => {
-        if ((ts.isImportDeclaration(n) || ts.isExportDeclaration(n)) &&
-            n.moduleSpecifier !== undefined &&
-            ts.isStringLiteral(n.moduleSpecifier)) {
-            push(n.moduleSpecifier.text, "static");
-            if (ts.isImportDeclaration(n) &&
-                n.importClause?.namedBindings !== undefined &&
-                ts.isNamedImports(n.importClause.namedBindings) &&
-                n.importClause.namedBindings.elements.some((el) => el.name.text === "__require")) {
-                requireHelperImport = n.moduleSpecifier.text;
-            }
-            if (ts.isExportDeclaration(n) &&
-                n.exportClause !== undefined &&
-                ts.isNamedExports(n.exportClause) &&
-                n.exportClause.elements.some((el) => (el.propertyName ?? el.name).text === "__require")) {
-                requireHelperReexport = n.moduleSpecifier.text;
-            }
-        }
-        else if (ts.isCallExpression(n)) {
-            const arg = n.arguments[0];
-            if (n.expression.kind === ts.SyntaxKind.ImportKeyword &&
-                arg !== undefined &&
-                ts.isStringLiteralLike(arg)) {
-                push(arg.text, "dynamicImport");
-            }
-            else if (ts.isPropertyAccessExpression(n.expression) &&
-                n.expression.name.text === "resolve" &&
-                ts.isMetaProperty(n.expression.expression) &&
-                n.expression.expression.keywordToken === ts.SyntaxKind.ImportKeyword &&
-                n.arguments.length >= 1 && arg !== undefined && ts.isStringLiteralLike(arg)) {
-                push(arg.text, null).importMetaResolve = true;
-            }
-            else if (ts.isIdentifier(n.expression) &&
-                (n.expression.text === "require" || n.expression.text === "__require") &&
-                n.arguments.length === 1 &&
-                arg !== undefined &&
-                ts.isStringLiteralLike(arg)) {
-                if (n.expression.text === "__require") {
-                    // local vs imported-helper attribution is decided after the walk
-                    viaHelperIdent.add(push(arg.text, null));
-                }
-                else {
-                    push(arg.text, "requireLocal");
-                }
-            }
-        }
-        ts.forEachChild(n, visit);
-    };
-    visit(sf);
-    for (const use of viaHelperIdent) {
-        if (requireHelperImport !== null)
-            use.requireViaHelper = true;
-        else
-            use.requireLocal = true;
-    }
-    for (const use of uses)
-        use.require = use.requireLocal || use.requireViaHelper;
-    return { uses, requireHelperImport, requireHelperReexport };
-}
 function builtinKeyOf(specifier) {
     if (specifier.startsWith("node:"))
         return specifier; // forced builtin
@@ -537,7 +191,7 @@ function builtinKeyOf(specifier) {
         return null;
     return `node:${specifier}`;
 }
-const realHost = {
+export const realNpmGraphHost = {
     readFile: (path) => {
         return trackedReadFile(path);
     },
@@ -556,7 +210,7 @@ export function packageNameOfPath(path) {
     const rest = norm.slice(idx + "/node_modules/".length);
     return rest === "" ? null : packageNameOf(rest);
 }
-export function probeNodeImportRefusal(fromFile, specifier, host = realHost) {
+export function probeNodeImportRefusal(fromFile, specifier, host = realNpmGraphHost) {
     if (specifier.startsWith("#") || specifier.startsWith("node:"))
         return null;
     const name = packageNameOf(specifier);
@@ -645,7 +299,7 @@ export function probeNodeImportRefusal(fromFile, specifier, host = realHost) {
  * the ESM startup-crash channel (SEMANTICS.md 287), this refusal is a
  * RUNTIME throw at the require site, catchable — the optional-dependency
  * try/require pattern depends on exactly that. */
-export function probeNodeRequireRefusal(fromFile, specifier, host = realHost) {
+export function probeNodeRequireRefusal(fromFile, specifier, host = realNpmGraphHost) {
     if (specifier.startsWith("./") || specifier.startsWith("../") ||
         specifier === "." || specifier === ".." ||
         specifier.startsWith("/") || specifier.startsWith("#") ||
@@ -679,6 +333,7 @@ export function probeNodeRequireRefusal(fromFile, specifier, host = realHost) {
     };
 }
 export class NpmGraphBuilder {
+    services;
     host;
     modules = new Map();
     edges = [];
@@ -703,7 +358,8 @@ export class NpmGraphBuilder {
      * once; the `__require` attribution chain re-reads helper chunks
      * through this cache. */
     specifiersCache = new Map();
-    constructor(host = realHost) {
+    constructor(services, host = realNpmGraphHost) {
+        this.services = services;
         this.host = host;
     }
     /** Resolve one runtime module without embedding it. This is the package
@@ -933,7 +589,7 @@ export class NpmGraphBuilder {
             const mod = this.modules.get(key);
             if (!mod || mod.format !== "cjs")
                 return names;
-            const lexed = cjsLexedExportsOf(mod.source, key);
+            const lexed = cjsLexedExportsOfFile(this.services.parse(key, mod.source, "js"));
             for (const n of lexed.exports)
                 names.add(n);
             for (const spec of lexed.reexports) {
@@ -953,7 +609,7 @@ export class NpmGraphBuilder {
     }
     finish() {
         this.synthesizeCjsFacades();
-        for (const key of embeddedModulesUsingGlobalFetch([...this.modules.values()])) {
+        for (const key of this.services.globalFetchModules([...this.modules.values()])) {
             const mod = this.modules.get(key);
             if (mod !== undefined)
                 mod.usesFetch = true;
@@ -979,7 +635,7 @@ export class NpmGraphBuilder {
             lazyTraps: [...this.lazyTrapsSeen.entries()]
                 .map(([specifier, t]) => ({
                 specifier,
-                via: ["require", "import()", "import"].filter((v) => t.via.has(v)),
+                via: LAZY_CALL_FORMS.filter((v) => t.via.has(v)),
                 packages: [...t.packages].sort(),
                 ...(t.native ? { native: true } : {}),
             }))
@@ -1348,7 +1004,7 @@ export class NpmGraphBuilder {
         let cached = this.specifiersCache.get(key);
         if (cached === undefined) {
             const text = source ?? this.host.readFile(key);
-            cached = text === null ? null : moduleSpecifiersOf(text, key);
+            cached = text === null ? null : moduleSpecifiersOfFile(this.services.parse(key, text, "js"));
             this.specifiersCache.set(key, cached);
         }
         return cached;
@@ -1406,8 +1062,12 @@ export class NpmGraphBuilder {
             this.edgeSeen.add(edgeKey);
             this.edges.push({ from, specifier: spec, to, kind });
         };
-        for (const use of this.specifiersOf(key, source)?.uses ?? []) {
+        const specifiers = this.specifiersOf(key, source);
+        if (specifiers === null)
+            return;
+        for (const use of specifiers.uses) {
             const spec = use.specifier;
+            const via = { require: use.require, dynamicImport: use.dynamicImport, static: use.static };
             const eager = !lazy && use.static;
             // CommonJS treats bare "." and ".." as directory-relative requires.
             const requireDirectory = (spec === "." || spec === "..") && use.require && !use.static && !use.dynamicImport;
@@ -1430,7 +1090,7 @@ export class NpmGraphBuilder {
                         });
                     }
                     else {
-                        this.noteLazyTrap(spec, use, pkgName, lazy);
+                        this.noteLazyTrap(spec, via, pkgName, lazy);
                         if (use.dynamicImport || (lazy && use.static)) {
                             pushEdge(key, spec, this.importNotFoundTrap(key, spec), "import");
                         }
@@ -1441,7 +1101,7 @@ export class NpmGraphBuilder {
                 // walk) — the inventory row keeps the coverage report honest
                 // about what the binary cannot reach.
                 if (to.endsWith(".node"))
-                    this.noteLazyTrap(spec, use, pkgName, lazy, true);
+                    this.noteLazyTrap(spec, via, pkgName, lazy, true);
                 pushEdge(key, spec, to, "any");
                 this.walk(to, chain, lazy || !use.static);
                 continue;