@timber-js/app 0.2.0-alpha.157 → 0.2.0-alpha.159

package/dist/index.js

@@ -1,9 +1,10 @@
-import { a as resolveAppDir, c as createNoopTimer, d as __toCommonJS, l as __esmMin, n as loadTimberConfigFile, o as resolveBuildDir, r as mergeFileConfig, s as resolveClientJavascript, t as createPluginContext, u as __exportAll } from "./_chunks/plugin-context-DUl3dnCF.js";
+import { a as __esmMin, o as __exportAll, s as __toCommonJS } from "./_chunks/dist-BA3u1z3W.js";
 import { c as isDynamicMetadataExtension, l as isMetadataRouteServePath, r as canonicalize } from "./_chunks/canonicalize-P41GR6tY.js";
 import { t as matchUrlParts } from "./_chunks/tree-match-D2l830j2.js";
-import { h as swallow } from "./_chunks/logger-C5v1IMuh.js";
-import { i as scanRoutes } from "./_chunks/cli-schema-sync-DcmQrzJG.js";
-import { a as generateRouteMap, i as validateSchemaAgainstRoutes, n as collectInterceptionRewrites, o as readFileCached, t as collectLeafRoutes } from "./_chunks/walkers-D5jCGPum.js";
+import { h as swallow } from "./_chunks/logger-CrRmZMlo.js";
+import { i as scanRoutes } from "./_chunks/cli-schema-sync-Bivx4Rn7.js";
+import { a as generateRouteMap, c as fileHasDirective, d as getPrerenderExport, i as validateSchemaAgainstRoutes, l as fileHasExport, n as collectInterceptionRewrites, o as fileHasAnyExport, s as fileHasDefaultExport, t as collectLeafRoutes, u as fileHasStarExport } from "./_chunks/walkers-DXbJkeCY.js";
+import { a as resolveAppDir, c as createNoopTimer, n as loadTimberConfigFile, o as resolveBuildDir, r as mergeFileConfig, s as resolveClientJavascript, t as createPluginContext } from "./_chunks/plugin-context-DeAxFRMq.js";
 import { t as fnv1aHash } from "./_chunks/fast-hash-D6hIVt1Y.js";
 import { t as formatSize } from "./_chunks/format-CfwjgPz9.js";
 import { basename, dirname, extname, join, normalize, relative, resolve, win32 } from "node:path";
@@ -11,9 +12,10 @@ import { builtinModules, createRequire } from "node:module";
 import react, { reactCompilerPreset } from "@vitejs/plugin-react";
 import { existsSync, readFileSync, statSync } from "node:fs";
 import { fileURLToPath, pathToFileURL } from "node:url";
+import { styleText } from "node:util";
 import { constants, createGzip, gzipSync } from "node:zlib";
 import { Readable, pipeline } from "node:stream";
-import { copyFile, mkdir, readFile, stat, writeFile } from "node:fs/promises";
+import { copyFile, mkdir, readFile, rename, rm, stat, writeFile } from "node:fs/promises";
 import { createHash, randomUUID } from "node:crypto";
 import { parseAst } from "vite";
 import http from "node:http";
@@ -171,12 +173,8 @@ function classifyStack(stack, projectRoot) {
 *
 * Design doc: 21-dev-server.md §"Error Overlay"
 */
-var RED$2 = "\x1B[31m";
-var CYAN = "\x1B[36m";
-var DIM$2 = "\x1B[2m";
-var RESET$2 = "\x1B[0m";
-var BOLD$2 = "\x1B[1m";
-var UNDERLINE = "\x1B[4m";
+var noValidate$1 = { validateStream: false };
+var style$1 = (fmt, text) => styleText(fmt, text, noValidate$1);
 /**
 * Wrap text in an OSC 8 hyperlink escape sequence.
 *
@@ -198,7 +196,7 @@ function hyperlink(text, url) {
 function fileLink(filePath, line, col) {
 	const display = line ? `${filePath}:${line}${col ? `:${col}` : ""}` : filePath;
 	const base = pathToFileURL(filePath).href;
-	return `${CYAN}${UNDERLINE}${hyperlink(display, line ? `${base}:${line}${col ? `:${col}` : ""}` : base)}${RESET$2}`;
+	return style$1(["cyan", "underline"], hyperlink(display, line ? `${base}:${line}${col ? `:${col}` : ""}` : base));
 }
 var BOX = {
 	topLeft: "╭",
@@ -214,12 +212,12 @@ var BOX = {
 * @param lines - Content lines (no ANSI length calculation — keeps it simple)
 * @param width - Box width (characters). Lines longer than this are not truncated.
 */
-function box(lines, borderColor, width = 80) {
+function box(lines, borderFormat, width = 80) {
 	const bar = BOX.horizontal.repeat(width - 2);
 	const output = [];
-	output.push(`${borderColor}${BOX.topLeft}${bar}${BOX.topRight}${RESET$2}`);
-	for (const line of lines) output.push(`${borderColor}${BOX.vertical}${RESET$2} ${line}`);
-	output.push(`${borderColor}${BOX.bottomLeft}${bar}${BOX.bottomRight}${RESET$2}`);
+	output.push(style$1(borderFormat, `${BOX.topLeft}${bar}${BOX.topRight}`));
+	for (const line of lines) output.push(`${style$1(borderFormat, BOX.vertical)} ${line}`);
+	output.push(style$1(borderFormat, `${BOX.bottomLeft}${bar}${BOX.bottomRight}`));
 	return output.join("\n");
 }
 /**
@@ -240,32 +238,32 @@ function formatTerminalError$1(error, phase, projectRoot) {
 	const appFrames = frames.filter((f) => f.type === "app");
 	const internalCount = frames.filter((f) => f.type !== "app").length;
 	const boxLines = [];
-	boxLines.push(`${RED$2}${BOLD$2}${PHASE_LABELS$1[phase]} Error${RESET$2}`);
+	boxLines.push(style$1(["red", "bold"], `${PHASE_LABELS$1[phase]} Error`));
 	boxLines.push("");
-	for (const msgLine of error.message.split("\n")) boxLines.push(`${RED$2}${msgLine}${RESET$2}`);
+	for (const msgLine of error.message.split("\n")) boxLines.push(style$1("red", msgLine));
 	if (loc) {
 		boxLines.push("");
 		const relPath = loc.file.startsWith(projectRoot) ? loc.file.slice(projectRoot.length + 1) : loc.file;
-		boxLines.push(`${BOLD$2}→${RESET$2} ${fileLink(loc.file, loc.line, loc.column)} ${DIM$2}(${relPath})${RESET$2}`);
+		boxLines.push(`${style$1("bold", "→")} ${fileLink(loc.file, loc.line, loc.column)} ${style$1("dim", `(${relPath})`)}`);
 	}
-	sections.push(box(boxLines, RED$2));
+	sections.push(box(boxLines, "red"));
 	if (componentStack) {
 		sections.push("");
-		sections.push(`  ${BOLD$2}Component Stack:${RESET$2}`);
-		for (const csLine of componentStack.trim().split("\n")) sections.push(`  ${DIM$2}${csLine.trim()}${RESET$2}`);
+		sections.push(`  ${style$1("bold", "Component Stack:")}`);
+		for (const csLine of componentStack.trim().split("\n")) sections.push(`  ${style$1("dim", csLine.trim())}`);
 	}
 	if (appFrames.length > 0) {
 		sections.push("");
-		sections.push(`  ${BOLD$2}Application Frames:${RESET$2}`);
+		sections.push(`  ${style$1("bold", "Application Frames:")}`);
 		for (let i = 0; i < appFrames.length; i++) {
 			const f = appFrames[i];
 			if (f.file && f.line) {
-				const prefix = i === 0 ? `${BOLD$2}▸${RESET$2}` : " ";
-				sections.push(`  ${prefix} ${fileLink(f.file, f.line, f.col)} ${DIM$2}${extractFnName(f.raw)}${RESET$2}`);
+				const prefix = i === 0 ? style$1("bold", "▸") : " ";
+				sections.push(`  ${prefix} ${fileLink(f.file, f.line, f.col)} ${style$1("dim", extractFnName(f.raw))}`);
 			} else sections.push(`  ${f.raw}`);
 		}
 	}
-	if (internalCount > 0) sections.push(`  ${DIM$2}… ${internalCount} internal frame${internalCount !== 1 ? "s" : ""} hidden${RESET$2}`);
+	if (internalCount > 0) sections.push(`  ${style$1("dim", `… ${internalCount} internal frame${internalCount !== 1 ? "s" : ""} hidden`)}`);
 	sections.push("");
 	return sections.join("\n");
 }
@@ -1147,11 +1145,11 @@ function validateConfig(config) {
 function formatConfigErrors(errors) {
 	if (errors.length === 0) return "";
 	const lines = [];
-	lines.push(`${RED$1}${BOLD$1}[timber]${RESET$1} ${RED$1}${errors.length} config error${errors.length !== 1 ? "s" : ""} in timber.config.ts:${RESET$1}`);
+	lines.push(`${RED}${BOLD}[timber]${RESET} ${RED}${errors.length} config error${errors.length !== 1 ? "s" : ""} in timber.config.ts:${RESET}`);
 	for (const err of errors) {
 		lines.push("");
-		lines.push(`  ${RED$1}✗${RESET$1} ${BOLD$1}${err.field}${RESET$1}: ${err.message}`);
-		if (err.suggestion) lines.push(`    ${DIM$1}${err.suggestion}${RESET$1}`);
+		lines.push(`  ${RED}✗${RESET} ${BOLD}${err.field}${RESET}: ${err.message}`);
+		if (err.suggestion) lines.push(`    ${DIM}${err.suggestion}${RESET}`);
 	}
 	return lines.join("\n");
 }
@@ -1196,15 +1194,15 @@ function formatMissingPeers(results) {
 	if (missing.length === 0) return "";
 	const names = missing.map((r) => r.name);
 	const lines = [];
-	lines.push(`${RED$1}${BOLD$1}[timber]${RESET$1} ${RED$1}Missing required dependencies:${RESET$1}`);
+	lines.push(`${RED}${BOLD}[timber]${RESET} ${RED}Missing required dependencies:${RESET}`);
 	lines.push("");
-	for (const name of names) lines.push(`  ${RED$1}✗${RESET$1} ${name}`);
+	for (const name of names) lines.push(`  ${RED}✗${RESET} ${name}`);
 	lines.push("");
-	lines.push(`  ${DIM$1}Install with:${RESET$1}`);
-	lines.push(`  ${BOLD$1}pnpm add ${names.join(" ")}${RESET$1}`);
+	lines.push(`  ${DIM}Install with:${RESET}`);
+	lines.push(`  ${BOLD}pnpm add ${names.join(" ")}${RESET}`);
 	return lines.join("\n");
 }
-var knownKeys, RED$1, BOLD$1, DIM$1, RESET$1, VIRTUAL_MODULE_NAMES, REQUIRED_PEERS;
+var knownKeys, RED, BOLD, DIM, RESET, VIRTUAL_MODULE_NAMES, REQUIRED_PEERS;
 var init_config_validation = __esmMin((() => {
 	knownKeys = new Set(Object.keys({
 		output: true,
@@ -1212,6 +1210,7 @@ var init_config_validation = __esmMin((() => {
 		clientJavascript: true,
 		adapter: true,
 		cacheHandler: true,
+		cdnPurge: true,
 		allowedOrigins: true,
 		csrf: true,
 		limits: true,
@@ -1232,10 +1231,10 @@ var init_config_validation = __esmMin((() => {
 		topLoader: true,
 		budget: true
 	}));
-	RED$1 = "\x1B[31m";
-	BOLD$1 = "\x1B[1m";
-	DIM$1 = "\x1B[2m";
-	RESET$1 = "\x1B[0m";
+	RED = "\x1B[31m";
+	BOLD = "\x1B[1m";
+	DIM = "\x1B[2m";
+	RESET = "\x1B[0m";
 	VIRTUAL_MODULE_NAMES = {
 		"virtual:timber-rsc-entry": "RSC entry (server component handler)",
 		"virtual:timber-ssr-entry": "SSR entry (HTML renderer)",
@@ -1832,7 +1831,8 @@ function generateConfigModule(ctx) {
 		renderTimeoutMs: ctx.config.renderTimeoutMs ?? 3e4,
 		sitemap: ctx.config.sitemap,
 		forms: serializeFormsConfig(ctx.config.forms),
-		deploymentId: ctx.deploymentId ?? null
+		deploymentId: ctx.deploymentId ?? null,
+		devBrowserLogs: ctx.config.devBrowserLogs
 	};
 	return [
 		"// Auto-generated runtime config — do not edit.",
@@ -1914,8 +1914,8 @@ function detectConfigFile(root) {
 * cannot be JSON-serialized into virtual:timber-config, so it must
 * be loaded at runtime via dynamic import. See TIM-599.
 */
-function generateCacheHandlerModule(configPath, hasCacheHandler) {
-	if (configPath && hasCacheHandler) return [
+function generateCacheHandlerModule(configPath, hasCacheHandler, hasCdnPurge) {
+	if (configPath && (hasCacheHandler || hasCdnPurge)) return [
 		"// Auto-generated cache handler loader — do not edit.",
 		"// Generated by timber-entries plugin.",
 		"",
@@ -1923,15 +1923,25 @@ function generateCacheHandlerModule(configPath, hasCacheHandler) {
 		`  const mod = await import(${JSON.stringify(configPath)});`,
 		`  const config = mod.default ?? mod;`,
 		`  return config.cacheHandler ?? null;`,
+		`}`,
+		"",
+		`export async function loadCdnPurgeHandler() {`,
+		`  const mod = await import(${JSON.stringify(configPath)});`,
+		`  const config = mod.default ?? mod;`,
+		`  return config.cdnPurge ?? null;`,
 		`}`
 	].join("\n");
 	return [
 		"// Auto-generated cache handler loader — do not edit.",
 		"// Generated by timber-entries plugin.",
-		"// No cacheHandler configured in timber.config.",
+		"// No cacheHandler or cdnPurge configured in timber.config.",
 		"",
 		`export default async function loadCacheHandler() {`,
 		`  return null;`,
+		`}`,
+		"",
+		`export async function loadCdnPurgeHandler() {`,
+		`  return null;`,
 		`}`
 	].join("\n");
 }
@@ -1972,7 +1982,7 @@ function timberEntries(ctx) {
 		load(id) {
 			if (id === RESOLVED_CONFIG_ID) return generateConfigModule(ctx);
 			if (id === RESOLVED_INSTRUMENTATION_ID) return generateInstrumentationModule(detectInstrumentationFile(ctx.root));
-			if (id === RESOLVED_CACHE_HANDLER_ID) return generateCacheHandlerModule(detectConfigFile(ctx.root), ctx.config.cacheHandler != null);
+			if (id === RESOLVED_CACHE_HANDLER_ID) return generateCacheHandlerModule(detectConfigFile(ctx.root), ctx.config.cacheHandler != null, ctx.config.cdnPurge != null);
 			return null;
 		}
 	};
@@ -2335,13 +2345,7 @@ function generateSearchParamsRegistryModule(tree) {
 	return lines.join("\n");
 }
 function fileHasSearchParamsExport(filePath) {
-	try {
-		if (!existsSync(filePath)) return false;
-		const content = readFileCached(filePath);
-		return /export\s+(const|let|var)\s+searchParams\b/.test(content) || /export\s*\{[^}]*\bsearchParams\b[^}]*\}/.test(content);
-	} catch {
-		return false;
-	}
+	return fileHasExport(filePath, "searchParams");
 }
 /**
 * Generate the virtual:timber-schema module.
@@ -2399,6 +2403,8 @@ function lintConventions(tree, appDir) {
 	checkRouteExports(tree.root, warnings);
 	checkRootLayout(tree.root, warnings);
 	checkDefaultExports(tree.root, warnings);
+	checkErrorDirectives(tree.root, warnings);
+	if (tree.globalError && isScriptExtension(tree.globalError.extension)) checkFileUseClientDirective(tree.globalError.filePath, "global-error", warnings);
 	return warnings;
 }
 /**
@@ -2455,28 +2461,18 @@ var HTTP_METHODS = [
 	"OPTIONS"
 ];
 /**
-* Pattern to detect named exports that look like HTTP method handlers.
-* Matches: export function GET, export const GET, export async function POST, etc.
-* Also matches: export { GET } or re-exports like export { GET } from './handler'.
-*
-* The re-export branch uses word boundaries (\b) around method names to avoid
-* matching substrings (e.g. TARGET should not match GET). See TIM-795.
-*/
-var EXPORT_PATTERN = new RegExp(`export\\s+(?:async\\s+)?(?:function|const|let|var)\\s+(${HTTP_METHODS.join("|")})\\b|export\\s*\\{[^}]*\\b(${HTTP_METHODS.join("|")})\\b[^}]*\\}`);
-/**
 * Warn when a route.ts file doesn't appear to export any recognized HTTP methods.
 *
-* Uses static analysis (regex on source text) — not module loading.
-* This is intentionally conservative: it may miss complex re-exports but
-* catches the common case of an empty route.ts or one with wrong export names.
+* Uses AST-based detection via parseAst for precise matching.
+* Falls back silently when the file can't be parsed (syntax errors produce
+* no spurious warning — the TS compiler will catch those).
 */
 function checkRouteExports(node, warnings) {
 	if (node.route) {
 		const filePath = node.route.filePath;
 		try {
-			const source = readFileCached(filePath);
-			if (!EXPORT_PATTERN.test(source)) {
-				const hint = /export\s+default\b/.test(source) ? "  It looks like you have a default export. route.ts uses named exports\n  for HTTP methods (GET, POST, etc.), not a default export.\n" : "";
+			if (fileHasAnyExport(filePath, HTTP_METHODS).size === 0 && !fileHasStarExport(filePath)) {
+				const hint = fileHasDefaultExport(filePath) ? "  It looks like you have a default export. route.ts uses named exports\n  for HTTP methods (GET, POST, etc.), not a default export.\n" : "";
 				warnings.push({
 					id: "ROUTE_NO_METHODS",
 					summary: `route.ts has no HTTP method exports: ${filePath}`,
@@ -2511,23 +2507,14 @@ function checkRootLayout(root, warnings) {
 	});
 }
 /**
-* Pattern to detect a default export in source code.
-* Matches: export default function, export default class, export default
-* Also matches: export { X as default }, export { default } from './Impl'
-*
-* The third alternative catches bare `default` re-exports (TIM-790).
-* The negative lookahead (?!\s+as\b) prevents matching `export { default as X }`
-* which is a named export, not a default export (TIM-806).
-*/
-var DEFAULT_EXPORT_PATTERN = /export\s+default\b|export\s*\{[^}]*\bas\s+default\b|export\s*\{[^}]*\bdefault\b(?!\s+as\b)[^}]*\}/;
-/**
 * Warn when page.tsx or layout.tsx files don't have a default export.
 *
 * Without a default export:
 * - page.tsx: the page renders nothing (empty content)
 * - layout.tsx: the layout module loads but has no component to render
 *
-* Uses static analysis (regex on source text) — intentionally conservative.
+* Uses AST-based detection via parseAst for precise matching. Falls back
+* silently when the file can't be parsed (no spurious warning on syntax errors).
 */
 function checkDefaultExports(node, warnings) {
 	if (node.page && isScriptExtension(node.page.extension)) checkFileDefaultExport(node.page.filePath, "page", warnings);
@@ -2540,8 +2527,7 @@ function isScriptExtension(ext) {
 }
 function checkFileDefaultExport(filePath, fileType, warnings) {
 	try {
-		const source = readFileCached(filePath);
-		if (!DEFAULT_EXPORT_PATTERN.test(source)) warnings.push({
+		if (!fileHasDefaultExport(filePath)) warnings.push({
 			id: `NO_DEFAULT_EXPORT:${filePath}`,
 			summary: `${fileType}.tsx has no default export: ${filePath}`,
 			details: `  File: ${filePath}\n\n  ${fileType}.tsx files must export a default React component.\n  Without a default export, the ${fileType === "page" ? "page renders nothing" : "layout has no component to wrap children"}.\n\n  To fix: Add a default export:\n\n    export default function My${fileType === "page" ? "Page" : "Layout"}(${fileType === "layout" ? "{ children }" : ""}) {\n      return ${fileType === "layout" ? "<div>{children}</div>" : "<h1>Hello</h1>"};\n    }\n`,
@@ -2552,6 +2538,39 @@ function checkFileDefaultExport(filePath, fileType, warnings) {
 	}
 }
 /**
+* Warn when error.tsx or global-error.tsx is missing 'use client'.
+*
+* React's error boundary API requires client components. Without the directive,
+* the error boundary silently fails — the component renders as a server component
+* with no error catching. Users discover this only via cryptic runtime errors.
+*/
+function checkErrorDirectives(node, warnings) {
+	if (node.error && isScriptExtension(node.error.extension)) checkFileUseClientDirective(node.error.filePath, "error", warnings);
+	for (const child of node.children) checkErrorDirectives(child, warnings);
+	for (const slot of Object.values(node.slots)) checkErrorDirectives(slot, warnings);
+}
+function checkFileUseClientDirective(filePath, fileType, warnings) {
+	try {
+		if (!fileHasDirective(filePath, "use client")) warnings.push({
+			id: `ERROR_NO_USE_CLIENT:${filePath}`,
+			summary: `${fileType}.tsx is missing 'use client': ${filePath}`,
+			details: `  File: ${filePath}\n\n  ${fileType}.tsx must start with 'use client' because React error\n  boundaries require client components. Without it, the error boundary
+  silently fails and errors are uncaught.
+
+  To fix: Add 'use client' as the first line of the file:
+
+    'use client';
+
+    export default function ${fileType === "global-error" ? "GlobalError" : "ErrorBoundary"}({ error, reset }) {\n      return <div><h2>Something went wrong</h2><button onClick={reset}>Try again</button></div>;
+    }
+`,
+			level: "warn"
+		});
+	} catch (err) {
+		swallow(err, `convention-lint: unreadable ${fileType} file ${filePath}`);
+	}
+}
+/**
 * Check if the app/ directory exists. Called before scanning.
 * Returns a warning if missing, or null if the directory exists.
 */
@@ -2571,11 +2590,8 @@ function checkAppDirExists(appDir) {
 		level: "error"
 	};
 }
-var YELLOW = "\x1B[33m";
-var RED = "\x1B[31m";
-var BOLD = "\x1B[1m";
-var DIM = "\x1B[2m";
-var RESET = "\x1B[0m";
+var noValidate = { validateStream: false };
+var style = (fmt, text) => styleText(fmt, text, noValidate);
 /**
 * Format warnings for terminal output.
 *
@@ -2587,20 +2603,20 @@ function formatConventionWarnings(warnings) {
 	const warns = warnings.filter((w) => w.level === "warn");
 	const lines = [];
 	if (errors.length > 0) {
-		lines.push(`${RED}${BOLD}[timber]${RESET} ${RED}${errors.length} configuration error${errors.length !== 1 ? "s" : ""}:${RESET}`);
+		lines.push(`${style(["red", "bold"], "[timber]")} ${style("red", `${errors.length} configuration error${errors.length !== 1 ? "s" : ""}:`)}`);
 		for (const e of errors) {
 			lines.push("");
-			lines.push(`  ${RED}✗${RESET} ${e.summary}`);
-			lines.push(`${DIM}${e.details}${RESET}`);
+			lines.push(`  ${style("red", "✗")} ${e.summary}`);
+			lines.push(style("dim", e.details));
 		}
 	}
 	if (warns.length > 0) {
 		if (errors.length > 0) lines.push("");
-		lines.push(`${YELLOW}${BOLD}[timber]${RESET} ${YELLOW}${warns.length} configuration warning${warns.length !== 1 ? "s" : ""}:${RESET}`);
+		lines.push(`${style(["yellow", "bold"], "[timber]")} ${style("yellow", `${warns.length} configuration warning${warns.length !== 1 ? "s" : ""}:`)}`);
 		for (const w of warns) {
 			lines.push("");
-			lines.push(`  ${YELLOW}⚠${RESET} ${w.summary}`);
-			lines.push(`${DIM}${w.details}${RESET}`);
+			lines.push(`  ${style("yellow", "⚠")} ${w.summary}`);
+			lines.push(style("dim", w.details));
 		}
 	}
 	return lines.join("\n");
@@ -2894,6 +2910,13 @@ var SUBPATH_SRC_MAP = {
 	"params": "params/index.ts",
 	"search-params": "search-params/index.ts",
 	"segment-params": "segment-params/index.ts",
+	"cache/stores/memory": "cache/stores/memory.ts",
+	"cache/stores/redis": "cache/stores/redis.ts",
+	"cache/stores/cloudflare-kv": "cache/stores/cloudflare-kv.ts",
+	"cache/stores/vercel": "cache/stores/vercel.ts",
+	"cdn": "cdn/index.ts",
+	"cdn/cloudflare": "cdn/cloudflare-purge.ts",
+	"cdn/fastly": "cdn/fastly-purge.ts",
 	"adapters/cloudflare": "adapters/cloudflare.ts",
 	"adapters/cloudflare/cache": "adapters/cloudflare-kv-cache.ts",
 	"adapters/cloudflare/dev": "adapters/cloudflare-dev.ts",
@@ -5666,30 +5689,6 @@ function buildFontResultLiteral(extracted) {
 	return extracted.variable ? `{ className: "${extracted.className}", style: { fontFamily: "${extracted.fontFamily}" }, variable: "${extracted.variable}" }` : `{ className: "${extracted.className}", style: { fontFamily: "${extracted.fontFamily}" } }`;
 }
 /**
-* File extensions that may contain real font imports. Only JS/TS module
-* variants are scanned. Excluding non-JS extensions (.mdx, .md, .css,
-* .json, etc.) prevents false-positive matches on text that mentions a
-* font specifier inside documentation, code fences, or asset metadata.
-*
-* See TIM-840.
-*/
-var FONT_IMPORT_SCANNABLE_EXTENSIONS = /* @__PURE__ */ new Set([
-	".js",
-	".jsx",
-	".ts",
-	".tsx",
-	".mjs",
-	".cjs",
-	".mts",
-	".cts"
-]);
-function hasScannableExtension(id) {
-	const path = id.split("?", 1)[0];
-	const dot = path.lastIndexOf(".");
-	if (dot === -1) return false;
-	return FONT_IMPORT_SCANNABLE_EXTENSIONS.has(path.slice(dot).toLowerCase());
-}
-/**
 * Run the timber-fonts transform pass on a single source file.
 *
 * Parses the source once with OXC (via vite.parseAst), walks the AST to find font imports
@@ -5698,13 +5697,12 @@ function hasScannableExtension(id) {
 * source map alongside the transformed code.
 *
 * Returns `null` if the file does not import from any font virtual module.
+*
+* Pre-filtering (extension allow-list, node_modules exclusion, and code
+* substring checks) is handled by Vite 8's rolldown-native `transform.filter`
+* in the plugin hook definition (plugins/fonts.ts). See TIM-840, TIM-1147.
 */
 function runFontsTransform(code, id, pipeline, emitError) {
-	if (id.startsWith("\0") || id.includes("node_modules")) return null;
-	if (!hasScannableExtension(id)) return null;
-	const hasGoogleImport = code.includes("@timber/fonts/google") || code.includes("@timber-js/app/fonts/google") || code.includes("next/font/google");
-	const hasLocalImport = code.includes("@timber/fonts/local") || code.includes("@timber-js/app/fonts/local") || code.includes("next/font/local");
-	if (!hasGoogleImport && !hasLocalImport) return null;
 	const analysis = findFontCallSites(code);
 	if (!analysis) return null;
 	if (analysis.dynamicCall) emitError(`Font function calls must be statically analyzable. Found dynamic call: ${analysis.dynamicCall}. Pass a literal object with string/array values instead.`);
@@ -6052,9 +6050,27 @@ function timberFonts(ctx) {
 		*
 		* Delegates to `runFontsTransform`. Errors raised through the
 		* `this.error` callback are surfaced as Vite plugin errors.
+		*
+		* The `filter` option uses Vite 8's rolldown-native hook filters to
+		* skip non-JS/TS files and files that don't mention any font module
+		* before crossing into JS — replacing the hand-rolled pre-filter that
+		* was previously inside `runFontsTransform` (TIM-840, TIM-1147).
 		*/
-		transform(code, id) {
-			return runFontsTransform(code, id, pipeline, (msg) => this.error(msg));
+		transform: {
+			filter: {
+				id: {
+					include: /^[^?]*\.(?:js|jsx|ts|tsx|mjs|cjs|mts|cts)(?:\?|$)/,
+					exclude: /(?:^\0|(?:^|\/)node_modules\/)/
+				},
+				code: [
+					"@timber/fonts/",
+					"@timber-js/app/fonts/",
+					"next/font/"
+				]
+			},
+			handler(code, id) {
+				return runFontsTransform(code, id, pipeline, (msg) => this.error(msg));
+			}
 		},
 		/**
 		* Emit font binaries and build-manifest entries.
@@ -6136,7 +6152,6 @@ function timberStaticBuild(ctx) {
 		*
 		* In static mode, we check every app/ file for:
 		* - Dynamic API usage (getCookies(), getHeaders()) → build error
-		* - When client JS disabled: 'use client' / 'use server' directives → build error
 		*/
 		transform(code, id) {
 			if (!(ctx.config.output === "static")) return null;
@@ -6532,180 +6547,32 @@ function timberDevLogs(_ctx) {
 }
 //#endregion
 //#region src/dev-tools/browser-logs.ts
-/** Max message size in bytes before truncation. */
-var MAX_MESSAGE_BYTES = 2048;
-/** HMR event name for browser→server log forwarding. */
-var HMR_EVENT = "timber:browser-log";
-/** ANSI color codes for terminal output. */
-var COLORS = {
-	red: "\x1B[31m",
-	yellow: "\x1B[33m",
-	blue: "\x1B[34m",
-	dim: "\x1B[2m",
-	reset: "\x1B[0m"
-};
-/** Level severity ordering for threshold comparison. */
-var LEVEL_SEVERITY = {
-	none: 0,
-	info: 1,
-	warn: 2,
-	error: 3
-};
-/**
-* Format a browser log payload for server terminal output.
-*
-* Produces color-coded output like:
-*   [browser:error] Uncaught TypeError: x is not a function
-*     at App (app.tsx:10:5)
-*   [browser:warn] Deprecation warning (app/page.tsx:42:12)
-*/
-function formatBrowserLog(payload) {
-	const { level, message, stack, source } = payload;
-	let output = `${`${level === "error" ? COLORS.red : level === "warn" ? COLORS.yellow : COLORS.blue}[browser:${level}]${COLORS.reset}`} ${message}${source ? ` ${COLORS.dim}(${source})${COLORS.reset}` : ""}`;
-	if (stack) {
-		const indented = stack.split("\n").map((line) => `  ${COLORS.dim}${line}${COLORS.reset}`).join("\n");
-		output += `\n${indented}`;
-	}
-	return output;
-}
-/**
-* Check if a log at `level` should be forwarded given the configured threshold.
-*
-* The threshold acts as a minimum severity:
-* - 'error' → only errors
-* - 'warn' → errors + warnings
-* - 'info' → errors + warnings + info
-* - 'none' → nothing
-*/
-function shouldForwardLevel(level, threshold) {
-	if (threshold === "none") return false;
-	return LEVEL_SEVERITY[level] >= LEVEL_SEVERITY[threshold];
-}
 /**
-* Truncate a message to `maxBytes` to avoid flooding the terminal.
-* Appends a suffix indicating how many bytes were dropped.
-*/
-function truncateMessage(message, maxBytes) {
-	if (message.length <= maxBytes) return message;
-	return `${message.slice(0, maxBytes)}… [truncated ${message.length - maxBytes} bytes]`;
-}
-/**
-* Generate the inline script injected into the browser in dev mode.
-*
-* This script:
-* 1. Saves references to the original console methods
-* 2. Wraps `console.error`, `console.warn`, `console.info`
-* 3. Calls the original first (browser devtools still work)
-* 4. Serializes and forwards via `import.meta.hot.send()`
-* 5. Truncates messages to MAX_MESSAGE_BYTES
-*
-* The script is minimal and self-contained — no imports, no dependencies.
-*/
-function generateClientScript(threshold) {
-	if (threshold === "none") return "";
-	const levels = [
-		"error",
-		"warn",
-		"info"
-	].filter((l) => shouldForwardLevel(l, threshold));
-	if (levels.length === 0) return "";
-	return `
-(function() {
-  if (!import.meta.hot) return;
-  var MAX_BYTES = ${MAX_MESSAGE_BYTES};
-  var levels = ${JSON.stringify(levels)};
-  var originals = {};
-
-  function serialize(arg) {
-    if (arg === null) return 'null';
-    if (arg === undefined) return 'undefined';
-    if (arg instanceof Error) return arg.stack || arg.message || String(arg);
-    if (typeof arg === 'object') {
-      try { return JSON.stringify(arg); } catch(e) { return String(arg); }
-    }
-    return String(arg);
-  }
-
-  function truncate(s) {
-    if (s.length <= MAX_BYTES) return s;
-    return s.slice(0, MAX_BYTES) + '... [truncated ' + (s.length - MAX_BYTES) + ' bytes]';
-  }
-
-  levels.forEach(function(level) {
-    originals[level] = console[level];
-    console[level] = function() {
-      originals[level].apply(console, arguments);
-      try {
-        var args = Array.prototype.slice.call(arguments);
-        var firstArg = args[0];
-        var stack = null;
-        var source = null;
-
-        if (firstArg instanceof Error) {
-          stack = firstArg.stack || null;
-          source = null;
-        }
-
-        var message = args.map(serialize).join(' ');
-        message = truncate(message);
-
-        import.meta.hot.send('${HMR_EVENT}', {
-          level: level,
-          message: message,
-          stack: stack,
-          source: source,
-          timestamp: Date.now()
-        });
-      } catch(e) {
-        // Never let log forwarding break the page
-      }
-    };
-  });
-})();
-`.trim();
-}
-/**
-* Create the timber-dev-browser-logs Vite plugin.
-*
-* - `configureServer`: Listens for HMR messages and prints them to the terminal
-* - `transformIndexHtml`: Injects the client-side interception script
-*
-* Only active during `vite dev` (apply: 'serve').
-*/
-function timberDevBrowserLogs(ctx) {
+* Map timber's devBrowserLogs threshold to Vite 8's server.forwardConsole.
+*
+* Vite defaults forwardConsole OFF for non-agent dev; timber enables it
+* based on the configured threshold (default: 'warn'). The threshold acts
+* as a minimum severity — 'warn' forwards errors + warnings, 'info'
+* forwards everything, 'error' forwards only errors, 'none' disables.
+*
+* Vite's unhandledErrors is explicitly disabled — timber's own
+* setupClientErrorForwarding (browser-dev.ts) already catches window
+* error/unhandledrejection, filters framework control-flow signals
+* (redirect/deny digests) and page-unload aborts (TIM-838), and
+* echoes errors to the Vite overlay. Enabling Vite's unhandledErrors
+* would duplicate terminal output for normal errors and reintroduce
+* unfiltered noise for framework signals.
+*/
+function resolveForwardConsole(threshold) {
+	const resolved = threshold ?? "warn";
+	if (resolved === "none") return false;
+	const logLevels = [];
+	if (resolved === "info") logLevels.push("info", "warn", "error");
+	else if (resolved === "warn") logLevels.push("warn", "error");
+	else logLevels.push("error");
 	return {
-		name: "timber-dev-browser-logs",
-		apply: "serve",
-		configureServer(server) {
-			const threshold = ctx.config.devBrowserLogs ?? "warn";
-			if (threshold === "none") {
-				delete globalThis.__timber_dev_browser_log_script;
-				return;
-			}
-			const script = generateClientScript(threshold);
-			if (script) globalThis.__timber_dev_browser_log_script = `<script type="module">${script}<\/script>`;
-			server.hot.on(HMR_EVENT, (payload) => {
-				try {
-					if (!shouldForwardLevel(payload.level, threshold)) return;
-					payload.message = truncateMessage(payload.message, MAX_MESSAGE_BYTES);
-					const formatted = formatBrowserLog(payload);
-					if (payload.level === "error") process.stderr.write(formatted + "\n");
-					else process.stdout.write(formatted + "\n");
-				} catch (e) {
-					process.stderr.write(`[timber] log forwarding failed: ${e instanceof Error ? e.message : e}\n`);
-				}
-			});
-		},
-		transformIndexHtml() {
-			const script = generateClientScript(ctx.config.devBrowserLogs ?? "warn");
-			if (!script) return [];
-			return [{
-				tag: "script",
-				attrs: { type: "module" },
-				children: script,
-				injectTo: "head"
-			}];
-		}
+		unhandledErrors: false,
+		logLevels
 	};
 }
 //#endregion
@@ -6939,8 +6806,16 @@ function clientChunkGroup(meta, appDir, root, sharedModuleFacades) {
 *
 * Design docs: design/11-platform.md, design/25-production-deployments.md
 */
+var NODE_BUILTINS = builtinModules.flatMap((m) => [m, `node:${m}`]);
+var CLOUDFLARE_BUILTINS = [
+	"cloudflare:workers",
+	"cloudflare:sockets",
+	"cloudflare:email",
+	"cloudflare:workflows"
+];
 var BUILD_ONLY_EXTERNALS = [
-	...builtinModules.flatMap((m) => [m, `node:${m}`]),
+	...NODE_BUILTINS,
+	...CLOUDFLARE_BUILTINS,
 	"vite",
 	"nitro",
 	"rollup",
@@ -6970,6 +6845,7 @@ function timberServerBundle() {
 								noExternal: true,
 								external: BUILD_ONLY_EXTERNALS
 							},
+							build: { rolldownOptions: { external: [/^cloudflare:/] } },
 							define: serverDefine
 						},
 						ssr: {
@@ -6977,6 +6853,7 @@ function timberServerBundle() {
 								noExternal: true,
 								external: BUILD_ONLY_EXTERNALS
 							},
+							build: { rolldownOptions: { external: [/^cloudflare:/] } },
 							define: serverDefine
 						}
 					}
@@ -7026,6 +6903,96 @@ function timberServerBundle() {
 	];
 }
 //#endregion
+//#region src/plugins/callsite-ast.ts
+/**
+* Shared AST helpers for callsite-ID transforms.
+*
+* Both timber-cache-transform (plugins/cache.ts) and timber-prebuilt
+* (plugins/prebuilt.ts) detect calls on bindings imported from the cache
+* module and stamp them with content-derived stable IDs. The node shapes,
+* import-binding resolution, recursive call walk, and ID derivation are
+* identical — only the callee shape and rewrite differ per plugin.
+*
+* See TIM-997, TIM-1053, design/06-caching.md §"Cache Key Security".
+*/
+/** Module specifiers whose bindings the transforms track. */
+var CACHE_MODULE_SOURCES = /* @__PURE__ */ new Set(["@timber-js/app/cache", "timber/cache"]);
+/**
+* Find the local binding name(s) for `importedName` imported from one of
+* `sources` — both named imports (including aliases) and namespace imports
+* (TIM-1054).
+*/
+function findImportBindings(program, sources, importedName) {
+	const named = /* @__PURE__ */ new Set();
+	const namespaces = /* @__PURE__ */ new Set();
+	for (const stmt of program.body) {
+		if (stmt.type !== "ImportDeclaration") continue;
+		const decl = stmt;
+		if (!sources.has(decl.source.value)) continue;
+		for (const spec of decl.specifiers) {
+			if (spec.type === "ImportNamespaceSpecifier") {
+				namespaces.add(spec.local.name);
+				continue;
+			}
+			if (spec.type !== "ImportSpecifier") continue;
+			if ((spec.imported?.name ?? spec.local.name) === importedName) named.add(spec.local.name);
+		}
+	}
+	return {
+		named,
+		namespaces
+	};
+}
+/**
+* Recursively walk AST nodes collecting call expressions accepted by
+* `matches`. Calls are typically at module scope, but calls inside
+* functions/blocks are handled for completeness.
+*
+* NOTE: matching is by binding NAME, so nested scopes that shadow a tracked
+* import can produce false positives for consumers of this walker (see
+* TIM-1141 for the cache transform). The prebuilt transform avoids the
+* class entirely by not using this walker — it allowlists top-level
+* declarator positions instead (plugins/prebuilt.ts).
+*/
+function findCallSites(node, matches, results) {
+	if (node.type === "CallExpression") {
+		const call = node;
+		if (matches(call)) results.push(call);
+	}
+	for (const key of Object.keys(node)) {
+		if (key === "type" || key === "start" || key === "end") continue;
+		const val = node[key];
+		if (val && typeof val === "object") {
+			if (Array.isArray(val)) {
+				for (const item of val) if (item && typeof item === "object" && typeof item.type === "string") findCallSites(item, matches, results);
+			} else if (typeof val.type === "string") findCallSites(val, matches, results);
+		}
+	}
+}
+/**
+* Generate a stable callsite ID from a module path, a kind discriminator
+* ('cache' | 'component'), the source text of the enclosing top-level
+* statement, the source text of the call expression, and an occurrence index
+* among fully byte-identical (statement, call) pairs in the same file.
+*
+* The ID is deterministic and:
+* - Stable across cold starts AND across builds/deploys for unchanged calls —
+*   inserting, deleting, or reordering other calls does not affect it
+* - Unique across different modules (relPath component)
+* - Unique across distinct calls within a module (statement + span hashes),
+*   with fully identical duplicates disambiguated by source-order occurrence
+* - Fresh when the wrapped fn, opts, or enclosing statement change, which
+*   intentionally invalidates the old persisted entries
+*
+* The enclosing-statement text is included so that byte-identical calls in
+* different scopes — e.g. two factory helpers with identical call spans —
+* get distinct, insertion-stable IDs. See plugins/cache.ts header for the
+* full derivation rationale (TIM-1053).
+*/
+function generateStableCallsiteId(relativeModulePath, kind, statementText, callSpanText, occurrence) {
+	return fnv1aHash(`${relativeModulePath}:${kind}:${fnv1aHash(statementText)}:${fnv1aHash(callSpanText)}:${occurrence}`);
+}
+//#endregion
 //#region src/plugins/cache.ts
 /**
 * timber-cache-transform — Vite plugin that injects stable callsite IDs
@@ -7076,34 +7043,11 @@ function timberServerBundle() {
 * referencing the same bindings — the same function, where an ID swap is
 * harmless.
 *
+* AST helpers and the ID derivation are shared with timber-prebuilt
+* (plugins/prebuilt.ts) via plugins/callsite-ast.ts.
+*
 * See TIM-997, TIM-1053, design/06-caching.md §"Cache Key Security".
 */
-var CACHE_MODULE_SOURCES = /* @__PURE__ */ new Set(["@timber-js/app/cache", "timber/cache"]);
-/**
-* Find the local binding name(s) for `cache` imported from the cache module —
-* both named imports and namespace imports (TIM-1054).
-*/
-function findCacheBindings(program) {
-	const named = /* @__PURE__ */ new Set();
-	const namespaces = /* @__PURE__ */ new Set();
-	for (const stmt of program.body) {
-		if (stmt.type !== "ImportDeclaration") continue;
-		const decl = stmt;
-		if (!CACHE_MODULE_SOURCES.has(decl.source.value)) continue;
-		for (const spec of decl.specifiers) {
-			if (spec.type === "ImportNamespaceSpecifier") {
-				namespaces.add(spec.local.name);
-				continue;
-			}
-			if (spec.type !== "ImportSpecifier") continue;
-			if ((spec.imported?.name ?? spec.local.name) === "cache") named.add(spec.local.name);
-		}
-	}
-	return {
-		named,
-		namespaces
-	};
-}
 /**
 * Is this callee a reference to the imported `cache` function — either a bare
 * identifier bound by a named import, or `ns.cache` on a namespace import?
@@ -7119,44 +7063,11 @@ function isCacheCallee(callee, bindings) {
 	return false;
 }
 /**
-* Recursively walk AST nodes to find cache() call expressions.
-*
-* cache() is typically called at module scope, but we also handle calls
-* inside functions/blocks for completeness.
-*/
-function findCacheCallSites(node, cacheBindings, results) {
-	if (node.type === "CallExpression") {
-		const call = node;
-		if (call.arguments.length === 2 && isCacheCallee(call.callee, cacheBindings)) results.push(call);
-	}
-	for (const key of Object.keys(node)) {
-		if (key === "type" || key === "start" || key === "end") continue;
-		const val = node[key];
-		if (val && typeof val === "object") {
-			if (Array.isArray(val)) {
-				for (const item of val) if (item && typeof item === "object" && typeof item.type === "string") findCacheCallSites(item, cacheBindings, results);
-			} else if (typeof val.type === "string") findCacheCallSites(val, cacheBindings, results);
-		}
-	}
-}
-/**
-* Generate a stable callsite ID from a module path, the source text of the
-* enclosing top-level statement, the source text of the cache(...) call
-* expression, and an occurrence index among fully byte-identical
-* (statement, call) pairs in the same file.
-*
-* The ID is deterministic and:
-* - Stable across cold starts AND across builds/deploys for unchanged calls —
-*   inserting, deleting, or reordering other cache() calls does not affect it
-* - Unique across different modules (relPath component)
-* - Unique across distinct cache() calls within a module (statement + span
-*   hashes), with fully identical duplicates disambiguated by source-order
-*   occurrence
-* - Fresh when the wrapped fn, opts, or enclosing statement change, which
-*   intentionally invalidates the old persisted entries
+* Generate a stable callsite ID for a cache() call. See callsite-ast.ts for
+* the derivation properties.
 */
 function generateStableId(relativeModulePath, statementText, callSpanText, occurrence) {
-	return fnv1aHash(`${relativeModulePath}:cache:${fnv1aHash(statementText)}:${fnv1aHash(callSpanText)}:${occurrence}`);
+	return generateStableCallsiteId(relativeModulePath, "cache", statementText, callSpanText, occurrence);
 }
 function timberCacheTransform(ctx) {
 	return {
@@ -7170,12 +7081,12 @@ function timberCacheTransform(ctx) {
 			} catch {
 				return;
 			}
-			const cacheBindings = findCacheBindings(program);
+			const cacheBindings = findImportBindings(program, CACHE_MODULE_SOURCES, "cache");
 			if (cacheBindings.named.size === 0 && cacheBindings.namespaces.size === 0) return;
 			const callSites = [];
 			for (const stmt of program.body) {
 				const calls = [];
-				findCacheCallSites(stmt, cacheBindings, calls);
+				findCallSites(stmt, (call) => call.arguments.length === 2 && isCacheCallee(call.callee, cacheBindings), calls);
 				for (const call of calls) callSites.push({
 					call,
 					stmt
@@ -7204,6 +7115,915 @@ function timberCacheTransform(ctx) {
 	};
 }
 //#endregion
+//#region src/plugins/callsite-jsx.ts
+/**
+* Try to extract a static JSON-safe value from an AST expression node.
+* Returns `undefined` (not null — null is a valid JSON value) when the
+* expression is dynamic/computed and cannot be captured statically.
+*/
+function tryExtractStaticValue(node) {
+	if (node.type === "Literal") {
+		const val = node.value;
+		if (val === null || typeof val === "string" || typeof val === "number" || typeof val === "boolean") return val;
+		return;
+	}
+	if (node.type === "UnaryExpression") {
+		const unary = node;
+		if (unary.operator === "-" && unary.argument.type === "Literal") {
+			const val = unary.argument.value;
+			if (typeof val === "number") return -val;
+		}
+		return;
+	}
+	if (node.type === "TemplateLiteral") {
+		const tpl = node;
+		if (tpl.expressions.length === 0) return tpl.quasis[0]?.value.cooked ?? void 0;
+		return;
+	}
+	if (node.type === "ArrayExpression") {
+		const elements = node.elements;
+		const arr = [];
+		for (const el of elements) {
+			if (el === null) return void 0;
+			const val = tryExtractStaticValue(el);
+			if (val === void 0) return void 0;
+			arr.push(val);
+		}
+		return arr;
+	}
+	if (node.type === "ObjectExpression") {
+		const properties = node.properties;
+		const obj = {};
+		for (const prop of properties) {
+			if (prop.type === "SpreadElement") return void 0;
+			if (prop.type !== "Property") return void 0;
+			const p = prop;
+			if (p.computed) return void 0;
+			const keyName = p.key.type === "Identifier" ? p.key.name : p.key.type === "Literal" ? String(p.key.value) : void 0;
+			if (keyName === void 0) return void 0;
+			const val = tryExtractStaticValue(p.value);
+			if (val === void 0) return void 0;
+			obj[keyName] = val;
+		}
+		return obj;
+	}
+}
+/**
+* Extract static props from a JSX element's attributes. Returns null if
+* any attribute is dynamic (spread, computed expression, JSX element, etc.)
+* — the component must fall back to dynamic rendering for that call site.
+*/
+function extractStaticJsxProps(attributes) {
+	const props = {};
+	for (const attr of attributes) {
+		if (attr.type === "JSXSpreadAttribute") return null;
+		if (attr.type !== "JSXAttribute") return null;
+		const jsxAttr = attr;
+		const name = jsxAttr.name?.name;
+		if (!name) return null;
+		if (name === "key" || name === "ref") continue;
+		if (jsxAttr.value === null) {
+			props[name] = true;
+			continue;
+		}
+		if (jsxAttr.value.type === "Literal") {
+			const val = tryExtractStaticValue(jsxAttr.value);
+			if (val === void 0) return null;
+			props[name] = val;
+			continue;
+		}
+		if (jsxAttr.value.type === "JSXExpressionContainer") {
+			const container = jsxAttr.value;
+			const val = tryExtractStaticValue(container.expression);
+			if (val === void 0) return null;
+			props[name] = val;
+			continue;
+		}
+		return null;
+	}
+	return props;
+}
+/**
+* Walk an AST tree and collect JSX usages of the given binding names,
+* returning the static props for each usage. Returns a map of
+* bindingName → array of static prop objects (or null for dynamic props).
+*/
+function collectJsxUsages(program, bindingNames) {
+	const result = /* @__PURE__ */ new Map();
+	const walk = (node) => {
+		if (!node || typeof node !== "object") return;
+		const n = node;
+		if (n.type === "JSXElement") {
+			const jsx = n;
+			const tagName = jsx.openingElement.name;
+			if (tagName.type === "JSXIdentifier") {
+				const name = tagName.name;
+				if (bindingNames.has(name)) {
+					const children = jsx.children ?? [];
+					const props = children.length > 0 && children.some((c) => {
+						const child = c;
+						if (child.type === "JSXText") return child.value.trim().length > 0;
+						return true;
+					}) ? null : extractStaticJsxProps(jsx.openingElement.attributes);
+					const usages = result.get(name) ?? [];
+					usages.push(props);
+					result.set(name, usages);
+				}
+			}
+		}
+		for (const value of Object.values(n)) if (Array.isArray(value)) for (const item of value) walk(item);
+		else if (value && typeof value === "object" && "type" in value) walk(value);
+	};
+	for (const stmt of program.body) walk(stmt);
+	return result;
+}
+/**
+* Deep stable JSON stringification with recursively sorted keys.
+* `JSON.stringify` with an array replacer only includes listed keys at
+* ALL nesting levels, so `{config:{theme:'dark'}}` and
+* `{config:{theme:'light'}}` would both serialize as `{"config":{}}`.
+*/
+function stableStringify(value) {
+	if (value === null || typeof value !== "object") return JSON.stringify(value);
+	if (Array.isArray(value)) return "[" + value.map(stableStringify).join(",") + "]";
+	const obj = value;
+	return "{" + Object.keys(obj).sort().map((k) => JSON.stringify(k) + ":" + stableStringify(obj[k])).join(",") + "}";
+}
+/**
+* Add a distinct props object to the call-site-props map for a component,
+* deduplicating by deep JSON value (recursively sorted keys).
+*/
+function recordCallSiteProps(ctx, componentId, props) {
+	ctx.prebuiltCallSiteProps ??= /* @__PURE__ */ new Map();
+	const existing = ctx.prebuiltCallSiteProps.get(componentId) ?? [];
+	const canonical = stableStringify(props);
+	if (!existing.some((p) => stableStringify(p) === canonical)) {
+		existing.push(props);
+		ctx.prebuiltCallSiteProps.set(componentId, existing);
+	}
+}
+//#endregion
+//#region src/plugins/prebuilt-capture.ts
+/**
+* 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
+* 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
+* component registry and flight renderer live. See
+* server/prebuilt-builder.ts and design/44-render-at-build-time.md
+* §Build Phase.
+*
+* This side owns PERSISTENCE: each captured payload is written to
+* `.timber/dist/prebuilt/<componentId>/<cacheKey>.flight` atomically
+* (temp file + rename — a crashed build never leaves a torn artifact
+* under its final name), and `manifest.json` is written last, only after
+* every payload it references is fully on disk. Keeping node:fs on the
+* plugin side keeps it out of the server bundle, which must also run on
+* Cloudflare Workers.
+*
+* NOTE: importing the built entry runs the app's production startup —
+* instrumentation.ts register() and the configured cache handler load
+* inside the build process. That is by design (prebuilt components may
+* call timber.cache), and it only happens when the app actually declares
+* prebuilt components.
+*/
+/**
+* Both patterns are framework-generated (plugins/prebuilt.ts assigns IDs,
+* server/prebuilt/cache-key.ts hashes keys), so a mismatch is a framework
+* bug or a tampered registry — either way it must never reach a path join.
+*/
+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
+* per cache key, one manifest.json mapping componentId + key → file +
+* metadata.
+*/
+function createPrebuiltArtifactWriter(prebuiltDir) {
+	const manifest = {};
+	const buildTimestamp = Date.now();
+	let count = 0;
+	return {
+		async write(entry) {
+			if (!COMPONENT_ID_RE.test(entry.componentId) || !CACHE_KEY_RE.test(entry.cacheKey)) throw new Error(`[timber] prebuilt artifact writer received a malformed identity (componentId: ${JSON.stringify(entry.componentId)}, cacheKey: ${JSON.stringify(entry.cacheKey)}) — refusing to write`);
+			const relativeFile = `${entry.componentId}/${entry.cacheKey}.flight`;
+			const path = join(prebuiltDir, relativeFile);
+			await mkdir(dirname(path), { recursive: true });
+			await writeFileAtomic(path, entry.bytes);
+			manifest[entry.componentId] ??= { entries: {} };
+			manifest[entry.componentId].entries[entry.cacheKey] = {
+				params: entry.params,
+				file: relativeFile,
+				bytes: entry.bytes.byteLength,
+				buildTimestamp,
+				...entry.tags ? { tags: entry.tags } : {}
+			};
+			count++;
+		},
+		async finalize() {
+			if (count === 0) return 0;
+			await writeFileAtomic(join(prebuiltDir, "manifest.json"), JSON.stringify(manifest, null, 2) + "\n");
+			return count;
+		}
+	};
+}
+/**
+* Remove any `prebuilt/` output left by a previous build in this
+* directory (watch mode, `emptyOutDir: false`). A stale manifest would
+* 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
+* longer declares any prebuilt components must also shed the artifacts
+* (codex P2 on PR #836).
+*/
+async function cleanPrebuiltDir(buildDir) {
+	await rm(join(buildDir, "prebuilt"), {
+		recursive: true,
+		force: true
+	});
+}
+/**
+* Load the built RSC entry and run the capture pass. Throws (failing the
+* build) on infrastructure errors — missing/unloadable entry — and on
+* dynamic-context hard errors (cookies()/headers() in a prerendered
+* component). Per-entry data errors skip-and-report per design/44
+* §Build-Phase Error Handling.
+*/
+async function runPrebuiltCapture(ctx) {
+	const routeComponents = ctx.routePrebuiltComponents;
+	if (!routeComponents || routeComponents.size === 0) return {
+		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 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…");
+	let mod;
+	try {
+		mod = await import(
+			/* @vite-ignore */
+			`${pathToFileURL(entryPath).href}?t=${Date.now()}`
+);
+	} catch (error) {
+		throw new Error(`[timber] prebuilt capture: failed to load the built RSC entry (${entryPath}). The capture pass runs the production server module inside the build process — its startup must succeed for prerendering to work.`, { cause: error });
+	}
+	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 summary = await capture({
+		fileComponentMap: Object.fromEntries(routeComponents),
+		callSiteProps: ctx.prebuiltCallSiteProps ? Object.fromEntries(ctx.prebuiltCallSiteProps) : void 0,
+		onEntry: (entry) => writer.write(entry)
+	});
+	if (summary.hardErrors.length > 0) {
+		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 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;
+}
+//#endregion
+//#region src/plugins/prebuilt.ts
+/**
+* timber-prebuilt — Vite plugin that detects `cache.component(...)` call
+* sites and rewrites them to `__prebuilt(stableId, component, options)`.
+*
+* `timber.cache.component(Component, { prerender: true })` is a build-time
+* transform, not a runtime function (design/44-render-at-build-time.md
+* §Registration, surface API renamed by design/45-cache-lifetimes.md). The
+* rewrite registers the component in the server-side prebuilt registry under
+* a stable ID that keys its cached flight payloads.
+*
+* Detected callsite forms (mirrors timber-cache-transform, TIM-1054):
+*   - named imports, including aliases:
+*       `import { cache } from '@timber-js/app/cache'` + `cache.component(fn, opts)`
+*   - namespace imports:
+*       `import * as timber` + `timber.cache.component(fn, opts)`
+* Computed access (`cache['component']`) is deliberately not matched — the
+* untransformed call reaches the runtime `cache.component` fallback
+* (cache/cache-api.ts), which warns once and renders dynamically.
+*
+* Matching is an ALLOWLIST of module-scope positions: the direct initializer
+* of a top-level variable declarator (including exported ones) and a
+* top-level `export default cache.component(...)`, with TS expression
+* wrappers (`as`, `satisfies`, `!`) unwrapped. Nothing else is walked — no
+* function/class/loop bodies, no params, no call arguments. Two reasons:
+* (1) `__prebuilt` must register exactly once at module load time; the
+* post-build capture pass walks the registry after loading modules, so a
+* call inside a function registers too late to ever be prebuilt, and a call
+* in a loop would re-register per iteration. (2) Name-based callee matching
+* is only shadow-proof in these positions — nested scopes can rebind `cache`
+* (`function render(cache) {...}`, `for (const cache of caches) ...`), and
+* rewriting those would corrupt user code; a top-level declarator initializer
+* cannot see a shadow of an import binding (redeclaration error). Calls in
+* other positions fall back to the runtime path like other untraceable forms.
+*
+* The rewrite per mode:
+*   production:  cache.component(fn, opts)  →  __prebuilt("<id>", fn, opts)
+*   dev:         cache.component(fn, opts)  →  __prebuiltDev("<name>", fn, opts)
+*
+* with `import { __prebuilt } from '#server-internal'` prepended. In dev the
+* wrapper is a no-op that logs once per component and renders dynamically —
+* no caching, no markers (design/44 §Dev Mode).
+*
+* Component identity: `<name>_<hash16>`, e.g. `blogbody_a1b2c3d4e5f6a7b8`.
+* The name prefix is the declaring variable's name (lowercased, for legible
+* manifest keys and log lines); the hash is the same content-derived callsite
+* scheme as the data cache transform (callsite-ast.ts) — deterministic across
+* builds for unchanged calls, immune to inserting/reordering other calls, and
+* fresh when the component or its options change. Component cache entries are
+* per-deploy (design/45 §Per-deploy namespacing) so cross-deploy ID reuse is
+* not a poisoning vector, but content-derived IDs keep prebuilt artifacts
+* addressable across incremental edits for free.
+*
+* The transform is skipped in the client environment: server components never
+* execute there, and `#server-internal` resolves to an empty stub in the
+* client bundle (plugins/shims.ts).
+*
+* See TIM-1118, design/44-render-at-build-time.md, design/45-cache-lifetimes.md.
+*/
+/**
+* Is this callee `cache.component` (named import, aliases included) or
+* `ns.cache.component` (namespace import)? Computed access is not matched.
+*/
+function isCacheComponentCallee(callee, bindings) {
+	if (callee.type !== "MemberExpression") return false;
+	const member = callee;
+	if (member.computed || member.property.type !== "Identifier" || member.property.name !== "component") return false;
+	if (member.object.type === "Identifier") return bindings.named.has(member.object.name);
+	if (member.object.type === "MemberExpression") {
+		const inner = member.object;
+		return !inner.computed && inner.object.type === "Identifier" && bindings.namespaces.has(inner.object.name) && inner.property.type === "Identifier" && inner.property.name === "cache";
+	}
+	return false;
+}
+/**
+* Offset where an injected import may be inserted: after the directive
+* prologue ('use server', 'use strict', ...). Prepending at offset 0 would
+* demote a leading directive to a plain expression statement — silently
+* disabling it.
+*/
+function importInsertionOffset(program) {
+	for (const stmt of program.body) if (!(stmt.type === "ExpressionStatement" && typeof stmt.directive === "string")) return stmt.start;
+	return program.body.length > 0 ? program.body[program.body.length - 1].end : 0;
+}
+/** TS/paren wrappers that may sit between a declarator and the call. */
+var EXPRESSION_WRAPPER_TYPES = /* @__PURE__ */ new Set([
+	"TSAsExpression",
+	"TSSatisfiesExpression",
+	"TSNonNullExpression",
+	"ParenthesizedExpression"
+]);
+function unwrapExpression(node) {
+	let current = node;
+	while (EXPRESSION_WRAPPER_TYPES.has(current.type) && current.expression) current = current.expression;
+	return current;
+}
+/**
+* Can this call site's options put the component in the prerender tier?
+*
+* Runtime-tier call sites (`ttl`/`tags` without `prerender`) must do NO
+* build work — recording them would make the post-build hook import the
+* built RSC entry (running production startup) and load route modules for
+* routes that have nothing to prerender (codex P2 on PR #836). The answer
+* is static only when the options argument is an object literal:
+*
+*   - literal with `prerender: true`            → yes
+*   - literal with `prerender: false`/absent    → no  (spread-free)
+*   - anything else (identifier, spread, non-literal `prerender` value)
+*     → conservatively yes — the capture pass re-checks the real options
+*       at runtime and skips non-prerender registrations; over-inclusion
+*       costs a wasted entry load, under-inclusion would silently skip
+*       prerendering.
+*/
+function mayPrerender(call) {
+	if (call.arguments.length < 2) return false;
+	const options = unwrapExpression(call.arguments[1]);
+	if (options.type !== "ObjectExpression") return true;
+	const properties = options.properties ?? [];
+	let verdict = "absent";
+	for (const prop of properties) {
+		if (prop.type === "SpreadElement") {
+			verdict = "unknown";
+			continue;
+		}
+		if (prop.type !== "Property") continue;
+		const property = prop;
+		if (property.computed) {
+			verdict = "unknown";
+			continue;
+		}
+		if ((property.key.type === "Identifier" ? property.key.name : property.key.type === "Literal" ? String(property.key.value) : void 0) !== "prerender") continue;
+		const value = unwrapExpression(property.value);
+		if (value.type === "Literal") verdict = value.value === true ? "true" : "false";
+		else verdict = "unknown";
+	}
+	return verdict === "true" || verdict === "unknown";
+}
+/**
+* Collect matching call sites from the allowlisted module-scope positions:
+* top-level (possibly exported) variable declarator initializers and
+* `export default` expressions. Returned in source order. The display name
+* is the declaring variable's name, or 'Component' for default exports.
+*/
+function collectModuleScopeSites(program, bindings) {
+	const isMatch = (node) => node.type === "CallExpression" && node.arguments.length >= 1 && node.arguments.length <= 2 && isCacheComponentCallee(node.callee, bindings);
+	const sites = [];
+	for (const stmt of program.body) {
+		if (stmt.type === "ExportDefaultDeclaration" && stmt.declaration) {
+			const call = unwrapExpression(stmt.declaration);
+			if (isMatch(call)) sites.push({
+				call,
+				stmt,
+				displayName: "Component"
+			});
+			continue;
+		}
+		let decl = stmt;
+		if (stmt.type === "ExportNamedDeclaration" && stmt.declaration) decl = stmt.declaration;
+		if (decl.type !== "VariableDeclaration" || !Array.isArray(decl.declarations)) continue;
+		for (const d of decl.declarations) {
+			if (!d.init) continue;
+			const call = unwrapExpression(d.init);
+			if (!isMatch(call)) continue;
+			const displayName = d.id.type === "Identifier" ? d.id.name : "Component";
+			sites.push({
+				call,
+				stmt,
+				displayName
+			});
+		}
+	}
+	return sites;
+}
+/**
+* Generate the stable component ID for a cache.component() call site:
+* `<sanitized-name>_<content-hash16>`. Exported for testing.
+*/
+function generatePrebuiltId(relativeModulePath, statementText, callSpanText, occurrence, displayName) {
+	return `${displayName.toLowerCase().replace(/[^a-z0-9]/g, "") || "component"}_${generateStableCallsiteId(relativeModulePath, "component", statementText, callSpanText, occurrence)}`;
+}
+/**
+* Collect the prebuilt component IDs transitively reachable from a route
+* file, following static AND dynamic imports. Same pattern as the
+* client-reference walk in build-manifest.ts; dynamic imports are included
+* because a dynamically-imported module still registers its components
+* when it eventually loads — attribution over-approximating registration
+* is handled at capture time (an attributed-but-unregistered component is
+* reported and skipped).
+*/
+function collectReachablePrebuiltComponents(entryModuleId, moduleComponents, getModuleInfo) {
+	const visited = /* @__PURE__ */ new Set();
+	const result = /* @__PURE__ */ new Set();
+	const stack = [entryModuleId];
+	while (stack.length > 0) {
+		const moduleId = stack.pop();
+		if (visited.has(moduleId)) continue;
+		visited.add(moduleId);
+		const ids = moduleComponents.get(moduleId);
+		if (ids) for (const id of ids) result.add(id);
+		const info = getModuleInfo(moduleId);
+		if (!info) continue;
+		for (const imported of info.importedIds) stack.push(imported);
+		for (const imported of info.dynamicallyImportedIds ?? []) stack.push(imported);
+	}
+	return Array.from(result);
+}
+/**
+* Collect page and layout file paths from the scanned route tree — the
+* walk roots for attribution. Slots and intercepting/private segments are
+* excluded, mirroring the capture pass's route walk
+* (server/prebuilt-builder.ts §collectCandidateRoutes).
+*/
+function collectPageAndLayoutFiles(root) {
+	const files = [];
+	const walk = (node) => {
+		if (node.segmentType === "intercepting" || node.segmentType === "private") return;
+		if (node.page) files.push(node.page.filePath);
+		if (node.layout) files.push(node.layout.filePath);
+		for (const child of node.children) walk(child);
+	};
+	walk(root);
+	return files;
+}
+/**
+* For a route file (page/layout), check if it imports from any prebuilt-
+* declaring module and extract JSX call-site props for those bindings.
+* Uses `getModuleInfo` to get the RESOLVED import targets and the module's
+* transformed code (available on Rollup's ModuleInfo at generateBundle).
+*/
+function collectCrossModuleProps(ctx, moduleId, getInfo) {
+	const bindingNames = ctx.prebuiltBindingNames;
+	const info = getInfo(moduleId);
+	if (!info) return;
+	const declaringImports = info.importedIds.filter((id) => bindingNames.has(id) && id !== moduleId);
+	if (declaringImports.length === 0) return;
+	const exportNameToId = /* @__PURE__ */ new Map();
+	const collisions = /* @__PURE__ */ new Set();
+	for (const declId of declaringImports) {
+		const map = bindingNames.get(declId);
+		for (const [name, compId] of map) {
+			if (exportNameToId.has(name)) collisions.add(name);
+			exportNameToId.set(name, compId);
+		}
+	}
+	for (const name of collisions) exportNameToId.delete(name);
+	let source = null;
+	const extInfo = getInfo(moduleId);
+	if (extInfo && typeof extInfo.code === "string") source = extInfo.code;
+	else try {
+		source = readFileSync(moduleId, "utf8");
+	} catch {
+		return;
+	}
+	if (!source) return;
+	let program;
+	try {
+		program = parseAst(source, { lang: "tsx" });
+	} catch {
+		return;
+	}
+	const localToComponentId = /* @__PURE__ */ new Map();
+	for (const stmt of program.body) {
+		if (stmt.type !== "ImportDeclaration") continue;
+		const importDecl = stmt;
+		for (const spec of importDecl.specifiers) if (spec.type === "ImportSpecifier") {
+			const exportedName = spec.imported?.name ?? spec.local.name;
+			const compId = exportNameToId.get(exportedName);
+			if (compId) localToComponentId.set(spec.local.name, compId);
+		} else if (spec.type === "ImportDefaultSpecifier") {
+			const compId = exportNameToId.get("Component") ?? exportNameToId.get("default");
+			if (compId) localToComponentId.set(spec.local.name, compId);
+			else if (exportNameToId.size === 1) {
+				const [, soleId] = [...exportNameToId.entries()][0];
+				localToComponentId.set(spec.local.name, soleId);
+			}
+		}
+	}
+	if (localToComponentId.size === 0) return;
+	const usages = collectJsxUsages(program, new Set(localToComponentId.keys()));
+	for (const [localName, propsList] of usages) {
+		const componentId = localToComponentId.get(localName);
+		if (!componentId) continue;
+		for (const props of propsList) {
+			if (props === null) continue;
+			recordCallSiteProps(ctx, componentId, props);
+		}
+	}
+}
+function timberPrebuilt(ctx) {
+	return {
+		name: "timber-prebuilt",
+		transform(code, id) {
+			if (!ctx.dev && this?.environment?.name === "rsc") ctx.prebuiltModuleComponents?.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;
+			let program;
+			try {
+				program = parseAst(code, { lang: "tsx" });
+			} catch {
+				return;
+			}
+			const bindings = findImportBindings(program, CACHE_MODULE_SOURCES, "cache");
+			if (bindings.named.size === 0 && bindings.namespaces.size === 0) return;
+			const callSites = collectModuleScopeSites(program, bindings);
+			if (callSites.length === 0) return;
+			const relPath = relative(ctx.root || process.cwd(), id);
+			const s = new MagicString(code);
+			const occurrences = /* @__PURE__ */ new Map();
+			const wrapperName = ctx.dev ? "__prebuiltDev" : "__prebuilt";
+			const componentIds = [];
+			for (const { call, stmt, displayName } of callSites) {
+				const stmtText = code.slice(stmt.start, stmt.end);
+				const spanText = code.slice(call.start, call.end);
+				const dupKey = stmtText + String.fromCharCode(0) + spanText;
+				const occurrence = occurrences.get(dupKey) ?? 0;
+				occurrences.set(dupKey, occurrence + 1);
+				const firstArg = ctx.dev ? displayName : generatePrebuiltId(relPath, stmtText, spanText, occurrence, displayName);
+				if (!ctx.dev && mayPrerender(call)) componentIds.push(firstArg);
+				s.overwrite(call.callee.start, call.callee.end, wrapperName);
+				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);
+				const bindingMap = /* @__PURE__ */ new Map();
+				let componentIdIdx = 0;
+				for (const { call, displayName } of callSites) if (!ctx.dev && mayPrerender(call)) bindingMap.set(displayName, componentIds[componentIdIdx++]);
+				for (const stmt of program.body) if (stmt.type === "ExportDefaultDeclaration" && stmt.declaration && stmt.declaration.type === "Identifier") {
+					const name = stmt.declaration.name;
+					if (bindingMap.has(name) && !bindingMap.has("default")) bindingMap.set("default", bindingMap.get(name));
+				}
+				if (bindingMap.size > 0) {
+					ctx.prebuiltBindingNames ??= /* @__PURE__ */ new Map();
+					ctx.prebuiltBindingNames.set(id, bindingMap);
+				}
+				const declaredBindings = new Set(bindingMap.keys());
+				if (declaredBindings.size > 0) {
+					const usages = collectJsxUsages(program, declaredBindings);
+					for (const [bindingName, propsList] of usages) {
+						const compId = bindingMap.get(bindingName);
+						if (!compId) continue;
+						for (const props of propsList) {
+							if (props === null) continue;
+							recordCallSiteProps(ctx, compId, props);
+						}
+					}
+				}
+			}
+			s.appendLeft(importInsertionOffset(program), `import { ${wrapperName} } from '#server-internal';\n`);
+			return {
+				code: s.toString(),
+				map: s.generateMap({ hires: "boundary" })
+			};
+		},
+		/**
+		* RSC environment, production: walk each route file's module graph to
+		* attribute prebuilt components to the routes that can render them.
+		* The graph walk (rather than load-order registry deltas) is what makes
+		* SHARED components work — a component imported by several routes is
+		* captured under every importing route's param combos.
+		*/
+		generateBundle() {
+			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;
+			const self = this;
+			const getInfo = (id) => self.getModuleInfo?.(id) ?? null;
+			const routeComponents = /* @__PURE__ */ new Map();
+			for (const filePath of collectPageAndLayoutFiles(ctx.routeTree.root)) {
+				const ids = collectReachablePrebuiltComponents(filePath, moduleComponents, getInfo);
+				if (ids.length > 0) routeComponents.set(filePath, ids);
+			}
+			if (routeComponents.size > 0) {
+				ctx.routePrebuiltComponents = routeComponents;
+				if (ctx.prebuiltBindingNames && ctx.prebuiltBindingNames.size > 0) {
+					const scannedModules = /* @__PURE__ */ new Set();
+					for (const filePath of routeComponents.keys()) {
+						const visited = /* @__PURE__ */ new Set();
+						const stack = [filePath];
+						while (stack.length > 0) {
+							const modId = stack.pop();
+							if (visited.has(modId)) continue;
+							visited.add(modId);
+							if (!scannedModules.has(modId)) {
+								scannedModules.add(modId);
+								collectCrossModuleProps(ctx, modId, getInfo);
+							}
+							const modInfo = getInfo(modId);
+							if (!modInfo) continue;
+							for (const imp of modInfo.importedIds) stack.push(imp);
+							for (const imp of modInfo.dynamicallyImportedIds ?? []) stack.push(imp);
+						}
+					}
+				}
+			} 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);
+			}
+		}
+	};
+}
+//#endregion
+//#region src/plugins/prerender-sugar.ts
+/**
+* timber-prerender-sugar — Vite plugin that desugars `export const prerender`
+* on page and layout files into `cache.component(...)` wrappers.
+*
+* Design doc: design/45-cache-lifetimes.md §"Route-Level Static" and
+* §"Layout Propagation".
+*
+* `export const prerender = true` on a page is pure sugar: it desugars to
+* wrapping the page's default export in `timber.cache.component(Component,
+* { prerender: true })`. Layout propagation cascades a layout's
+* `export const prerender` to descendant pages via most-specific-wins:
+* walk the segment tree from leaf to root, first explicit value wins.
+*
+* A layout that declares `export const prerender` is ALSO wrapped — the
+* layout's flight payload is its own static shell (`children` is a
+* separate component boundary), so caching it is natural (nav, sidebar,
+* footer benefit from build-time rendering). See design/45 §Layout
+* Propagation.
+*
+* This transform runs BEFORE timber-prebuilt so the generated
+* `cache.component(...)` call is picked up by the callsite rewrite.
+*/
+/**
+* Walk the segment tree and resolve the effective prerender value for
+* every page and layout. Returns a map from file path to resolved value.
+*
+* **Pages:** walk from leaf toward root; first explicit `export const prerender`
+* wins (page > nearest layout > ... > root layout). If none, dynamic.
+*
+* **Layouts:** a layout that declares `export const prerender` is wrapped
+* directly (its own shell is a separate component boundary from `children`).
+* Layouts without their own declaration are NOT wrapped — they don't
+* inherit from ancestors, because wrapping a layout's shell without the
+* author's explicit opt-in would cache content they may expect to be dynamic.
+*/
+function resolvePagePrerender(root) {
+	const result = /* @__PURE__ */ new Map();
+	function walk(node, ancestorStack) {
+		if (node.segmentType === "intercepting" || node.segmentType === "private") return;
+		const layoutValue = node.layout ? getPrerenderExport(node.layout.filePath) : void 0;
+		const stack = layoutValue !== void 0 ? [layoutValue, ...ancestorStack] : ancestorStack;
+		if (node.layout && layoutValue !== void 0 && layoutValue !== false) result.set(node.layout.filePath, layoutValue);
+		if (node.page) {
+			const pageValue = getPrerenderExport(node.page.filePath);
+			const resolved = pageValue !== void 0 ? pageValue : stack[0];
+			if (resolved !== void 0 && resolved !== false) result.set(node.page.filePath, resolved);
+		}
+		for (const child of node.children) walk(child, stack);
+		for (const slot of Object.values(node.slots)) walk(slot, stack);
+	}
+	walk(root, []);
+	return result;
+}
+/**
+* Build the `cache.component` options source text from a resolved value.
+*/
+function buildOptionsSource(value) {
+	if (value === true) return "{ prerender: true }";
+	if (typeof value === "object") {
+		const parts = ["prerender: true"];
+		if (value.ttl !== void 0) parts.push(`ttl: ${value.ttl}`);
+		if (value.tags !== void 0) parts.push(`tags: ${JSON.stringify(value.tags)}`);
+		return `{ ${parts.join(", ")} }`;
+	}
+	return "{ prerender: true }";
+}
+function findDefaultExport(program, source) {
+	for (const stmt of program.body) {
+		if (stmt.type !== "ExportDefaultDeclaration" || !stmt.declaration) continue;
+		const decl = stmt.declaration;
+		if (decl.type === "FunctionDeclaration" || decl.type === "ClassDeclaration") {
+			const name = decl.id?.name;
+			if (name) return {
+				kind: "declaration",
+				node: stmt,
+				name
+			};
+			return {
+				kind: "expression",
+				node: stmt
+			};
+		}
+		if (decl.type === "Identifier") return {
+			kind: "identifier",
+			node: stmt,
+			name: decl.name
+		};
+		return {
+			kind: "expression",
+			node: stmt
+		};
+	}
+	for (const stmt of program.body) {
+		if (stmt.type !== "ExportNamedDeclaration") continue;
+		if (stmt.source) continue;
+		const specifiers = stmt.specifiers;
+		if (!specifiers) continue;
+		for (let i = 0; i < specifiers.length; i++) {
+			const spec = specifiers[i];
+			if (spec.exported?.name === "default" && spec.local?.name && spec.local.name !== "default") return {
+				kind: "identifier",
+				node: stmt,
+				name: spec.local.name,
+				specifierIndex: i,
+				specifierCount: specifiers.length,
+				specifierStart: spec.start,
+				specifierEnd: spec.end
+			};
+		}
+	}
+	return null;
+}
+function timberPrerenderSugar(ctx) {
+	let resolvedPages = null;
+	function ensureResolved() {
+		if (resolvedPages) return;
+		if (!ctx.routeTree) {
+			resolvedPages = /* @__PURE__ */ new Map();
+			return;
+		}
+		resolvedPages = resolvePagePrerender(ctx.routeTree.root);
+	}
+	return {
+		name: "timber-prerender-sugar",
+		buildStart() {
+			resolvedPages = null;
+		},
+		transform(code, id) {
+			if (this?.environment?.name === "client") return;
+			if (id.includes("node_modules")) return;
+			ensureResolved();
+			if (!resolvedPages || resolvedPages.size === 0) return;
+			const value = resolvedPages.get(id);
+			if (!value) return;
+			let program;
+			try {
+				program = parseAst(code, { lang: "tsx" });
+			} catch {
+				return;
+			}
+			const defaultExport = findDefaultExport(program, code);
+			if (!defaultExport) {
+				if (value) {
+					const relPath = id.replace(ctx.root + "/", "");
+					console.warn(`[timber] ${relPath}: export const prerender is declared but the default export cannot be wrapped (re-export or missing). The prerender declaration will be ignored for this file.`);
+				}
+				return;
+			}
+			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__";
+			let insertOffset = 0;
+			for (const stmt of program.body) if (!(stmt.type === "ExpressionStatement" && typeof stmt.directive === "string")) {
+				insertOffset = stmt.start;
+				break;
+			}
+			s.appendLeft(insertOffset, `import { cache as ${importAlias} } from '@timber-js/app/cache';\n`);
+			switch (defaultExport.kind) {
+				case "declaration": {
+					const declStart = defaultExport.node.declaration.start;
+					s.overwrite(defaultExport.node.start, declStart, "");
+					s.append(`\nexport default ${importAlias}.component(${defaultExport.name}, ${optionsSource});\n`);
+					break;
+				}
+				case "identifier":
+					if (defaultExport.specifierCount !== void 0 && defaultExport.specifierCount > 1) {
+						const specStart = defaultExport.specifierStart;
+						const specEnd = defaultExport.specifierEnd;
+						const idx = defaultExport.specifierIndex;
+						if (idx === 0) {
+							const nextSpec = defaultExport.node.specifiers?.[1];
+							if (nextSpec) s.remove(specStart, nextSpec.start);
+						} else {
+							const prevSpec = defaultExport.node.specifiers?.[idx - 1];
+							if (prevSpec) s.remove(prevSpec.end, specEnd);
+						}
+						s.appendLeft(defaultExport.node.end, `\nexport default ${importAlias}.component(${defaultExport.name}, ${optionsSource});`);
+					} else s.overwrite(defaultExport.node.start, defaultExport.node.end, `export default ${importAlias}.component(${defaultExport.name}, ${optionsSource});`);
+					break;
+				case "expression": {
+					const decl = defaultExport.node.declaration;
+					s.overwrite(defaultExport.node.start, decl.start, "const __timber_default_page__ = ");
+					const afterExpr = code.charAt(defaultExport.node.end - 1) === ";" ? "" : ";";
+					s.appendLeft(defaultExport.node.end, `${afterExpr}\nexport default ${importAlias}.component(__timber_default_page__, ${optionsSource});`);
+					break;
+				}
+			}
+			return {
+				code: s.toString(),
+				map: s.generateMap({ hires: "boundary" })
+			};
+		}
+	};
+}
+//#endregion
 //#region src/plugins/cloudflare-wasm.ts
 /**
 * timber-cloudflare-wasm — Handle WASM modules for Cloudflare Workers builds.
@@ -7504,6 +8324,82 @@ 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;
+	}
+}
+function buildPrebuiltReportData(manifest, summary) {
+	const hasCaptures = summary && (summary.captured > 0 || summary.skipped.length > 0);
+	if (!manifest && !hasCaptures) return null;
+	const components = [];
+	let totalEntries = 0;
+	let totalBytes = 0;
+	if (manifest) {
+		for (const [componentId, component] of Object.entries(manifest)) {
+			let entryCount = 0;
+			let componentBytes = 0;
+			for (const entry of Object.values(component.entries)) {
+				entryCount++;
+				componentBytes += entry.bytes ?? 0;
+			}
+			components.push({
+				componentId,
+				entryCount,
+				totalBytes: componentBytes
+			});
+			totalEntries += entryCount;
+			totalBytes += componentBytes;
+		}
+		components.sort((a, b) => a.componentId.localeCompare(b.componentId));
+	}
+	const skippedCount = summary?.skipped.length ?? 0;
+	const skippedReasons = (summary?.skipped ?? []).map((s) => ({
+		componentId: s.componentId,
+		route: s.routeUrlPath,
+		message: s.message
+	}));
+	return {
+		components,
+		totalEntries,
+		totalBytes,
+		skippedCount,
+		skippedReasons
+	};
+}
+function buildPrebuiltReport(data) {
+	const lines = [];
+	const total = data.totalEntries + data.skippedCount;
+	lines.push(`Prebuilt ${data.totalEntries}/${total} entries across ${data.components.length} component${data.components.length !== 1 ? "s" : ""}` + (data.totalBytes > 0 ? ` (${formatSize(data.totalBytes)} total)` : "") + "." + (data.skippedCount > 0 ? ` ${data.skippedCount} skipped due to errors.` : ""));
+	if (data.components.length > 0) {
+		lines.push("");
+		const nameHeader = "Component";
+		const entriesHeader = "Entries";
+		const sizeHeader = "Size";
+		const nameW = Math.max(11, ...data.components.map((c) => c.componentId.length + 4));
+		const entriesW = Math.max(7, 8);
+		const sizeW = Math.max(4, 10);
+		const totalW = nameW + entriesW + sizeW + 4;
+		const sep = "─".repeat(totalW);
+		lines.push(`${pad(nameHeader, nameW)}  ${pad(entriesHeader, entriesW, "left")}  ${pad(sizeHeader, sizeW, "left")}`);
+		lines.push(sep);
+		for (const comp of data.components) {
+			const nameStr = `  ◆ ${comp.componentId}`;
+			const entriesStr = String(comp.entryCount);
+			const sizeStr = formatSize(comp.totalBytes);
+			lines.push(`${pad(nameStr, nameW)}  ${pad(entriesStr, entriesW, "left")}  ${pad(sizeStr, sizeW, "left")}`);
+		}
+	}
+	if (data.skippedReasons.length > 0) {
+		lines.push("");
+		lines.push("Skipped entries:");
+		for (const s of data.skippedReasons) lines.push(`  ⚠ ${s.componentId} (${s.route}) — ${s.message}`);
+	}
+	return lines;
+}
 /** Measure raw + gzip sizes for all JS chunks and CSS assets in a bundle. */
 function collectChunkSizes(bundle) {
 	const sizes = /* @__PURE__ */ new Map();
@@ -7691,6 +8587,18 @@ function timberBuildReport(ctx) {
 			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("");
+			}
 		}
 	};
 }
@@ -8202,6 +9110,7 @@ function timber(config) {
 				previewConfig.port = resolvedDevPort;
 				previewConfig.strictPort = resolvedDevPortExplicit;
 			}
+			serverConfig.forwardConsole = resolveForwardConsole(ctx.config.devBrowserLogs);
 			return {
 				build: { outDir: buildOutDir },
 				environments: envOutDirs,
@@ -8247,6 +9156,8 @@ function timber(config) {
 		timberFonts(ctx),
 		timberMdx(ctx),
 		timberCacheTransform(ctx),
+		timberPrerenderSugar(ctx),
+		timberPrebuilt(ctx),
 		timberContent(ctx),
 		timberServerBundle(),
 		timberCloudflareWasm(ctx),
@@ -8254,7 +9165,6 @@ function timber(config) {
 		timberBuildReport(ctx),
 		timberAdapterBuild(ctx),
 		timberDevLogs(ctx),
-		timberDevBrowserLogs(ctx),
 		timberDevServer(ctx)
 	];
 }