@timber-js/app 0.2.0-alpha.20 → 0.2.0-alpha.201

package/dist/analyze/classify.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"classify.d.ts","sourceRoot":"","sources":["../../src/analyze/classify.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AAcH,MAAM,MAAM,UAAU,GAClB,QAAQ,GACR,iBAAiB,GACjB,iBAAiB,GACjB,QAAQ,GACR,eAAe,GACf,cAAc,CAAC;AAEnB,MAAM,MAAM,SAAS,GAAG,YAAY,GAAG,YAAY,GAAG,IAAI,CAAC;AAE3D;;;;;GAKG;AACH,MAAM,WAAW,iBAAiB;IAChC,wCAAwC;IACxC,IAAI,EAAE,MAAM,CAAC;IACb,qDAAqD;IACrD,KAAK,EAAE,OAAO,CAAC;IACf,qDAAqD;IACrD,KAAK,EAAE,OAAO,CAAC;IACf;;;;;OAKG;IACH,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB;;;;;OAKG;IACH,cAAc,CAAC,EAAE,OAAO,CAAC;IACzB,uDAAuD;IACvD,SAAS,EAAE,SAAS,CAAC;CACtB;AAED,MAAM,WAAW,oBAAoB;IACnC,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,UAAU,CAAC;IACjB;;;;;OAKG;IACH,IAAI,EAAE;QAAE,GAAG,EAAE,OAAO,CAAC;QAAC,GAAG,EAAE,OAAO,CAAC;QAAC,MAAM,EAAE,OAAO,CAAA;KAAE,CAAC;IACtD;;;;OAIG;IACH,OAAO,EAAE,OAAO,CAAC;IACjB;;;;;OAKG;IACH,cAAc,EAAE,OAAO,CAAC;CACzB;AAKD;;;;;;;;GAQG;AACH,wBAAgB,WAAW,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI,GAAG,KAAK,GAAG,KAAK,CAI9D;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,eAAe,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,SAAS,CAerE;AAED,2CAA2C;AAC3C,MAAM,WAAW,eAAe;IAC9B;;;;;OAKG;IACH,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB;;;OAGG;IACH,cAAc,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;CACpC;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,sBAAsB,CAAC,IAAI,EAAE,MAAM,EAAE,cAAc,CAAC,EAAE,SAAS,MAAM,EAAE,GAAG,OAAO,CAQhG;AAoBD;;;GAGG;AACH,wBAAgB,cAAc,CAC5B,GAAG,EAAE,iBAAiB,EACtB,GAAG,CAAC,EAAE,eAAe,GACpB,oBAAoB,CA2BtB;AAED,0EAA0E;AAC1E,wBAAgB,eAAe,CAC7B,YAAY,EAAE,QAAQ,CAAC,iBAAiB,CAAC,EACzC,GAAG,CAAC,EAAE,eAAe,GACpB,oBAAoB,EAAE,CAIxB"}

package/dist/analyze/crawl-entry.d.ts

@@ -0,0 +1,17 @@
+/**
+ * crawl-entry — child-process entry point for the cold crawl.
+ *
+ * The crawl's memory footprint is transient but large (~1.3 GB RSS on
+ * plugin-heavy apps — design/47 §6), so consumers spawn this module as a
+ * short-lived child process instead of crawling in-process:
+ *
+ *   node --import tsx/esm crawl-entry.ts --root <dir> [--config <file>]
+ *        [--out <file>] [--timeout <ms>]
+ *
+ * With `--out`, the JSON report is written to that file. Otherwise it is
+ * printed to stdout after a marker line — plugins in the booted app may
+ * write their own stdout noise, so consumers parse everything after the
+ * marker, not the whole stream.
+ */
+export {};
+//# sourceMappingURL=crawl-entry.d.ts.map

package/dist/analyze/crawl-entry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"crawl-entry.d.ts","sourceRoot":"","sources":["../../src/analyze/crawl-entry.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG"}

package/dist/analyze/crawl-entry.js

@@ -0,0 +1,313 @@
+import { i as scanProjectSourceFiles, n as isScannableSourceFile, t as buildSourceExtensions } from "../_chunks/scan-BoP17W3w.js";
+import { n as isTimberPluginApi, o as resolveAppDir } from "../_chunks/plugin-context-8idfR3UZ.js";
+import { a as detectDirective, i as classifyModules, n as stitchImportChains } from "../_chunks/chains-CBNA0Ozj.js";
+import { n as importSignals, r as poisoningsFor, t as collectImportSpecifiers } from "../_chunks/poison-scan-lEbz4pQE.js";
+import { normalizePath } from "vite";
+import { join, resolve } from "node:path";
+import { readFile, realpath, writeFile } from "node:fs/promises";
+//#region src/analyze/crawl.ts
+/**
+* crawl — programmatic middleware-mode crawl (the cold path).
+*
+* Boots `createServer({ middlewareMode: true })` — no HTTP port, no route
+* rendering — and BFS-walks `env.transformRequest(url)` → importedModules
+* edges from `virtual:timber-rsc-entry`, then from every discovered
+* `'use client'` boundary through the SSR environment. This reuses Vite's
+* actual resolution (aliases, tsconfig paths, react-server export
+* conditions, virtual modules), so it cannot drift from what dev or the
+* build does; hand-rolled resolution was evaluated and rejected
+* (design/47 §"Verified Prototype Findings").
+*
+* Cost model (design/47 §6): 2.5 s on small apps to ~10 s on dep-heavy
+* plugin stacks, with a transient ~1.3 GB RSS — callers MUST run this in
+* a short-lived child process (see crawl-entry.ts) and cache the
+* classification output, not the Vite transforms. The crawl always
+* covers the full project: one crawl per project state, never per
+* question — marginal per-file cost is ~zero once booted.
+*
+* `TIMBER_ANALYZE=1` is set before the server boots so platform dev
+* plugins (wrangler bindings — a measured ~6.8 s remote-bindings
+* handshake on website) skip work the crawl never needs: classification
+* wants import edges, not live Cloudflare connections.
+*
+* Design docs: 47-module-environment-tooling.md §6, §8.
+*/
+var RSC_ENTRY_URL = "virtual:timber-rsc-entry";
+/**
+* Marker preceding the JSON report on crawl-entry's stdout. Lives here
+* (not in crawl-entry.ts) so consumers can import it without executing
+* the child entry's main().
+*/
+var CRAWL_RESULT_MARKER = "__TIMBER_CRAWL_RESULT__";
+/** Marker error for deadline expiry — structurally distinguishable
+* from a deterministic transform failure (consumers must not cache a
+* deadline-truncated report; a transform failure recurs on retry and
+* caches fine). */
+var CrawlDeadlineError = class extends Error {};
+/** Race a promise against the crawl deadline. */
+function withDeadline(promise, remainingMs, label) {
+	return new Promise((resolvePromise, rejectPromise) => {
+		const timer = setTimeout(() => rejectPromise(new CrawlDeadlineError(`crawl deadline exceeded while transforming ${label}`)), Math.max(remainingMs, 1));
+		promise.then((value) => {
+			clearTimeout(timer);
+			resolvePromise(value);
+		}, (error) => {
+			clearTimeout(timer);
+			rejectPromise(error);
+		});
+	});
+}
+/**
+* Whether a graph node's file belongs in the report. `root` must be
+* slash-normalized; module-node paths already are (Vite normalizes
+* them, even on Windows — comparing against a backslashed root would
+* reject every physical module there and misreport the whole app as
+* pending). The rule set is the scan's own (isScannableSourceFile), so
+* report membership, disk-scan coverage, and the cache fingerprint are
+* one set — a graph-reachable file the fingerprint never tracked would
+* let its edits serve a stale cache (codex review, PR #1056).
+*/
+function isProjectFile(file, root, extensions) {
+	if (!file) return false;
+	return isScannableSourceFile(normalizePath(file), root, extensions);
+}
+/**
+* BFS one environment from the given seed URLs, transforming every
+* discovered module unconditionally. Transforming (rather than reading
+* live graphs) is what closes the §8 blind spot: modules behind
+* unexecuted dynamic imports are transformed here like any other edge.
+*
+* Exported for tests (deadline behavior is exercised with a fake env).
+*/
+async function crawlEnvironment(env, envName, seeds, root, deadlineAt, errors, extensions) {
+	const queue = [...seeds];
+	const enqueued = new Set(queue);
+	const projectFiles = /* @__PURE__ */ new Set();
+	const failedFiles = /* @__PURE__ */ new Set();
+	let visited = 0;
+	let deadlineHit = false;
+	for (let cursor = 0; cursor < queue.length; cursor++) {
+		const url = queue[cursor];
+		const remaining = deadlineAt - Date.now();
+		if (remaining <= 0) {
+			errors.push({
+				environment: envName,
+				id: url,
+				message: "crawl deadline exceeded"
+			});
+			deadlineHit = true;
+			break;
+		}
+		let node;
+		try {
+			await withDeadline(env.transformRequest(url), remaining, url);
+			node = await env.moduleGraph.getModuleByUrl(url);
+		} catch (error) {
+			if (error instanceof CrawlDeadlineError) deadlineHit = true;
+			errors.push({
+				environment: envName,
+				id: url,
+				message: error instanceof Error ? error.message : String(error)
+			});
+			node = await env.moduleGraph.getModuleByUrl(url).catch(() => void 0);
+			if (node && isProjectFile(node.file, root, extensions)) {
+				projectFiles.add(node.file);
+				failedFiles.add(node.file);
+			}
+			continue;
+		}
+		if (!node) continue;
+		visited++;
+		if (isProjectFile(node.file, root, extensions)) projectFiles.add(node.file);
+		for (const child of node.importedModules) {
+			const childUrl = child.url ?? child.id;
+			if (!childUrl || enqueued.has(childUrl)) continue;
+			enqueued.add(childUrl);
+			queue.push(childUrl);
+		}
+	}
+	return {
+		projectFiles,
+		failedFiles,
+		visited,
+		deadlineHit
+	};
+}
+/** Root-relative Vite URL for an absolute project file path.
+* Both arguments must be slash-normalized (the crawl normalizes at
+* the boundary, so callers always satisfy this). */
+function fileToUrl(file, root) {
+	return file.slice(root.length);
+}
+/**
+* Read a file's first directive and poison signals from its original
+* source on disk, in one read. A failure is recorded, not swallowed —
+* a lost 'use client' here would silently drop the whole client
+* subtree from the SSR crawl.
+*/
+async function sourceFactsOf(file, errors) {
+	try {
+		const code = await readFile(file, "utf8");
+		return {
+			directive: detectDirective(code, file),
+			signals: importSignals(collectImportSpecifiers(code, file))
+		};
+	} catch (error) {
+		errors.push({
+			environment: "scan",
+			id: file,
+			message: `directive read failed: ${error instanceof Error ? error.message : String(error)}`
+		});
+		return {
+			directive: null,
+			signals: []
+		};
+	}
+}
+/**
+* Crawl a project cold and classify every project file.
+*
+* Boots a middleware-mode Vite server with the app's own config (all
+* timber plugins, real resolution), crawls the RSC graph from the entry,
+* detects directives from original sources, crawls the SSR graph from
+* every `'use client'` boundary, and intersects the memberships.
+*/
+async function crawlProject(options) {
+	const startedAt = Date.now();
+	const deadlineAt = startedAt + (options.timeoutMs ?? 12e4);
+	process.env.TIMBER_ANALYZE = "1";
+	const { createServer } = await import("vite");
+	const server = await createServer({
+		root: options.root,
+		configFile: options.configFile,
+		server: {
+			middlewareMode: true,
+			watch: null
+		},
+		logLevel: "error"
+	});
+	try {
+		const root = normalizePath(server.config.resolve.preserveSymlinks ? server.config.root : await realpath(server.config.root));
+		const rscEnv = server.environments.rsc;
+		const ssrEnv = server.environments.ssr;
+		if (!rscEnv?.transformRequest || !ssrEnv?.transformRequest) throw new Error("[timber] crawl requires the rsc and ssr Vite environments");
+		const errors = [];
+		const rootSyncPlugin = server.config.plugins.find((p) => p.name === "timber-root-sync");
+		let appDir;
+		let pageExtensions;
+		if (rootSyncPlugin && isTimberPluginApi(rootSyncPlugin.api)) {
+			const pluginCtx = rootSyncPlugin.api.getContext();
+			appDir = pluginCtx.appDir;
+			pageExtensions = pluginCtx.config.pageExtensions;
+		} else try {
+			appDir = resolveAppDir(root);
+		} catch {
+			appDir = join(root, "app");
+		}
+		appDir = normalizePath(appDir);
+		const extensions = buildSourceExtensions(pageExtensions);
+		const rsc = await crawlEnvironment(rscEnv, "rsc", [RSC_ENTRY_URL], root, deadlineAt, errors, extensions);
+		const diskFiles = [];
+		await scanProjectSourceFiles(root, diskFiles, (failure) => errors.push({
+			environment: "scan",
+			id: failure.dir,
+			message: failure.message
+		}), 0, extensions);
+		const allFiles = /* @__PURE__ */ new Set([...rsc.projectFiles, ...diskFiles.map(normalizePath)]);
+		const facts = /* @__PURE__ */ new Map();
+		for (const file of allFiles) facts.set(file, await sourceFactsOf(file, errors));
+		const ssr = await crawlEnvironment(ssrEnv, "ssr", [...rsc.projectFiles].filter((file) => facts.get(file)?.directive === "use client").map((file) => fileToUrl(file, root)), root, deadlineAt, errors, extensions);
+		for (const file of ssr.projectFiles) if (!facts.has(file)) {
+			facts.set(file, await sourceFactsOf(file, errors));
+			allFiles.add(file);
+		}
+		const classifications = classifyModules([...allFiles].map((file) => ({
+			file,
+			inRsc: rsc.projectFiles.has(file),
+			inSsr: ssr.projectFiles.has(file),
+			ssrTransformed: ssr.projectFiles.has(file) ? !ssr.failedFiles.has(file) : void 0,
+			directive: facts.get(file)?.directive ?? null
+		})), {
+			appDir,
+			pageExtensions
+		});
+		const chainCtx = {
+			rsc: server.environments.rsc.moduleGraph,
+			ssr: server.environments.ssr.moduleGraph,
+			appDir,
+			pageExtensions,
+			getDirective: (file) => facts.get(file)?.directive ?? null
+		};
+		const modules = classifications.map((classification) => ({
+			...classification,
+			boundary: facts.get(classification.file)?.directive === "use client",
+			chains: stitchImportChains(classification.file, chainCtx),
+			poisonings: poisoningsFor(classification.kind, classification.pending, facts.get(classification.file)?.signals ?? [])
+		}));
+		return {
+			root,
+			incomplete: rsc.deadlineHit || ssr.deadlineHit,
+			modules,
+			errors,
+			stats: {
+				rscGraphModules: rsc.visited,
+				ssrGraphModules: ssr.visited,
+				projectFiles: allFiles.size,
+				durationMs: Date.now() - startedAt
+			}
+		};
+	} finally {
+		await Promise.race([server.close().catch(() => {}), new Promise((resolveTimer) => setTimeout(resolveTimer, 5e3))]);
+	}
+}
+//#endregion
+//#region src/analyze/crawl-entry.ts
+/**
+* crawl-entry — child-process entry point for the cold crawl.
+*
+* The crawl's memory footprint is transient but large (~1.3 GB RSS on
+* plugin-heavy apps — design/47 §6), so consumers spawn this module as a
+* short-lived child process instead of crawling in-process:
+*
+*   node --import tsx/esm crawl-entry.ts --root <dir> [--config <file>]
+*        [--out <file>] [--timeout <ms>]
+*
+* With `--out`, the JSON report is written to that file. Otherwise it is
+* printed to stdout after a marker line — plugins in the booted app may
+* write their own stdout noise, so consumers parse everything after the
+* marker, not the whole stream.
+*/
+function readFlag(argv, name) {
+	const index = argv.indexOf(name);
+	return index !== -1 ? argv[index + 1] : void 0;
+}
+async function main() {
+	const argv = process.argv.slice(2);
+	const rootArg = readFlag(argv, "--root");
+	if (!rootArg) {
+		process.stderr.write("usage: crawl-entry --root <dir> [--config <file>] [--out <file>]\n");
+		process.exitCode = 2;
+		return;
+	}
+	const timeoutArg = readFlag(argv, "--timeout");
+	const report = await crawlProject({
+		root: resolve(rootArg),
+		configFile: readFlag(argv, "--config"),
+		timeoutMs: timeoutArg ? Number(timeoutArg) : void 0
+	});
+	const json = JSON.stringify(report);
+	const outFile = readFlag(argv, "--out");
+	if (outFile) await writeFile(resolve(outFile), json);
+	else await new Promise((resolveWrite, rejectWrite) => {
+		process.stdout.write(`\n${CRAWL_RESULT_MARKER}\n${json}\n`, (error) => error ? rejectWrite(error) : resolveWrite());
+	});
+}
+main().then(() => {
+	process.exit(process.exitCode ?? 0);
+}, (error) => {
+	process.stderr.write(`[timber] crawl failed: ${error?.stack ?? String(error)}\n`);
+	process.exit(1);
+});
+//#endregion
+
+//# sourceMappingURL=crawl-entry.js.map

package/dist/analyze/crawl-entry.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"crawl-entry.js","names":[],"sources":["../../src/analyze/crawl.ts","../../src/analyze/crawl-entry.ts"],"sourcesContent":["/**\n * crawl — programmatic middleware-mode crawl (the cold path).\n *\n * Boots `createServer({ middlewareMode: true })` — no HTTP port, no route\n * rendering — and BFS-walks `env.transformRequest(url)` → importedModules\n * edges from `virtual:timber-rsc-entry`, then from every discovered\n * `'use client'` boundary through the SSR environment. This reuses Vite's\n * actual resolution (aliases, tsconfig paths, react-server export\n * conditions, virtual modules), so it cannot drift from what dev or the\n * build does; hand-rolled resolution was evaluated and rejected\n * (design/47 §\"Verified Prototype Findings\").\n *\n * Cost model (design/47 §6): 2.5 s on small apps to ~10 s on dep-heavy\n * plugin stacks, with a transient ~1.3 GB RSS — callers MUST run this in\n * a short-lived child process (see crawl-entry.ts) and cache the\n * classification output, not the Vite transforms. The crawl always\n * covers the full project: one crawl per project state, never per\n * question — marginal per-file cost is ~zero once booted.\n *\n * `TIMBER_ANALYZE=1` is set before the server boots so platform dev\n * plugins (wrangler bindings — a measured ~6.8 s remote-bindings\n * handshake on website) skip work the crawl never needs: classification\n * wants import edges, not live Cloudflare connections.\n *\n * Design docs: 47-module-environment-tooling.md §6, §8.\n */\n\nimport { readFile, realpath } from 'node:fs/promises';\nimport { join } from 'node:path';\nimport type { ViteDevServer } from 'vite';\nimport { normalizePath } from 'vite';\nimport {\n  classifyModules,\n  detectDirective,\n  type Directive,\n  type ModuleClassification,\n} from './classify.ts';\nimport { buildSourceExtensions, scanProjectSourceFiles, isScannableSourceFile } from './scan.ts';\nimport { stitchImportChains, type ChainGraph, type ImportChain } from './chains.ts';\nimport {\n  collectImportSpecifiers,\n  importSignals,\n  poisoningsFor,\n  type Poisoning,\n} from './poison-scan.ts';\nimport { isTimberPluginApi, resolveAppDir } from '../plugin-context.ts';\n\nconst RSC_ENTRY_URL = 'virtual:timber-rsc-entry';\n\n/**\n * Marker preceding the JSON report on crawl-entry's stdout. Lives here\n * (not in crawl-entry.ts) so consumers can import it without executing\n * the child entry's main().\n */\nexport const CRAWL_RESULT_MARKER = '__TIMBER_CRAWL_RESULT__';\n\nexport interface CrawlOptions {\n  /** Project root (the app directory containing vite.config). */\n  root: string;\n  /** Explicit Vite config file; discovered from root when omitted. */\n  configFile?: string;\n  /** Overall crawl deadline. Default 120s. */\n  timeoutMs?: number;\n}\n\nexport interface CrawlError {\n  /** 'scan' covers disk-scan and directive-read failures. */\n  environment: 'rsc' | 'ssr' | 'scan';\n  id: string;\n  message: string;\n}\n\n/**\n * One project file's full graph answer — the classification plus the\n * remaining JSON-contract fields (`boundary`, `chains`, `poisonings`)\n * that need the open graphs / original sources to compute. This is the\n * per-module unit `timber graph` caches and serves.\n */\nexport interface GraphModuleReport extends ModuleClassification {\n  /** True when the file itself carries `'use client'`. */\n  boundary: boolean;\n  /** Boundary-aware import chains (design/47 §7); [] when in no graph. */\n  chains: ImportChain[];\n  /** Report-only poisoning conflicts (design/47 §3); [] when clean. */\n  poisonings: Poisoning[];\n}\n\nexport interface CrawlReport {\n  root: string;\n  /**\n   * True when the crawl deadline expired mid-walk — the report is\n   * truncated, not wrong, and the condition is transient (a slow\n   * machine, a cold dep-optimizer). Consumers must not cache an\n   * incomplete report: with unchanged files it would be served forever,\n   * never retrying after the transient cause cleared. Deterministic\n   * per-module transform failures do NOT set this — they recur on\n   * retry, so caching them is correct.\n   */\n  incomplete: boolean;\n  /** Classification of every project file, sorted by path. */\n  modules: GraphModuleReport[];\n  /**\n   * Transform failures encountered during the BFS. These are classified,\n   * not swallowed — CSS/asset URLs and non-transformable modules land\n   * here (44 on website in the §6 measurement) and the crawl continues.\n   */\n  errors: CrawlError[];\n  stats: {\n    rscGraphModules: number;\n    ssrGraphModules: number;\n    projectFiles: number;\n    durationMs: number;\n  };\n}\n\n/** Marker error for deadline expiry — structurally distinguishable\n * from a deterministic transform failure (consumers must not cache a\n * deadline-truncated report; a transform failure recurs on retry and\n * caches fine). */\nclass CrawlDeadlineError extends Error {}\n\n/** Race a promise against the crawl deadline. */\nfunction withDeadline<T>(promise: Promise<T>, remainingMs: number, label: string): Promise<T> {\n  return new Promise<T>((resolvePromise, rejectPromise) => {\n    const timer = setTimeout(\n      () =>\n        rejectPromise(\n          new CrawlDeadlineError(`crawl deadline exceeded while transforming ${label}`)\n        ),\n      Math.max(remainingMs, 1)\n    );\n    promise.then(\n      (value) => {\n        clearTimeout(timer);\n        resolvePromise(value);\n      },\n      (error) => {\n        clearTimeout(timer);\n        rejectPromise(error);\n      }\n    );\n  });\n}\n\n/** Duck-typed view of the Vite dev environment surface the crawl uses. */\nexport interface CrawlEnvironment {\n  transformRequest(url: string): Promise<unknown>;\n  moduleGraph: {\n    getModuleByUrl(url: string): Promise<CrawlModuleNode | undefined>;\n  };\n}\n\ninterface CrawlModuleNode {\n  id: string | null;\n  url: string;\n  file: string | null;\n  importedModules: Set<CrawlModuleNode>;\n  transformResult: unknown;\n}\n\ninterface EnvCrawlResult {\n  /** Absolute paths of project files reached in this environment. */\n  projectFiles: Set<string>;\n  /** Project files whose own transform failed (membership unconfirmed subtree). */\n  failedFiles: Set<string>;\n  /** Total graph modules visited (project + deps + virtual). */\n  visited: number;\n  /** The deadline expired mid-walk — the result is truncated. */\n  deadlineHit: boolean;\n}\n\n/**\n * Whether a graph node's file belongs in the report. `root` must be\n * slash-normalized; module-node paths already are (Vite normalizes\n * them, even on Windows — comparing against a backslashed root would\n * reject every physical module there and misreport the whole app as\n * pending). The rule set is the scan's own (isScannableSourceFile), so\n * report membership, disk-scan coverage, and the cache fingerprint are\n * one set — a graph-reachable file the fingerprint never tracked would\n * let its edits serve a stale cache (codex review, PR #1056).\n */\nfunction isProjectFile(file: string | null, root: string, extensions?: RegExp): file is string {\n  if (!file) return false;\n  return isScannableSourceFile(normalizePath(file), root, extensions);\n}\n\n/**\n * BFS one environment from the given seed URLs, transforming every\n * discovered module unconditionally. Transforming (rather than reading\n * live graphs) is what closes the §8 blind spot: modules behind\n * unexecuted dynamic imports are transformed here like any other edge.\n *\n * Exported for tests (deadline behavior is exercised with a fake env).\n */\nexport async function crawlEnvironment(\n  env: CrawlEnvironment,\n  envName: 'rsc' | 'ssr',\n  seeds: string[],\n  root: string,\n  deadlineAt: number,\n  errors: CrawlError[],\n  extensions?: RegExp\n): Promise<EnvCrawlResult> {\n  const queue = [...seeds];\n  const enqueued = new Set(queue);\n  const projectFiles = new Set<string>();\n  const failedFiles = new Set<string>();\n  let visited = 0;\n  let deadlineHit = false;\n\n  // Index-cursor BFS — the queue only grows, so this walks each entry once.\n  for (let cursor = 0; cursor < queue.length; cursor++) {\n    const url = queue[cursor];\n    const remaining = deadlineAt - Date.now();\n    if (remaining <= 0) {\n      errors.push({ environment: envName, id: url, message: 'crawl deadline exceeded' });\n      deadlineHit = true;\n      break;\n    }\n\n    let node: CrawlModuleNode | undefined;\n    try {\n      await withDeadline(env.transformRequest(url), remaining, url);\n      node = await env.moduleGraph.getModuleByUrl(url);\n    } catch (error) {\n      if (error instanceof CrawlDeadlineError) deadlineHit = true;\n      errors.push({\n        environment: envName,\n        id: url,\n        message: error instanceof Error ? error.message : String(error),\n      });\n      // The URL may still have a graph node with a file — it IS a graph\n      // member (reachable), its transform just failed. Record membership\n      // AND the failure so classification reports it as reachable with\n      // subtreeUnknown, not as pending/unreferenced.\n      node = await env.moduleGraph.getModuleByUrl(url).catch(() => undefined);\n      if (node && isProjectFile(node.file, root, extensions)) {\n        projectFiles.add(node.file);\n        failedFiles.add(node.file);\n      }\n      continue;\n    }\n\n    if (!node) continue;\n    visited++;\n    if (isProjectFile(node.file, root, extensions)) projectFiles.add(node.file);\n\n    for (const child of node.importedModules) {\n      const childUrl = child.url ?? child.id;\n      if (!childUrl || enqueued.has(childUrl)) continue;\n      enqueued.add(childUrl);\n      queue.push(childUrl);\n    }\n  }\n\n  return { projectFiles, failedFiles, visited, deadlineHit };\n}\n\n/** Root-relative Vite URL for an absolute project file path.\n * Both arguments must be slash-normalized (the crawl normalizes at\n * the boundary, so callers always satisfy this). */\nfunction fileToUrl(file: string, root: string): string {\n  return file.slice(root.length);\n}\n\n/** What one read of a module's original source yields. */\ninterface SourceFacts {\n  directive: Directive;\n  /** Import-specifier exclusivity signals (poison-scan). */\n  signals: Poisoning[];\n}\n\n/**\n * Read a file's first directive and poison signals from its original\n * source on disk, in one read. A failure is recorded, not swallowed —\n * a lost 'use client' here would silently drop the whole client\n * subtree from the SSR crawl.\n */\nasync function sourceFactsOf(file: string, errors: CrawlError[]): Promise<SourceFacts> {\n  try {\n    const code = await readFile(file, 'utf8');\n    return {\n      directive: detectDirective(code, file),\n      signals: importSignals(collectImportSpecifiers(code, file)),\n    };\n  } catch (error) {\n    errors.push({\n      environment: 'scan',\n      id: file,\n      message: `directive read failed: ${error instanceof Error ? error.message : String(error)}`,\n    });\n    return { directive: null, signals: [] };\n  }\n}\n\n/**\n * Crawl a project cold and classify every project file.\n *\n * Boots a middleware-mode Vite server with the app's own config (all\n * timber plugins, real resolution), crawls the RSC graph from the entry,\n * detects directives from original sources, crawls the SSR graph from\n * every `'use client'` boundary, and intersects the memberships.\n */\nexport async function crawlProject(options: CrawlOptions): Promise<CrawlReport> {\n  const startedAt = Date.now();\n  const deadlineAt = startedAt + (options.timeoutMs ?? 120_000);\n  // Signal platform dev plugins (wrangler bindings) to skip boot work the\n  // crawl never uses. Must be set before createServer runs plugin hooks.\n  process.env.TIMBER_ANALYZE = '1';\n\n  const { createServer } = await import('vite');\n  const server: ViteDevServer = await createServer({\n    root: options.root,\n    configFile: options.configFile,\n    server: { middlewareMode: true, watch: null },\n    logLevel: 'error',\n  });\n\n  try {\n    // The root must live in the same path space as the graph nodes.\n    // By default Vite resolves through symlinks, so nodes carry\n    // realpaths and a symlinked root (pnpm workspaces, ~ links) would\n    // string-mismatch every file and misclassify the whole project as\n    // unreferenced (design/43 open question 3). Under\n    // resolve.preserveSymlinks the graphs keep the SYMLINK paths, and\n    // realpathing would create exactly the mismatch it normally\n    // prevents — honor the resolved setting. Slash-normalize either\n    // way: module-node paths are slash-normalized even on Windows.\n    const root = normalizePath(\n      server.config.resolve.preserveSymlinks\n        ? server.config.root\n        : await realpath(server.config.root)\n    );\n    // Structural assignment, no cast: CrawlEnvironment/CrawlModuleNode\n    // are supertypes of Vite's DevEnvironment/EnvironmentModuleNode for\n    // the members the BFS reads, so an upstream shape change fails here\n    // at compile time instead of inside the walk.\n    const rscEnv: CrawlEnvironment | undefined = server.environments.rsc;\n    const ssrEnv: CrawlEnvironment | undefined = server.environments.ssr;\n    if (!rscEnv?.transformRequest || !ssrEnv?.transformRequest) {\n      throw new Error('[timber] crawl requires the rsc and ssr Vite environments');\n    }\n\n    const errors: CrawlError[] = [];\n\n    // appDir and pageExtensions come from the booted server's own\n    // resolved timber config (the root-sync plugin api — the single\n    // supported way to read it; cf. cli-check.ts). Resolved before\n    // Phase 1 so the scan extension set is available to isProjectFile\n    // and scanProjectSourceFiles — custom pageExtensions must be\n    // admitted throughout, or graph membership disagrees with the\n    // disk scan and fingerprint (TIM-1392).\n    const rootSyncPlugin = server.config.plugins.find((p) => p.name === 'timber-root-sync');\n    let appDir: string;\n    let pageExtensions: readonly string[] | undefined;\n    if (rootSyncPlugin && isTimberPluginApi(rootSyncPlugin.api)) {\n      const pluginCtx = rootSyncPlugin.api.getContext();\n      appDir = pluginCtx.appDir;\n      pageExtensions = pluginCtx.config.pageExtensions;\n    } else {\n      try {\n        appDir = resolveAppDir(root);\n      } catch {\n        // No app directory at all — provisional convention hints just\n        // never fire; graph-membership classification is unaffected.\n        appDir = join(root, 'app');\n      }\n    }\n    // Normalize once at the boundary: appDir comes from node:path\n    // join() (backslashes on Windows) but all downstream comparisons\n    // — classify, chains, isRouteRoot — expect slash-normalized paths.\n    appDir = normalizePath(appDir);\n    const extensions = buildSourceExtensions(pageExtensions);\n\n    // Phase 1 — RSC graph from the entry.\n    const rsc = await crawlEnvironment(\n      rscEnv,\n      'rsc',\n      [RSC_ENTRY_URL],\n      root,\n      deadlineAt,\n      errors,\n      extensions\n    );\n\n    // Phase 2 — directives + poison signals for everything discovered so\n    // far plus files on disk that no graph reached (the provisional/\n    // pending set). The disk walk is the same one the graph cache\n    // fingerprints (scan.ts) so cache validity covers exactly this set.\n    const diskFiles: string[] = [];\n    await scanProjectSourceFiles(\n      root,\n      diskFiles,\n      (failure) => errors.push({ environment: 'scan', id: failure.dir, message: failure.message }),\n      0,\n      extensions\n    );\n    // One path space throughout: graph paths are already slash-\n    // normalized, disk-walk paths are node-joined (backslashed on\n    // Windows) — mixing them in one Set would duplicate every file.\n    const allFiles = new Set([...rsc.projectFiles, ...diskFiles.map(normalizePath)]);\n    const facts = new Map<string, SourceFacts>();\n    for (const file of allFiles) {\n      facts.set(file, await sourceFactsOf(file, errors));\n    }\n\n    // Phase 3 — SSR graph from every RSC-REACHABLE 'use client'\n    // boundary. SSR renders exactly the tree the browser hydrates, so\n    // this yields the client tree (boundaries plus everything they\n    // transitively import). Disk-only boundaries are deliberately NOT\n    // seeded: an unreferenced 'use client' file must keep its\n    // provisional pending classification, not get promoted to a\n    // confirmed boundary (and drag its imports in as client-internal)\n    // by the act of analyzing it.\n    const boundarySeeds = [...rsc.projectFiles]\n      .filter((file) => facts.get(file)?.directive === 'use client')\n      .map((file) => fileToUrl(file, root));\n    const ssr = await crawlEnvironment(\n      ssrEnv,\n      'ssr',\n      boundarySeeds,\n      root,\n      deadlineAt,\n      errors,\n      extensions\n    );\n\n    // SSR-only discoveries (client-internal files) need facts too.\n    for (const file of ssr.projectFiles) {\n      if (!facts.has(file)) {\n        facts.set(file, await sourceFactsOf(file, errors));\n        allFiles.add(file);\n      }\n    }\n\n    const classifications = classifyModules(\n      [...allFiles].map((file) => ({\n        file,\n        inRsc: rsc.projectFiles.has(file),\n        inSsr: ssr.projectFiles.has(file),\n        // The crawl transforms unconditionally, so the untransformed\n        // frontier only arises where the transform itself failed.\n        ssrTransformed: ssr.projectFiles.has(file) ? !ssr.failedFiles.has(file) : undefined,\n        directive: facts.get(file)?.directive ?? null,\n      })),\n      { appDir, pageExtensions }\n    );\n\n    // Phase 4 — chains, from the live graphs of the still-open server.\n    // ChainGraph is a structural supertype of Vite's module graphs\n    // (TIM-1382), so the assignment is cast-free and an upstream shape\n    // change fails at compile time.\n    const rscChainGraph: ChainGraph = server.environments.rsc.moduleGraph;\n    const ssrChainGraph: ChainGraph = server.environments.ssr.moduleGraph;\n    const chainCtx = {\n      rsc: rscChainGraph,\n      ssr: ssrChainGraph,\n      appDir,\n      pageExtensions,\n      // facts keys are already slash-normalized (allFiles is built from\n      // graph membership + diskFiles.map(normalizePath)), so no\n      // per-lookup normalization is needed.\n      getDirective: (file: string) => facts.get(file)?.directive ?? null,\n    };\n\n    const modules: GraphModuleReport[] = classifications.map((classification) => ({\n      ...classification,\n      boundary: facts.get(classification.file)?.directive === 'use client',\n      chains: stitchImportChains(classification.file, chainCtx),\n      poisonings: poisoningsFor(\n        classification.kind,\n        classification.pending,\n        facts.get(classification.file)?.signals ?? []\n      ),\n    }));\n\n    return {\n      root,\n      incomplete: rsc.deadlineHit || ssr.deadlineHit,\n      modules,\n      errors,\n      stats: {\n        rscGraphModules: rsc.visited,\n        ssrGraphModules: ssr.visited,\n        projectFiles: allFiles.size,\n        durationMs: Date.now() - startedAt,\n      },\n    };\n  } finally {\n    // Bound the cleanup: after a deadline expiry the very transforms\n    // that hung are what server.close() waits on — an unbounded await\n    // here would hang the child past its own --timeout and the report\n    // would never be emitted. The child's process.exit reaps whatever\n    // close left behind.\n    await Promise.race([\n      server.close().catch(() => {}),\n      new Promise<void>((resolveTimer) => setTimeout(resolveTimer, 5_000)),\n    ]);\n  }\n}\n","/**\n * crawl-entry — child-process entry point for the cold crawl.\n *\n * The crawl's memory footprint is transient but large (~1.3 GB RSS on\n * plugin-heavy apps — design/47 §6), so consumers spawn this module as a\n * short-lived child process instead of crawling in-process:\n *\n *   node --import tsx/esm crawl-entry.ts --root <dir> [--config <file>]\n *        [--out <file>] [--timeout <ms>]\n *\n * With `--out`, the JSON report is written to that file. Otherwise it is\n * printed to stdout after a marker line — plugins in the booted app may\n * write their own stdout noise, so consumers parse everything after the\n * marker, not the whole stream.\n */\n\nimport { writeFile } from 'node:fs/promises';\nimport { resolve } from 'node:path';\nimport { crawlProject, CRAWL_RESULT_MARKER } from './crawl.ts';\n\nfunction readFlag(argv: string[], name: string): string | undefined {\n  const index = argv.indexOf(name);\n  return index !== -1 ? argv[index + 1] : undefined;\n}\n\nasync function main(): Promise<void> {\n  const argv = process.argv.slice(2);\n  const rootArg = readFlag(argv, '--root');\n  if (!rootArg) {\n    process.stderr.write('usage: crawl-entry --root <dir> [--config <file>] [--out <file>]\\n');\n    process.exitCode = 2;\n    return;\n  }\n\n  const timeoutArg = readFlag(argv, '--timeout');\n  const report = await crawlProject({\n    root: resolve(rootArg),\n    configFile: readFlag(argv, '--config'),\n    timeoutMs: timeoutArg ? Number(timeoutArg) : undefined,\n  });\n\n  const json = JSON.stringify(report);\n  const outFile = readFlag(argv, '--out');\n  if (outFile) {\n    await writeFile(resolve(outFile), json);\n  } else {\n    // Await the flush: stdout to a pipe is async, and process.exit()\n    // below does NOT flush pending pipe writes — a large report would\n    // be truncated right after the marker.\n    await new Promise<void>((resolveWrite, rejectWrite) => {\n      process.stdout.write(`\\n${CRAWL_RESULT_MARKER}\\n${json}\\n`, (error) =>\n        error ? rejectWrite(error) : resolveWrite()\n      );\n    });\n  }\n}\n\nmain().then(\n  () => {\n    // The booted app's plugins may hold handles (watchers, sockets) past\n    // server.close(); the crawl is a read-only child, so exit explicitly.\n    process.exit(process.exitCode ?? 0);\n  },\n  (error) => {\n    process.stderr.write(`[timber] crawl failed: ${error?.stack ?? String(error)}\\n`);\n    process.exit(1);\n  }\n);\n"],"mappings":"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"}

package/dist/analyze/crawl.d.ts

@@ -0,0 +1,134 @@
+/**
+ * crawl — programmatic middleware-mode crawl (the cold path).
+ *
+ * Boots `createServer({ middlewareMode: true })` — no HTTP port, no route
+ * rendering — and BFS-walks `env.transformRequest(url)` → importedModules
+ * edges from `virtual:timber-rsc-entry`, then from every discovered
+ * `'use client'` boundary through the SSR environment. This reuses Vite's
+ * actual resolution (aliases, tsconfig paths, react-server export
+ * conditions, virtual modules), so it cannot drift from what dev or the
+ * build does; hand-rolled resolution was evaluated and rejected
+ * (design/47 §"Verified Prototype Findings").
+ *
+ * Cost model (design/47 §6): 2.5 s on small apps to ~10 s on dep-heavy
+ * plugin stacks, with a transient ~1.3 GB RSS — callers MUST run this in
+ * a short-lived child process (see crawl-entry.ts) and cache the
+ * classification output, not the Vite transforms. The crawl always
+ * covers the full project: one crawl per project state, never per
+ * question — marginal per-file cost is ~zero once booted.
+ *
+ * `TIMBER_ANALYZE=1` is set before the server boots so platform dev
+ * plugins (wrangler bindings — a measured ~6.8 s remote-bindings
+ * handshake on website) skip work the crawl never needs: classification
+ * wants import edges, not live Cloudflare connections.
+ *
+ * Design docs: 47-module-environment-tooling.md §6, §8.
+ */
+import { type ModuleClassification } from './classify.ts';
+import { type ImportChain } from './chains.ts';
+import { type Poisoning } from './poison-scan.ts';
+/**
+ * Marker preceding the JSON report on crawl-entry's stdout. Lives here
+ * (not in crawl-entry.ts) so consumers can import it without executing
+ * the child entry's main().
+ */
+export declare const CRAWL_RESULT_MARKER = "__TIMBER_CRAWL_RESULT__";
+export interface CrawlOptions {
+    /** Project root (the app directory containing vite.config). */
+    root: string;
+    /** Explicit Vite config file; discovered from root when omitted. */
+    configFile?: string;
+    /** Overall crawl deadline. Default 120s. */
+    timeoutMs?: number;
+}
+export interface CrawlError {
+    /** 'scan' covers disk-scan and directive-read failures. */
+    environment: 'rsc' | 'ssr' | 'scan';
+    id: string;
+    message: string;
+}
+/**
+ * One project file's full graph answer — the classification plus the
+ * remaining JSON-contract fields (`boundary`, `chains`, `poisonings`)
+ * that need the open graphs / original sources to compute. This is the
+ * per-module unit `timber graph` caches and serves.
+ */
+export interface GraphModuleReport extends ModuleClassification {
+    /** True when the file itself carries `'use client'`. */
+    boundary: boolean;
+    /** Boundary-aware import chains (design/47 §7); [] when in no graph. */
+    chains: ImportChain[];
+    /** Report-only poisoning conflicts (design/47 §3); [] when clean. */
+    poisonings: Poisoning[];
+}
+export interface CrawlReport {
+    root: string;
+    /**
+     * True when the crawl deadline expired mid-walk — the report is
+     * truncated, not wrong, and the condition is transient (a slow
+     * machine, a cold dep-optimizer). Consumers must not cache an
+     * incomplete report: with unchanged files it would be served forever,
+     * never retrying after the transient cause cleared. Deterministic
+     * per-module transform failures do NOT set this — they recur on
+     * retry, so caching them is correct.
+     */
+    incomplete: boolean;
+    /** Classification of every project file, sorted by path. */
+    modules: GraphModuleReport[];
+    /**
+     * Transform failures encountered during the BFS. These are classified,
+     * not swallowed — CSS/asset URLs and non-transformable modules land
+     * here (44 on website in the §6 measurement) and the crawl continues.
+     */
+    errors: CrawlError[];
+    stats: {
+        rscGraphModules: number;
+        ssrGraphModules: number;
+        projectFiles: number;
+        durationMs: number;
+    };
+}
+/** Duck-typed view of the Vite dev environment surface the crawl uses. */
+export interface CrawlEnvironment {
+    transformRequest(url: string): Promise<unknown>;
+    moduleGraph: {
+        getModuleByUrl(url: string): Promise<CrawlModuleNode | undefined>;
+    };
+}
+interface CrawlModuleNode {
+    id: string | null;
+    url: string;
+    file: string | null;
+    importedModules: Set<CrawlModuleNode>;
+    transformResult: unknown;
+}
+interface EnvCrawlResult {
+    /** Absolute paths of project files reached in this environment. */
+    projectFiles: Set<string>;
+    /** Project files whose own transform failed (membership unconfirmed subtree). */
+    failedFiles: Set<string>;
+    /** Total graph modules visited (project + deps + virtual). */
+    visited: number;
+    /** The deadline expired mid-walk — the result is truncated. */
+    deadlineHit: boolean;
+}
+/**
+ * BFS one environment from the given seed URLs, transforming every
+ * discovered module unconditionally. Transforming (rather than reading
+ * live graphs) is what closes the §8 blind spot: modules behind
+ * unexecuted dynamic imports are transformed here like any other edge.
+ *
+ * Exported for tests (deadline behavior is exercised with a fake env).
+ */
+export declare function crawlEnvironment(env: CrawlEnvironment, envName: 'rsc' | 'ssr', seeds: string[], root: string, deadlineAt: number, errors: CrawlError[], extensions?: RegExp): Promise<EnvCrawlResult>;
+/**
+ * Crawl a project cold and classify every project file.
+ *
+ * Boots a middleware-mode Vite server with the app's own config (all
+ * timber plugins, real resolution), crawls the RSC graph from the entry,
+ * detects directives from original sources, crawls the SSR graph from
+ * every `'use client'` boundary, and intersects the memberships.
+ */
+export declare function crawlProject(options: CrawlOptions): Promise<CrawlReport>;
+export {};
+//# sourceMappingURL=crawl.d.ts.map

package/dist/analyze/crawl.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"crawl.d.ts","sourceRoot":"","sources":["../../src/analyze/crawl.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AAMH,OAAO,EAIL,KAAK,oBAAoB,EAC1B,MAAM,eAAe,CAAC;AAEvB,OAAO,EAAuC,KAAK,WAAW,EAAE,MAAM,aAAa,CAAC;AACpF,OAAO,EAIL,KAAK,SAAS,EACf,MAAM,kBAAkB,CAAC;AAK1B;;;;GAIG;AACH,eAAO,MAAM,mBAAmB,4BAA4B,CAAC;AAE7D,MAAM,WAAW,YAAY;IAC3B,+DAA+D;IAC/D,IAAI,EAAE,MAAM,CAAC;IACb,oEAAoE;IACpE,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,4CAA4C;IAC5C,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB;AAED,MAAM,WAAW,UAAU;IACzB,2DAA2D;IAC3D,WAAW,EAAE,KAAK,GAAG,KAAK,GAAG,MAAM,CAAC;IACpC,EAAE,EAAE,MAAM,CAAC;IACX,OAAO,EAAE,MAAM,CAAC;CACjB;AAED;;;;;GAKG;AACH,MAAM,WAAW,iBAAkB,SAAQ,oBAAoB;IAC7D,wDAAwD;IACxD,QAAQ,EAAE,OAAO,CAAC;IAClB,wEAAwE;IACxE,MAAM,EAAE,WAAW,EAAE,CAAC;IACtB,qEAAqE;IACrE,UAAU,EAAE,SAAS,EAAE,CAAC;CACzB;AAED,MAAM,WAAW,WAAW;IAC1B,IAAI,EAAE,MAAM,CAAC;IACb;;;;;;;;OAQG;IACH,UAAU,EAAE,OAAO,CAAC;IACpB,4DAA4D;IAC5D,OAAO,EAAE,iBAAiB,EAAE,CAAC;IAC7B;;;;OAIG;IACH,MAAM,EAAE,UAAU,EAAE,CAAC;IACrB,KAAK,EAAE;QACL,eAAe,EAAE,MAAM,CAAC;QACxB,eAAe,EAAE,MAAM,CAAC;QACxB,YAAY,EAAE,MAAM,CAAC;QACrB,UAAU,EAAE,MAAM,CAAC;KACpB,CAAC;CACH;AA+BD,0EAA0E;AAC1E,MAAM,WAAW,gBAAgB;IAC/B,gBAAgB,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC;IAChD,WAAW,EAAE;QACX,cAAc,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,eAAe,GAAG,SAAS,CAAC,CAAC;KACnE,CAAC;CACH;AAED,UAAU,eAAe;IACvB,EAAE,EAAE,MAAM,GAAG,IAAI,CAAC;IAClB,GAAG,EAAE,MAAM,CAAC;IACZ,IAAI,EAAE,MAAM,GAAG,IAAI,CAAC;IACpB,eAAe,EAAE,GAAG,CAAC,eAAe,CAAC,CAAC;IACtC,eAAe,EAAE,OAAO,CAAC;CAC1B;AAED,UAAU,cAAc;IACtB,mEAAmE;IACnE,YAAY,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC;IAC1B,iFAAiF;IACjF,WAAW,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC;IACzB,8DAA8D;IAC9D,OAAO,EAAE,MAAM,CAAC;IAChB,+DAA+D;IAC/D,WAAW,EAAE,OAAO,CAAC;CACtB;AAiBD;;;;;;;GAOG;AACH,wBAAsB,gBAAgB,CACpC,GAAG,EAAE,gBAAgB,EACrB,OAAO,EAAE,KAAK,GAAG,KAAK,EACtB,KAAK,EAAE,MAAM,EAAE,EACf,IAAI,EAAE,MAAM,EACZ,UAAU,EAAE,MAAM,EAClB,MAAM,EAAE,UAAU,EAAE,EACpB,UAAU,CAAC,EAAE,MAAM,GAClB,OAAO,CAAC,cAAc,CAAC,CAsDzB;AAuCD;;;;;;;GAOG;AACH,wBAAsB,YAAY,CAAC,OAAO,EAAE,YAAY,GAAG,OAAO,CAAC,WAAW,CAAC,CAoM9E"}

package/dist/analyze/graph-cache.d.ts

@@ -0,0 +1,104 @@
+/**
+ * graph-cache — the mtime-keyed output cache for `timber graph`.
+ *
+ * The cold crawl costs seconds (design/47 §6) and its cost is setup +
+ * dependency compilation, not project-file count — so the cacheable
+ * unit is the classification OUTPUT, never Vite's transforms. One
+ * crawl per project state: the first question after a clone pays for
+ * the crawl, every subsequent question is a cache hit until the
+ * project changes.
+ *
+ * Validity is a fingerprint over (path, mtime, size) of every project
+ * source file — the same disk walk the crawl itself uses (scan.ts), so
+ * cache coverage and crawl coverage cannot drift — plus the config
+ * files and the nearest lockfile, since dependency changes change
+ * resolution (export conditions can flip a file's environment without
+ * touching project code).
+ *
+ * Deliberately vite-free: a cache hit answers without importing Vite.
+ *
+ * Design docs: 47-module-environment-tooling.md §"Cold-path policy".
+ */
+import type { CrawlReport } from './crawl.ts';
+/**
+ * JSON contract version (design/47 §9) — one constant for every
+ * frontend (CLI and dev-server endpoint), so the two cannot drift.
+ * Lives here rather than graph-command.ts because this module is
+ * vite-free and both frontends already depend on the analyze core.
+ */
+export declare const GRAPH_JSON_VERSION = 1;
+/** Bump when the report shape or fingerprint inputs change. */
+export declare const GRAPH_CACHE_VERSION = 2;
+export interface GraphCacheFile {
+    version: number;
+    fingerprint: string;
+    /** The Vite config file the cached crawl booted with. */
+    configFile: string;
+    /**
+     * The resolved pageExtensions from the timber config at crawl time.
+     * Stored so the vite-free hit path can reproduce the same scan
+     * extension set (custom extensions like 'foo' must be admitted on
+     * both the write and the hit path, or the fingerprint disagrees
+     * with what was cached).
+     */
+    pageExtensions?: string[];
+    /**
+     * Files the fingerprint tracks BEYOND the disk scan, discovered at
+     * crawl time: Vite's `configFileDependencies` (a config helper
+     * imported from outside the app root can reshape the whole app) and
+     * every file the report itself classifies (the graph can reach files
+     * the scan skips — `app/.well-known/page.tsx`, a route under a
+     * directory named `dist`). The hit path re-stats exactly this list,
+     * so an edit to any of them misses the cache.
+     */
+    trackedExtras: string[];
+    report: CrawlReport;
+}
+/**
+ * Follow a tsconfig/jsconfig `extends` chain, returning every file on
+ * it (the start file included). A base config outside the app —
+ * `"extends": "../tsconfig.base.json"` with a `paths` mapping — can
+ * reshape Vite's resolution without touching anything else the
+ * fingerprint tracks. Parsing is a targeted regex, not JSONC: tsconfig
+ * allows comments, and all we need is the `extends` value. Package
+ * specifiers resolve through Node resolution (an approximation of
+ * TypeScript's — the `.json` append covers the common shapes): a
+ * WORKSPACE package like `@repo/tsconfig/base.json` is a link, so its
+ * edits change neither the lockfile nor any scanned file and must be
+ * fingerprinted directly; registry packages resolve too, harmlessly.
+ * Cycles and unresolvable targets just end the walk (bounded at 16).
+ */
+/**
+ * Strip JSONC comments so a commented-out `"extends"` line cannot
+ * shadow the real one. String-aware: comment markers inside string
+ * literals (a path containing `//`) survive.
+ */
+export declare function stripJsonComments(raw: string): string;
+/** `path\0mtime\0size` entries for a file list; absent files contribute nothing. */
+export declare function fingerprintEntriesForFiles(files: Iterable<string>): Promise<string[]>;
+/**
+ * Entries for the scan-derived base set: project source files, the
+ * config, root manifests, and the nearest lockfile. Scan failures are
+ * folded into the entry list rather than thrown: an unreadable
+ * directory changes the answer's completeness, so it must change the
+ * key too.
+ */
+export declare function collectBaseFingerprintEntries(root: string, configFile: string, pageExtensions?: readonly string[]): Promise<string[]>;
+/** Hash an entry list order-independently. */
+export declare function hashFingerprintEntries(entries: string[]): string;
+/**
+ * Fingerprint the project state `timber graph`'s answers depend on:
+ * the scan-derived base set plus `extraFiles` (the cache's
+ * trackedExtras on the hit path; config dependencies + report files on
+ * the write path).
+ */
+export declare function computeProjectFingerprint(root: string, configFile: string, extraFiles?: readonly string[], pageExtensions?: readonly string[]): Promise<string>;
+/** Read the cache file; anything unreadable or version-mismatched is a miss. */
+export declare function readGraphCache(root: string): Promise<GraphCacheFile | null>;
+/**
+ * Write the cache atomically (temp file + rename) so a concurrent
+ * reader — parallel agent invocations are the expected workload —
+ * never sees a torn JSON file.
+ */
+export declare function writeGraphCache(root: string, cache: GraphCacheFile): Promise<void>;
+//# sourceMappingURL=graph-cache.d.ts.map

package/dist/analyze/graph-cache.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"graph-cache.d.ts","sourceRoot":"","sources":["../../src/analyze/graph-cache.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AAOH,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AAE9C;;;;;GAKG;AACH,eAAO,MAAM,kBAAkB,IAAI,CAAC;AAEpC,+DAA+D;AAC/D,eAAO,MAAM,mBAAmB,IAAI,CAAC;AAuCrC,MAAM,WAAW,cAAc;IAC7B,OAAO,EAAE,MAAM,CAAC;IAChB,WAAW,EAAE,MAAM,CAAC;IACpB,yDAAyD;IACzD,UAAU,EAAE,MAAM,CAAC;IACnB;;;;;;OAMG;IACH,cAAc,CAAC,EAAE,MAAM,EAAE,CAAC;IAC1B;;;;;;;;OAQG;IACH,aAAa,EAAE,MAAM,EAAE,CAAC;IACxB,MAAM,EAAE,WAAW,CAAC;CACrB;AAED;;;;;;;;;;;;;GAaG;AACH;;;;GAIG;AACH,wBAAgB,iBAAiB,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CA4BrD;AAsED,oFAAoF;AACpF,wBAAsB,0BAA0B,CAAC,KAAK,EAAE,QAAQ,CAAC,MAAM,CAAC,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC,CAY3F;AAED;;;;;;GAMG;AACH,wBAAsB,6BAA6B,CACjD,IAAI,EAAE,MAAM,EACZ,UAAU,EAAE,MAAM,EAClB,cAAc,CAAC,EAAE,SAAS,MAAM,EAAE,GACjC,OAAO,CAAC,MAAM,EAAE,CAAC,CA4BnB;AAED,8CAA8C;AAC9C,wBAAgB,sBAAsB,CAAC,OAAO,EAAE,MAAM,EAAE,GAAG,MAAM,CAGhE;AAED;;;;;GAKG;AACH,wBAAsB,yBAAyB,CAC7C,IAAI,EAAE,MAAM,EACZ,UAAU,EAAE,MAAM,EAClB,UAAU,GAAE,SAAS,MAAM,EAAO,EAClC,cAAc,CAAC,EAAE,SAAS,MAAM,EAAE,GACjC,OAAO,CAAC,MAAM,CAAC,CAIjB;AAED,gFAAgF;AAChF,wBAAsB,cAAc,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,cAAc,GAAG,IAAI,CAAC,CAkBjF;AAED;;;;GAIG;AACH,wBAAsB,eAAe,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,cAAc,GAAG,OAAO,CAAC,IAAI,CAAC,CAMxF"}