@invinite-org/chartlang-compiler 1.0.1 → 1.1.0

package/dist/api.js

@@ -2,15 +2,17 @@
 // See the LICENSE file in the repo root for full license text.
 import { randomBytes } from "node:crypto";
 import { readFile, readdir, rename, unlink, writeFile } from "node:fs/promises";
-import { isAbsolute, join, relative, resolve as resolvePath } from "node:path";
+import { dirname, isAbsolute, join, relative, resolve as resolvePath } from "node:path";
 import { STATEFUL_PRIMITIVES_BY_NAME } from "@invinite-org/chartlang-core";
 import ts from "typescript";
-import { extractAlertConditions, extractCapabilities, extractInputs, extractMaxLookback, extractRequestedIntervals, extractRequiresIntervals, runForbiddenConstructs, runStatefulCallInLoop, runStructuralChecks, validateLowerTfIntervals, } from "./analysis/index.js";
-import { bundleModule, formatManifestAssignment } from "./bundle.js";
+import { extractAlertConditions, extractCapabilities, extractDependencyGraph, extractInputs, extractMaxLookback, extractRequestedIntervals, extractRequiresIntervals, runForbiddenConstructs, runStatefulCallInLoop, runStructuralChecks, validateLowerTfIntervals, } from "./analysis/index.js";
+import { bundleModule, formatDependenciesAssignment, formatManifestAssignment } from "./bundle.js";
+import { createProducerResolver, } from "./dependency/index.js";
 import { mapTsDiagnostic } from "./diagnostics.js";
 import { buildManifest } from "./manifest.js";
 import { createProgramForSource } from "./program.js";
 import { injectCallsiteIds } from "./transformers/callsiteIdInjection.js";
+import { rewriteDependencyAccessors } from "./transformers/rewriteDependencyAccessors.js";
 import { emitTypes } from "./typesEmit.js";
 /**
  * Run the Phase-1 compiler pipeline against an in-memory script source.
@@ -36,7 +38,11 @@ import { emitTypes } from "./typesEmit.js";
  */
 export function transformAndAnalyse(source, opts) {
     const sourcePath = opts.sourcePath;
-    const { program, sourceFile, checker } = createProgramForSource(source, { sourcePath });
+    const chartImports = preScanChartImports(source, sourcePath);
+    const { program, sourceFile, checker } = createProgramForSource(source, {
+        sourcePath,
+        chartImports,
+    });
     const structural = runStructuralChecks(sourceFile, checker, sourcePath);
     const forbidden = runForbiddenConstructs(sourceFile, sourcePath);
     const statefulInLoop = runStatefulCallInLoop(sourceFile, checker, sourcePath, STATEFUL_PRIMITIVES_BY_NAME);
@@ -50,11 +56,28 @@ export function transformAndAnalyse(source, opts) {
         .getSemanticDiagnostics(sourceFile)
         .filter((d) => d.file?.fileName === sourceFile.fileName)
         .map((d) => mapTsDiagnostic(d, sourcePath));
+    const depGraph = extractDependencyGraph(sourceFile, checker, sourcePath, structural.bindings, opts.resolveProducer === undefined
+        ? () => null
+        : (modSpec, expName) => {
+            const snap = opts.resolveProducer?.(modSpec, expName);
+            /* v8 ignore next */
+            if (snap === undefined || snap === null)
+                return null;
+            return Object.freeze({
+                name: snap.name,
+                outputs: Object.freeze(snap.outputs.map((o) => Object.freeze({
+                    title: o.title,
+                    kind: o.kind,
+                }))),
+                inputs: snap.inputs,
+            });
+        });
     const earlyDiagnostics = [
         ...semanticDiagnostics,
         ...structural.diagnostics,
         ...forbidden,
         ...statefulInLoop,
+        ...depGraph.diagnostics,
     ];
     const hasError = earlyDiagnostics.some((d) => d.severity === "error");
     if (hasError) {
@@ -74,41 +97,79 @@ export function transformAndAnalyse(source, opts) {
             diagnostics: Object.freeze(earlyDiagnostics.slice()),
         });
     }
-    const injection = injectCallsiteIds(sourceFile, checker, {
+    const rewrite = rewriteDependencyAccessors(sourceFile, depGraph, sourcePath);
+    const rewrittenSource = rewrite.transformed;
+    const plotSlots = [];
+    const injection = injectCallsiteIds(rewrittenSource, checker, {
         sourcePath,
         statefulByName: STATEFUL_PRIMITIVES_BY_NAME,
+        plotSlots,
     });
-    const capabilities = extractCapabilities(sourceFile, checker, structural.kind);
-    const lookback = extractMaxLookback(sourceFile, checker, sourcePath);
-    const inputs = extractInputs(sourceFile, checker, sourcePath);
     const alertConditions = extractAlertConditions(sourceFile, checker, sourcePath);
     const intervalDiagnostics = [];
-    const requestedIntervalsFromCalls = extractRequestedIntervals(sourceFile, checker, inputs.inputs, intervalDiagnostics, sourcePath);
-    const requiresIntervals = extractRequiresIntervals(sourceFile, checker, intervalDiagnostics, sourcePath);
     const lowerTfDiagnostics = validateLowerTfIntervals(sourceFile, checker, sourcePath, opts.declaredIntervals ?? []);
-    const requestedIntervals = Array.from(new Set([...requestedIntervalsFromCalls, ...requiresIntervals])).sort();
     const { requiresIntervals: structuralRequiresIntervals, ...structuralOverrides } = structural.overrides;
     void structuralRequiresIntervals;
-    const manifest = buildManifest({
-        name: structural.name,
-        kind: structural.kind,
-        capabilities,
-        requestedIntervals,
-        userPickableInterval: inputs.userPickableInterval,
-        seriesCapacities: lookback.seriesCapacities,
-        maxLookback: lookback.maxLookback,
-        inputs: inputs.inputs,
-        ...structuralOverrides,
-        ...(requiresIntervals.length === 0 ? {} : { requiresIntervals }),
-        ...(alertConditions.alertConditions.length === 0
-            ? {}
-            : { alertConditions: alertConditions.alertConditions }),
-    });
+    // The structural pass guarantees a single default-export drawn
+    // entry before we reach this code (errors short-circuit above);
+    // we surface the default here for manifest assembly.
+    const defaultDrawn = depGraph.drawn.find((d) => d.exportName === "default");
+    /* v8 ignore start */
+    if (defaultDrawn === undefined) {
+        // The structural pass guarantees a default-export drawn entry
+        // before we reach this code (errors short-circuit above).
+        throw new Error("internal: depGraph.drawn missing default entry");
+    }
+    /* v8 ignore stop */
+    const isMultiExport = depGraph.drawn.length > 1;
+    // File-level extractions (single-export back-compat path) — full source
+    // walk so existing single-script manifests stay byte-identical.
+    const fileCapabilities = extractCapabilities(sourceFile, checker, structural.kind);
+    const fileLookback = extractMaxLookback(sourceFile, checker, sourcePath);
+    const fileInputs = extractInputs(sourceFile, checker, sourcePath);
+    const fileRequestedIntervalsFromCalls = extractRequestedIntervals(sourceFile, checker, fileInputs.inputs, intervalDiagnostics, sourcePath);
+    const fileRequiresIntervals = extractRequiresIntervals(sourceFile, checker, intervalDiagnostics, sourcePath);
+    const fileRequestedIntervals = Array.from(new Set([...fileRequestedIntervalsFromCalls, ...fileRequiresIntervals])).sort();
+    const namedManifests = [];
+    if (isMultiExport) {
+        for (const drawn of depGraph.drawn) {
+            if (drawn.exportName === "default")
+                continue;
+            namedManifests.push(buildDrawnManifest(drawn, depGraph, sourceFile, checker, sourcePath, structural.kind, structuralOverrides, alertConditions.alertConditions));
+        }
+    }
+    const defaultDependencies = buildDependencyDeclarations(defaultDrawn, depGraph, sourcePath);
+    const defaultOutputs = defaultDrawn.outputs.length === 0 ? undefined : defaultDrawn.outputs;
+    const manifest = isMultiExport
+        ? buildDrawnManifest(defaultDrawn, depGraph, sourceFile, checker, sourcePath, structural.kind, structuralOverrides, alertConditions.alertConditions, namedManifests, plotSlots)
+        : buildManifest({
+            name: structural.name,
+            kind: structural.kind,
+            capabilities: fileCapabilities,
+            requestedIntervals: fileRequestedIntervals,
+            userPickableInterval: fileInputs.userPickableInterval,
+            seriesCapacities: fileLookback.seriesCapacities,
+            maxLookback: fileLookback.maxLookback,
+            inputs: fileInputs.inputs,
+            ...structuralOverrides,
+            ...(fileRequiresIntervals.length === 0
+                ? {}
+                : { requiresIntervals: fileRequiresIntervals }),
+            ...(alertConditions.alertConditions.length === 0
+                ? {}
+                : { alertConditions: alertConditions.alertConditions }),
+            ...(defaultDependencies === undefined || defaultDependencies.length === 0
+                ? {}
+                : { dependencies: defaultDependencies }),
+            ...(defaultOutputs === undefined ? {} : { outputs: defaultOutputs }),
+            ...(plotSlots.length === 0 ? {} : { plots: plotSlots }),
+        });
     const allDiagnostics = [
         ...earlyDiagnostics,
         ...injection.diagnostics,
-        ...lookback.diagnostics,
-        ...inputs.diagnostics,
+        ...rewrite.diagnostics,
+        ...fileLookback.diagnostics,
+        ...fileInputs.diagnostics,
         ...alertConditions.diagnostics,
         ...intervalDiagnostics,
         ...lowerTfDiagnostics,
@@ -117,8 +178,68 @@ export function transformAndAnalyse(source, opts) {
         transformed: injection.transformed,
         manifest,
         diagnostics: Object.freeze(allDiagnostics.slice()),
+        ...(isMultiExport ? { siblings: Object.freeze(namedManifests.slice()) } : {}),
     });
 }
+function buildDrawnManifest(drawn, depGraph, sourceFile, checker, sourcePath, kind, structuralOverrides, sharedAlertConditions, siblings, plotSlots) {
+    const intervalDiagnostics = [];
+    const scope = drawn.defineCall;
+    const capabilities = extractCapabilities(sourceFile, checker, kind, scope);
+    const lookback = extractMaxLookback(sourceFile, checker, sourcePath, scope);
+    const inputs = extractInputs(sourceFile, checker, sourcePath, scope);
+    const requestedFromCalls = extractRequestedIntervals(sourceFile, checker, inputs.inputs, intervalDiagnostics, sourcePath);
+    const requiresIntervalsScoped = extractRequiresIntervals(sourceFile, checker, intervalDiagnostics, sourcePath);
+    const requestedIntervals = Array.from(new Set([...requestedFromCalls, ...requiresIntervalsScoped])).sort();
+    const dependencies = buildDependencyDeclarations(drawn, depGraph, sourcePath);
+    const outputs = drawn.outputs.length === 0 ? undefined : drawn.outputs;
+    const isDefault = drawn.exportName === "default";
+    const nameForManifest = isDefault ? readDefineCallName(drawn.defineCall) : drawn.bindingName;
+    return buildManifest({
+        name: nameForManifest,
+        kind,
+        capabilities,
+        requestedIntervals,
+        userPickableInterval: inputs.userPickableInterval,
+        seriesCapacities: lookback.seriesCapacities,
+        maxLookback: lookback.maxLookback,
+        inputs: inputs.inputs,
+        ...structuralOverrides,
+        /* v8 ignore start */
+        ...(requiresIntervalsScoped.length === 0
+            ? {}
+            : { requiresIntervals: requiresIntervalsScoped }),
+        ...(sharedAlertConditions.length === 0 ? {} : { alertConditions: sharedAlertConditions }),
+        /* v8 ignore stop */
+        ...(dependencies === undefined || dependencies.length === 0 ? {} : { dependencies }),
+        ...(outputs === undefined ? {} : { outputs }),
+        ...(plotSlots === undefined || plotSlots.length === 0 ? {} : { plots: plotSlots }),
+        exportName: drawn.exportName,
+        isDrawn: true,
+        ...(siblings !== undefined && siblings.length > 0 ? { siblings } : {}),
+    });
+}
+function readDefineCallName(defineCall) {
+    const arg = defineCall.arguments[0];
+    /* v8 ignore next 3 */
+    if (arg === undefined || !ts.isObjectLiteralExpression(arg)) {
+        return "";
+    }
+    for (const property of arg.properties) {
+        /* v8 ignore next */
+        if (!ts.isPropertyAssignment(property))
+            continue;
+        const name = property.name;
+        /* v8 ignore next */
+        if (!ts.isIdentifier(name) || name.text !== "name")
+            continue;
+        const initializer = property.initializer;
+        if (ts.isStringLiteral(initializer))
+            return initializer.text;
+        /* v8 ignore next */
+    }
+    /* v8 ignore next 2 */
+    return "";
+}
 /**
  * Error thrown by `compile` / `compileFile` / `compileProject` when any
  * compilation produces an error-severity diagnostic. Carries the full
@@ -166,26 +287,122 @@ const PRINTER = ts.createPrinter({
  */
 export async function compile(source, opts) {
     const sourcePath = opts.sourcePath ?? "script.chart.ts";
-    const result = transformAndAnalyse(source, {
+    const resolveProducer = opts.resolveProducer ?? createDefaultProducerResolver(sourcePath, opts);
+    // Pre-scan the consumer's source for `import X from "./Y.chart"`
+    // statements + resolve them in parallel. Each producer's resolved
+    // snapshot feeds the sync lookup passed to `transformAndAnalyse`;
+    // the same snapshots become the bundler's `inlinedProducers`.
+    const preScan = preScanChartImports(source, sourcePath);
+    const resolved = await Promise.all(preScan.map(async (specifier) => {
+        const compiled = await resolveProducer(specifier, sourcePath);
+        return { specifier, compiled };
+    }));
+    const resolvedBySpecifier = new Map();
+    for (const entry of resolved) {
+        resolvedBySpecifier.set(entry.specifier, entry.compiled);
+    }
+    const transformOpts = {
         sourcePath,
+        /* v8 ignore next 3 */
         ...(opts.declaredIntervals === undefined
             ? {}
             : { declaredIntervals: opts.declaredIntervals }),
-    });
+        resolveProducer: (modSpec, expName) => {
+            const compiled = resolvedBySpecifier.get(modSpec);
+            /* v8 ignore next 3 */
+            if (compiled === undefined || compiled === null) {
+                return null;
+            }
+            const manifest = compiled.drawnByExportName.get(expName);
+            /* v8 ignore next 3 */
+            if (manifest === undefined) {
+                return null;
+            }
+            /* v8 ignore next */
+            const outputs = manifest.outputs ?? [];
+            return Object.freeze({
+                name: manifest.name,
+                outputs: Object.freeze(outputs.map((o) => Object.freeze({ title: o.title, kind: o.kind }))),
+                inputs: Object.fromEntries(Object.entries(manifest.inputs).map(([key, descriptor]) => [
+                    key,
+                    descriptor,
+                ])),
+            });
+        },
+    };
+    const result = transformAndAnalyse(source, transformOpts);
     const errors = result.diagnostics.filter((d) => d.severity === "error");
     if (errors.length > 0) {
         throw new CompileError(Object.freeze(errors.slice()));
     }
-    const transformedSource = PRINTER.printFile(result.transformed);
+    const printedSource = PRINTER.printFile(result.transformed);
     const sourcemap = opts.sourcemap ?? false;
+    // Walk every direct dep's transitive producer tree to build a
+    // topologically-ordered list (leaves first). Dedup by hash so a
+    // producer reached via two paths inlines exactly once.
+    const orderedProducers = [];
+    const seenHashes = new Set();
+    const collectTransitive = (p) => {
+        if (seenHashes.has(p.hash))
+            return;
+        for (const nested of p.transitiveProducers)
+            collectTransitive(nested);
+        seenHashes.add(p.hash);
+        orderedProducers.push(p);
+    };
+    for (const { compiled } of resolved) {
+        /* v8 ignore next */
+        if (compiled === null)
+            continue;
+        collectTransitive(compiled);
+    }
+    // Lower each cross-file `import <name> from "./X.chart"` line in
+    // the consumer's source to `const <name> = __producer_<hash>__default;`
+    // so the inlined producer's local binding feeds the rest of the
+    // consumer's body. Imports of non-resolved producers stay as-is so
+    // esbuild surfaces the unresolved-import error.
+    const specifierToHash = new Map();
+    for (const entry of resolved) {
+        /* v8 ignore next */
+        if (entry.compiled === null)
+            continue;
+        specifierToHash.set(entry.specifier, entry.compiled.hash);
+    }
+    const consumerSourceWithRewrittenImports = rewriteConsumerChartImports(printedSource, specifierToHash);
+    // §22.10 indicator-composition: when the default manifest declares
+    // private deps, append a hidden `export const __dependencies = [...]`
+    // BEFORE handing the source to esbuild so the bundler sees every
+    // alias binding referenced from the export graph. Pre-bundle inclusion
+    // is load-bearing — appending after `bundleModule` would let esbuild's
+    // tree-shaker drop aliases declared via `const trend = baseTrend;`
+    // (cross-file aliases reduce to a bare reference after the §22.10
+    // `withInputs` chain rewrite, which esbuild treats as side-effect-free
+    // and DCE-eligible).
+    const defaultDeps = result.manifest.dependencies ?? [];
+    const depsAssignment = formatDependenciesAssignment(defaultDeps.map((d) => ({
+        localId: d.localId,
+        bindingExpression: d.localId,
+        ...(Object.keys(d.effectiveInputs).length === 0
+            ? {}
+            : { effectiveInputs: d.effectiveInputs }),
+    })));
+    const transformedSource = `${consumerSourceWithRewrittenImports}\n${depsAssignment}`;
+    const inlinedProducers = orderedProducers.map((p) => ({
+        hash: p.hash,
+        rewrittenSource: p.rewrittenSource,
+    }));
     const bundle = await bundleModule({
         transformedSource,
         sourcePath,
         sourcemap,
         minify: opts.minify ?? false,
+        ...(inlinedProducers.length === 0 ? {} : { inlinedProducers }),
     });
-    const moduleSource = `${bundle.moduleSource}${formatManifestAssignment(result.manifest)}`;
-    const types = emitTypes({ manifest: result.manifest, sourcePath });
+    const sidecar = result.siblings === undefined
+        ? result.manifest
+        : Object.freeze([result.manifest, ...result.siblings]);
+    const moduleSource = `${bundle.moduleSource}${formatManifestAssignment(sidecar)}`;
+    const types = emitTypes({ manifest: sidecar, sourcePath });
     if (bundle.sourcemap !== undefined) {
         return Object.freeze({
             moduleSource,
@@ -253,8 +470,11 @@ export async function compileFile(path, opts) {
     const jsPath = `${base}.chart.js`;
     const manifestPath = `${base}.chart.manifest.json`;
     const dtsPath = `${base}.chart.d.ts`;
+    const sidecar = result.manifest.siblings === undefined
+        ? result.manifest
+        : Object.freeze([result.manifest, ...result.manifest.siblings]);
     await writeAtomic(jsPath, result.moduleSource);
-    await writeAtomic(manifestPath, JSON.stringify(result.manifest, null, 4));
+    await writeAtomic(manifestPath, JSON.stringify(sidecar, null, 4));
     await writeAtomic(dtsPath, result.types);
     if ((opts.sourcemap === true || opts.sourcemap === "external") &&
         result.sourcemap !== undefined) {
@@ -318,10 +538,22 @@ export async function walkChartFiles(rootDir) {
  */
 export async function compileProject(rootDir, opts) {
     const files = await walkChartFiles(rootDir);
+    let absoluteRoot;
+    if (isAbsolute(rootDir)) {
+        absoluteRoot = rootDir;
+        /* v8 ignore next 3 */
+    }
+    else {
+        absoluteRoot = resolvePath(process.cwd(), rootDir);
+    }
+    const sharedResolver = opts.resolveProducer ??
+        createProducerResolver({ rootDir: absoluteRoot }, (source, producerSourcePath) => compileProducerArtefacts(source, producerSourcePath, sharedResolver));
     const compiled = await Promise.all(files.map((file) => compileFile(file, {
         ...opts,
         write: false,
         sourcePath: toPosixRelative(process.cwd(), file),
+        resolveProducer: sharedResolver,
+        rootDir: absoluteRoot,
     })));
     return Object.freeze(compiled);
 }
@@ -336,8 +568,49 @@ async function readDirEntries(dir) {
         isFile: entry.isFile(),
     }));
 }
+function buildDependencyDeclarations(drawn, depGraph, sourcePath) {
+    if (drawn.consumes.length === 0)
+        return Object.freeze([]);
+    const declarations = [];
+    for (const consume of drawn.consumes) {
+        declarations.push(buildOneDependencyDeclaration(consume, depGraph, sourcePath));
+    }
+    return Object.freeze(declarations);
+}
+function buildOneDependencyDeclaration(consume, depGraph, sourcePath) {
+    const ref = consume.producerRef;
+    const outputsCopy = consume.outputs.map((o) => Object.freeze({ title: o.title, kind: o.kind }));
+    /* v8 ignore next */
+    if (ref.kind !== "same-file")
+        return buildCrossFileDeclaration(consume, ref, outputsCopy);
+    const isDrawn = depGraph.drawn.some((d) => d.bindingName === ref.bindingName && d.exportName !== "default");
+    const exportName = depGraph.drawn.find((d) => d.bindingName === ref.bindingName)?.exportName ??
+        ref.bindingName;
+    return Object.freeze({
+        localId: consume.localId,
+        producerName: ref.bindingName,
+        producerSourcePath: sourcePath,
+        producerExportName: exportName,
+        effectiveInputs: Object.freeze({ ...consume.effectiveInputs }),
+        outputs: Object.freeze(outputsCopy),
+        isDrawn,
+    });
+}
+/* v8 ignore start */
+function buildCrossFileDeclaration(consume, ref, outputsCopy) {
+    return Object.freeze({
+        localId: consume.localId,
+        producerName: ref.exportName,
+        producerSourcePath: ref.sourcePath,
+        producerExportName: ref.exportName,
+        effectiveInputs: Object.freeze({ ...consume.effectiveInputs }),
+        outputs: Object.freeze(outputsCopy),
+        isDrawn: false,
+    });
+}
+/* v8 ignore stop */
 function stripWriteFlag(opts) {
-    const { apiVersion, sourcePath, sourcemap, minify, target, declaredIntervals } = opts;
+    const { apiVersion, sourcePath, sourcemap, minify, target, declaredIntervals, resolveProducer, rootDir, } = opts;
     const out = { apiVersion };
     if (sourcePath !== undefined)
         out.sourcePath = sourcePath;
@@ -349,6 +622,182 @@ function stripWriteFlag(opts) {
         out.target = target;
     if (declaredIntervals !== undefined)
         out.declaredIntervals = declaredIntervals;
+    if (resolveProducer !== undefined)
+        out.resolveProducer = resolveProducer;
+    if (rootDir !== undefined)
+        out.rootDir = rootDir;
     return out;
 }
+/**
+ * Lower each cross-file `import <name> from "./X.chart"` line in the
+ * consumer's printed TS source to `const <name> = __producer_<hash>__default;`
+ * so the inlined producer's local binding wires into the consumer's body.
+ * Imports of unresolved specifiers (no entry in `specifierToHash`) stay
+ * as-is so esbuild surfaces the resolution failure.
+ *
+ * Phase 1 only supports the default-import form — named imports remain
+ * untouched and will be addressed when same-file named-export composition
+ * crosses file boundaries.
+ *
+ * @since 0.7
+ */
+function rewriteConsumerChartImports(source, specifierToHash) {
+    if (specifierToHash.size === 0)
+        return source;
+    return source.replace(/^\s*import\s+([A-Za-z_$][A-Za-z0-9_$]*)\s+from\s+(['"])([^'"]+)\2;\s*$/gm, (match, name, _quote, specifier) => {
+        const hash = specifierToHash.get(specifier);
+        /* v8 ignore next */
+        if (hash === undefined)
+            return match;
+        return `const ${name} = __producer_${hash}__default;`;
+    });
+}
+/**
+ * Pre-scan a `.chart.ts` source for `.chart.ts` / `.chart` import
+ * specifiers using a one-pass AST walk. Returns a deduplicated array of
+ * specifiers in source-declaration order. The list feeds `compile`'s
+ * async resolver before `transformAndAnalyse` runs so the analysis pass
+ * can resolve cross-file producer snapshots synchronously.
+ *
+ * @since 0.7
+ */
+function preScanChartImports(source, sourcePath) {
+    const sourceFile = ts.createSourceFile(sourcePath, source, ts.ScriptTarget.ES2022, true, ts.ScriptKind.TS);
+    const specifiers = [];
+    const seen = new Set();
+    for (const statement of sourceFile.statements) {
+        if (!ts.isImportDeclaration(statement))
+            continue;
+        const specifier = statement.moduleSpecifier;
+        /* v8 ignore next 3 */
+        if (!ts.isStringLiteral(specifier)) {
+            continue;
+        }
+        const text = specifier.text;
+        if (!text.endsWith(".chart") && !text.endsWith(".chart.ts"))
+            continue;
+        /* v8 ignore next 3 */
+        if (seen.has(text)) {
+            continue;
+        }
+        seen.add(text);
+        specifiers.push(text);
+    }
+    return Object.freeze(specifiers);
+}
+/**
+ * Build a per-`compile` cross-file resolver rooted at the consumer's
+ * directory. `compileProject` overrides this by sharing a single
+ * resolver across every file so the inline-once invariant holds.
+ *
+ * @since 0.7
+ */
+function createDefaultProducerResolver(sourcePath, opts) {
+    let absSourcePath;
+    /* v8 ignore next 3 */
+    if (isAbsolute(sourcePath)) {
+        absSourcePath = sourcePath;
+    }
+    else {
+        absSourcePath = resolvePath(process.cwd(), sourcePath);
+    }
+    const rootDir = opts.rootDir ?? dirname(absSourcePath);
+    const resolver = createProducerResolver({ rootDir }, (source, producerSourcePath) => compileProducerArtefacts(source, producerSourcePath, resolver));
+    return resolver;
+}
+/**
+ * Compile one producer file for the resolver. Pre-scans its imports,
+ * resolves them recursively (so transitive producers populate the
+ * cache before we hand control back), runs the producer's own
+ * `compile` + `transformAndAnalyse`, and returns the artefacts the
+ * resolver wraps into a {@link ProducerCompiled} snapshot.
+ *
+ * @since 0.7
+ */
+async function compileProducerArtefacts(source, producerSourcePath, resolver) {
+    try {
+        // Pre-resolve the producer's own cross-file deps so the
+        // recursive `compile` can pull the matching snapshot from the
+        // shared resolver's cache instead of compiling twice.
+        const preScan = preScanChartImports(source, producerSourcePath);
+        const nested = await Promise.all(preScan.map(async (specifier) => ({
+            specifier,
+            compiled: await resolver(specifier, producerSourcePath),
+        })));
+        const result = await compile(source, {
+            apiVersion: 1,
+            sourcePath: producerSourcePath,
+            resolveProducer: resolver,
+        });
+        const transformAndAnalyseResult = transformAndAnalyse(source, {
+            sourcePath: producerSourcePath,
+            resolveProducer: buildSyncSnapshotResolver(nested),
+        });
+        const transformedSource = PRINTER.printFile(transformAndAnalyseResult.transformed);
+        const transitiveProducers = [];
+        const specifierToHash = new Map();
+        for (const { specifier, compiled } of nested) {
+            /* v8 ignore next */
+            if (compiled === null)
+                continue;
+            transitiveProducers.push(compiled);
+            specifierToHash.set(specifier, compiled.hash);
+        }
+        let siblings;
+        if (transformAndAnalyseResult.siblings === undefined) {
+            siblings = Object.freeze([]);
+            /* v8 ignore next 3 */
+        }
+        else {
+            siblings = transformAndAnalyseResult.siblings;
+        }
+        return Object.freeze({
+            moduleSource: result.moduleSource,
+            transformedSource,
+            manifest: result.manifest,
+            siblings,
+            transitiveProducers: Object.freeze(transitiveProducers),
+            specifierToHash,
+        });
+        /* v8 ignore next 3 */
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Build a sync snapshot resolver from a pre-resolved list of cross-file
+ * producers. Returns the producer manifest's `ProducerSnapshot` shape
+ * `transformAndAnalyse` calls when walking consumer-side
+ * `<binding>.output("title")` references.
+ */
+function buildSyncSnapshotResolver(nested) {
+    const bySpecifier = new Map();
+    for (const entry of nested) {
+        if (entry.compiled !== null)
+            bySpecifier.set(entry.specifier, entry.compiled);
+    }
+    return (modSpec, expName) => {
+        const compiled = bySpecifier.get(modSpec);
+        /* v8 ignore next 3 */
+        if (compiled === undefined) {
+            return null;
+        }
+        const manifest = compiled.drawnByExportName.get(expName);
+        /* v8 ignore next 3 */
+        if (manifest === undefined) {
+            return null;
+        }
+        /* v8 ignore next */
+        const outputs = manifest.outputs ?? [];
+        return Object.freeze({
+            name: manifest.name,
+            outputs: Object.freeze(outputs.map((o) => Object.freeze({ title: o.title, kind: o.kind }))),
+            inputs: Object.fromEntries(Object.entries(manifest.inputs).map(([key, descriptor]) => [
+                key,
+                descriptor,
+            ])),
+        });
+    };
+}
 //# sourceMappingURL=api.js.map