@markless/router 0.1.1 → 0.2.1

package/dist/vite/runtime/create-server-entry.js

@@ -1,10 +1,13 @@
-import { n as matchRouteManifest, t as buildRouteManifestFromFileIds } from "../../route-manifest-OTaWQ_TC.js";
+import { t as __marklessDebugBootstrapSource } from "../../debug-channel-C7v9u5SM.js";
+import { i as normalizeRouteFileId, n as matchRouteManifest, t as buildRouteManifestFromFileIds } from "../../route-manifest-DPgGIyrS.js";
 import { renderToString } from "@markless/web/render-to-string";
 import { renderToStream } from "@markless/web/render-to-stream";
+import { normalizeMarklessDevError, renderMarklessDevErrorDocument } from "@markless/bundler/dev-error";
 //#region src/vite/runtime/create-server-entry.ts
 const DOCUMENT_CHILDREN_PLACEHOLDER = "__markless_router_document_children__";
 function createServerEntry(options) {
 	const manifest = buildRouteManifestFromFileIds(options.routeFileIds);
+	assertCurrentRouteAssets(options);
 	async function fetch(request) {
 		const url = new URL(request.url);
 		if (isNitroApiPathname(url.pathname)) return new Response("Not found", { status: 404 });
@@ -14,7 +17,37 @@ function createServerEntry(options) {
 			return await renderPage(url, match.route.file, match.params, 200);
 		} catch (error) {
 			console.error("[markless-router] page render failed:", error);
-			return renderStatusPage(url, manifest.statusPages.error, 500, "Internal Server Error");
+			if (options.dev) return renderDevelopmentError(url, error);
+			try {
+				return await renderStatusPage(url, manifest.statusPages.error, 500, "Internal Server Error");
+			} catch (errorPageError) {
+				console.error("[markless-router] error page render failed:", errorPageError);
+				return new Response("Internal Server Error", {
+					status: 500,
+					headers: { "content-type": "text/plain;charset=utf-8" }
+				});
+			}
+		}
+	}
+	function renderDevelopmentError(url, error) {
+		const headers = {
+			"cache-control": "no-store",
+			"content-type": "text/html;charset=utf-8"
+		};
+		try {
+			const payload = normalizeMarklessDevError(error, { id: `navigation:${url.pathname}` });
+			return new Response(renderMarklessDevErrorDocument(payload), {
+				status: 500,
+				headers
+			});
+		} catch {
+			return new Response(escapeHtml(flattenError(error)), {
+				status: 500,
+				headers: {
+					...headers,
+					"content-type": "text/plain;charset=utf-8"
+				}
+			});
 		}
 	}
 	async function renderStatusPage(url, file, status, fallbackText) {
@@ -46,14 +79,14 @@ function createServerEntry(options) {
 				headers
 			});
 		}
-		const pageArtifact = routedPageArtifact(renderSsr, baseArtifact, pageProps, file, options.navigationEntryPath);
+		const pageArtifact = routedPageArtifact(renderSsr, baseArtifact, pageProps, file, options.navigationEntryPath, options.routeStylesheets?.[file]);
 		const renderOptions = {
 			props: pageProps,
 			resumeModuleUrl: options.resumeEntryPath ?? baseArtifact?.resumeModuleUrl,
 			modulePreloads: (html) => modulePreloadsForPage(file, html, pageProps.url.href, manifest, options.routeModulePreloads, options.routeSsrModulePreloads)
 		};
 		if (options.render === "blocking") {
-			const pageHtml = splitLeadingModulePreloadLinks(await renderToString(pageArtifact, renderOptions));
+			const pageHtml = splitLeadingHeadHtml(await renderToString(pageArtifact, renderOptions));
 			const shell = await renderDocumentShell(documentModule, pageProps, pageHtml.headHtml);
 			return new Response(fillDocumentChildren(shell, pageHtml.bodyHtml), {
 				status,
@@ -61,7 +94,7 @@ function createServerEntry(options) {
 			});
 		}
 		const stream = await renderToStream(pageArtifact, renderOptions);
-		const pageHtml = splitLeadingModulePreloadLinks(stream.shell);
+		const pageHtml = splitLeadingHeadHtml(stream.shell);
 		const shell = await renderDocumentShell(documentModule, pageProps, pageHtml.headHtml);
 		if (stream.pendingArmCount === 0) return new Response(fillDocumentChildren(shell, pageHtml.bodyHtml), {
 			status,
@@ -90,9 +123,38 @@ function createServerEntry(options) {
 	}
 	return { fetch };
 }
-function routedPageArtifact(renderSsr, baseArtifact, pageProps, file, navigationEntryPath) {
+function flattenError(error) {
+	if (error instanceof Error) return error.message;
+	if (typeof error === "object" && error !== null && "message" in error && typeof error.message === "string") return error.message;
+	return String(error);
+}
+function assertCurrentRouteAssets(options) {
+	if (options.routeStylesheets === void 0) return;
+	const routeMaps = [
+		["navigation", options.routeModulePreloads ?? {}],
+		["SSR", options.routeSsrModulePreloads ?? {}],
+		["style", options.routeStylesheets]
+	];
+	const expected = [...new Set(options.routeFileIds.map(normalizeRouteFileId))].filter((file) => /^pages\/.+\.(?:tsrx|mdx)$/.test(file)).toSorted();
+	for (const [label, routes] of routeMaps) {
+		const actual = Object.keys(routes).toSorted();
+		if (JSON.stringify(actual) !== JSON.stringify(expected)) throw new Error(`Markless Router ${label} client-asset routes are stale; expected ${JSON.stringify(expected)}, received ${JSON.stringify(actual)}. Rebuild the client environment before the server environment.`);
+	}
+}
+function routedPageArtifact(renderSsr, baseArtifact, pageProps, file, navigationEntryPath, stylesheetHrefs) {
+	const headInjections = [...baseArtifact?.headInjections ?? [], ...(stylesheetHrefs ?? []).map((href) => ({
+		tag: "link",
+		location: "head",
+		attributes: {
+			rel: "stylesheet",
+			href
+		}
+	}))];
 	return {
 		resumeModuleUrl: baseArtifact?.resumeModuleUrl,
+		inlineResumerSources: baseArtifact?.inlineResumerSources,
+		storageSeeds: baseArtifact?.storageSeeds,
+		...headInjections.length > 0 ? { headInjections } : {},
 		async renderSsr(renderProps, renderContext) {
 			const output = await renderSsr(renderProps ?? pageProps, renderContext);
 			if (!output) return { html: "" };
@@ -156,20 +218,15 @@ function addModulePreloads(preloads, seen, items) {
 		preloads.push(preload);
 	}
 }
-function splitLeadingModulePreloadLinks(html) {
-	let bodyHtml = html;
-	const links = [];
-	while (bodyHtml.startsWith("<link ")) {
-		const end = bodyHtml.indexOf(">");
-		if (end === -1) break;
-		const link = bodyHtml.slice(0, end + 1);
-		if (!link.includes("rel=\"modulepreload\"")) break;
-		links.push(link);
-		bodyHtml = bodyHtml.slice(end + 1);
-	}
+function splitLeadingHeadHtml(html) {
+	const containerStart = html.indexOf("<div data-async-container");
+	if (containerStart <= 0) return {
+		bodyHtml: html,
+		headHtml: ""
+	};
 	return {
-		bodyHtml,
-		headHtml: links.join("")
+		bodyHtml: html.slice(containerStart),
+		headHtml: html.slice(0, containerStart)
 	};
 }
 async function renderDocumentShell(documentModule, pageProps, headHtml) {
@@ -216,7 +273,20 @@ function renderRouteScript(file) {
 	return `<script type="@markless/core/route">${escapeScriptJson({ file })}<\/script>`;
 }
 function renderLinkBridgeScript(resumeEntryPath) {
-	return `<script data-markless-router-link-resumer>${escapeInlineScript(`(() => {
+	const debugBootstrap = typeof __MARKLESS_DEBUG_ENABLED__ !== "undefined" && __MARKLESS_DEBUG_ENABLED__ ? `<script data-markless-router-debug-bootstrap>${escapeInlineScript(`(() => {
+	const d = document;
+	const s = d.currentScript;
+	const r = s && s.closest('[data-async-container]');
+	if (!r) return;
+	try { globalThis[Symbol.for('markless.debug.channel.v1.bootstrap')] = ${__marklessDebugBootstrapSource()}(r, 'ssr-inline', false); } catch {}
+})();`)}<\/script>` : "";
+	const debugRegistration = typeof __MARKLESS_DEBUG_ENABLED__ !== "undefined" && __MARKLESS_DEBUG_ENABLED__ ? `
+	try {
+		const key = Symbol.for('markless.debug.channel.v1.bootstrap');
+		const md = globalThis[key];
+		if (md) { md.router('ssr-link-bridge'); md.activate(); }
+	} catch {}` : "";
+	return `${debugBootstrap}<script data-markless-router-link-resumer>${escapeInlineScript(`(() => {
 	const d = document;
 	const s = d.currentScript;
 	const r = s && s.closest('[data-async-container]');
@@ -266,7 +336,7 @@ function renderLinkBridgeScript(resumeEntryPath) {
 			setTimeout(() => { throw error; });
 			location.assign(url.href);
 		}
-	}, true);
+	}, true);${debugRegistration}
 })();`)}<\/script>`;
 }
 function htmlAttributes(documentModule, pageProps) {

package/dist/vite.js

@@ -1,12 +1,13 @@
-import { t as buildRouteManifestFromFileIds } from "./route-manifest-OTaWQ_TC.js";
-import { r as transformRequestFileSource } from "./request-files-DTkeaKxU.js";
-import { dirname, extname, isAbsolute, join, normalize, relative } from "pathe";
+import { t as buildRouteManifestFromFileIds } from "./route-manifest-DPgGIyrS.js";
+import { r as transformRequestFileSource } from "./request-files-C-0LLSsx.js";
+import { dirname, extname, isAbsolute, join, normalize, relative, resolve } from "pathe";
 import { decodePath, joinURL, parsePath, parseQuery, parseURL, stringifyQuery, withLeadingSlash, withoutLeadingSlash } from "ufo";
 import { existsSync } from "node:fs";
 import { nitro } from "nitro/vite";
 import { sortUserPlugins } from "vite";
 import { symbolVirtualModuleSourceFile } from "@markless/bundler/preload";
 import { parseModule } from "@tsrx/core";
+import { mkdir, readFile, rename, rm, stat, writeFile } from "node:fs/promises";
 import { toHtml } from "hast-util-to-html";
 import { HastReader, createMdxHastHandle, defineHastPlugin, dropHandle, materializeHastTree, resolveHastSubscriptions, serializeHandle, visitHastHandle } from "satteri";
 //#region src/route-types.ts
@@ -371,6 +372,169 @@ function fail$1(message) {
 	throw new Error(message);
 }
 //#endregion
+//#region src/vite/client-assets-manifest.ts
+const MARKLESS_ROUTER_CLIENT_ASSETS_MANIFEST = ".vite/markless-router-client-manifest.json";
+const MARKLESS_ROUTER_CLIENT_ASSETS_MANIFEST_VERSION = 1;
+const VALID_ROUTE_FILE = /^pages\/.+\.(?:tsrx|mdx)$/;
+const ABSOLUTE_OR_PROTOCOL_RELATIVE_URL = /^(?:[a-z][a-z\d+.-]*:|\/\/)/i;
+function createClientAssetsManifest(input) {
+	return {
+		version: MARKLESS_ROUTER_CLIENT_ASSETS_MANIFEST_VERSION,
+		base: input.base,
+		entries: {
+			resume: input.resumeEntry,
+			navigation: input.navigationEntry
+		},
+		routes: {
+			navigation: sortRouteMap(input.routes.navigation),
+			ssr: sortRouteMap(input.routes.ssr),
+			styles: sortRouteMap(input.routes.styles)
+		}
+	};
+}
+async function removeClientAssetsManifest(clientOutDir) {
+	const path = clientAssetsManifestPath(clientOutDir);
+	await Promise.all([rm(path, { force: true }), rm(clientAssetsManifestTemporaryPath(clientOutDir), { force: true })]);
+}
+async function writeClientAssetsManifest(clientOutDir, manifest) {
+	const validated = await validateClientAssetsManifest(manifest, manifest.base, clientOutDir);
+	const path = clientAssetsManifestPath(clientOutDir);
+	const temporaryPath = clientAssetsManifestTemporaryPath(clientOutDir);
+	await mkdir(dirname(path), { recursive: true });
+	await writeFile(temporaryPath, `${JSON.stringify(validated, null, 2)}\n`, "utf8");
+	await rename(temporaryPath, path);
+}
+async function readClientAssetsManifest(clientOutDir, base) {
+	const path = clientAssetsManifestPath(clientOutDir);
+	let source;
+	try {
+		source = await readFile(path, "utf8");
+	} catch (error) {
+		throw clientAssetsManifestError(`is missing at ${path}. Build the client environment before the server environment`, error);
+	}
+	let parsed;
+	try {
+		parsed = JSON.parse(source);
+	} catch (error) {
+		throw clientAssetsManifestError(`is malformed at ${path}`, error);
+	}
+	return validateClientAssetsManifest(parsed, base, clientOutDir);
+}
+function clientAssetFileName(href, base) {
+	const dummyOrigin = "https://markless-router.invalid/";
+	if (hasControlCharacter(href) || !ABSOLUTE_OR_PROTOCOL_RELATIVE_URL.test(base) && ABSOLUTE_OR_PROTOCOL_RELATIVE_URL.test(href)) throw clientAssetsManifestError(`contains an asset URL outside base ${JSON.stringify(base)}: ${JSON.stringify(href)}`);
+	let baseUrl;
+	let assetUrl;
+	try {
+		baseUrl = new URL(base || "/", dummyOrigin);
+		assetUrl = new URL(href, baseUrl);
+	} catch (error) {
+		throw clientAssetsManifestError(`contains an invalid asset URL ${JSON.stringify(href)}`, error);
+	}
+	if (assetUrl.origin !== baseUrl.origin || assetUrl.search || assetUrl.hash) throw clientAssetsManifestError(`contains an asset URL outside base ${JSON.stringify(base)}: ${JSON.stringify(href)}`);
+	const basePath = baseUrl.pathname.endsWith("/") ? baseUrl.pathname : `${baseUrl.pathname}/`;
+	if (!assetUrl.pathname.startsWith(basePath)) throw clientAssetsManifestError(`contains an asset URL outside base ${JSON.stringify(base)}: ${JSON.stringify(href)}`);
+	let fileName;
+	try {
+		fileName = decodeURIComponent(assetUrl.pathname.slice(basePath.length));
+	} catch (error) {
+		throw clientAssetsManifestError(`contains an invalid encoded asset URL ${JSON.stringify(href)}`, error);
+	}
+	const normalized = normalize(fileName);
+	if (fileName === "" || hasControlCharacter(fileName) || fileName.includes("\\") || isAbsolute(fileName) || normalized !== fileName || normalized === ".." || normalized.startsWith("../")) throw clientAssetsManifestError(`contains an unsafe asset path ${JSON.stringify(href)}`);
+	if (href !== joinURL(base, fileName)) throw clientAssetsManifestError(`contains a non-canonical asset URL ${JSON.stringify(href)} for base ${JSON.stringify(base)}`);
+	return fileName;
+}
+function clientAssetsManifestPath(clientOutDir) {
+	return join(clientOutDir, MARKLESS_ROUTER_CLIENT_ASSETS_MANIFEST);
+}
+function clientAssetsManifestTemporaryPath(clientOutDir) {
+	return `${clientAssetsManifestPath(clientOutDir)}.tmp`;
+}
+async function validateClientAssetsManifest(input, base, clientOutDir) {
+	if (!isRecord$1(input)) throw clientAssetsManifestError("must be a JSON object");
+	if (input.version !== MARKLESS_ROUTER_CLIENT_ASSETS_MANIFEST_VERSION) throw clientAssetsManifestError(`has unsupported version ${JSON.stringify(input.version)}; expected ${MARKLESS_ROUTER_CLIENT_ASSETS_MANIFEST_VERSION}`);
+	if (input.base !== base) throw clientAssetsManifestError(`was built for base ${JSON.stringify(input.base)}; expected ${JSON.stringify(base)}`);
+	if (!isRecord$1(input.entries)) throw clientAssetsManifestError("has invalid entries");
+	if (!isRecord$1(input.routes)) throw clientAssetsManifestError("has invalid route maps");
+	const entries = {
+		resume: requiredString(input.entries.resume, "entries.resume"),
+		navigation: requiredString(input.entries.navigation, "entries.navigation")
+	};
+	const routes = {
+		navigation: routeMap(input.routes.navigation, "routes.navigation"),
+		ssr: routeMap(input.routes.ssr, "routes.ssr"),
+		styles: routeMap(input.routes.styles, "routes.styles")
+	};
+	assertMatchingRouteKeys(routes);
+	const hrefs = new Set([
+		entries.resume,
+		entries.navigation,
+		...Object.values(routes.navigation).flat(),
+		...Object.values(routes.ssr).flat(),
+		...Object.values(routes.styles).flat()
+	]);
+	for (const href of hrefs) {
+		const assetPath = join(clientOutDir, clientAssetFileName(href, base));
+		const relativeAssetPath = relative(clientOutDir, assetPath);
+		if (relativeAssetPath === ".." || relativeAssetPath.startsWith("../") || isAbsolute(relativeAssetPath)) throw clientAssetsManifestError(`contains an unsafe asset path ${JSON.stringify(href)}`);
+		try {
+			if (!(await stat(assetPath)).isFile()) throw new Error("not a file");
+		} catch (error) {
+			throw clientAssetsManifestError(`references missing client asset ${JSON.stringify(href)}`, error);
+		}
+	}
+	return {
+		version: MARKLESS_ROUTER_CLIENT_ASSETS_MANIFEST_VERSION,
+		base,
+		entries,
+		routes
+	};
+}
+function routeMap(input, label) {
+	if (!isRecord$1(input)) throw clientAssetsManifestError(`has invalid ${label}`);
+	const routes = {};
+	for (const [routeFile, hrefs] of Object.entries(input)) {
+		let decodedRouteFile;
+		try {
+			decodedRouteFile = decodeURIComponent(routeFile);
+		} catch (error) {
+			throw clientAssetsManifestError(`contains invalid route key ${JSON.stringify(routeFile)}`, error);
+		}
+		if (!VALID_ROUTE_FILE.test(routeFile) || hasControlCharacter(routeFile) || decodedRouteFile !== routeFile || routeFile.includes("\\") || normalize(routeFile) !== routeFile) throw clientAssetsManifestError(`contains invalid route key ${JSON.stringify(routeFile)}`);
+		if (!Array.isArray(hrefs) || !hrefs.every((href) => typeof href === "string")) throw clientAssetsManifestError(`has invalid assets for route ${JSON.stringify(routeFile)}`);
+		routes[routeFile] = hrefs;
+	}
+	return routes;
+}
+function assertMatchingRouteKeys(routes) {
+	const navigationKeys = Object.keys(routes.navigation).toSorted();
+	for (const [label, routeMap] of [["SSR", routes.ssr], ["style", routes.styles]]) {
+		const keys = Object.keys(routeMap).toSorted();
+		if (JSON.stringify(keys) !== JSON.stringify(navigationKeys)) throw clientAssetsManifestError(`${label} route keys do not match navigation route keys`);
+	}
+}
+function sortRouteMap(routes) {
+	return Object.fromEntries(Object.entries(routes).toSorted(([left], [right]) => left.localeCompare(right)).map(([routeFile, hrefs]) => [routeFile, [...hrefs]]));
+}
+function requiredString(input, label) {
+	if (typeof input !== "string" || input === "") throw clientAssetsManifestError(`has invalid ${label}`);
+	return input;
+}
+function hasControlCharacter(input) {
+	for (let index = 0; index < input.length; index++) {
+		const code = input.charCodeAt(index);
+		if (code <= 31 || code === 127) return true;
+	}
+	return false;
+}
+function isRecord$1(input) {
+	return typeof input === "object" && input !== null && !Array.isArray(input);
+}
+function clientAssetsManifestError(message, cause) {
+	return new Error(`Markless Router client-assets manifest ${message}.`, { cause });
+}
+//#endregion
 //#region src/vite/html-transform.ts
 const HELPER = "__marklessRouterHtmlAttributes";
 const SAFE_GLOBALS = new Set([
@@ -912,9 +1076,16 @@ function devSourceModuleRequestPlugin() {
 	};
 }
 function routerConfigPlugin(nitroPluginsFromRouter, resumeEntry, navigationEntry, routePreloads) {
+	let clientOutDir = "";
+	let clientEnvironmentName = "";
+	let clientEnvironmentConfig;
+	let serverEnvironmentConfig;
+	let productionBuild = false;
+	let pendingClientAssets;
 	return {
 		name: "markless-router:vite",
 		enforce: "pre",
+		sharedDuringBuild: true,
 		config(config) {
 			throwIfUserAddedNitro(config.plugins, nitroPluginsFromRouter);
 			config.environments ??= {};
@@ -932,6 +1103,16 @@ function routerConfigPlugin(nitroPluginsFromRouter, resumeEntry, navigationEntry
 			};
 		},
 		configResolved(config) {
+			productionBuild = config.command === "build";
+			if (productionBuild) {
+				const clientEnvironments = Object.entries(config.environments).filter(([, environment]) => environment.consumer === "client");
+				if (clientEnvironments.length !== 1) throw new Error(`Markless Router requires exactly one client build environment; found ${clientEnvironments.length}.`);
+				const [name, environment] = clientEnvironments[0];
+				clientEnvironmentName = name;
+				clientEnvironmentConfig = environment;
+				serverEnvironmentConfig = config.environments.ssr;
+				clientOutDir = resolve(config.root, environment.build.outDir);
+			}
 			for (const entry of [
 				resumeEntry,
 				navigationEntry,
@@ -942,20 +1123,65 @@ function routerConfigPlugin(nitroPluginsFromRouter, resumeEntry, navigationEntry
 		configEnvironment(_name, config) {
 			configureRouteInputs(config);
 		},
-		generateBundle(_options, bundle) {
-			if (this.environment?.config.consumer !== "client") return;
-			const resumeChunk = Object.values(bundle).find((item) => item.type === "chunk" && isVirtualEntryChunk(item, RESUME_ENTRY_ORIGIN));
-			if (resumeChunk) resumeEntry.fileName = resumeChunk.fileName;
-			const navigationChunk = Object.values(bundle).find((item) => item.type === "chunk" && isVirtualEntryChunk(item, NAVIGATION_ENTRY_ORIGIN));
-			if (navigationChunk) navigationEntry.fileName = navigationChunk.fileName;
-			routePreloads.routes = routeModulePreloadsFromBundle({
-				base: routePreloads.base,
-				bundle,
-				navigationChunk,
-				resumeChunk,
-				root: routePreloads.root
-			});
-			patchRoutePreloadsInBundle(bundle, routePreloads.routes);
+		async buildStart() {
+			if (!productionBuild) return;
+			if (!clientOutDir) throw new Error("Markless Router could not resolve the client output directory for its client-assets manifest.");
+			const environment = this.environment;
+			const isClientEnvironment = environment?.name ? environment.name === clientEnvironmentName : environment?.config === clientEnvironmentConfig;
+			const isRouterServerEnvironment = environment?.name ? environment.name === "ssr" : environment?.config === serverEnvironmentConfig;
+			if (isClientEnvironment) {
+				pendingClientAssets = void 0;
+				resumeEntry.fileName = void 0;
+				navigationEntry.fileName = void 0;
+				routePreloads.routes = {
+					navigation: {},
+					ssr: {},
+					styles: {}
+				};
+				routePreloads.persisted = false;
+				await removeClientAssetsManifest(clientOutDir);
+				return;
+			}
+			if (!isRouterServerEnvironment) return;
+			const manifest = await readClientAssetsManifest(clientOutDir, routePreloads.base);
+			resumeEntry.fileName = clientAssetFileName(manifest.entries.resume, manifest.base);
+			navigationEntry.fileName = clientAssetFileName(manifest.entries.navigation, manifest.base);
+			routePreloads.routes = manifest.routes;
+			routePreloads.persisted = true;
+		},
+		generateBundle: {
+			order: "post",
+			handler(_options, bundle) {
+				if (this.environment?.config.consumer !== "client") return;
+				const resumeChunk = Object.values(bundle).find((item) => item.type === "chunk" && isVirtualEntryChunk(item, RESUME_ENTRY_ORIGIN));
+				if (resumeChunk) resumeEntry.fileName = resumeChunk.fileName;
+				const navigationChunk = Object.values(bundle).find((item) => item.type === "chunk" && isVirtualEntryChunk(item, NAVIGATION_ENTRY_ORIGIN));
+				if (navigationChunk) navigationEntry.fileName = navigationChunk.fileName;
+				routePreloads.routes = routeModulePreloadsFromBundle({
+					base: routePreloads.base,
+					bundle,
+					navigationChunk,
+					resumeChunk,
+					root: routePreloads.root
+				});
+				patchRoutePreloadsInBundle(bundle, routePreloads.routes);
+				if (productionBuild) {
+					if (!resumeEntry.fileName || !navigationEntry.fileName) throw new Error("Markless Router client build did not emit its resume and navigation entries.");
+					pendingClientAssets = createClientAssetsManifest({
+						base: routePreloads.base,
+						resumeEntry: joinURL(routePreloads.base, resumeEntry.fileName),
+						navigationEntry: joinURL(routePreloads.base, navigationEntry.fileName),
+						routes: routePreloads.routes
+					});
+				}
+			}
+		},
+		async writeBundle() {
+			const environment = this.environment;
+			const isClientEnvironment = environment?.name ? environment.name === clientEnvironmentName : environment?.config === clientEnvironmentConfig;
+			if (!productionBuild || !isClientEnvironment) return;
+			if (!pendingClientAssets) throw new Error("Markless Router client build finished without a client-assets manifest.");
+			await writeClientAssetsManifest(clientOutDir, pendingClientAssets);
 		}
 	};
 }
@@ -1083,10 +1309,12 @@ function resumeEntryState() {
 function routePreloadState() {
 	return {
 		base: "/",
+		persisted: false,
 		root: ".",
 		routes: {
 			navigation: {},
-			ssr: {}
+			ssr: {},
+			styles: {}
 		}
 	};
 }
@@ -1113,6 +1341,7 @@ function virtualModulesPlugin(resumeEntry = resumeEntryState(), navigationEntry
 	let root = "";
 	return {
 		name: "markless-router:routes",
+		sharedDuringBuild: true,
 		configResolved(config) {
 			root = config.root;
 		},
@@ -1130,7 +1359,7 @@ function virtualModulesPlugin(resumeEntry = resumeEntryState(), navigationEntry
 			if (id.startsWith(`\0${SERVER_ENTRY_ID}`)) return serverEntrySource(root);
 			if (id.startsWith(`\0${RESUME_ENTRY_PATH_ID}`)) return entryPathSource("resumeEntryPath", resumeEntry, RESUME_ENTRY_ID, root);
 			if (id.startsWith(`\0${NAVIGATION_ENTRY_PATH_ID}`)) return entryPathSource("navigationEntryPath", navigationEntry, NAVIGATION_ENTRY_ID, root);
-			if (id.startsWith(`\0${ROUTE_PRELOADS_ID}`)) return routePreloadsSource(routePreloads);
+			if (id.startsWith(`\0${ROUTE_PRELOADS_ID}`)) return routePreloadsSource(routePreloads, this?.environment?.config.consumer === "client");
 			if (id.startsWith(`\0${ROUTER_OPTIONS_ID}`)) return "export const routerMode = \"path\"; // retained for compat; hash paths are always first-class";
 		}
 	};
@@ -1145,14 +1374,16 @@ function serverEntrySource(root) {
 		`import { createServerEntry } from '@markless/router/vite/runtime/create-server-entry';`,
 		`import { resumeEntryPath } from '${RESUME_ENTRY_PATH_ID}${query}';`,
 		`import { navigationEntryPath } from '${NAVIGATION_ENTRY_PATH_ID}${query}';`,
-		`import { routeModulePreloads, routeSsrModulePreloads } from '${ROUTE_PRELOADS_ID}${query}';`,
+		`import { routeModulePreloads, routeSsrModulePreloads, routeStylesheets } from '${ROUTE_PRELOADS_ID}${query}';`,
 		`import { pageModuleLoaders, routeFileIds } from '${ROUTE_DISCOVERY_ID}${query}';`,
 		`const documentModuleLoaders = import.meta.glob(['/document.tsrx']);`,
 		`const entry = createServerEntry({`,
+		`  dev: import.meta.env.DEV,`,
 		`  resumeEntryPath,`,
 		`  navigationEntryPath,`,
 		`  routeModulePreloads,`,
 		`  routeSsrModulePreloads,`,
+		`  routeStylesheets,`,
 		`  documentModuleLoader: documentModuleLoaders['/document.tsrx'],`,
 		`  pageModuleLoaders,`,
 		`  routeFileIds,`,
@@ -1166,14 +1397,20 @@ function rootScopeQuery(root, id = "") {
 		...parseQuery(parsePath(id).search),
 		"markless-router-root": root || "."
 	});
-	return query ? `?${query}` : "";
-}
-function routePreloadsSource(state) {
+	return query ? `?${query}&lang.ts` : "";
+}
+function routePreloadsSource(state, client) {
+	const routes = client || !state.persisted ? {
+		navigation: state.routes.navigation,
+		ssr: state.routes.ssr
+	} : state.routes;
+	const routeStylesheetExport = client ? [] : [`export const routeStylesheets = ${state.persisted ? "routePreloadData.styles ?? {}" : "undefined"};`];
 	return [
 		`const routePreloadsJson = globalThis.__marklessRouterRoutePreloadsJson ?? ${JSON.stringify(ROUTE_PRELOADS_PLACEHOLDER)};`,
-		`const routePreloadData = routePreloadsJson === ${JSON.stringify(ROUTE_PRELOADS_PLACEHOLDER)} ? ${JSON.stringify(state.routes)} : JSON.parse(routePreloadsJson);`,
+		`const routePreloadData = routePreloadsJson === ${JSON.stringify(ROUTE_PRELOADS_PLACEHOLDER)} ? ${JSON.stringify(routes)} : JSON.parse(routePreloadsJson);`,
 		`export const routeModulePreloads = routePreloadData.navigation ?? {};`,
 		`export const routeSsrModulePreloads = routePreloadData.ssr ?? {};`,
+		...routeStylesheetExport,
 		`export function preloadRouteModule(file, document = globalThis.document) {`,
 		`  const hrefs = routeModulePreloads[file];`,
 		`  if (!hrefs?.length || !document?.head) return [];`,
@@ -1194,7 +1431,10 @@ function routePreloadsSource(state) {
 	].join("\n");
 }
 function patchRoutePreloadsInBundle(bundle, routes) {
-	const replacement = jsStringLiteralContent(JSON.stringify(routes));
+	const replacement = jsStringLiteralContent(JSON.stringify({
+		navigation: routes.navigation,
+		ssr: routes.ssr
+	}));
 	for (const chunk of outputChunks(bundle)) {
 		if (!chunk.code?.includes(ROUTE_PRELOADS_PLACEHOLDER)) continue;
 		chunk.code = chunk.code.replace(ROUTE_PRELOADS_PLACEHOLDER, replacement);
@@ -1211,13 +1451,17 @@ function routeModulePreloadsFromBundle(input) {
 	for (const chunk of chunks) {
 		const routeFile = routeFileForChunk(input.root, chunk);
 		if (!routeFile) continue;
-		routeChunks.set(routeFile, chunk);
+		const routeFileChunks = routeChunks.get(routeFile) ?? [];
+		routeFileChunks.push(chunk);
+		routeChunks.set(routeFile, routeFileChunks);
 		routeChunkFileNames.add(chunk.fileName);
 	}
 	const symbolChunks = symbolChunksBySourceFile(chunks);
 	const navigation = {};
 	const ssr = {};
-	for (const [routeFile, routeChunk] of routeChunks) {
+	const styles = {};
+	for (const [routeFile, routeFileChunks] of routeChunks) {
+		const routeChunk = primaryRouteChunk(input.root, routeFile, routeFileChunks);
 		const navigationFileNames = /* @__PURE__ */ new Set();
 		if (input.navigationChunk) {
 			includeChunk(navigationFileNames, chunksByFileName, input.navigationChunk.fileName);
@@ -1242,11 +1486,28 @@ function routeModulePreloadsFromBundle(input) {
 		}
 		navigation[routeFile] = [...navigationFileNames].map((fileName) => joinURL(input.base, fileName));
 		ssr[routeFile] = [...ssrFileNames].map((fileName) => joinURL(input.base, fileName));
+		styles[routeFile] = routeStylesheetsForChunk(routeChunk, chunksByFileName, input.base);
 	}
 	return {
 		navigation,
-		ssr
+		ssr,
+		styles
+	};
+}
+function routeStylesheetsForChunk(routeChunk, chunksByFileName, base) {
+	const styles = /* @__PURE__ */ new Set();
+	const visited = /* @__PURE__ */ new Set();
+	const visit = (chunk) => {
+		if (visited.has(chunk.fileName)) return;
+		visited.add(chunk.fileName);
+		for (const imported of [...chunk.imports, ...codeStaticImports(chunk)]) {
+			const dependency = chunksByFileName.get(imported);
+			if (dependency) visit(dependency);
+		}
+		for (const stylesheet of chunk.viteMetadata?.importedCss ?? []) styles.add(joinURL(base, stylesheet));
 	};
+	visit(routeChunk);
+	return [...styles];
 }
 function symbolChunksBySourceFile(chunks) {
 	const bySourceFile = /* @__PURE__ */ new Map();
@@ -1334,6 +1595,28 @@ function routeFileForChunk(root, chunk) {
 		if (routeFile) return routeFile;
 	}
 }
+function primaryRouteChunk(root, routeFile, chunks) {
+	let selected = chunks[0];
+	let selectedRank = routeChunkRank(root, routeFile, selected);
+	for (const chunk of chunks.slice(1)) {
+		const rank = routeChunkRank(root, routeFile, chunk);
+		if (rank <= selectedRank) continue;
+		selected = chunk;
+		selectedRank = rank;
+	}
+	return selected;
+}
+function routeChunkRank(root, routeFile, chunk) {
+	let rank = 0;
+	for (const moduleId of [chunk.facadeModuleId, ...chunk.moduleIds ?? []]) {
+		if (routeFileForModuleId(root, moduleId) !== routeFile) continue;
+		const search = parsePath(moduleId).search;
+		if (/(?:^|[?&])markless-symbols(?:[=&]|$)/.test(search)) rank = Math.max(rank, 1);
+		else if (/(?:^|[?&])markless-resume(?:[=&]|$)/.test(search)) rank = Math.max(rank, 2);
+		else return 3;
+	}
+	return rank;
+}
 function routeFileForModuleId(root, moduleId) {
 	if (!moduleId || moduleId.startsWith("\0")) return void 0;
 	const pathname = decodePath(parseURL(moduleId).pathname);