@timber-js/app 0.2.0-alpha.21 → 0.2.0-alpha.210

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

@@ -0,0 +1 @@
+{"version":3,"file":"chains.d.ts","sourceRoot":"","sources":["../../src/analyze/chains.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AAIH,OAAO,EAA0B,KAAK,SAAS,EAAE,MAAM,eAAe,CAAC;AAEvE;;;;GAIG;AACH,MAAM,WAAW,eAAe;IAC9B,EAAE,EAAE,MAAM,GAAG,IAAI,CAAC;IAClB,GAAG,EAAE,MAAM,CAAC;IACZ,IAAI,EAAE,MAAM,GAAG,IAAI,CAAC;IACpB,SAAS,EAAE,GAAG,CAAC,eAAe,CAAC,CAAC;CACjC;AAED,0DAA0D;AAC1D,MAAM,WAAW,UAAU;IACzB,gBAAgB,CAAC,IAAI,EAAE,MAAM,GAAG,GAAG,CAAC,eAAe,CAAC,GAAG,SAAS,CAAC;CAClE;AAED,qDAAqD;AACrD,MAAM,MAAM,YAAY,GAAG,QAAQ,GAAG,QAAQ,GAAG,IAAI,CAAC;AAEtD,MAAM,WAAW,QAAQ;IACvB,mEAAmE;IACnE,EAAE,EAAE,MAAM,CAAC;IACX,SAAS,EAAE,YAAY,CAAC;IACxB,oEAAoE;IACpE,QAAQ,EAAE,OAAO,CAAC;CACnB;AAED,MAAM,WAAW,WAAW;IAC1B;;;;;;OAMG;IACH,KAAK,EAAE,MAAM,GAAG,IAAI,CAAC;IACrB;;;OAGG;IACH,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAC;IACxB,wDAAwD;IACxD,IAAI,EAAE,QAAQ,EAAE,CAAC;CAClB;AAED,MAAM,WAAW,YAAY;IAC3B,GAAG,EAAE,UAAU,CAAC;IAChB,GAAG,EAAE,UAAU,CAAC;IAChB,uEAAuE;IACvE,MAAM,EAAE,MAAM,CAAC;IACf;;;;OAIG;IACH,cAAc,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IACnC;;;OAGG;IACH,YAAY,CAAC,IAAI,EAAE,MAAM,GAAG,SAAS,CAAC;CACvC;AAsMD;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,kBAAkB,CAAC,aAAa,EAAE,MAAM,EAAE,MAAM,EAAE,YAAY,GAAG,WAAW,EAAE,CA0D7F;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,YAAY,CAAC,MAAM,EAAE,WAAW,EAAE,EAAE,WAAW,EAAE,MAAM,GAAG,MAAM,CAuB/E"}

package/dist/analyze/classify.d.ts

@@ -0,0 +1,151 @@
+/**
+ * classify — environment-graph classification for project modules.
+ *
+ * The one classification module every frontend shares (design/47): the
+ * `timber graph` CLI, the dev-server endpoint, the VS Code extension,
+ * and the cold crawl must never disagree about a file's environment.
+ * Classification intersects RSC/SSR module-graph membership with
+ * first-directive detection to produce the decided taxonomy:
+ *
+ * - `server`          — RSC graph only
+ * - `client-boundary` — has `'use client'`
+ * - `client-internal` — reachable only behind a boundary, no directive
+ * - `shared`          — instantiated in both environments; INFO, never a
+ *                       warning — shared-by-design is a legitimate pattern
+ * - `server-action`   — has `'use server'`
+ * - `unreferenced`    — in no graph and no provisional signal; files with
+ *                       a directive or filename convention get that
+ *                       provisional kind instead, marked `pending`
+ *
+ * The browser (`client`) Vite graph stays empty until a real browser
+ * requests modules, so membership is RSC × SSR — the SSR graph is a
+ * faithful proxy for the client tree (design/47 §8, with the frontier
+ * caveat below).
+ *
+ * Design docs: 47-module-environment-tooling.md (taxonomy, §8),
+ * 43-analyze-cli.md (directive detection rules).
+ */
+export type ModuleKind = 'server' | 'client-boundary' | 'client-internal' | 'shared' | 'server-action' | 'unreferenced';
+export type Directive = 'use client' | 'use server' | null;
+/**
+ * What a frontend observed about one project module. Graph membership
+ * comes from the live dev-server graphs or the cold crawl; the directive
+ * comes from the module's original source (never the transformed output,
+ * where the RSC plugin has already stripped or proxied it).
+ */
+export interface ModuleObservation {
+    /** Absolute path of the source file. */
+    file: string;
+    /** Present in the RSC environment's module graph. */
+    inRsc: boolean;
+    /** Present in the SSR environment's module graph. */
+    inSsr: boolean;
+    /**
+     * Present in the browser (`client`) environment's module graph. Only a
+     * live dev server with a real connected browser can confirm this — the
+     * client graph stays empty otherwise (design/47 §8) — so the cold
+     * crawl always observes false. Defaults to false.
+     */
+    inClient?: boolean;
+    /**
+     * False when the SSR graph has a node for this file but Vite never
+     * transformed it — the §8 signature of a module behind an unexecuted
+     * dynamic import (`transformResult == null`). Its own membership is
+     * trustworthy; its subtree is not. Defaults to true.
+     */
+    ssrTransformed?: boolean;
+    /** First directive of the original source, or null. */
+    directive: Directive;
+}
+export interface ModuleClassification {
+    file: string;
+    kind: ModuleKind;
+    /**
+     * Raw per-environment graph membership, in doc 43's classification
+     * vocabulary (`{ client, ssr, rsc }`). `kind` is the interpreted
+     * answer; this is the evidence. `client` is confirmable only by a
+     * live browser graph — static scans always report false.
+     */
+    envs: {
+        rsc: boolean;
+        ssr: boolean;
+        client: boolean;
+    };
+    /**
+     * True when no graph has confirmed this module — the kind is
+     * provisional, derived from directive + filename convention, and
+     * frontends must visibly mark it "pending" (design/47 §2).
+     */
+    pending: boolean;
+    /**
+     * §8 frontier: the module is reachable (it ships to the browser) but
+     * was never transformed, so modules behind it may be missing from the
+     * graphs entirely. Consumers should transform-on-demand or surface
+     * "reachable, subtree unknown".
+     */
+    subtreeUnknown: boolean;
+}
+/**
+ * Parse language for a source file, from its extension. Never force
+ * `tsx` onto plain `.ts`: JSX-ambiguous TypeScript such as
+ * `const identity = <T>(value: T) => value` is valid TS but rejected
+ * by a TSX parse, and the resulting parse failure would silently drop
+ * the file's directive and poison signals. Plain JS parses as `jsx`
+ * (JSX-in-.js is common in Vite projects and JS has no generic-arrow
+ * ambiguity for the x-syntax to break).
+ */
+export declare function langForFile(file: string): 'ts' | 'tsx' | 'jsx';
+/**
+ * Detect the first directive of a module's original source.
+ *
+ * Never string-match or regex directives (design/43): `hasDirective`
+ * from @vitejs/plugin-rsc checks for the `directive` property on
+ * ExpressionStatements — the same check the RSC plugin runs to decide
+ * boundaries, so classification agrees with what the framework actually
+ * does with the file. The directive must be in prologue position (before
+ * any import or statement) per the ECMAScript spec. Non-JS sources
+ * (CSS, MDX, assets) and sources that fail to parse return null — no
+ * directive is a safe default; classification then falls back to graph
+ * membership.
+ */
+export declare function detectDirective(code: string, file: string): Directive;
+/** Optional context for classification. */
+export interface ClassifyContext {
+    /**
+     * Absolute path of the app directory. When provided, convention-based
+     * provisional classification only applies to files inside it — a
+     * `lib/page.tsx` is not a route file, and the scanner would never
+     * recognize it there.
+     */
+    appDir?: string;
+    /**
+     * Configured pageExtensions, when the caller has resolved the app
+     * config. Omitted → scanner defaults.
+     */
+    pageExtensions?: readonly string[];
+}
+/**
+ * Whether a file is a route-convention source the framework itself
+ * imports (page/layout/route/… plus metadata routes). Conventions are
+ * derived from the routing scanner and the metadata route table — never
+ * a local duplicate list (drift lesson). Each family carries the
+ * scanner's own extension rules.
+ *
+ * Shared by the provisional classifier below and by chains.ts, whose
+ * RSC-side walks terminate at the first route-convention file
+ * (design/47 §7) — the two must never disagree about what counts.
+ *
+ * `pageExtensions` mirrors the scanner's parameter: callers that have
+ * resolved the app config pass the configured set (a `page.mdx` app);
+ * callers without config access fall back to the defaults and tolerate
+ * the mismatch.
+ */
+export declare function isConventionSourceFile(file: string, pageExtensions?: readonly string[]): boolean;
+/**
+ * Classify one module from its observation. Pure — all frontends call
+ * this with membership data from their own graph source.
+ */
+export declare function classifyModule(obs: ModuleObservation, ctx?: ClassifyContext): ModuleClassification;
+/** Classify a batch of observations, sorted by file for stable output. */
+export declare function classifyModules(observations: Iterable<ModuleObservation>, ctx?: ClassifyContext): ModuleClassification[];
+//# sourceMappingURL=classify.d.ts.map

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;;;;;;;;;;;;GAYG;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 { c as resolveAppDir, i as isTimberPluginApi } from "../_chunks/plugin-context-BPBPc3lL.js";
+import { a as detectDirective, i as classifyModules, n as stitchImportChains } from "../_chunks/chains-BoO51joc.js";
+import { n as importSignals, r as poisoningsFor, t as collectImportSpecifiers } from "../_chunks/poison-scan-vGV7Re0B.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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"}