xbintsc 0.3.15 → 0.3.18

package/src/driver/bundler/merge.ts

@@ -0,0 +1,312 @@
+/**
+ * Merge every reachable module's statements into a single source file.
+ *
+ * Dependencies come first (post-order over the import graph), the entry module
+ * last. Top-level bindings are renamed to globally unique names and imports are
+ * rewritten to the (renamed) exported binding; namespace imports are lowered
+ * to a synthetic object literal.
+ */
+
+import { dirname } from "node:path";
+import {
+  ModifierKind,
+  SyntaxKind,
+  type ExportAssignment,
+  type ExportDeclaration,
+  type Identifier,
+  type ImportDeclaration,
+  type Node,
+  type ObjectLiteralExpression,
+  type PropertyAssignment,
+  type SourceFileNode,
+  type Statement,
+  type VariableDeclaration,
+  type VariableDeclarationList,
+  type VariableStatement,
+} from "../../ast/nodes.js";
+import type { BindingName } from "../../ast/declarations.js";
+import { SymbolKind } from "../../binder/binder.js";
+import type { DiagnosticBag } from "../../diagnostics/diagnostic.js";
+import { loadGraph } from "./graph.js";
+import { classifyDependency } from "./resolve.js";
+import {
+  declarationName,
+  hasModifier,
+  moduleScope,
+  renameReferences,
+  renameSymbol,
+  topLevelSymbols,
+} from "./symbols.js";
+import type { BundleResult, ModuleRecord } from "./types.js";
+
+export function bundleModules(
+  entryPath: string,
+  diagnostics: DiagnosticBag,
+  externalSpecifiers: ReadonlySet<string> = new Set(),
+): BundleResult | undefined {
+  const records = loadGraph(entryPath, diagnostics, externalSpecifiers);
+  if (!records) return undefined;
+
+  const byPath = new Map(records.map((record) => [record.path, record]));
+  const dependencyOf = (record: ModuleRecord, specifier: string): ModuleRecord | undefined => {
+    const resolution = classifyDependency(dirname(record.path), specifier, externalSpecifiers);
+    return resolution.kind === "file" ? byPath.get(resolution.path) : undefined;
+  };
+
+  // Phase 1: record every top-level binding and pick a unique final name.
+  for (const record of records) {
+    for (const symbol of topLevelSymbols(record)) {
+      record.originalNames.set(symbol.id, symbol.name);
+      if (symbol.kind === SymbolKind.Import) continue;
+      record.finalNames.set(symbol.id, record.prefix + symbol.name);
+    }
+  }
+
+  // Phase 2: collect each module's exported names.
+  for (const record of records) {
+    const scope = moduleScope(record);
+    if (!scope) continue;
+    const symbolByName = scope.symbols;
+    for (const statement of record.sourceFile.statements) {
+      if (statement.kind === SyntaxKind.ExportDeclaration) {
+        const declaration = statement as ExportDeclaration;
+        if (declaration.exportClause && declaration.exportClause.kind === SyntaxKind.NamedExports) {
+          for (const specifier of declaration.exportClause.elements) {
+            const localName = specifier.propertyName?.text ?? specifier.name.text;
+            const exportedName = specifier.name.text;
+            if (declaration.moduleSpecifier) {
+              const dependency = dependencyOf(record, declaration.moduleSpecifier.value);
+              const target = dependency?.exports.get(localName);
+              if (target) record.exports.set(exportedName, target);
+            } else {
+              const symbol = symbolByName.get(localName);
+              if (symbol) {
+                const finalName = record.finalNames.get(symbol.id) ?? symbol.name;
+                record.exports.set(exportedName, finalName);
+              }
+            }
+          }
+        } else if (!declaration.exportClause && declaration.moduleSpecifier) {
+          // `export * from "..."`: copy every re-exported name.
+          const dependency = dependencyOf(record, declaration.moduleSpecifier.value);
+          if (dependency) for (const [name, value] of dependency.exports) record.exports.set(name, value);
+        }
+        continue;
+      }
+      if (statement.kind === SyntaxKind.ExportAssignment) {
+        record.exports.set("default", `${record.prefix}default`);
+        continue;
+      }
+      if (hasModifier(statement, ModifierKind.Default)) {
+        const name = declarationName(statement) ?? declarationName((statement as { declaration?: Node }).declaration ?? statement);
+        if (name) {
+          const symbol = symbolByName.get(name.text);
+          if (symbol) record.exports.set("default", record.finalNames.get(symbol.id) ?? symbol.name);
+        }
+        continue;
+      }
+      if (hasModifier(statement, ModifierKind.Export)) {
+        const names = exportedNames(statement);
+        for (const name of names) {
+          const symbol = symbolByName.get(name);
+          if (symbol) record.exports.set(name, record.finalNames.get(symbol.id) ?? symbol.name);
+        }
+      }
+    }
+  }
+
+  // Phase 3: rewrite imported names and record re-exports. Namespace imports
+  // are lowered to a synthetic object literal holding every export, built
+  // from the dependency's (already renamed) final names.
+  const namespaceStatements = new Map<Statement, Statement>();
+  for (const record of records) {
+    const scope = moduleScope(record);
+    if (!scope) continue;
+    for (const statement of record.sourceFile.statements) {
+      if (statement.kind !== SyntaxKind.ImportDeclaration) continue;
+      const declaration = statement as ImportDeclaration;
+      const dependency = dependencyOf(record, declaration.moduleSpecifier.value);
+      const clause = declaration.importClause;
+      if (!clause || !dependency) continue;
+      if (clause.name) {
+        const target = dependency.exports.get("default") ?? dependency.exports.get("default");
+        const local = scope.symbols.get(clause.name.text);
+        if (target && local) renameReferences(local, target);
+      }
+      const bindings = clause.namedBindings;
+      if (bindings && bindings.kind === SyntaxKind.NamedImports) {
+        for (const specifier of bindings.elements) {
+          const importedName = specifier.propertyName?.text ?? specifier.name.text;
+          const target = dependency.exports.get(importedName);
+          const local = scope.symbols.get(specifier.name.text);
+          if (target && local) renameReferences(local, target);
+        }
+      } else if (bindings && bindings.kind === SyntaxKind.NamespaceImport) {
+        const local = scope.symbols.get(bindings.name.text);
+        const finalName = `${record.prefix}${bindings.name.text}`;
+        if (local) renameReferences(local, finalName);
+        namespaceStatements.set(statement, namespaceImportToStatement(statement, finalName, dependency));
+      }
+    }
+  }
+
+  // Phase 4: concatenate statements, dropping imports and pure export wrappers.
+  const merged: Statement[] = [];
+  const first = records[records.length - 1]!;
+  for (const record of records) {
+    for (const statement of record.sourceFile.statements) {
+      if (statement.kind === SyntaxKind.ImportDeclaration) {
+        // External (extension / built-in) imports stay in place for codegen.
+        const declaration = statement as ImportDeclaration;
+        const resolution = classifyDependency(
+          dirname(record.path),
+          declaration.moduleSpecifier.value,
+          externalSpecifiers,
+        );
+        if (resolution.kind === "external") {
+          merged.push(statement);
+        } else {
+          const synthetic = namespaceStatements.get(statement);
+          if (synthetic) merged.push(synthetic);
+        }
+        continue;
+      }
+      if (statement.kind === SyntaxKind.ExportDeclaration) {
+        const declaration = statement as ExportDeclaration;
+        const inner = (declaration as unknown as { declaration?: Statement }).declaration;
+        if (inner) merged.push(inner);
+        continue;
+      }
+      if (statement.kind === SyntaxKind.ExportAssignment) {
+        const assignment = statement as ExportAssignment;
+        merged.push(exportAssignmentToStatement(record, assignment));
+        continue;
+      }
+      merged.push(statement);
+    }
+  }
+
+  // Phase 5: rename every top-level binding (declaration + references) to its
+  // unique final name, now that import references have been rewritten.
+  for (const record of records) {
+    for (const symbol of topLevelSymbols(record)) {
+      if (symbol.kind === SymbolKind.Import) continue;
+      const finalName = record.finalNames.get(symbol.id);
+      if (finalName) renameSymbol(symbol, finalName);
+    }
+  }
+
+  const sourceFile: SourceFileNode = {
+    kind: SyntaxKind.SourceFile,
+    statements: merged,
+    fileName: first.path,
+    text: records.map((record) => record.text).join("\n"),
+    start: 0,
+    end: 0,
+  };
+  return { sourceFile, text: sourceFile.text, moduleCount: records.length };
+}
+
+function exportedNames(statement: Statement): string[] {
+  const names: string[] = [];
+  if (statement.kind === SyntaxKind.VariableStatement) {
+    for (const declaration of (statement as VariableStatement).declarationList.declarations) {
+      collectBindingIdentifiers(declaration.name, names);
+    }
+  } else {
+    const name = declarationName(statement);
+    if (name) names.push(name.text);
+  }
+  return names;
+}
+
+function collectBindingIdentifiers(name: BindingName, out: string[]): void {
+  if (name.kind === SyntaxKind.Identifier) {
+    out.push(name.text);
+    return;
+  }
+  const elements = name.kind === SyntaxKind.ArrayBindingPattern ? name.elements : name.elements;
+  for (const element of elements) {
+    if (element) collectBindingIdentifiers(element.name, out);
+  }
+}
+
+/** Lower `import * as ns from "./mod"` to `const m0_ns = { ...exports }`. */
+function namespaceImportToStatement(
+  statement: Statement,
+  finalName: string,
+  dependency: ModuleRecord,
+): Statement {
+  const properties: PropertyAssignment[] = [];
+  for (const [exportedName, target] of dependency.exports) {
+    properties.push({
+      kind: SyntaxKind.PropertyAssignment,
+      name: { kind: SyntaxKind.Identifier, text: exportedName, start: statement.start, end: statement.start },
+      initializer: { kind: SyntaxKind.Identifier, text: target, start: statement.start, end: statement.start },
+      start: statement.start,
+      end: statement.start,
+    });
+  }
+  const initializer: ObjectLiteralExpression = {
+    kind: SyntaxKind.ObjectLiteralExpression,
+    properties,
+    start: statement.start,
+    end: statement.end,
+  };
+  const declaration: VariableDeclaration = {
+    kind: SyntaxKind.VariableDeclaration,
+    name: { kind: SyntaxKind.Identifier, text: finalName, start: statement.start, end: statement.start },
+    exclamation: false,
+    initializer,
+    start: statement.start,
+    end: statement.end,
+  };
+  const list: VariableDeclarationList = {
+    kind: SyntaxKind.VariableDeclarationList,
+    declarationKind: "const" as const,
+    declarations: [declaration],
+    start: statement.start,
+    end: statement.end,
+  };
+  return {
+    kind: SyntaxKind.VariableStatement,
+    declarationList: list,
+    modifiers: [],
+    start: statement.start,
+    end: statement.end,
+  };
+}
+
+/** Turn `export default expr` into a synthetic `const` declaration. */
+function exportAssignmentToStatement(record: ModuleRecord, assignment: ExportAssignment): Statement {
+  const name: Identifier = {
+    kind: SyntaxKind.Identifier,
+    text: `${record.prefix}default`,
+    start: assignment.start,
+    end: assignment.start,
+  };
+  record.exports.set("default", name.text);
+  const declaration: VariableDeclaration = {
+    kind: SyntaxKind.VariableDeclaration,
+    name,
+    exclamation: false,
+    initializer: assignment.expression,
+    start: assignment.start,
+    end: assignment.end,
+  };
+  const list: VariableDeclarationList = {
+    kind: SyntaxKind.VariableDeclarationList,
+    declarationKind: "const" as const,
+    declarations: [declaration],
+    start: assignment.start,
+    end: assignment.end,
+  };
+  const statement: VariableStatement = {
+    kind: SyntaxKind.VariableStatement,
+    declarationList: list,
+    modifiers: [],
+    start: assignment.start,
+    end: assignment.end,
+  };
+  return statement;
+}

package/src/driver/bundler/resolve.ts

@@ -0,0 +1,240 @@
+/**
+ * Module resolution for the bundler: relative paths, directory `index`
+ * entries, package `exports` maps and `node_modules` lookup.
+ */
+
+import { existsSync, readFileSync, statSync } from "node:fs";
+import { dirname, isAbsolute, join, resolve } from "node:path";
+import type { DependencyResolution, PackageJson } from "./types.js";
+
+/**
+ * Source extensions probed for an extension-less specifier. TypeScript suffixes
+ * are tried before their JavaScript counterparts so a project that ships both
+ * `foo.ts` and a compiled `foo.js` prefers the source it is compiled from.
+ */
+const RESOLVE_SUFFIXES = ["", ".ts", ".tsx", ".mts", ".cts", ".js", ".jsx", ".mjs", ".cjs"];
+/** File extensions a directory `index` entry may use. */
+const INDEX_SUFFIXES = [".ts", ".tsx", ".mts", ".cts", ".js", ".jsx", ".mjs", ".cjs"];
+/** Conditions consulted, in order, when reading a package `exports` map. */
+const EXPORT_CONDITIONS = ["import", "module", "default", "node", "require"];
+
+/** A specifier is a file path (`./x`, `../x`, `/x`) rather than a package. */
+function isRelativeSpecifier(specifier: string): boolean {
+  return specifier.startsWith(".") || isAbsolute(specifier);
+}
+
+/**
+ * Resolve a path on disk, tolerating TypeScript's `.js` import convention
+ * (`import "./foo.js"` pointing at `foo.ts`) and Node's directory/`index`
+ * conventions.
+ */
+function resolvePath(base: string): string | undefined {
+  // A JavaScript specifier may refer to a TypeScript source that will emit it
+  // (`import "./foo.js"` pointing at `foo.ts`). Probe the matching TypeScript
+  // extensions after the literal path: `.js`/`.jsx` -> `.ts`/`.tsx`,
+  // `.mjs` -> `.mts`, `.cjs` -> `.cts`.
+  const candidates = [base];
+  const jsExtension = /\.((?:m|c)?jsx?)$/.exec(base);
+  if (jsExtension) {
+    const stem = base.slice(0, jsExtension.index);
+    switch (jsExtension[1]) {
+      case "jsx":
+        candidates.push(`${stem}.tsx`, `${stem}.ts`);
+        break;
+      case "mjs":
+        candidates.push(`${stem}.mts`);
+        break;
+      case "cjs":
+        candidates.push(`${stem}.cts`);
+        break;
+      default:
+        candidates.push(`${stem}.ts`, `${stem}.tsx`);
+        break;
+    }
+  }
+  for (const candidate of candidates) {
+    if (existsSync(candidate) && statSync(candidate).isFile()) return candidate;
+  }
+  for (const suffix of RESOLVE_SUFFIXES) {
+    const candidate = base + suffix;
+    if (existsSync(candidate) && statSync(candidate).isFile()) return candidate;
+  }
+  if (existsSync(base) && statSync(base).isDirectory()) return resolveDirectory(base);
+  return undefined;
+}
+
+/** Resolve a directory to its package entry or an `index` file. */
+function resolveDirectory(directory: string): string | undefined {
+  const pkg = readPackageJson(directory);
+  if (pkg && typeof pkg.main === "string") {
+    const main = resolvePath(resolve(directory, pkg.main));
+    if (main) return main;
+  }
+  for (const suffix of INDEX_SUFFIXES) {
+    const candidate = join(directory, `index${suffix}`);
+    if (existsSync(candidate) && statSync(candidate).isFile()) return candidate;
+  }
+  return undefined;
+}
+
+function resolveModule(fromDir: string, specifier: string): string | undefined {
+  return resolvePath(resolve(fromDir, specifier));
+}
+
+function readPackageJson(directory: string): PackageJson | undefined {
+  const file = join(directory, "package.json");
+  if (!existsSync(file) || !statSync(file).isFile()) return undefined;
+  try {
+    const parsed = JSON.parse(readFileSync(file, "utf8")) as unknown;
+    return parsed && typeof parsed === "object" ? (parsed as PackageJson) : undefined;
+  } catch {
+    return undefined;
+  }
+}
+
+/** Split `pkg/sub/path` or `@scope/pkg/sub/path` into package name and subpath. */
+function splitPackageSpecifier(specifier: string): { packageName: string; subpath: string } {
+  const parts = specifier.split("/");
+  if (specifier.startsWith("@")) {
+    return { packageName: parts.slice(0, 2).join("/"), subpath: parts.slice(2).join("/") };
+  }
+  return { packageName: parts[0] ?? specifier, subpath: parts.slice(1).join("/") };
+}
+
+/**
+ * Resolve a bare specifier against the `node_modules` directories above
+ * `fromDir`, following a package's `exports` map and falling back to
+ * `module`/`main`/`index`. Packages that only ship CommonJS resolve here too;
+ * their `require` calls are then rejected during code generation.
+ */
+function resolveNodePackage(fromDir: string, specifier: string): string | undefined {
+  const { packageName, subpath } = splitPackageSpecifier(specifier);
+  if (!packageName || packageName.startsWith(".")) return undefined;
+  let directory = fromDir;
+  for (;;) {
+    const packageDir = join(directory, "node_modules", packageName);
+    if (existsSync(packageDir) && statSync(packageDir).isDirectory()) {
+      const resolved = subpath
+        ? resolvePackageSubpath(packageDir, subpath)
+        : resolvePackageEntry(packageDir);
+      if (resolved) return resolved;
+    }
+    const parent = dirname(directory);
+    if (parent === directory) return undefined;
+    directory = parent;
+  }
+}
+
+function resolvePackageEntry(packageDir: string): string | undefined {
+  const pkg = readPackageJson(packageDir);
+  if (pkg) {
+    const exported = resolveExportTarget(subpathValue(pkg.exports, "."));
+    if (exported) {
+      const resolved = resolvePath(resolve(packageDir, exported));
+      if (resolved) return resolved;
+    }
+    if (typeof pkg.module === "string") {
+      const resolved = resolvePath(resolve(packageDir, pkg.module));
+      if (resolved) return resolved;
+    }
+    if (typeof pkg.main === "string") {
+      const resolved = resolvePath(resolve(packageDir, pkg.main));
+      if (resolved) return resolved;
+    }
+  }
+  return resolveDirectory(packageDir);
+}
+
+function resolvePackageSubpath(packageDir: string, subpath: string): string | undefined {
+  const pkg = readPackageJson(packageDir);
+  const exported = resolveExportTarget(subpathValue(pkg?.exports, `./${subpath}`));
+  if (exported) {
+    const resolved = resolvePath(resolve(packageDir, exported));
+    if (resolved) return resolved;
+  }
+  return resolvePath(join(packageDir, subpath));
+}
+
+/** Pick the export target for a subpath (`"."` or `"./sub"`) from an exports map. */
+function subpathValue(exportsField: unknown, subpath: string): unknown {
+  if (exportsField === undefined) return undefined;
+  if (typeof exportsField === "string" || Array.isArray(exportsField)) {
+    return subpath === "." ? exportsField : undefined;
+  }
+  if (!exportsField || typeof exportsField !== "object") return undefined;
+  const record = exportsField as Record<string, unknown>;
+  const keys = Object.keys(record);
+  // A map without `.`-prefixed keys is a condition map for the root export.
+  if (!keys.some((key) => key.startsWith("."))) {
+    return subpath === "." ? exportsField : undefined;
+  }
+  if (subpath in record) return record[subpath];
+  // Wildcard patterns such as `"./*": "./dist/*.js"`.
+  for (const key of keys) {
+    const star = key.indexOf("*");
+    if (star === -1) continue;
+    const prefix = key.slice(0, star);
+    const suffix = key.slice(star + 1);
+    if (subpath.startsWith(prefix) && subpath.endsWith(suffix)) {
+      const matched = subpath.slice(prefix.length, subpath.length - suffix.length);
+      return substituteStar(record[key], matched);
+    }
+  }
+  return undefined;
+}
+
+function substituteStar(target: unknown, matched: string): unknown {
+  if (typeof target === "string") return target.split("*").join(matched);
+  if (Array.isArray(target)) return target.map((entry) => substituteStar(entry, matched));
+  if (target && typeof target === "object") {
+    const record: Record<string, unknown> = {};
+    for (const [key, value] of Object.entries(target)) record[key] = substituteStar(value, matched);
+    return record;
+  }
+  return target;
+}
+
+/** Pick a runtime string from a (possibly conditional) exports target. */
+function resolveExportTarget(target: unknown): string | undefined {
+  if (typeof target === "string") return target;
+  if (Array.isArray(target)) {
+    for (const entry of target) {
+      const resolved = resolveExportTarget(entry);
+      if (resolved) return resolved;
+    }
+    return undefined;
+  }
+  if (target && typeof target === "object") {
+    const record = target as Record<string, unknown>;
+    for (const condition of EXPORT_CONDITIONS) {
+      if (condition in record) {
+        const resolved = resolveExportTarget(record[condition]);
+        if (resolved) return resolved;
+      }
+    }
+  }
+  return undefined;
+}
+
+/**
+ * Classify an import specifier. Known platform modules (extension modules and
+ * `node:` builtins) are left for code generation; relative paths and
+ * `node_modules` packages are resolved to a source file to bundle; a relative
+ * path that does not exist is an error.
+ */
+export function classifyDependency(
+  fromDir: string,
+  specifier: string,
+  externalSpecifiers: ReadonlySet<string>,
+): DependencyResolution {
+  if (specifier.startsWith("node:") || externalSpecifiers.has(specifier)) {
+    return { kind: "external" };
+  }
+  const resolved = isRelativeSpecifier(specifier)
+    ? resolveModule(fromDir, specifier)
+    : resolveNodePackage(fromDir, specifier);
+  if (resolved) return { kind: "file", path: resolved };
+  // A bare specifier that is not a file may still be a platform module the
+  // generator knows about (e.g. when the caller passes no extension registry).
+  return isRelativeSpecifier(specifier) ? { kind: "missing" } : { kind: "external" };
+}

package/src/driver/bundler/symbols.ts

@@ -0,0 +1,55 @@
+/**
+ * Top-level symbol helpers: name extraction and declaration/reference
+ * renaming used while merging modules into a single file.
+ */
+
+import { ModifierKind, SyntaxKind, type Identifier, type Node, type VariableDeclaration } from "../../ast/nodes.js";
+import type { SymbolInfo } from "../../binder/binder.js";
+import type { ModuleRecord } from "./types.js";
+
+export function hasModifier(node: Node, kind: ModifierKind): boolean {
+  const modifiers = (node as { modifiers?: { modifierKind: ModifierKind }[] }).modifiers;
+  return !!modifiers && modifiers.some((modifier) => modifier.modifierKind === kind);
+}
+
+export function declarationName(node: Node): Identifier | undefined {
+  switch (node.kind) {
+    case SyntaxKind.FunctionDeclaration:
+    case SyntaxKind.ClassDeclaration:
+    case SyntaxKind.EnumDeclaration:
+    case SyntaxKind.InterfaceDeclaration:
+    case SyntaxKind.TypeAliasDeclaration:
+    case SyntaxKind.ModuleDeclaration:
+      return (node as { name?: Identifier }).name;
+    case SyntaxKind.VariableDeclaration: {
+      const name = (node as VariableDeclaration).name;
+      return name.kind === SyntaxKind.Identifier ? name : undefined;
+    }
+    default:
+      return undefined;
+  }
+}
+
+/** Rewrite a symbol's declaration and every reference to `finalName`. */
+export function renameSymbol(symbol: SymbolInfo, finalName: string): void {
+  for (const declaration of symbol.declarations) {
+    const name = declarationName(declaration);
+    if (name) (name as { text: string }).text = finalName;
+  }
+  for (const reference of symbol.references) (reference as { text: string }).text = finalName;
+}
+
+/** Rewrite just the references of a symbol (used for imported names). */
+export function renameReferences(symbol: SymbolInfo, finalName: string): void {
+  for (const reference of symbol.references) (reference as { text: string }).text = finalName;
+}
+
+export function moduleScope(record: ModuleRecord) {
+  return record.bind.scopes.get(record.sourceFile);
+}
+
+export function topLevelSymbols(record: ModuleRecord): SymbolInfo[] {
+  const scope = moduleScope(record);
+  if (!scope) return [];
+  return [...scope.symbols.values()];
+}

package/src/driver/bundler/types.ts

@@ -0,0 +1,37 @@
+/**
+ * Shared types for the source-level module bundler.
+ */
+
+import type { SourceFileNode } from "../../ast/nodes.js";
+import type { BindResult } from "../../binder/binder.js";
+
+export interface ModuleRecord {
+  readonly path: string;
+  readonly text: string;
+  readonly sourceFile: SourceFileNode;
+  readonly bind: BindResult;
+  readonly prefix: string;
+  /** exported name -> final (renamed) local name */
+  readonly exports: Map<string, string>;
+  /** original local name of every top-level symbol */
+  readonly originalNames: Map<number, string>;
+  /** final name of every top-level symbol */
+  readonly finalNames: Map<number, string>;
+}
+
+export interface BundleResult {
+  readonly sourceFile: SourceFileNode;
+  readonly text: string;
+  readonly moduleCount: number;
+}
+
+export interface PackageJson {
+  readonly main?: string;
+  readonly module?: string;
+  readonly exports?: unknown;
+}
+
+export type DependencyResolution =
+  | { readonly kind: "external" }
+  | { readonly kind: "file"; readonly path: string }
+  | { readonly kind: "missing" };