@timber-js/app 0.2.0-alpha.207 → 0.2.0-alpha.209

package/dist/index.js

@@ -1,15 +1,17 @@
-import { a as formatMissingPeers, i as formatConfigErrors, n as timberDevServer, o as validateConfig, r as checkPeerDependencies } from "./_chunks/dev-server-BzBxgYAV.js";
+import { a as formatMissingPeers, i as formatConfigErrors, n as timberDevServer, o as validateConfig, r as checkPeerDependencies } from "./_chunks/dev-server-C4WZdB7L.js";
+import { i as resolveRenderTimeoutMs } from "./_chunks/render-timeout-DOf_BBcO.js";
+import { t as writeFileAtomic } from "./_chunks/write-file-atomic-D1qWqHb4.js";
 import { a as isDynamicMetadataExtension } from "./_chunks/metadata-routes-DSDjM_hJ.js";
-import { n as scanRoutes, r as collectInterceptionRewrites } from "./_chunks/scanner-BQ5sPIJ7.js";
-import { h as swallow } from "./_chunks/logger-k2DQ4EUf.js";
-import { c as writeRouteCodegen, i as getPrerenderExport, l as buildDirToRouteMap, n as formatConventionWarnings, r as lintConventions, s as flushCodegenWrites, t as checkAppDirExists } from "./_chunks/convention-lint-5KzoMg_A.js";
-import { c as resolveClientJavascript, i as mergeFileConfig, l as createNoopTimer, o as resolveAppDir, r as loadTimberConfigFile, s as resolveBuildDir, t as createPluginContext } from "./_chunks/plugin-context-8idfR3UZ.js";
-import { r as validateSchemaAgainstRoutes, t as collectLeafRoutes } from "./_chunks/walkers-CN2N_bA-.js";
-import { i as poisonPillSource, r as markerFor, t as EXPLICIT_MARKERS } from "./_chunks/poison-rules-DoEhbqaY.js";
+import { n as scanRoutes, r as collectInterceptionRewrites } from "./_chunks/scanner-Bw0oq1HB.js";
+import { _ as swallow } from "./_chunks/logger-DiDt5ppH.js";
+import { c as writeRouteCodegen, i as getPrerenderExport, l as buildDirToRouteMap, n as formatConventionWarnings, r as lintConventions, s as flushCodegenWrites, t as checkAppDirExists } from "./_chunks/convention-lint-jKTwKwPe.js";
+import { a as loadTimberConfigFile, c as resolveAppDir, d as createNoopTimer, l as resolveBuildDir, n as contextAdapter, o as mergeFileConfig, r as createPluginContext, t as adapterConfig, u as resolveClientJavascript } from "./_chunks/plugin-context-BPBPc3lL.js";
 import { i as withBasePath, n as normalizeBasePath, t as isRelativeBase } from "./_chunks/base-path-DaQrzbez.js";
-import { t as EMPTY_BUILD_MANIFEST } from "./_chunks/build-manifest-DTmSGLRz.js";
-import { t as rscPayloadPath } from "./_chunks/rsc-payload-path-B_LBodc2.js";
-import { a as REDIRECTS_FILE, n as detectFsIdentity, o as RESERVED_OUTPUT_PATHS, r as fsKey, t as EXACT_FS_IDENTITY } from "./_chunks/fs-identity-D7vb6GdI.js";
+import { r as validateSchemaAgainstRoutes, t as collectLeafRoutes } from "./_chunks/walkers-BXExhzzk.js";
+import { i as poisonPillSource, r as markerFor, t as EXPLICIT_MARKERS } from "./_chunks/poison-rules-DoEhbqaY.js";
+import { n as rscPayloadPath, t as RSC_PAYLOAD_DIR } from "./_chunks/rsc-payload-path-dffcs4jp.js";
+import { a as REDIRECTS_FILE, n as detectFsIdentity, o as RESERVED_OUTPUT_PATHS, r as fsKey, t as EXACT_FS_IDENTITY } from "./_chunks/fs-identity-BRKuL215.js";
+import { t as EMPTY_BUILD_MANIFEST } from "./_chunks/build-manifest-DWppEdLB.js";
 import { t as fnv1aHash } from "./_chunks/fast-hash-C-tVYrLb.js";
 import { t as formatSize } from "./_chunks/format-BKclgVbk.js";
 import { createLogger, parseAst } from "vite";
@@ -202,7 +204,7 @@ function generateConfigModule(ctx) {
 		topLoader: ctx.config.topLoader,
 		debug: ctx.config.debug ?? false,
 		serverTiming: ctx.config.serverTiming,
-		renderTimeoutMs: ctx.config.renderTimeoutMs ?? 3e4,
+		renderTimeoutMs: resolveRenderTimeoutMs(ctx.config.renderTimeoutMs),
 		sitemap: ctx.config.sitemap,
 		forms: serializeFormsConfig(ctx.config.forms),
 		deploymentId: ctx.deploymentId ?? null,
@@ -962,7 +964,8 @@ var SUBPATH_SRC_MAP = {
 	"adapters/cloudflare": "adapters/cloudflare.ts",
 	"adapters/cloudflare/cache": "adapters/cloudflare-kv-cache.ts",
 	"adapters/cloudflare/dev": "adapters/cloudflare-dev.ts",
-	"adapters/nitro": "adapters/nitro.ts"
+	"adapters/nitro": "adapters/nitro.ts",
+	"adapters/types": "adapters/types.ts"
 };
 /**
 * Runtime value exports of @timber-js/app/server, stubbed in the client
@@ -4543,8 +4546,14 @@ function writeFontManifest(pipeline, buildManifest, base = "/") {
 */
 function timberFonts(ctx) {
 	const pipeline = new FontPipeline({ hashOnRegister: !ctx.dev });
+	/** Whether the client environment emitted a binary this build. */
+	let emittedToClient = false;
 	return {
 		name: "timber-fonts",
+		api: {
+			contributeManifest: (manifest) => writeFontManifest(pipeline, manifest, ctx.base),
+			immutableDirs: () => emittedToClient ? [FONT_OUTPUT_DIR] : []
+		},
 		/**
 		* Push Vite's resolved `base` into the pipeline so every font URL it
 		* emits (@font-face src, manifest hrefs, dev middleware matching)
@@ -4724,212 +4733,23 @@ function timberFonts(ctx) {
 			}
 		},
 		/**
-		* Emit font binaries and build-manifest entries.
+		* Emit font binaries.
 		*
 		* All font binaries (Google and local) use content-hashed filenames
 		* for immutable caching. Font CSS is handled by Vite's CSS pipeline
-		* via virtual modules — we only emit binaries here.
+		* via virtual modules — we only emit binaries here. Manifest entries are
+		* written by the post-build phase through `api.contributeManifest`.
 		*/
 		generateBundle() {
-			emitFontAssets(pipeline, (asset) => this.emitFile(asset), (msg) => this.warn(msg));
-			if (!ctx.buildManifest) return;
-			writeFontManifest(pipeline, ctx.buildManifest, ctx.base);
-		}
-	};
-}
-//#endregion
-//#region src/plugins/adapter-build.ts
-function timberAdapterBuild(ctx) {
-	return {
-		name: "timber-adapter-build",
-		buildApp: {
-			order: "post",
-			async handler() {
-				if (ctx.dev) return;
-				const adapter = ctx.config.adapter;
-				if (!adapter || typeof adapter.buildOutput !== "function") return;
-				const buildDir = ctx.buildDir;
-				if (ctx.buildManifest) await mergeRscAssetsManifest(buildDir, ctx.root, ctx.buildManifest, ctx.routeClientRefKeys);
-				let manifestInit;
-				if (ctx.buildManifest) {
-					const manifest = ctx.clientJavascript.disabled ? {
-						...ctx.buildManifest,
-						js: {},
-						modulepreload: {}
-					} : ctx.buildManifest;
-					manifestInit = `globalThis.__TIMBER_BUILD_MANIFEST__ = ${JSON.stringify(manifest)};\n`;
-					if (ctx.deploymentId) manifestInit += `globalThis.__TIMBER_DEPLOYMENT_ID__ = ${JSON.stringify(ctx.deploymentId)};\n`;
-				}
-				if (ctx.clientJavascript.disabled) await stripJsFromRscAssetsManifests(buildDir);
-				const adapterConfig = {
-					root: ctx.root,
-					base: normalizeBasePath(ctx.base),
-					output: ctx.config.output ?? "server",
-					clientJavascriptDisabled: ctx.clientJavascript.disabled,
-					manifestInit,
-					staticPagesDir: (ctx.config.output ?? "server") === "static" ? join(buildDir, "static-pages") : void 0,
-					staticContentTypes: ctx.staticContentTypes
-				};
-				await adapter.buildOutput(adapterConfig, buildDir);
-			}
+			let emitted = 0;
+			emitFontAssets(pipeline, (asset) => {
+				emitted++;
+				return this.emitFile(asset);
+			}, (msg) => this.warn(msg));
+			if (this.environment?.name === "client") emittedToClient = emitted > 0;
 		}
 	};
 }
-/**
-* Parse the RSC assets manifest at `manifestPath`. Tries JSON.parse first
-* (fast path for plain-string manifests); falls back to a dynamic import()
-* for manifests that contain runtime expressions from renderBuiltUrl.
-* Returns null if both paths fail.
-*/
-async function parseRscManifest(manifestPath, content) {
-	const jsonStr = content.replace(/^export default\s*/, "").replace(/;?\s*$/, "");
-	try {
-		return JSON.parse(jsonStr);
-	} catch {}
-	try {
-		return (await import(`${pathToFileURL(manifestPath).href}?t=${Date.now()}`)).default ?? null;
-	} catch (err) {
-		swallow(err, `failed to evaluate RSC assets manifest: ${manifestPath}`, { level: "warn" });
-		return null;
-	}
-}
-/**
-* Replace all `"js": [...]` array contents with `"js": []` using balanced
-* bracket matching. Handles nested brackets from runtime expressions like
-* `__rbu("path/to/[slug]/file.js")`.
-*/
-function clearJsArrays(src) {
-	const pattern = /"js"\s*:\s*\[/g;
-	let result = "";
-	let lastEnd = 0;
-	let match;
-	while ((match = pattern.exec(src)) !== null) {
-		const arrayStart = match.index + match[0].length;
-		let depth = 1;
-		let i = arrayStart;
-		while (i < src.length && depth > 0) {
-			if (src[i] === "[") depth++;
-			else if (src[i] === "]") depth--;
-			i++;
-		}
-		result += src.slice(lastEnd, match.index) + "\"js\": []";
-		lastEnd = i;
-	}
-	result += src.slice(lastEnd);
-	return result;
-}
-/**
-* Replace `"bootstrapScriptContent": <value>` with an empty string. The
-* value may be a JS expression (e.g., concatenation with runtime helpers),
-* not a simple string literal. Scans forward from the colon, tracking
-* balanced parens and brackets, and stops at the next unbalanced `,` or `}`.
-*/
-function clearBootstrapScriptContent(src) {
-	const idx = src.indexOf("\"bootstrapScriptContent\"");
-	if (idx === -1) return src;
-	const colonIdx = src.indexOf(":", idx + 24);
-	if (colonIdx === -1) return src;
-	let valStart = colonIdx + 1;
-	while (valStart < src.length && /\s/.test(src[valStart])) valStart++;
-	let i = valStart;
-	let depth = 0;
-	let inString = false;
-	let stringChar = "";
-	while (i < src.length) {
-		const ch = src[i];
-		if (inString) {
-			if (ch === "\\") {
-				i += 2;
-				continue;
-			}
-			if (ch === stringChar) inString = false;
-		} else if (ch === "\"" || ch === "'") {
-			inString = true;
-			stringChar = ch;
-		} else if (ch === "(" || ch === "[") depth++;
-		else if (ch === ")" || ch === "]") depth--;
-		else if (depth === 0 && (ch === "," || ch === "}" || ch === "\n")) break;
-		i++;
-	}
-	return src.slice(0, idx) + "\"bootstrapScriptContent\": \"\"" + src.slice(i);
-}
-/**
-* Strip JS references from the RSC plugin's assets manifest files.
-*
-* The RSC plugin writes `__vite_rsc_assets_manifest.js` to rsc/ and ssr/
-* as standalone files (not Rollup chunks), so generateBundle can't
-* intercept them. This rewrites the files on disk after all builds
-* complete but before the adapter copies them to the output directory.
-*/
-/**
-* Read the RSC plugin's assets manifest and merge per-route CSS and
-* per-route JS modulepreloads into the build manifest.
-*
-* CSS: `serverResources` maps server component paths to CSS URLs.
-* JS: `clientReferenceDeps` maps reference hashes to JS dep URLs.
-*     Combined with `routeClientRefKeys` (from the RSC generateBundle
-*     module graph walk) to produce per-route modulepreload entries.
-*/
-async function mergeRscAssetsManifest(buildDir, root, buildManifest, routeClientRefKeys) {
-	const manifestPath = join(buildDir, "rsc", "__vite_rsc_assets_manifest.js");
-	let content;
-	try {
-		content = await readFile(manifestPath, "utf-8");
-	} catch {
-		return;
-	}
-	const manifest = await parseRscManifest(manifestPath, content);
-	if (!manifest) return;
-	const serverResources = manifest.serverResources;
-	if (serverResources) {
-		for (const [relativePath, deps] of Object.entries(serverResources)) if (deps.css && deps.css.length > 0) {
-			const absolutePath = join(root, relativePath);
-			buildManifest.css[absolutePath] = deps.css;
-		}
-	}
-	if (routeClientRefKeys && routeClientRefKeys.size > 0) {
-		const clientReferenceDeps = manifest.clientReferenceDeps;
-		if (clientReferenceDeps) for (const [filePath, refKeys] of routeClientRefKeys) {
-			const jsUrls = /* @__PURE__ */ new Set();
-			for (const key of refKeys) {
-				const deps = clientReferenceDeps[key];
-				if (deps?.js) for (const url of deps.js) jsUrls.add(url);
-			}
-			if (jsUrls.size > 0) buildManifest.modulepreload[filePath] = Array.from(jsUrls);
-		}
-	}
-}
-async function stripJsFromRscAssetsManifests(buildDir) {
-	const manifestName = "__vite_rsc_assets_manifest.js";
-	const paths = [join(buildDir, "rsc", manifestName), join(buildDir, "ssr", manifestName)];
-	for (const path of paths) {
-		let content;
-		try {
-			content = await readFile(path, "utf-8");
-		} catch {
-			continue;
-		}
-		const jsonStr = content.replace(/^export default\s*/, "").replace(/;?\s*$/, "");
-		let isStrictJson = true;
-		let manifest = null;
-		try {
-			manifest = JSON.parse(jsonStr);
-		} catch {
-			isStrictJson = false;
-		}
-		if (!isStrictJson) {
-			let rewritten = content;
-			rewritten = clearJsArrays(rewritten);
-			rewritten = clearBootstrapScriptContent(rewritten);
-			await writeFile(path, rewritten);
-			continue;
-		}
-		const deps = manifest?.clientReferenceDeps;
-		if (deps) for (const entry of Object.values(deps)) entry.js = [];
-		if (manifest) manifest.bootstrapScriptContent = "";
-		await writeFile(path, `export default ${JSON.stringify(manifest, null, 2)};\n`);
-	}
-}
 //#endregion
 //#region src/server/flight-scripts.ts
 /**
@@ -5012,12 +4832,6 @@ function generateRedirectsFile(redirects, base) {
 	const target = (to) => to.startsWith("/") && !to.startsWith("//") ? withBasePath(base, to) : to;
 	return redirects.map((r) => `${withBasePath(base, r.from)} ${target(r.to)} ${r.status}`).join("\n") + "\n";
 }
-/** Write a file atomically: temp sibling + rename. */
-async function writeFileAtomic$1(path, data) {
-	const tmp = `${path}.tmp`;
-	await writeFile(tmp, data);
-	await rename(tmp, path);
-}
 /**
 * Determine the output file path for a static page entry.
 *
@@ -5056,7 +4870,7 @@ function staticOutputPath(entry) {
 * API route, `about/index.html` from a page). The filesystem does refuse that
 * one — `EISDIR` on the rename, `ENOTDIR` on the mkdir, depending on which
 * lands second — but an errno names a path, and in the rename case the path
-* it names is `about.tmp`. Reported here instead, so the message says which
+* it names is the write's temp file. Reported here instead, so the message says which
 * two routes.
 *
 * Collisions are **collected, not thrown**. `onEntry` runs inside the
@@ -5145,7 +4959,7 @@ var StaticSiteWriter = class {
 		if (rel.split(/[\\/]/)[0] === ".." || isAbsolute(rel) || resolve(this.staticDir, rel) !== fullPath) throw new Error(`[timber] Static generation: output path "${relPath}" escapes the static output directory — check generateStaticSegmentParams for path traversal characters in ${entry.urlPath}`);
 		if (!this.paths.claim(rel.replace(/\\/g, "/"), entry)) return;
 		await mkdir(dirname(fullPath), { recursive: true });
-		await writeFileAtomic$1(fullPath, entry.body);
+		await writeFileAtomic(fullPath, entry.body);
 		if (entry.kind === "api" && !extname(relPath) && entry.contentType) this.contentTypes[entry.urlPath] = entry.contentType;
 	}
 	/** Throw if any two entries could not both be written. */
@@ -5173,7 +4987,7 @@ var StaticSiteWriter = class {
 * @internal Exported for testing.
 */
 async function cleanConditionalArtifacts(staticDir) {
-	await rm(join(staticDir, "_rsc"), {
+	await rm(join(staticDir, RSC_PAYLOAD_DIR), {
 		recursive: true,
 		force: true
 	}).catch(() => {});
@@ -5219,19 +5033,21 @@ async function withSchedulerPortsReleased(fn) {
 	}
 }
 /**
-* Load the built RSC entry and run the static generation pass.
+* Load the built RSC entry and run the static generation pass — the static
+* generation step of the post-build phase (plugins/post-build.ts).
 *
-* Unlike prebuilt capture, this needs the FULL pipeline handler, so
+* The build manifest it renders with is already final: the phase merged the
+* RSC assets manifest into it and published it before this step. Unlike
+* prebuilt capture, this needs the FULL pipeline handler, so
 * __TIMBER_CAPTURE_MODE__ must be false.
+*
+* Returns the site only once it is complete, so an adapter is never handed a
+* directory a failed pass left half-written — a failure throws instead.
 */
-async function runStaticGeneration(ctx) {
-	const entryPath = join(ctx.buildDir, "rsc", "index.js");
-	if (!existsSync(entryPath)) throw new Error(`[timber] Static generation: built RSC entry not found at ${entryPath} — the build output is missing`);
-	const g = globalThis;
-	if (ctx.buildManifest) g.__TIMBER_BUILD_MANIFEST__ ??= ctx.buildManifest;
-	if (ctx.deploymentId) g.__TIMBER_DEPLOYMENT_ID__ ??= ctx.deploymentId;
-	g.__TIMBER_CAPTURE_MODE__ = false;
-	if (ctx.buildManifest) await mergeRscAssetsManifest(ctx.buildDir, ctx.root, ctx.buildManifest, ctx.routeClientRefKeys);
+async function runStaticGeneration(ctx, rscDir) {
+	const entryPath = join(rscDir, "index.js");
+	warnUnusableBase(ctx);
+	globalThis.__TIMBER_CAPTURE_MODE__ = false;
 	console.log("[timber] Static generation: building site…");
 	const staticDir = join(ctx.buildDir, "static-pages");
 	await cleanConditionalArtifacts(staticDir);
@@ -5265,12 +5081,12 @@ async function runStaticGeneration(ctx) {
 		throw new Error(`[timber] Static generation failed:\n${details}`);
 	}
 	writer.assertNoCollisions();
-	if (Object.keys(writer.contentTypes).length > 0) ctx.staticContentTypes = writer.contentTypes;
+	const immutableDirs = [];
 	if (!ctx.clientJavascript.disabled) {
 		const rscManifest = await hashRscPayloads(staticDir);
 		if (Object.keys(rscManifest).length > 0) {
+			immutableDirs.push(RSC_PAYLOAD_DIR);
 			await injectRscManifestIntoHtml(staticDir, rscManifest);
-			ctx.rscManifest = rscManifest;
 			console.log(`[timber] Static generation: hashed ${Object.keys(rscManifest).length} RSC flight payloads`);
 		}
 	}
@@ -5279,14 +5095,18 @@ async function runStaticGeneration(ctx) {
 		const redirectsPath = join(staticDir, REDIRECTS_FILE);
 		const userRedirects = await readUserRedirects(ctx.root);
 		if (userRedirects !== null) {
-			await writeFileAtomic$1(redirectsPath, generated + "\n" + userRedirects);
+			await writeFileAtomic(redirectsPath, generated + "\n" + userRedirects);
 			console.log(`[timber] Static generation: wrote _redirects with ${summary.redirects.length} generated rule(s), merged with user-authored _redirects`);
 		} else {
-			await writeFileAtomic$1(redirectsPath, generated);
+			await writeFileAtomic(redirectsPath, generated);
 			console.log(`[timber] Static generation: wrote _redirects with ${summary.redirects.length} rule(s)`);
 		}
 	}
-	return summary;
+	return {
+		pages: { path: staticDir },
+		contentTypes: writer.contentTypes,
+		immutableDirs
+	};
 }
 /**
 * Warn when Vite's `base` is document-relative (`'./'`) in static mode.
@@ -5359,7 +5179,7 @@ async function walkDir(dir) {
 * @internal Exported for testing.
 */
 async function hashRscPayloads(staticDir) {
-	const files = await walkDir(join(staticDir, "_rsc"));
+	const files = await walkDir(join(staticDir, RSC_PAYLOAD_DIR));
 	const manifest = {};
 	for (const filePath of files) {
 		if (!filePath.endsWith(".rsc")) continue;
@@ -5407,11 +5227,9 @@ async function readUserRedirects(root) {
 /**
 * Create the timber-static-build Vite plugin.
 *
-* Only active when output: 'static' is configured.
-*
-* Hooks:
-* - transform: Validates source files for static mode violations
-* - buildApp (post): Renders all routes to static HTML after the build
+* Only active when output: 'static' is configured. Validates source files
+* for static mode violations; rendering the site is `runStaticGeneration`,
+* which the post-build phase calls.
 */
 function timberStaticBuild(ctx) {
 	return {
@@ -5433,22 +5251,6 @@ function timberStaticBuild(ctx) {
 				this.error(messages.join("\n\n"));
 			}
 			return null;
-		},
-		/**
-		* After all environments are built, render every route to static HTML.
-		*
-		* Runs with order: 'post' so the RSC plugin's buildApp completes first,
-		* producing the built entry we import. Must run BEFORE the adapter
-		* build copies output to its platform-specific directory.
-		*/
-		buildApp: {
-			order: "post",
-			async handler() {
-				if (ctx.dev) return;
-				if (!(ctx.config.output === "static")) return;
-				warnUnusableBase(ctx);
-				await runStaticGeneration(ctx);
-			}
 		}
 	};
 }
@@ -5658,8 +5460,6 @@ function timberBuildManifest(ctx) {
 				if (ctx.requestDepMap === void 0) throw new Error("[timber] Build manifest: the request-dependency map was never computed. The RSC environment's buildEnd hook did not run before the client build, so no segment or slot could be skipped on client navigation. This is a plugin pipeline bug — timber-request-dep must run in the rsc environment.");
 				ctx.buildManifest.requestDep = ctx.requestDepMap;
 				if (ctx.clientJavascript.disabled) {
-					ctx.buildManifest.js = {};
-					ctx.buildManifest.modulepreload = {};
 					for (const [fileName, item] of Object.entries(bundle)) if (item.type === "chunk") delete bundle[fileName];
 				}
 			}
@@ -5989,6 +5789,106 @@ function timberReactProd() {
 	};
 }
 //#endregion
+//#region src/plugins/react-resolve.ts
+/**
+* timber-react-resolve — Deduplicate React across timber and user project.
+*
+* Without this plugin, pnpm's strict isolation can install two physical
+* copies of React when the user's pinned version differs from timber's
+* peer dep. Timber's 47 bare `from 'react'` imports resolve to one copy
+* while react-dom uses the other — causing "Invalid hook call" hydration
+* crashes with no indication of the real cause.
+*
+* The fix: inject `resolve.dedupe` entries so Vite always resolves React
+* packages from the project root. Unlike `resolve.alias`, `dedupe`
+* preserves Vite's per-environment export conditions — the RSC
+* environment still gets the `react-server` build, SSR gets the SSR
+* build, and the browser gets the browser build. The deduplication
+* happens at the package level, not the file level.
+*
+* A `configResolved` check detects version mismatches between timber's
+* resolved React and the project's React, and logs an actionable error.
+*
+* Design doc: 18-build-system.md §"Module Resolution"
+* Task: TIM-1520
+*/
+/**
+* React packages to deduplicate. Vite's `resolve.dedupe` extracts the
+* base package name (via `deepImportRE`) before checking, so subpath
+* specifiers like `react/jsx-runtime` are covered by the base `react`
+* entry — listing them separately has no effect.
+*/
+var REACT_DEDUPE_PACKAGES = ["react", "react-dom"];
+var RED = "\x1B[31m";
+var BOLD = "\x1B[1m";
+var DIM = "\x1B[2m";
+var RESET = "\x1B[0m";
+/**
+* Read the version from a package's package.json given a resolve root.
+*/
+function readPackageVersion(packageName, resolveRoot) {
+	try {
+		const req = createRequire(`${resolveRoot}/package.json`);
+		return req(req.resolve(`${packageName}/package.json`)).version ?? null;
+	} catch {
+		return null;
+	}
+}
+/**
+* Check whether timber's React and the user project's React resolve to
+* the same version. Returns mismatches if any.
+*/
+function detectReactMismatch(projectRoot) {
+	const mismatches = [];
+	const timberRoot = dirname(dirname(fileURLToPath(import.meta.url)));
+	for (const pkg of ["react", "react-dom"]) {
+		const timberVersion = readPackageVersion(pkg, timberRoot);
+		const projectVersion = readPackageVersion(pkg, projectRoot);
+		if (timberVersion && projectVersion && timberVersion !== projectVersion) mismatches.push({
+			specifier: pkg,
+			timberVersion,
+			projectVersion
+		});
+	}
+	return mismatches;
+}
+/**
+* Format React version mismatches as an actionable warning.
+*/
+function formatReactMismatch(mismatches) {
+	if (mismatches.length === 0) return "";
+	const lines = [];
+	lines.push(`${RED}${BOLD}[timber]${RESET} ${RED}React version mismatch detected — this causes silent hydration crashes${RESET}`);
+	lines.push("");
+	for (const m of mismatches) lines.push(`  ${RED}✗${RESET} ${m.specifier}: timber has ${BOLD}${m.timberVersion}${RESET}, project has ${BOLD}${m.projectVersion}${RESET}`);
+	lines.push("");
+	lines.push(`  ${DIM}This typically causes "Invalid hook call" errors because two copies of${RESET}`);
+	lines.push(`  ${DIM}React are loaded. timber's resolve.dedupe should handle this, but${RESET}`);
+	lines.push(`  ${DIM}if you see hook errors, ensure your React version satisfies timber's peer dep.${RESET}`);
+	lines.push("");
+	lines.push(`  ${DIM}Fix: update React in your project to match —${RESET}`);
+	lines.push(`  ${BOLD}pnpm add react@${mismatches[0].timberVersion} react-dom@${mismatches[0].timberVersion}${RESET}`);
+	return lines.join("\n");
+}
+/**
+* Create the timber-react-resolve Vite plugin.
+*/
+function timberReactResolve() {
+	return {
+		name: "timber-react-resolve",
+		enforce: "pre",
+		config(userConfig) {
+			const merged = [...userConfig.resolve?.dedupe ?? []];
+			for (const pkg of REACT_DEDUPE_PACKAGES) if (!merged.includes(pkg)) merged.push(pkg);
+			return { resolve: { dedupe: merged } };
+		},
+		configResolved(resolved) {
+			const mismatches = detectReactMismatch(resolved.root);
+			if (mismatches.length > 0) process.stderr.write(`${formatReactMismatch(mismatches)}\n\n`);
+		}
+	};
+}
+//#endregion
 //#region src/plugins/chunks.ts
 /**
 * Build a map from absolute module IDs in non-facade RSC chunks to the
@@ -7741,8 +7641,8 @@ function mayPrerender(call) {
 /**
 * Post-build prebuilt capture — Node-side orchestration (TIM-1119).
 *
-* Runs from timber-prebuilt's `buildApp` post hook, after Vite's 5-step
-* build sequence. Imports the BUILT `rsc/index.js` (the bundle carries
+* Runs as the capture step of the post-build phase (plugins/post-build.ts),
+* after Vite's 5-step build sequence and the manifest finalization step. Imports the BUILT `rsc/index.js` (the bundle carries
 * the react-server condition resolved at build time, so a plain dynamic
 * import works) and calls its `__timber_capturePrebuilt` export — the
 * capture itself must run inside the bundle's module graph, where the
@@ -7771,12 +7671,6 @@ function mayPrerender(call) {
 */
 var COMPONENT_ID_RE = /^[a-z0-9]+_[0-9a-f]{16}$/;
 var CACHE_KEY_RE = /^[0-9a-f]{16}$/;
-/** Write a file atomically: temp sibling + rename. */
-async function writeFileAtomic(path, data) {
-	const tmp = `${path}.tmp`;
-	await writeFile(tmp, data);
-	await rename(tmp, path);
-}
 /**
 * Create the writer for `.timber/dist/prebuilt/`. Storage layout per
 * design/44 §Storage: one directory per component ID, one `.flight` file
@@ -7818,7 +7712,7 @@ function createPrebuiltArtifactWriter(prebuiltDir) {
 * make adapters ship payloads from an OLD build — reviving them serves
 * outdated content with that build's chunk references instead of the
 * intended miss → live render. Runs unconditionally at the start of the
-* post-build hook, BEFORE the capture decision: a build whose app no
+* capture step, BEFORE the capture decision: a build whose app no
 * longer declares any prebuilt components must also shed the artifacts
 * (codex P2 on PR #836).
 */
@@ -7835,19 +7729,16 @@ async function cleanPrebuiltDir(buildDir) {
 * component). Per-entry data errors skip-and-report per design/44
 * §Build-Phase Error Handling.
 */
-async function runPrebuiltCapture(ctx) {
+async function runPrebuiltCapture(ctx, rscDir) {
 	const routeComponents = ctx.routePrebuiltComponents;
-	if (!routeComponents || routeComponents.size === 0) return {
+	if (!routeComponents || routeComponents.size === 0) return { summary: {
 		captured: 0,
 		skipped: [],
 		hardErrors: [],
 		nestingWarnings: 0
-	};
-	const entryPath = join(ctx.buildDir, "rsc", "index.js");
-	if (!existsSync(entryPath)) throw new Error(`[timber] prebuilt capture: built RSC entry not found at ${entryPath} — the app declares cache.component({ prerender: true }) call sites but the RSC build output is missing`);
+	} };
+	const entryPath = join(rscDir, "index.js");
 	const g = globalThis;
-	if (ctx.buildManifest) g.__TIMBER_BUILD_MANIFEST__ ??= ctx.buildManifest;
-	if (ctx.deploymentId) g.__TIMBER_DEPLOYMENT_ID__ ??= ctx.deploymentId;
 	console.log("[timber] cache.component: capturing prebuilt flight payloads…");
 	g.__TIMBER_CAPTURE_MODE__ = true;
 	let mod;
@@ -7861,7 +7752,8 @@ async function runPrebuiltCapture(ctx) {
 	}
 	const capture = mod.__timber_capturePrebuilt;
 	if (typeof capture !== "function") throw new Error("[timber] prebuilt capture: built RSC entry does not export __timber_capturePrebuilt — the build output predates this framework version; rebuild from a clean .timber/dist");
-	const writer = createPrebuiltArtifactWriter(join(ctx.buildDir, "prebuilt"));
+	const prebuiltDir = join(ctx.buildDir, "prebuilt");
+	const writer = createPrebuiltArtifactWriter(prebuiltDir);
 	const summary = await capture({
 		fileComponentMap: Object.fromEntries(routeComponents),
 		callSiteProps: ctx.prebuiltCallSiteProps ? Object.fromEntries(ctx.prebuiltCallSiteProps) : void 0,
@@ -7872,10 +7764,13 @@ async function runPrebuiltCapture(ctx) {
 		const details = summary.hardErrors.map((issue) => `  - ${issue.message}`).join("\n");
 		throw new Error(`[timber] prebuilt capture failed: ${summary.hardErrors.length} component(s) read per-request context at build time:\n${details}`);
 	}
-	await writer.finalize();
+	const written = await writer.finalize();
 	const total = summary.captured + summary.skipped.length;
 	console.log(`[timber] Prebuilt ${summary.captured}/${total} entries.` + (summary.skipped.length > 0 ? ` ${summary.skipped.length} skipped due to errors.` : ""));
-	return summary;
+	return written > 0 ? {
+		summary,
+		artifact: { path: prebuiltDir }
+	} : { summary };
 }
 //#endregion
 //#region src/plugins/prebuilt.ts
@@ -8049,8 +7944,7 @@ function collectPageAndLayoutFiles(root) {
 	return files;
 }
 var DEFAULT_SENTINEL = "\0default";
-async function collectCrossModuleProps(ctx, moduleId, getInfo, resolve) {
-	const bindingNames = ctx.prebuiltBindingNames;
+async function collectCrossModuleProps(ctx, bindingNames, moduleId, getInfo, resolve) {
 	const info = getInfo(moduleId);
 	if (!info) return;
 	const declaringImports = info.importedIds.filter((id) => bindingNames.has(id) && id !== moduleId);
@@ -8118,10 +8012,34 @@ async function collectCrossModuleProps(ctx, moduleId, getInfo, resolve) {
 	}
 }
 function timberPrebuilt(ctx) {
+	/**
+	* Module ID → prerender-capable component IDs declared in it. Recorded by
+	* the RSC transform, read by the RSC `generateBundle` module-graph walk
+	* that computes `ctx.routePrebuiltComponents`. Build only.
+	*/
+	const moduleComponents = /* @__PURE__ */ new Map();
+	/**
+	* Module ID → variable name → component ID, for the prebuilt components
+	* that module declares. Read at `generateBundle` time to trace imports in
+	* other modules back to component IDs (cross-module call-site props).
+	*/
+	const bindingNames = /* @__PURE__ */ new Map();
 	return {
 		name: "timber-prebuilt",
+		api: { async capture(rscDir) {
+			await cleanPrebuiltDir(ctx.buildDir);
+			if (!ctx.routePrebuiltComponents || ctx.routePrebuiltComponents.size === 0) return null;
+			if (ctx.config.output === "static") {
+				console.log(`[timber] cache.component: skipped prerender capture (output: 'static' renders all components at build time)`);
+				return null;
+			}
+			return runPrebuiltCapture(ctx, rscDir);
+		} },
 		transform(code, id) {
-			if (!ctx.dev && this?.environment?.name === "rsc") ctx.prebuiltModuleComponents?.delete(id);
+			if (!ctx.dev && this?.environment?.name === "rsc") {
+				moduleComponents.delete(id);
+				bindingNames.delete(id);
+			}
 			if (!code.includes("@timber-js/app/cache") && !code.includes("timber/cache")) return;
 			if (id.includes("node_modules")) return;
 			if (this?.environment?.name === "client") return;
@@ -8153,8 +8071,7 @@ function timberPrebuilt(ctx) {
 				s.appendLeft(call.arguments[0].start, `${JSON.stringify(firstArg)}, `);
 			}
 			if (!ctx.dev && componentIds.length > 0 && this?.environment?.name === "rsc") {
-				ctx.prebuiltModuleComponents ??= /* @__PURE__ */ new Map();
-				ctx.prebuiltModuleComponents.set(id, componentIds);
+				moduleComponents.set(id, componentIds);
 				const bindingMap = /* @__PURE__ */ new Map();
 				let componentIdIdx = 0;
 				for (const { call, stmt, displayName } of callSites) if (!ctx.dev && mayPrerender(call)) {
@@ -8174,10 +8091,7 @@ function timberPrebuilt(ctx) {
 						}
 					}
 				}
-				if (bindingMap.size > 0) {
-					ctx.prebuiltBindingNames ??= /* @__PURE__ */ new Map();
-					ctx.prebuiltBindingNames.set(id, bindingMap);
-				}
+				if (bindingMap.size > 0) bindingNames.set(id, bindingMap);
 				const declaredBindings = new Set([...bindingMap.keys()].filter((k) => k !== DEFAULT_SENTINEL));
 				if (declaredBindings.size > 0) {
 					const usages = collectJsxUsages(program, declaredBindings);
@@ -8208,8 +8122,8 @@ function timberPrebuilt(ctx) {
 			if (ctx.dev) return;
 			if (this?.environment?.name !== "rsc") return;
 			ctx.routePrebuiltComponents = void 0;
-			const moduleComponents = ctx.prebuiltModuleComponents;
-			if (!moduleComponents || moduleComponents.size === 0 || !ctx.routeTree) return;
+			ctx.prebuiltLazyChunks = void 0;
+			if (moduleComponents.size === 0 || !ctx.routeTree) return;
 			const self = this;
 			const getInfo = (id) => self.getModuleInfo?.(id) ?? null;
 			const resolveFn = async (source, importer) => {
@@ -8237,7 +8151,7 @@ function timberPrebuilt(ctx) {
 					}
 					if (lazyChunks.size > 0) ctx.prebuiltLazyChunks = lazyChunks;
 				}
-				if (ctx.prebuiltBindingNames && ctx.prebuiltBindingNames.size > 0) {
+				if (bindingNames.size > 0) {
 					const scannedModules = /* @__PURE__ */ new Set();
 					for (const filePath of routeComponents.keys()) {
 						const visited = /* @__PURE__ */ new Set();
@@ -8248,7 +8162,7 @@ function timberPrebuilt(ctx) {
 							visited.add(modId);
 							if (!scannedModules.has(modId)) {
 								scannedModules.add(modId);
-								await collectCrossModuleProps(ctx, modId, getInfo, resolveFn);
+								await collectCrossModuleProps(ctx, bindingNames, modId, getInfo, resolveFn);
 							}
 							const modInfo = getInfo(modId);
 							if (!modInfo) continue;
@@ -8258,26 +8172,6 @@ function timberPrebuilt(ctx) {
 					}
 				}
 			} else console.warn(`[timber] cache.component: ${moduleComponents.size} module(s) declare prebuilt components, but none are reachable from any page or layout — no payloads will be prerendered`);
-		},
-		/**
-		* Post-build capture (design/44 §Build Phase). `order: 'post'` runs
-		* after the RSC plugin's buildApp — all five build steps are complete —
-		* and BEFORE timber-adapter-build's post hook (plugin array order), so
-		* `prebuilt/` exists when the adapter assembles its output (TIM-1122).
-		*/
-		buildApp: {
-			order: "post",
-			async handler() {
-				if (ctx.dev) return;
-				ctx.captureSummary = void 0;
-				await cleanPrebuiltDir(ctx.buildDir);
-				if (!ctx.routePrebuiltComponents || ctx.routePrebuiltComponents.size === 0) return;
-				if (ctx.config.output === "static") {
-					console.log(`[timber] cache.component: skipped prerender capture (output: 'static' renders all components at build time)`);
-					return;
-				}
-				ctx.captureSummary = await runPrebuiltCapture(ctx);
-			}
 		}
 	};
 }
@@ -8430,8 +8324,6 @@ function timberPrerenderSugar(ctx) {
 			if (defaultExport.kind === "expression" && defaultExport.node.declaration) {
 				if (code.slice(defaultExport.node.declaration.start, defaultExport.node.declaration.end).includes(".component(")) return;
 			}
-			ctx.prerenderSugarPages ??= /* @__PURE__ */ new Set();
-			ctx.prerenderSugarPages.add(id);
 			const s = new MagicString(code);
 			const optionsSource = buildOptionsSource(value);
 			const importAlias = "__timber_prerender_cache__";
@@ -8568,6 +8460,378 @@ function timberCloudflareWasm(ctx) {
 	}];
 }
 //#endregion
+//#region src/plugins/rsc-assets-manifest.ts
+/**
+* The RSC plugin's assets manifest (`__vite_rsc_assets_manifest.js`) — read
+* into the build manifest, and stripped of JavaScript when client JS is off.
+*
+* The RSC plugin writes the file to rsc/ and ssr/ as a standalone file, not
+* a Rollup chunk, so no `generateBundle` can intercept it; both operations
+* work on the written files. Both run once, from the post-build phase's
+* manifest finalization step (plugins/post-build.ts), before anything
+* imports the built bundle.
+*
+* Design doc: 18-build-system.md §"Post-Build Phase"
+*/
+/**
+* Parse the RSC assets manifest at `manifestPath`. Tries JSON.parse first
+* (fast path for plain-string manifests); falls back to a dynamic import()
+* for manifests that contain runtime expressions from renderBuiltUrl.
+* Returns null if both paths fail.
+*/
+async function parseRscManifest(manifestPath, content) {
+	const jsonStr = content.replace(/^export default\s*/, "").replace(/;?\s*$/, "");
+	try {
+		return JSON.parse(jsonStr);
+	} catch {}
+	try {
+		return (await import(`${pathToFileURL(manifestPath).href}?t=${Date.now()}`)).default ?? null;
+	} catch (err) {
+		swallow(err, `failed to evaluate RSC assets manifest: ${manifestPath}`, { level: "warn" });
+		return null;
+	}
+}
+/**
+* Replace all `"js": [...]` array contents with `"js": []` using balanced
+* bracket matching. Handles nested brackets from runtime expressions like
+* `__rbu("path/to/[slug]/file.js")`.
+*/
+function clearJsArrays(src) {
+	const pattern = /"js"\s*:\s*\[/g;
+	let result = "";
+	let lastEnd = 0;
+	let match;
+	while ((match = pattern.exec(src)) !== null) {
+		const arrayStart = match.index + match[0].length;
+		let depth = 1;
+		let i = arrayStart;
+		while (i < src.length && depth > 0) {
+			if (src[i] === "[") depth++;
+			else if (src[i] === "]") depth--;
+			i++;
+		}
+		result += src.slice(lastEnd, match.index) + "\"js\": []";
+		lastEnd = i;
+	}
+	result += src.slice(lastEnd);
+	return result;
+}
+/**
+* Replace `"bootstrapScriptContent": <value>` with an empty string. The
+* value may be a JS expression (e.g., concatenation with runtime helpers),
+* not a simple string literal. Scans forward from the colon, tracking
+* balanced parens and brackets, and stops at the next unbalanced `,` or `}`.
+*/
+function clearBootstrapScriptContent(src) {
+	const idx = src.indexOf("\"bootstrapScriptContent\"");
+	if (idx === -1) return src;
+	const colonIdx = src.indexOf(":", idx + 24);
+	if (colonIdx === -1) return src;
+	let valStart = colonIdx + 1;
+	while (valStart < src.length && /\s/.test(src[valStart])) valStart++;
+	let i = valStart;
+	let depth = 0;
+	let inString = false;
+	let stringChar = "";
+	while (i < src.length) {
+		const ch = src[i];
+		if (inString) {
+			if (ch === "\\") {
+				i += 2;
+				continue;
+			}
+			if (ch === stringChar) inString = false;
+		} else if (ch === "\"" || ch === "'") {
+			inString = true;
+			stringChar = ch;
+		} else if (ch === "(" || ch === "[") depth++;
+		else if (ch === ")" || ch === "]") depth--;
+		else if (depth === 0 && (ch === "," || ch === "}" || ch === "\n")) break;
+		i++;
+	}
+	return src.slice(0, idx) + "\"bootstrapScriptContent\": \"\"" + src.slice(i);
+}
+/**
+* Read the RSC plugin's assets manifest and merge per-route CSS and
+* per-route JS modulepreloads into the build manifest.
+*
+* CSS: `serverResources` maps server component paths to CSS URLs.
+* JS: `clientReferenceDeps` maps reference hashes to JS dep URLs.
+*     Combined with `routeClientRefKeys` (from the RSC generateBundle
+*     module graph walk) to produce per-route modulepreload entries.
+*/
+async function mergeRscAssetsManifest(rscDir, root, buildManifest, routeClientRefKeys) {
+	const manifestPath = join(rscDir, "__vite_rsc_assets_manifest.js");
+	let content;
+	try {
+		content = await readFile(manifestPath, "utf-8");
+	} catch {
+		return;
+	}
+	const manifest = await parseRscManifest(manifestPath, content);
+	if (!manifest) return;
+	const serverResources = manifest.serverResources;
+	if (serverResources) {
+		for (const [relativePath, deps] of Object.entries(serverResources)) if (deps.css && deps.css.length > 0) {
+			const absolutePath = join(root, relativePath);
+			buildManifest.css[absolutePath] = deps.css;
+		}
+	}
+	if (routeClientRefKeys && routeClientRefKeys.size > 0) {
+		const clientReferenceDeps = manifest.clientReferenceDeps;
+		if (clientReferenceDeps) for (const [filePath, refKeys] of routeClientRefKeys) {
+			const jsUrls = /* @__PURE__ */ new Set();
+			for (const key of refKeys) {
+				const deps = clientReferenceDeps[key];
+				if (deps?.js) for (const url of deps.js) jsUrls.add(url);
+			}
+			if (jsUrls.size > 0) buildManifest.modulepreload[filePath] = Array.from(jsUrls);
+		}
+	}
+}
+/**
+* Strip JS references from the RSC plugin's assets manifest files.
+*
+* The RSC plugin writes `__vite_rsc_assets_manifest.js` to rsc/ and ssr/
+* as standalone files (not Rollup chunks), so generateBundle can't
+* intercept them. This rewrites the files on disk after all builds
+* complete but before the adapter copies them to the output directory.
+*/
+async function stripJsFromRscAssetsManifests(serverDirs) {
+	const paths = serverDirs.map((dir) => join(dir, "__vite_rsc_assets_manifest.js"));
+	for (const path of paths) {
+		let content;
+		try {
+			content = await readFile(path, "utf-8");
+		} catch {
+			continue;
+		}
+		const jsonStr = content.replace(/^export default\s*/, "").replace(/;?\s*$/, "");
+		let isStrictJson = true;
+		let manifest = null;
+		try {
+			manifest = JSON.parse(jsonStr);
+		} catch {
+			isStrictJson = false;
+		}
+		if (!isStrictJson) {
+			let rewritten = content;
+			rewritten = clearJsArrays(rewritten);
+			rewritten = clearBootstrapScriptContent(rewritten);
+			await writeFile(path, rewritten);
+			continue;
+		}
+		const deps = manifest?.clientReferenceDeps;
+		if (deps) for (const entry of Object.values(deps)) entry.js = [];
+		if (manifest) manifest.bootstrapScriptContent = "";
+		await writeFile(path, `export default ${JSON.stringify(manifest, null, 2)};\n`);
+	}
+}
+//#endregion
+//#region src/plugins/post-build.ts
+/** The Vite environments whose output adapters consume. */
+var ARTIFACT_ENVIRONMENTS = [
+	"client",
+	"rsc",
+	"ssr"
+];
+function isArtifactEnvironment(name) {
+	return ARTIFACT_ENVIRONMENTS.includes(name);
+}
+function timberPostBuild(ctx, steps) {
+	const environments = {};
+	/** What the client environment's bundle wrote, from its `writeBundle`. */
+	let clientOutput = {
+		assetsDir: "",
+		emitted: /* @__PURE__ */ new Set()
+	};
+	return {
+		name: "timber-post-build",
+		writeBundle(options, bundle) {
+			if (ctx.dev) return;
+			const env = this.environment;
+			if (!isArtifactEnvironment(env.name)) return;
+			environments[env.name] = { path: resolve(env.config.root, env.config.build.outDir) };
+			if (env.name === "client") clientOutput = {
+				assetsDir: hashedAssetsDir(env.config.build.assetsDir, options),
+				emitted: new Set(Object.keys(bundle))
+			};
+		},
+		buildApp: {
+			order: "post",
+			async handler() {
+				if (ctx.dev) return;
+				await runPostBuild(ctx, steps, environments, clientOutput);
+			}
+		}
+	};
+}
+/**
+* The client bundle's assets directory, in the artifacts' form (no leading
+* or trailing slash) — or `''` when its files are not all content-hashed.
+*
+* `assetsDir` names where Vite writes; it is the naming patterns that decide
+* whether a file name carries a hash. Vite's defaults do
+* (`<assetsDir>/[name]-[hash].js`), but an app can set
+* `assetFileNames: 'static/[name][extname]'`, and marking that directory
+* immutable would pin a changed image under an unchanged URL for a year. A
+* pattern given as a function cannot be inspected, so it counts as unhashed:
+* those files fall back to the revalidating per-file rule.
+*
+* @internal Exported for testing.
+*/
+function hashedAssetsDir(assetsDir, output) {
+	const dir = assetsDir.replace(/^\/+|\/+$/g, "");
+	return [
+		output.entryFileNames,
+		output.chunkFileNames,
+		output.assetFileNames
+	].every((p) => typeof p === "string" && p.includes("[hash")) ? dir : "";
+}
+/**
+* Keep only the directories whose every file the client bundle emitted.
+*
+* A producer knows it hashes what *it* writes, not what else lands beside it:
+* Vite copies `public/` into the client output verbatim, so `public/assets/logo.png`
+* sits in `assets/` under a stable name, and `public/_rsc/…` would sit among
+* the hashed payloads. A directory holding any file the bundle did not emit
+* is not content-hashed as a whole, and marking it immutable would pin that
+* file for a year — so it is dropped, and its files take the per-file rule.
+*
+* @internal Exported for testing.
+*/
+async function onlyEmittedDirs(clientDir, dirs, emitted) {
+	const kept = [];
+	for (const dir of dirs) {
+		const root = join(clientDir, dir);
+		if (!(await readdir(root, {
+			recursive: true,
+			withFileTypes: true
+		}).catch(() => [])).some((entry) => entry.isFile() && !emitted.has(relative(clientDir, join(entry.parentPath, entry.name)).replace(/\\/g, "/")))) kept.push(dir);
+	}
+	return kept;
+}
+async function runPostBuild(ctx, steps, environments, clientOutput) {
+	const output = ctx.config.output ?? "server";
+	const rsc = requireEnvironment(environments, "rsc");
+	const ssr = requireEnvironment(environments, "ssr");
+	const manifest = await finalizeBuildManifest(ctx, steps.fonts, rsc, ssr);
+	if (manifest) Reflect.set(globalThis, "__TIMBER_BUILD_MANIFEST__", manifest);
+	const prebuilt = await steps.prebuilt.capture(rsc.path);
+	const site = output === "static" ? await runStaticGeneration(ctx, rsc.path) : void 0;
+	steps.report.print(prebuilt);
+	const adapter = contextAdapter(ctx);
+	if (!adapter || typeof adapter.buildOutput !== "function") return;
+	await adapter.buildOutput(adapterConfig(ctx), assembleBuildArtifacts({
+		output,
+		outputDir: ctx.buildDir,
+		environments,
+		immutableDirs: await onlyEmittedDirs(requireEnvironment(environments, "client").path, [
+			...clientOutput.assetsDir ? [clientOutput.assetsDir] : [],
+			...steps.fonts.immutableDirs(),
+			...site?.immutableDirs ?? []
+		], clientOutput.emitted),
+		prebuilt: prebuilt?.artifact,
+		site,
+		manifestInit: manifest ? serializeManifestInit(manifest) : void 0
+	}));
+}
+function requireEnvironment(environments, name) {
+	const artifact = environments[name];
+	if (!artifact) throw new Error(`[timber] Build output: the ${name} environment wrote no bundle`);
+	return artifact;
+}
+/**
+* Step 1: bring the build manifest to its final shape, once.
+*
+* `timber-build-manifest` creates it from the client bundle; this adds what
+* only exists once every environment is built — the font entries and the
+* per-route CSS and modulepreloads in the RSC plugin's assets manifest —
+* and then, when client JavaScript is disabled, removes every JavaScript
+* reference, from the manifest and from the assets manifests on disk. The
+* manifest's `js` / `modulepreload` are cleared after the merge has written
+* into them, so nothing the merge adds survives.
+*
+* Returns null only when no client bundle produced a manifest.
+*
+* @internal Exported for testing.
+*/
+async function finalizeBuildManifest(ctx, fonts, rsc, ssr) {
+	const manifest = ctx.buildManifest;
+	if (manifest) {
+		fonts.contributeManifest(manifest);
+		await mergeRscAssetsManifest(rsc.path, ctx.root, manifest, ctx.routeClientRefKeys);
+	}
+	if (ctx.clientJavascript.disabled) {
+		if (manifest) {
+			manifest.js = {};
+			manifest.modulepreload = {};
+		}
+		await stripJsFromRscAssetsManifests([rsc.path, ssr.path]);
+	}
+	return manifest;
+}
+/**
+* The build manifest as a JS module that sets the global. Adapters write
+* it as `_timber-manifest-init.js` (or prepend it to the entry) and
+* evaluate it before the RSC handler, so `virtual:timber-build-manifest`
+* finds it.
+*/
+function serializeManifestInit(manifest) {
+	return `globalThis.__TIMBER_BUILD_MANIFEST__ = ${JSON.stringify(manifest)};\n`;
+}
+/**
+* Dedupe the producers' directories and drop any that sits inside another.
+*
+* Two producers can name overlapping directories — a custom `assetsDir` of
+* `_timber` beside the fonts' `_timber/fonts`. Cloudflare and Netlify apply
+* every matching `_headers` rule, so emitting both would send two
+* `Cache-Control` values for one file; the outer directory already covers
+* the inner one.
+*/
+function canonicalImmutableDirs(dirs) {
+	const unique = [...new Set(dirs)];
+	return unique.filter((dir) => !unique.some((other) => other !== dir && dir.startsWith(`${other}/`)));
+}
+/**
+* Assemble the adapter's view of the build from what each step returned.
+*
+* Not a validator: every field is copied from the phase that produced it.
+* The throws are the states the union cannot represent — a Vite environment
+* that wrote no bundle, a static build with no site. Each means an earlier
+* phase failed without failing the build, and a deploy missing its SSR
+* bundle fails on the first request rather than here.
+*
+* @internal Exported for testing.
+*/
+function assembleBuildArtifacts(input) {
+	const { output, outputDir, environments } = input;
+	const client = requireEnvironment(environments, "client");
+	const immutableDirs = canonicalImmutableDirs(input.immutableDirs);
+	if (output === "static") {
+		if (!input.site) throw new Error("[timber] Build output: output is 'static' but static generation recorded no site");
+		const { pages, contentTypes } = input.site;
+		return {
+			output,
+			outputDir,
+			client,
+			immutableDirs,
+			pages,
+			contentTypes
+		};
+	}
+	return {
+		output,
+		outputDir,
+		client,
+		immutableDirs,
+		rsc: requireEnvironment(environments, "rsc"),
+		ssr: requireEnvironment(environments, "ssr"),
+		prebuilt: input.prebuilt,
+		manifestInit: input.manifestInit
+	};
+}
+//#endregion
 //#region src/plugins/build-report.ts
 /**
 * timber-build-report — Post-build route summary table.
@@ -8671,13 +8935,10 @@ function pad(str, width, align = "right") {
 function stripAnsi(str) {
 	return str.replace(/\u001b\[\d+m/g, "");
 }
-function loadPrebuiltManifest(buildDir) {
-	try {
-		const raw = readFileSync(join(buildDir, "prebuilt", "manifest.json"), "utf-8");
-		return JSON.parse(raw);
-	} catch {
-		return null;
-	}
+/** Read the manifest of the prebuilt artifact this build recorded, if any. */
+function loadPrebuiltManifest(prebuiltDir) {
+	if (!prebuiltDir) return null;
+	return JSON.parse(readFileSync(join(prebuiltDir, "manifest.json"), "utf-8"));
 }
 function buildPrebuiltReportData(manifest, summary) {
 	const hasCaptures = summary && (summary.captured > 0 || summary.skipped.length > 0);
@@ -8881,11 +9142,47 @@ function timberBuildReport(ctx) {
 	let logger = null;
 	let chunkSizes = null;
 	let clientBundle = null;
-	let reported = false;
-	let deferReport = false;
 	const buildStart = performance.now();
+	function printRouteTable() {
+		if (!ctx.routeTree || !chunkSizes || !clientBundle || !logger) return;
+		const outputMode = ctx.config.output ?? "server";
+		const { entries, sharedGzip } = ctx.clientJavascript.disabled ? {
+			entries: collectRoutes(ctx.routeTree).map((info) => ({
+				path: info.path,
+				type: classifyRoute(info.segments, outputMode),
+				size: 0,
+				firstLoadSize: 0
+			})),
+			sharedGzip: 0
+		} : buildEntries(ctx.routeTree, chunkSizes, clientBundle, outputMode, ctx.appDir, ctx.root);
+		const elapsed = ((performance.now() - buildStart) / 1e3).toFixed(2);
+		const lines = buildRouteReport(entries, sharedGzip);
+		logger.info("");
+		for (const line of lines) logger.info(line);
+		const warnings = buildWarnings(entries, ctx.config.budget);
+		if (warnings.length > 0) {
+			logger.info("");
+			for (const w of warnings) logger.warn(w);
+		}
+		logger.info("");
+		logger.info(`✓ built ${entries.length} routes for all three environments (rsc, ssr, client) in ${elapsed}s`);
+		logger.info("");
+	}
+	function printPrebuiltReport(prebuilt) {
+		if (!logger || !prebuilt) return;
+		const prebuiltData = buildPrebuiltReportData(loadPrebuiltManifest(prebuilt.artifact?.path), prebuilt.summary);
+		if (!prebuiltData) return;
+		logger.info("");
+		for (const line of buildPrebuiltReport(prebuiltData)) logger.info(line);
+		logger.info("");
+	}
 	return {
 		name: "timber-build-report",
+		api: { print(prebuilt) {
+			if (ctx.dev) return;
+			printRouteTable();
+			printPrebuiltReport(prebuilt);
+		} },
 		config(_cfg, { command }) {
 			if (command !== "build") return;
 			return { environments: {
@@ -8902,50 +9199,6 @@ function timberBuildReport(ctx) {
 			if (this.environment?.name && this.environment.name !== "client") return;
 			chunkSizes = collectChunkSizes(bundle);
 			clientBundle = { ...bundle };
-			deferReport = true;
-		},
-		closeBundle() {
-			if (ctx.dev || reported) return;
-			if (deferReport) {
-				deferReport = false;
-				return;
-			}
-			if (!ctx.routeTree || !chunkSizes || !clientBundle || !logger) return;
-			reported = true;
-			const outputMode = ctx.config.output ?? "server";
-			const { entries, sharedGzip } = ctx.clientJavascript.disabled ? {
-				entries: collectRoutes(ctx.routeTree).map((info) => ({
-					path: info.path,
-					type: classifyRoute(info.segments, outputMode),
-					size: 0,
-					firstLoadSize: 0
-				})),
-				sharedGzip: 0
-			} : buildEntries(ctx.routeTree, chunkSizes, clientBundle, outputMode, ctx.appDir, ctx.root);
-			const elapsed = ((performance.now() - buildStart) / 1e3).toFixed(2);
-			const lines = buildRouteReport(entries, sharedGzip);
-			logger.info("");
-			for (const line of lines) logger.info(line);
-			const warnings = buildWarnings(entries, ctx.config.budget);
-			if (warnings.length > 0) {
-				logger.info("");
-				for (const w of warnings) logger.warn(w);
-			}
-			logger.info("");
-			logger.info(`✓ built ${entries.length} routes for all three environments (rsc, ssr, client) in ${elapsed}s`);
-			logger.info("");
-		},
-		buildApp: {
-			order: "post",
-			async handler() {
-				if (ctx.dev || !logger) return;
-				const prebuiltData = buildPrebuiltReportData(loadPrebuiltManifest(ctx.buildDir), ctx.captureSummary);
-				if (!prebuiltData) return;
-				logger.info("");
-				const prebuiltLines = buildPrebuiltReport(prebuiltData);
-				for (const line of prebuiltLines) logger.info(line);
-				logger.info("");
-			}
 		}
 	};
 }
@@ -9287,10 +9540,8 @@ function timber(config) {
 			}
 			ctx.config.output ??= "server";
 			ctx.timer.end("config-load");
-			const viteOutDir = userConfig.build?.outDir;
-			const timberBuildDir = ctx.config.buildDir;
 			const resolvedRoot = resolve(userConfig.root ?? process.cwd());
-			ctx.buildDir = resolveBuildDir(resolvedRoot, timberBuildDir, viteOutDir);
+			const buildDir = resolveBuildDir(resolvedRoot, ctx.config.buildDir, userConfig.build?.outDir);
 			if (viteRoot !== process.cwd()) {
 				const hasCompilerInReloaded = !config?.reactCompiler && ctx.config.reactCompiler;
 				const hadCompilerInEarly = !config?.reactCompiler && earlyFileConfig?.reactCompiler;
@@ -9321,7 +9572,7 @@ function timber(config) {
 				resolvedDevPort = start.port;
 				resolvedDevPortExplicit = start.explicit;
 			}
-			const buildOutDir = relative(resolvedRoot, ctx.buildDir);
+			const buildOutDir = relative(resolvedRoot, buildDir);
 			const envOutDirs = {};
 			for (const envName of [
 				"rsc",
@@ -9385,8 +9636,12 @@ function timber(config) {
 	};
 	const effectiveReactCompiler = config?.reactCompiler ?? earlyFileConfig?.reactCompiler ?? true;
 	// @vitejs/plugin-rsc handles:
+	const fonts = timberFonts(ctx);
+	const prebuilt = timberPrebuilt(ctx);
+	const buildReport = timberBuildReport(ctx);
 	return [
 		rootSync,
+		timberReactResolve(),
 		timberReactProd(),
 		...patchReactCompilerForProdJsx(react({ compiler: effectiveReactCompiler || false })),
 		vitePluginRsc(createRscOptions(ctx, encryptionKeyExpr)),
@@ -9394,19 +9649,23 @@ function timber(config) {
 		timberRouting(ctx),
 		timberEntries(ctx),
 		timberBuildManifest(ctx),
-		timberFonts(ctx),
+		fonts,
 		timberMdx(ctx),
 		timberRequestDep(ctx),
 		timberCacheTransform(ctx),
 		timberPrerenderSugar(ctx),
-		timberPrebuilt(ctx),
+		prebuilt,
 		timberStaticBuild(ctx),
 		timberContent(ctx),
 		timberServerBundle(),
 		timberCloudflareWasm(ctx),
 		timberChunks(ctx),
-		timberBuildReport(ctx),
-		timberAdapterBuild(ctx),
+		buildReport,
+		timberPostBuild(ctx, {
+			fonts: fonts.api,
+			prebuilt: prebuilt.api,
+			report: buildReport.api
+		}),
 		timberDevLogs(ctx),
 		timberDevServer(ctx)
 	];