@timber-js/app 0.2.0-alpha.166 → 0.2.0-alpha.168

package/dist/index.js

@@ -1,9 +1,8 @@
 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-t3uxAmbX.js";
-import { i as scanRoutes } from "./_chunks/cli-schema-sync-EXGYPhI2.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-DBVzXuWc.js";
+import { h as swallow } from "./_chunks/logger-AWfuX-KJ.js";
+import { i as scanRoutes } from "./_chunks/cli-schema-sync-B73L6pMq.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-CoOC8Hga.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---kTF5v8.js";
 import { t as fnv1aHash } from "./_chunks/fast-hash-D6hIVt1Y.js";
 import { t as formatSize } from "./_chunks/format-CfwjgPz9.js";
@@ -107,11 +106,18 @@ function timberContent(ctx) {
 	};
 }
 //#endregion
-//#region ../../node_modules/.pnpm/srvx@0.11.17/node_modules/srvx/dist/adapters/node.mjs
-async function sendNodeResponse(nodeRes, webRes) {
+//#region ../../node_modules/.pnpm/srvx@0.11.22/node_modules/srvx/dist/adapters/node.mjs
+function sendNodeResponse(nodeRes, webRes) {
+	try {
+		return _sendNodeResponse(nodeRes, webRes, false) || Promise.resolve();
+	} catch (error) {
+		return Promise.reject(error);
+	}
+}
+function _sendNodeResponse(nodeRes, webRes, detached) {
 	if (!webRes) {
 		nodeRes.statusCode = 500;
-		return endNodeResponse(nodeRes);
+		return endNodeResponse(nodeRes, detached);
 	}
 	if (webRes._toNodeResponse) {
 		const res = webRes._toNodeResponse();
@@ -123,18 +129,22 @@ async function sendNodeResponse(nodeRes, webRes) {
 			writeHead(nodeRes, res.status, res.statusText, res.headers);
 			nodeRes.write(res.body);
 		} else writeHead(nodeRes, res.status, res.statusText, res.headers);
-		return endNodeResponse(nodeRes);
+		return endNodeResponse(nodeRes, detached);
 	}
-	const rawHeaders = [...webRes.headers];
+	const rawHeaders = [];
+	for (const [key, value] of webRes.headers) rawHeaders.push(key, value);
 	writeHead(nodeRes, webRes.status, webRes.statusText, rawHeaders);
-	return webRes.body ? streamBody(webRes.body, nodeRes) : endNodeResponse(nodeRes);
+	return webRes.body ? streamBody(webRes.body, nodeRes) : endNodeResponse(nodeRes, detached);
 }
 function writeHead(nodeRes, status, statusText, rawHeaders) {
-	const writeHeaders = rawHeaders.flat();
-	if (!nodeRes.headersSent) if (nodeRes.req?.httpVersion === "2.0") nodeRes.writeHead(status, writeHeaders);
-	else nodeRes.writeHead(status, statusText, writeHeaders);
+	if (!nodeRes.headersSent) if (nodeRes.req?.httpVersion === "2.0") nodeRes.writeHead(status, rawHeaders);
+	else nodeRes.writeHead(status, statusText, rawHeaders);
 }
-function endNodeResponse(nodeRes) {
+function endNodeResponse(nodeRes, detached) {
+	if (detached) {
+		nodeRes.end();
+		return;
+	}
 	return new Promise((resolve) => nodeRes.end(resolve));
 }
 function pipeBody(stream, nodeRes, status, statusText, headers) {
@@ -1227,10 +1237,11 @@ function validateConfig(config) {
 			suggestion: "Example: budget: { firstLoadJs: 150_000 } for a ~150 kB limit."
 		});
 	}
+	const MOVED_TO_CACHE_FILE = /* @__PURE__ */ new Set(["cacheHandler", "cdnPurge"]);
 	for (const key of Object.keys(config)) if (!knownKeys.has(key)) errors.push({
 		field: key,
 		message: `Unknown config option: "${key}".`,
-		suggestion: `Check for typos. Known options: ${[...knownKeys].sort().join(", ")}.`
+		suggestion: MOVED_TO_CACHE_FILE.has(key) ? `"${key}" has moved to timber.cache.ts. Export cacheHandler as default, cdnPurge as a named export.` : `Check for typos. Known options: ${[...knownKeys].sort().join(", ")}.`
 	});
 	return errors;
 }
@@ -1304,12 +1315,9 @@ var init_config_validation = __esmMin((() => {
 		debug: true,
 		clientJavascript: true,
 		adapter: true,
-		cacheHandler: true,
-		cdnPurge: true,
 		allowedOrigins: true,
 		csrf: true,
 		limits: true,
-		actions: true,
 		forms: true,
 		pageExtensions: true,
 		slowRequestMs: true,
@@ -1323,6 +1331,7 @@ var init_config_validation = __esmMin((() => {
 		reactCompiler: true,
 		sitemap: true,
 		buildDir: true,
+		clientSegmentCache: true,
 		topLoader: true,
 		budget: true
 	}));
@@ -1337,7 +1346,7 @@ var init_config_validation = __esmMin((() => {
 		"virtual:timber-config": "Runtime config (timber.config.ts)",
 		"virtual:timber-route-manifest": "Route manifest (app/ file tree)",
 		"virtual:timber-instrumentation": "Instrumentation (instrumentation.ts)",
-		"virtual:timber-cache-handler": "Cache handler (cacheHandler config)",
+		"virtual:timber-cache-handler": "Cache handler (timber.cache.ts)",
 		"virtual:timber-build-manifest": "Build manifest (asset mapping)"
 	};
 	REQUIRED_PEERS = [
@@ -1466,6 +1475,105 @@ function compressWithGzip(body) {
 	return Readable.toWeb(gzip);
 }
 //#endregion
+//#region src/server/tree-match.ts
+/**
+* Match URL path parts against a segment tree.
+*
+* Walks the tree depth-first with backtracking, applying priority
+* ordering globally across group boundaries. Returns the matched
+* segment chain and collected params, or null if no route matches.
+*
+* By default, a match requires a terminal node (one with `page` or
+* `route`) at the leaf. Pass `{ requireTerminal: false }` to match
+* any segment (used by metadata route matching).
+*
+* @param root  The root segment node to start matching from.
+* @param parts URL path parts (e.g. ['blog', 'hello-world']).
+*              Empty array matches the root itself (if terminal).
+*/
+function matchUrlParts(root, parts, options) {
+	const chain = [];
+	const params = {};
+	if (matchNode(root, parts, 0, chain, params, options?.requireTerminal ?? true)) return {
+		chain,
+		params
+	};
+	return null;
+}
+/**
+* Flatten children through group segments.
+*
+* Groups are transparent for URL matching — their non-group descendants
+* are returned with the chain of group nodes leading to them. This lets
+* the caller apply priority ordering (static > dynamic > catch-all >
+* optional-catch-all) across all groups uniformly instead of per-group.
+*/
+function collectEffectiveChildren(node, groupChain = []) {
+	const result = [];
+	for (const child of node.children) if (child.segmentType === "group") {
+		const nested = collectEffectiveChildren(child, [...groupChain, child]);
+		result.push(...nested);
+	} else result.push({
+		child,
+		groupChain
+	});
+	return result;
+}
+/** A node is terminal if it can serve a response (has a page or route handler). */
+function isTerminal(node) {
+	return !!(node.page || node.route);
+}
+/**
+* Recursive depth-first matcher with backtracking.
+*
+* Mutates `chain` and `params` in place for performance; backtracks
+* (restores previous state) when a candidate doesn't lead to a match.
+*/
+function matchNode(node, parts, index, chain, params, requireTerminal) {
+	chain.push(node);
+	if (index >= parts.length) {
+		if (!requireTerminal || isTerminal(node)) return true;
+		for (const child of node.children) if (child.segmentType === "group") {
+			if (matchNode(child, parts, index, chain, params, requireTerminal)) return true;
+		}
+		const effective = collectEffectiveChildren(node);
+		for (const { child, groupChain } of effective) if (child.segmentType === "optional-catch-all" && (!requireTerminal || isTerminal(child))) {
+			chain.push(...groupChain, child);
+			return true;
+		}
+		chain.pop();
+		return false;
+	}
+	const part = parts[index];
+	const effective = collectEffectiveChildren(node);
+	for (const { child, groupChain } of effective) if (child.segmentType === "static" && child.segmentName === part) {
+		chain.push(...groupChain);
+		if (matchNode(child, parts, index + 1, chain, params, requireTerminal)) return true;
+		chain.length -= groupChain.length;
+	}
+	for (const { child, groupChain } of effective) if (child.segmentType === "dynamic" && child.paramName) {
+		chain.push(...groupChain);
+		const prev = params[child.paramName];
+		params[child.paramName] = part;
+		if (matchNode(child, parts, index + 1, chain, params, requireTerminal)) return true;
+		chain.length -= groupChain.length;
+		if (prev !== void 0) params[child.paramName] = prev;
+		else delete params[child.paramName];
+	}
+	for (const { child, groupChain } of effective) if (child.segmentType === "catch-all" && child.paramName && (!requireTerminal || isTerminal(child))) {
+		chain.push(...groupChain, child);
+		params[child.paramName] = parts.slice(index);
+		return true;
+	}
+	for (const { child, groupChain } of effective) if (child.segmentType === "optional-catch-all" && child.paramName && (!requireTerminal || isTerminal(child))) {
+		chain.push(...groupChain, child);
+		params[child.paramName] = parts.slice(index);
+		return true;
+	}
+	chain.pop();
+	return false;
+}
+//#endregion
 //#region src/plugins/dev-server.ts
 var RSC_ENTRY_ID = "virtual:timber-rsc-entry";
 /**
@@ -1892,6 +2000,7 @@ function generateConfigModule(ctx) {
 		sitemap: ctx.config.sitemap,
 		forms: serializeFormsConfig(ctx.config.forms),
 		deploymentId: ctx.deploymentId ?? null,
+		clientSegmentCache: ctx.config.clientSegmentCache ?? false,
 		devBrowserLogs: ctx.config.devBrowserLogs
 	};
 	return [
@@ -1904,12 +2013,12 @@ function generateConfigModule(ctx) {
 	].join("\n");
 }
 /**
-* Detect the user's instrumentation.ts file at the project root.
+* Detect a user convention file at both root and src/.
 *
-* Checks for instrumentation.ts, .js, and .mjs — matching the same
-* extensions as timber.config.ts detection.
+* Root takes precedence over src/, extension priority: .ts > .js > .mjs.
+* Used for instrumentation.ts, timber.cache.ts, and similar file conventions.
 */
-function detectInstrumentationFile(root) {
+function detectConventionFile(root, basename) {
 	const extensions = [
 		".ts",
 		".js",
@@ -1917,11 +2026,25 @@ function detectInstrumentationFile(root) {
 	];
 	const dirs = [root, resolve(root, "src")];
 	for (const dir of dirs) for (const ext of extensions) {
-		const candidate = resolve(dir, `instrumentation${ext}`);
+		const candidate = resolve(dir, `${basename}${ext}`);
 		if (existsSync(candidate)) return candidate;
 	}
 	return null;
 }
+function detectInstrumentationFile(root) {
+	return detectConventionFile(root, "instrumentation");
+}
+/**
+* Detect the user's timber.cache file.
+*
+* This file holds runtime cache instances (cacheHandler, cdnPurge)
+* that cannot be JSON-serialized. Separating them from timber.config.ts
+* prevents the RSC build from pulling build-time deps (adapters, MDX,
+* rollup) into the runtime bundle. See TIM-1211.
+*/
+function detectCacheFile(root) {
+	return detectConventionFile(root, "timber.cache");
+}
 /**
 * Generate the virtual:timber-instrumentation module source.
 *
@@ -1951,50 +2074,37 @@ function generateInstrumentationModule(instrumentationPath) {
 	].join("\n");
 }
 /**
-* Detect the user's timber.config file at the project root.
-* Returns the absolute path or null if not found.
-*/
-function detectConfigFile(root) {
-	for (const name of [
-		"timber.config.ts",
-		"timber.config.js",
-		"timber.config.mjs"
-	]) {
-		const candidate = resolve(root, name);
-		if (existsSync(candidate)) return candidate;
-	}
-	return null;
-}
-/**
 * Generate the virtual:timber-cache-handler module source.
 *
-* When the user's config has a cacheHandler, generates a module that
-* dynamically imports the config file and extracts the cacheHandler.
-* The cacheHandler is a class instance (e.g. RedisCacheHandler) that
-* cannot be JSON-serialized into virtual:timber-config, so it must
-* be loaded at runtime via dynamic import. See TIM-599.
+* When the user's timber.cache.ts exists, generates a module that
+* dynamically imports it and extracts cacheHandler and cdnPurge.
+* These are class instances (e.g. RedisCacheHandler) that cannot be
+* JSON-serialized into virtual:timber-config, so they must be loaded
+* at runtime via dynamic import.
+*
+* timber.cache.ts exports: default cacheHandler, named cdnPurge.
+*
+* See TIM-1211, TIM-599.
 */
-function generateCacheHandlerModule(configPath, hasCacheHandler, hasCdnPurge) {
-	if (configPath && (hasCacheHandler || hasCdnPurge)) return [
+function generateCacheHandlerModule(cachePath) {
+	if (cachePath) return [
 		"// Auto-generated cache handler loader — do not edit.",
 		"// Generated by timber-entries plugin.",
 		"",
 		`export default async function loadCacheHandler() {`,
-		`  const mod = await import(${JSON.stringify(configPath)});`,
-		`  const config = mod.default ?? mod;`,
-		`  return config.cacheHandler ?? null;`,
+		`  const mod = await import(${JSON.stringify(cachePath)});`,
+		`  return mod.default ?? null;`,
 		`}`,
 		"",
 		`export async function loadCdnPurgeHandler() {`,
-		`  const mod = await import(${JSON.stringify(configPath)});`,
-		`  const config = mod.default ?? mod;`,
-		`  return config.cdnPurge ?? null;`,
+		`  const mod = await import(${JSON.stringify(cachePath)});`,
+		`  return mod.cdnPurge ?? null;`,
 		`}`
 	].join("\n");
 	return [
 		"// Auto-generated cache handler loader — do not edit.",
 		"// Generated by timber-entries plugin.",
-		"// No cacheHandler or cdnPurge configured in timber.config.",
+		"// No timber.cache.ts found.",
 		"",
 		`export default async function loadCacheHandler() {`,
 		`  return null;`,
@@ -2042,7 +2152,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, ctx.config.cdnPurge != null);
+			if (id === RESOLVED_CACHE_HANDLER_ID) return generateCacheHandlerModule(detectCacheFile(ctx.root));
 			return null;
 		}
 	};
@@ -4610,6 +4720,30 @@ var FontPipeline = class {
 		const familyKey = family.toLowerCase();
 		for (const [id, entry] of this._entries) if (entry.importer === importer && entry.family.toLowerCase() === familyKey) this._entries.delete(id);
 	}
+	/** True if at least one entry is registered under `importer`. */
+	hasImporter(importer) {
+		for (const entry of this._entries.values()) if (entry.importer === importer) return true;
+		return false;
+	}
+	/**
+	* Drop **every** registry entry that originated from `importer`,
+	* regardless of family.
+	*
+	* Called at the start of the transform hook before re-registering the
+	* current extraction set. This handles the cases `pruneFor` misses:
+	*
+	* - **Family rename** (Inter → Roboto): the old family's entries are
+	*   cleared because we prune by importer, not by (importer, family).
+	* - **Font call deleted**: the old entries are cleared even though no
+	*   new call provides a family to prune against.
+	*
+	* Other importers' fonts are untouched.
+	*
+	* See TIM-1087.
+	*/
+	pruneImporter(importer) {
+		for (const [id, entry] of this._entries) if (entry.importer === importer) this._entries.delete(id);
+	}
 	/** Drop every registered font. Used by tests and rebuild flows. */
 	clear() {
 		this._entries.clear();
@@ -5788,6 +5922,7 @@ function runFontsTransform(code, id, pipeline, emitError) {
 	}
 	if (analysis.callSites.length === 0 && analysis.bindings.length === 0) return null;
 	const s = new MagicString(code);
+	const pending = [];
 	for (const site of analysis.callSites) if (site.binding.provider === "google") {
 		const family = site.binding.importedName.replace(/_/g, " ");
 		const config = extractGoogleFontConfigFromNode(site.configNode);
@@ -5796,27 +5931,32 @@ function runFontsTransform(code, id, pipeline, emitError) {
 		const className = familyToClassName(family);
 		const fontStack = buildFontStack(family);
 		const display = config.display ?? "swap";
-		const extracted = {
-			id: fontId,
-			family,
-			provider: "google",
-			weights: normalizeWeightArray(config.weight),
-			styles: normalizeStyleArray(config.style),
-			subsets: config.subsets ?? ["latin"],
-			display,
-			variable: config.variable,
-			className,
-			fontFamily: fontStack,
-			importer: id
-		};
-		pipeline.pruneFor(id, family);
-		pipeline.register(extracted);
-		s.overwrite(site.replaceStart, site.replaceEnd, buildFontResultLiteral(extracted));
+		pending.push({
+			site,
+			extracted: {
+				id: fontId,
+				family,
+				provider: "google",
+				weights: normalizeWeightArray(config.weight),
+				styles: normalizeStyleArray(config.style),
+				subsets: config.subsets ?? ["latin"],
+				display,
+				variable: config.variable,
+				className,
+				fontFamily: fontStack,
+				importer: id
+			}
+		});
 	} else {
 		const config = extractLocalFontConfigFromNode(site.configNode);
 		if (!config) emitError(`Could not statically analyze local font config at line ${site.line}, column ${site.column}. Ensure src is a string or array of { path, weight?, style? } objects.`);
-		const extracted = processLocalFont(config, id);
-		pipeline.pruneFor(id, extracted.family);
+		pending.push({
+			site,
+			extracted: processLocalFont(config, id)
+		});
+	}
+	pipeline.pruneImporter(id);
+	for (const { extracted, site } of pending) {
 		pipeline.register(extracted);
 		s.overwrite(site.replaceStart, site.replaceEnd, buildFontResultLiteral(extracted));
 	}
@@ -5986,6 +6126,25 @@ function writeFontManifest(pipeline, buildManifest, base = "/") {
 //#endregion
 //#region src/plugins/fonts.ts
 /**
+* timber-fonts — Vite sub-plugin shell for build-time font processing.
+*
+* This file is intentionally thin: it wires the Vite plugin hooks to the
+* pipeline + per-concern modules under `../fonts/`. All real logic lives
+* in:
+*
+* - `../fonts/pipeline.ts`        — `FontPipeline` (state, mutators)
+* - `../fonts/transform.ts`       — transform-hook logic, parsing helpers
+* - `../fonts/dev-middleware.ts`  — dev font binary server
+* - `../fonts/virtual-modules.ts` — virtual module ID constants + source
+*
+* The public exports below are the stable API that the test suite and
+* other parts of the framework import. Anything new should be added to
+* one of the per-concern modules and re-exported here only if external
+* consumers need it.
+*
+* Design doc: 24-fonts.md
+*/
+/**
 * Create the timber-fonts Vite plugin.
 */
 function timberFonts(ctx) {
@@ -6119,6 +6278,27 @@ function timberFonts(ctx) {
 		*/
 		buildStart() {},
 		/**
+		* Prune stale font entries when a module that previously imported fonts
+		* no longer contains any font import. The transform hook's `filter.code`
+		* skips such modules, so without this hook the old entries would persist
+		* until dev restart. See TIM-1087.
+		*/
+		async hotUpdate({ type, file, read }) {
+			if (!pipeline.hasImporter(file)) return;
+			if (type === "delete") {
+				pipeline.pruneImporter(file);
+				return;
+			}
+			const code = await read();
+			if (code.includes("@timber/fonts/") || code.includes("@timber-js/app/fonts/") || code.includes("next/font/")) return;
+			try {
+				parseAst(code, { lang: "tsx" });
+			} catch {
+				return;
+			}
+			pipeline.pruneImporter(file);
+		},
+		/**
 		* Scan source files for font function calls and extract static config.
 		*
 		* Delegates to `runFontsTransform`. Errors raised through the
@@ -7383,14 +7563,14 @@ function generateStableCallsiteId(relativeModulePath, kind, statementText, callS
 //#region src/plugins/cache.ts
 /**
 * timber-cache-transform — Vite plugin that injects stable callsite IDs
-* into `cache()` calls imported from `@timber-js/app/cache`.
+* into `cache.data()` calls imported from `@timber-js/app/cache`.
 *
 * Detected callsite forms (TIM-1054):
-*   - named imports, including aliases: `import { cache as c }` + `c(fn, opts)`
-*   - namespace imports: `import * as ns` + `ns.cache(fn, opts)`
+*   - named imports, including aliases: `import { cache as c }` + `c.data(fn, opts)`
+*   - namespace imports: `import * as ns` + `ns.cache.data(fn, opts)`
 * Forms a per-module transform cannot trace — local variable aliases
 * (`const c = cache`), user re-export wrapper modules, computed access
-* (`ns['cache']`) — fall back to the runtime fnId derived from
+* (`cache['data']`) — fall back to the runtime fnId derived from
 * fnv1a(fn.toString()) (see cache/timber-cache.ts), which is deterministic
 * across instances and cold starts of the same build. Without either
 * mechanism, an ordinal counter would collide across instances with a shared
@@ -7398,8 +7578,8 @@ function generateStableCallsiteId(relativeModulePath, kind, statementText, callS
 * data to another.
 *
 * The plugin transforms:
-*   cache(fn, opts)      →  cache(fn, opts, "stable-id")
-*   ns.cache(fn, opts)   →  ns.cache(fn, opts, "stable-id")
+*   cache.data(fn, opts)          →  cache.data(fn, opts, "stable-id")
+*   ns.cache.data(fn, opts)       →  ns.cache.data(fn, opts, "stable-id")
 *
 * where stable-id =
 *   fnv1a(relPath + ":cache:" + fnv1a(stmtText) + ":" + fnv1a(callSpanText) + ":" + occurrence)
@@ -7417,9 +7597,9 @@ function generateStableCallsiteId(relativeModulePath, kind, statementText, callS
 * unrelated edits, while a changed call gets a fresh ID — which is exactly
 * when invalidation is wanted.
 *
-* The enclosing-statement text is included so that byte-identical cache()
+* The enclosing-statement text is included so that byte-identical cache.data()
 * calls in different scopes — e.g. two factory helpers that each `return
-* cache(fn, { ttl: 60 })` — get distinct, insertion-stable IDs: their
+* cache.data(fn, { ttl: 60 })` — get distinct, insertion-stable IDs: their
 * enclosing declarations differ by name/body even when the call spans are
 * identical. Without it, a source-order occurrence counter alone would shift
 * when an identical span is inserted above, reassigning IDs across deploys.
@@ -7436,32 +7616,40 @@ function generateStableCallsiteId(relativeModulePath, kind, statementText, callS
 * See TIM-997, TIM-1053, design/06-caching.md §"Cache Key Security".
 */
 /**
-* 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?
-* Computed access (`ns['cache']`) is deliberately not matched; it falls back
+* Is this callee a `cache.data(...)` call? Matches two forms:
+*   - Named import: `cache.data(fn, opts)` where `cache` is the imported binding
+*   - Namespace import: `ns.cache.data(fn, opts)` where `ns` is the namespace
+* Computed access (`cache['data']`) is deliberately not matched; it falls back
 * to the runtime fnId derivation.
 */
-function isCacheCallee(callee, bindings) {
-	if (callee.type === "Identifier") return bindings.named.has(callee.name);
-	if (callee.type === "MemberExpression") {
-		const member = callee;
-		return !member.computed && member.object.type === "Identifier" && bindings.namespaces.has(member.object.name) && member.property.type === "Identifier" && member.property.name === "cache";
+function isCacheDataCallee(callee, bindings) {
+	if (callee.type !== "MemberExpression") return false;
+	const member = callee;
+	if (member.computed) return false;
+	if (member.property.type !== "Identifier" || member.property.name !== "data") return false;
+	const obj = member.object;
+	if (obj.type === "Identifier") return bindings.named.has(obj.name);
+	if (obj.type === "MemberExpression") {
+		const outer = obj;
+		return !outer.computed && outer.object.type === "Identifier" && bindings.namespaces.has(outer.object.name) && outer.property.type === "Identifier" && outer.property.name === "cache";
 	}
 	return false;
 }
 /**
-* Extract the local binding name that a cache callee resolves to — the
-* identifier for named imports, or the namespace object for `ns.cache()`.
+* Extract the local binding name that a cache.data callee resolves to — the
+* `cache` identifier for named imports, or the namespace object for `ns.cache.data()`.
 */
 function calleeBindingName(callee, bindings) {
-	if (callee.type === "Identifier") {
-		const name = callee.name;
+	if (callee.type !== "MemberExpression") return null;
+	const obj = callee.object;
+	if (obj.type === "Identifier") {
+		const name = obj.name;
 		return bindings.named.has(name) ? name : null;
 	}
-	if (callee.type === "MemberExpression") {
-		const member = callee;
-		if (member.object.type === "Identifier") {
-			const name = member.object.name;
+	if (obj.type === "MemberExpression") {
+		const outer = obj;
+		if (outer.object.type === "Identifier") {
+			const name = outer.object.name;
 			return bindings.namespaces.has(name) ? name : null;
 		}
 	}
@@ -7499,7 +7687,7 @@ function timberCacheTransform(ctx) {
 			const callSites = [];
 			for (const stmt of program.body) {
 				const calls = [];
-				findCallSites(stmt, (call) => call.arguments.length === 2 && isCacheCallee(call.callee, cacheBindings) && !isCalleeShadowed(call), calls);
+				findCallSites(stmt, (call) => call.arguments.length === 2 && isCacheDataCallee(call.callee, cacheBindings) && !isCalleeShadowed(call), calls);
 				for (const call of calls) callSites.push({
 					call,
 					stmt
@@ -8650,6 +8838,7 @@ function timberAdapterBuild(ctx) {
 				}
 				if (ctx.clientJavascript.disabled) await stripJsFromRscAssetsManifests(buildDir);
 				const adapterConfig = {
+					root: ctx.root,
 					output: ctx.config.output ?? "server",
 					clientJavascriptDisabled: ctx.clientJavascript.disabled,
 					manifestInit
@@ -8660,6 +8849,84 @@ function timberAdapterBuild(ctx) {
 	};
 }
 /**
+* 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/
@@ -8684,13 +8951,8 @@ async function mergeRscAssetsManifest(buildDir, root, buildManifest, routeClient
 	} catch {
 		return;
 	}
-	const jsonStr = content.replace(/^export default\s*/, "").replace(/;?\s*$/, "");
-	let manifest;
-	try {
-		manifest = JSON.parse(jsonStr);
-	} 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) {
@@ -8721,16 +8983,23 @@ async function stripJsFromRscAssetsManifests(buildDir) {
 			continue;
 		}
 		const jsonStr = content.replace(/^export default\s*/, "").replace(/;?\s*$/, "");
-		let manifest;
+		let isStrictJson = true;
+		let manifest = null;
 		try {
 			manifest = JSON.parse(jsonStr);
-		} catch (err) {
-			swallow(err, `corrupted RSC assets manifest: ${path}`, { level: "warn" });
+		} catch {
+			isStrictJson = false;
+		}
+		if (!isStrictJson) {
+			let rewritten = content;
+			rewritten = clearJsArrays(rewritten);
+			rewritten = clearBootstrapScriptContent(rewritten);
+			await writeFile(path, rewritten);
 			continue;
 		}
-		const deps = manifest.clientReferenceDeps;
+		const deps = manifest?.clientReferenceDeps;
 		if (deps) for (const entry of Object.values(deps)) entry.js = [];
-		manifest.bootstrapScriptContent = "";
+		if (manifest) manifest.bootstrapScriptContent = "";
 		await writeFile(path, `export default ${JSON.stringify(manifest, null, 2)};\n`);
 	}
 }