@markless/router 0.4.0 → 0.6.0

package/dist/vite.js

@@ -1,16 +1,20 @@
-import { t as buildRouteManifestFromFileIds } from "./route-manifest-DPgGIyrS.js";
-import { r as transformRequestFileSource } from "./request-files-C-0LLSsx.js";
-import { __marklessRouteHref } from "./vite/route-href.js";
+import { c as PREFETCH_ATTRIBUTE, l as REPLACE_ATTRIBUTE, s as LINK_ATTRIBUTE, u as SCROLL_ATTRIBUTE } from "./request-locals-z3rJTizs.js";
+import { l as transformRequestFileSource, n as buildRouteManifestFromFileIds, o as normalizeRouteFileId, r as isPageModuleFile, t as assertNoEndpointConflicts } from "./route-manifest-DMizh42B.js";
+import { t as __marklessRouteHref } from "./route-href-CGooO_g6.js";
+import { r as protocolIslandSegment } from "./protocol-constants-B4WxrZAS.js";
+import { a as runFragmentNavigation, i as FRAGMENT_PATH_PREFIX, n as routerLinkBridgeModules, o as startFragmentNavigation, s as listenForLinkIntent } from "./create-server-entry-DaYssO9x.js";
 import { dirname, extname, isAbsolute, join, normalize, relative, resolve } from "pathe";
 import { decodePath, joinURL, parsePath, parseQuery, parseURL, stringifyQuery, withLeadingSlash, withQuery, 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 "yuku-tsrx";
 import { mkdir, readFile, rename, rm, stat, writeFile } from "node:fs/promises";
+import { nitro } from "nitro/vite";
+import { minifySync, sortUserPlugins } from "vite";
+import { isClientPrimarySourceRequest, isExecutionLogChunk, isMarklessNavigationPack, isRenderDataSourceRequest, isResumeSourceRequest, isRouteNavigationSourceRequest, isSymbolOnlySourceRequest, lazyStartupPackName, marklessDeferredChunkFileNames, optimizedDepsToInclude, plannedLandingFiles, resolverVirtualModuleSourceFile, startupPackOfLazy, symbolVirtualModuleSourceFile, warmEvaluatedImports } from "@markless/bundler/preload";
+import { MARKLESS_BUILD_PREFIX, MARKLESS_CHUNK_SPECIFIER_PREFIX, MARKLESS_IMPORT_MAP_ASSET, MARKLESS_PUBLIC_BUILD_METADATA_FILES, importMapScript, marklessBuildManifestDir } from "@markless/bundler/rolldown";
+import { parseModule } from "@tsrx/yuku";
 import { toHtml } from "hast-util-to-html";
 import { HastReader, createMdxHastHandle, defineHastPlugin, dropHandle, materializeHastTree, resolveHastSubscriptions, serializeHandle, visitHastHandle } from "satteri";
+import "@markless/web/render-to-string";
 //#region src/route-types.ts
 const routeTypesEnvPath = "markless-router-env.d.ts";
 const routeTypesOutputPath = ".output/markless/router/types/routes.d.ts";
@@ -96,7 +100,7 @@ function createLinkTypes() {
 		"};",
 		"",
 		"export type MarklessRouterNavigationProps = {",
-		"	readonly prefetch?: boolean | \"intent\" | \"viewport\";",
+		"	readonly prefetch?: boolean;",
 		"	readonly replace?: boolean;",
 		"	readonly scroll?: boolean;",
 		"};",
@@ -113,7 +117,8 @@ function createLinkTypes() {
 }
 //#endregion
 //#region src/vite/route-typegen.ts
-const PAGE_EXTENSIONS = new Set([".tsrx", ".mdx"]);
+const PAGE_EXTENSIONS = /* @__PURE__ */ new Set([".tsrx", ".mdx"]);
+const ENDPOINT_EXTENSIONS = /* @__PURE__ */ new Set([".ts"]);
 function routeTypegenPlugin() {
 	let root = "";
 	return {
@@ -130,27 +135,27 @@ function routeTypegenPlugin() {
 	};
 }
 async function writeRouteTypes(fs, root) {
-	const manifest = buildRouteManifestFromFileIds(await discoverPageFiles(fs, root));
+	const pageFiles = await discoverPageFiles(fs, root);
+	const manifest = buildRouteManifestFromFileIds(pageFiles);
+	assertNoEndpointConflicts(manifest, await discoverFiles(fs, root, "api", ENDPOINT_EXTENSIONS));
 	await writeIfChanged(fs, join(root, routeTypesEnvPath), routeTypesEnvDeclaration);
 	await writeIfChanged(fs, join(root, routeTypesOutputPath), createRouteTypesDeclaration(manifest));
 }
-async function discoverPageFiles(fs, root) {
-	const pagesDir = join(root, "pages");
+function discoverPageFiles(fs, root) {
+	return discoverFiles(fs, root, "pages", PAGE_EXTENSIONS);
+}
+async function discoverFiles(fs, root, dir, extensions) {
 	const files = [];
-	await collectPageFiles(fs, root, pagesDir, files);
+	await collectFiles(fs, root, join(root, dir), extensions, files);
 	return files.toSorted((left, right) => left.localeCompare(right));
 }
-async function collectPageFiles(fs, root, dir, files) {
+async function collectFiles(fs, root, dir, extensions, files) {
 	const entries = await readdirIfExists(fs, dir);
-	await Promise.all(entries.map((entry) => collectPageFile(fs, root, dir, files, entry)));
-}
-async function collectPageFile(fs, root, dir, files, entry) {
-	const path = join(dir, entry.name);
-	if (entry.isDirectory()) {
-		await collectPageFiles(fs, root, path, files);
-		return;
-	}
-	if (entry.isFile() && PAGE_EXTENSIONS.has(extname(path))) files.push(withLeadingSlash(relative(root, path)));
+	await Promise.all(entries.map(async (entry) => {
+		const path = join(dir, entry.name);
+		if (entry.isDirectory()) await collectFiles(fs, root, path, extensions, files);
+		else if (entry.isFile() && extensions.has(extname(path))) files.push(withLeadingSlash(relative(root, path)));
+	}));
 }
 async function readdirIfExists(fs, dir) {
 	try {
@@ -180,14 +185,20 @@ function isNotFoundError(error) {
 //#region src/vite/anchor-transform.ts
 const ROUTE_HREF_HELPER_ID = "virtual:markless-router/route-href";
 const JSX_FILE_FILTER = /\.(?:[jt]sx|tsrx)(?:$|\?)/;
-const ROUTER_IMPORT_SOURCES = new Set(["@markless/router", "@markless/core/router"]);
+const REWRITE_CACHE_LIMIT = 2048;
+const ROUTER_IMPORT_SOURCES = /* @__PURE__ */ new Set(["@markless/router", "@markless/core/router"]);
 function anchorTransformPlugin() {
 	let root = "";
 	let routePatterns = /* @__PURE__ */ new Map();
 	let routesLoaded = false;
+	let routeFingerprint = "";
+	const rewrites = /* @__PURE__ */ new Map();
 	const refreshRoutes = async (fs) => {
 		routePatterns = routePatternMap(buildRouteManifestFromFileIds(await discoverPageFiles(fs, root)));
 		routesLoaded = true;
+		const fingerprint = JSON.stringify([...routePatterns]);
+		if (fingerprint !== routeFingerprint) rewrites.clear();
+		routeFingerprint = fingerprint;
 	};
 	return {
 		name: "markless-router:anchors",
@@ -197,7 +208,18 @@ function anchorTransformPlugin() {
 			async handler(code, id) {
 				if (!isTransformCandidateCode(code)) return;
 				if (!routesLoaded) await refreshRoutes(this.fs);
-				const transformed = transformAnchorSource(code, parseTransformAst(code, id, (source, options) => this.parse(source, options)), routePatterns);
+				const key = `${id.includes(".tsrx") ? "tsrx" : id.includes(".jsx") ? "jsx" : "tsx"}\0${code}`;
+				let transformed = rewrites.get(key);
+				if (transformed === void 0) {
+					const ast = parseTransformAst(code, id, (source, options) => this.parse(source, options));
+					transformed = transformAnchorSource(code, ast, routePatterns);
+					if (id.includes(".tsrx")) {
+						const linkedAst = transformed === code ? ast : parseTransformAst(transformed, id, (source, options) => this.parse(source, options));
+						transformed = lowerRouterLinks(transformed, linkedAst);
+					}
+					if (rewrites.size >= REWRITE_CACHE_LIMIT) rewrites.delete(rewrites.keys().next().value);
+					rewrites.set(key, transformed);
+				}
 				return transformed === code ? void 0 : {
 					code: transformed,
 					map: null
@@ -215,6 +237,68 @@ function anchorTransformPlugin() {
 		}
 	};
 }
+function lowerRouterLinks(code, ast) {
+	const linkNames = marklessRouterLinkImportNames(ast);
+	const edits = [];
+	walk(ast, (current) => {
+		if (current.type !== "JSXElement") return;
+		const opening = node$2(current.openingElement);
+		const name = opening && node$2(opening.name);
+		if (!name || !linkNames.has(jsxName$1(name) ?? "")) return;
+		const attributes = nodes$2(opening?.attributes);
+		if (attributes.some((attribute) => attribute.type === "JSXSpreadAttribute")) return;
+		if (findJsxAttribute(attributes, "children")) return;
+		const href = findJsxAttribute(attributes, "href") ? "" : " href=\"#\"";
+		edits.push({
+			...rangeOf(name),
+			text: `a ${LINK_ATTRIBUTE}${href}`
+		});
+		const closingName = node$2(node$2(current.closingElement)?.name);
+		if (closingName) edits.push({
+			...rangeOf(closingName),
+			text: "a"
+		});
+		for (const attribute of attributes) {
+			const attributeName = jsxName$1(node$2(attribute.name));
+			if (attributeName === "params" || attributeName === "prefetch" && !attribute.value) edits.push({
+				...attributeRemovalRange(code, attribute),
+				text: ""
+			});
+			else if (attributeName === "prefetch") {
+				const value = node$2(attribute.value);
+				const literal = jsxExpression(value) ?? value;
+				if ([
+					"Literal",
+					"StringLiteral",
+					"BooleanLiteral"
+				].includes(literal.type ?? "")) {
+					const choice = literal.value;
+					edits.push(choice === false ? {
+						...rangeOf(attribute),
+						text: `${PREFETCH_ATTRIBUTE}="none"`
+					} : {
+						...attributeRemovalRange(code, attribute),
+						text: ""
+					});
+					continue;
+				}
+				const expression = `(${slice$1(code, jsxExpression(value) ?? value)})`;
+				edits.push({
+					...rangeOf(attribute),
+					text: `${PREFETCH_ATTRIBUTE}={${expression} === false ? 'none' : undefined}`
+				});
+			} else if (attributeName === "replace" || attributeName === "scroll") {
+				const value = node$2(attribute.value);
+				const expression = value ? slice$1(code, jsxExpression(value) ?? value) : "true";
+				edits.push({
+					...rangeOf(attribute),
+					text: attributeName === "replace" ? `${REPLACE_ATTRIBUTE}={(${expression}) ? '' : undefined}` : `${SCROLL_ATTRIBUTE}={(${expression}) === false ? 'manual' : undefined}`
+				});
+			}
+		}
+	});
+	return applyEdits(code, edits);
+}
 function parseTransformAst(code, id, parse) {
 	if (id.includes(".tsrx")) return parseModule(code, id);
 	return parse(code, {
@@ -227,24 +311,24 @@ function isTransformCandidateCode(code) {
 	return code.includes("<a") || [...ROUTER_IMPORT_SOURCES].some((importSource) => code.includes(importSource));
 }
 function transformAnchorSource(code, astInput, routePatterns) {
-	const ast = node$1(astInput);
+	const ast = node$2(astInput);
 	if (!ast) return code;
 	const edits = [];
 	let needsHrefHelper = false;
 	const linkNames = marklessRouterLinkImportNames(ast);
 	walk(ast, (current) => {
 		if (current.type !== "JSXOpeningElement") return;
-		const name = jsxName$1(node$1(current.name));
+		const name = jsxName$1(node$2(current.name));
 		if (name !== "a" && (!name || !linkNames.has(name))) return;
-		const attributes = nodes$1(current.attributes);
+		const attributes = nodes$2(current.attributes);
 		const href = findJsxAttribute(attributes, "href");
-		const hrefValue = href ? stringLiteralValue(node$1(href.value)) : void 0;
+		const hrefValue = href ? stringLiteralValue(node$2(href.value)) : void 0;
 		if (!href || !hrefValue || !isRoutePatternHref(hrefValue)) return;
 		const routeParams = routePatterns.get(hrefValue);
 		if (!routeParams) fail$1(`Typed route error: ${hrefValue} does not match any route in pages/.`);
 		const params = findJsxAttribute(attributes, "params");
 		if (!params) fail$1(missingParamsMessage(hrefValue, routeParams));
-		const paramsExpression = jsxExpression(node$1(params.value));
+		const paramsExpression = jsxExpression(node$2(params.value));
 		if (!paramsExpression) fail$1(missingParamsMessage(hrefValue, routeParams));
 		validateObjectLiteralParams(hrefValue, routeParams, paramsExpression);
 		const staticParams = staticObjectValue(paramsExpression);
@@ -270,11 +354,11 @@ function transformAnchorSource(code, astInput, routePatterns) {
 function staticObjectValue(expression) {
 	if (expression.type !== "ObjectExpression") return void 0;
 	const value = {};
-	for (const property of nodes$1(expression.properties)) {
+	for (const property of nodes$2(expression.properties)) {
 		if (property.type !== "Property" || property.computed === true) return void 0;
-		const key = node$1(property.key);
+		const key = node$2(property.key);
 		const name = key?.type === "Identifier" ? string$1(key.name) : literalString(key);
-		const propertyValue = staticExpressionValue(node$1(property.value));
+		const propertyValue = staticExpressionValue(node$2(property.value));
 		if (!name || !propertyValue.known) return void 0;
 		value[name] = propertyValue.value;
 	}
@@ -288,7 +372,7 @@ function staticExpressionValue(expression) {
 	};
 	if (expression.type === "ArrayExpression") {
 		const values = [];
-		for (const element of nodes$1(expression.elements)) {
+		for (const element of nodes$2(expression.elements)) {
 			const value = staticExpressionValue(element);
 			if (!value.known) return { known: false };
 			values.push(value.value);
@@ -303,9 +387,9 @@ function staticExpressionValue(expression) {
 function marklessRouterLinkImportNames(ast) {
 	const names = /* @__PURE__ */ new Set();
 	walk(ast, (current) => {
-		if (current.type !== "ImportDeclaration" || !ROUTER_IMPORT_SOURCES.has(literalString(node$1(current.source)) ?? "")) return;
-		for (const specifier of nodes$1(current.specifiers)) if (specifier.type === "ImportSpecifier" && identifierName(node$1(specifier.imported)) === "Link") {
-			const localName = identifierName(node$1(specifier.local));
+		if (current.type !== "ImportDeclaration" || !ROUTER_IMPORT_SOURCES.has(literalString(node$2(current.source)) ?? "")) return;
+		for (const specifier of nodes$2(current.specifiers)) if (specifier.type === "ImportSpecifier" && identifierName(node$2(specifier.imported)) === "Link") {
+			const localName = identifierName(node$2(specifier.local));
 			if (localName) names.add(localName);
 		}
 	});
@@ -324,9 +408,9 @@ function validateObjectLiteralParams(pattern, routeParams, paramsExpression) {
 	if (missing.length > 0) fail$1(`Typed route error: ${pattern} requires params:\n${list(missing)}`);
 }
 function objectLiteralKeys(expression) {
-	return nodes$1(expression.properties).flatMap((property) => {
+	return nodes$2(expression.properties).flatMap((property) => {
 		if (property.type !== "Property") return [];
-		const key = node$1(property.key);
+		const key = node$2(property.key);
 		const name = key?.type === "Identifier" ? string$1(key.name) : literalString(key);
 		return name ? [name] : [];
 	});
@@ -341,7 +425,7 @@ function list(items) {
 	return items.map((item) => `- ${item}`).join("\n");
 }
 function findJsxAttribute(attributes, name) {
-	return attributes.find((attr) => attr.type === "JSXAttribute" && jsxName$1(node$1(attr.name)) === name);
+	return attributes.find((attr) => attr.type === "JSXAttribute" && jsxName$1(node$2(attr.name)) === name);
 }
 function stringLiteralValue(value) {
 	return value?.type === "Literal" ? string$1(value.value) : void 0;
@@ -354,7 +438,7 @@ function identifierName(value) {
 }
 function jsxExpression(value) {
 	if (value?.type !== "JSXExpressionContainer") return;
-	const expression = node$1(value.expression);
+	const expression = node$2(value.expression);
 	return expression?.type === "JSXEmptyExpression" ? void 0 : expression;
 }
 function isRoutePatternHref(href) {
@@ -377,7 +461,7 @@ function applyEdits(code, edits) {
 function walk(root, visit) {
 	const stack = [root];
 	while (stack.length > 0) {
-		const current = node$1(stack.pop());
+		const current = node$2(stack.pop());
 		if (!current) continue;
 		visit(current);
 		for (const child of Object.values(current)) if (Array.isArray(child)) stack.push(...child);
@@ -402,10 +486,10 @@ function rangeOf(value) {
 		end: value.end
 	};
 }
-function nodes$1(value) {
-	return Array.isArray(value) ? value.filter((item) => !!node$1(item)) : [];
+function nodes$2(value) {
+	return Array.isArray(value) ? value.filter((item) => !!node$2(item)) : [];
 }
-function node$1(value) {
+function node$2(value) {
 	return typeof value === "object" && value !== null ? value : void 0;
 }
 function string$1(value) {
@@ -416,7 +500,7 @@ function fail$1(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 = "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;
@@ -427,7 +511,9 @@ function createClientAssetsManifest(input) {
 		entries: {
 			resume: input.resumeEntry,
 			...input.prerenderWakeEntry ? { prerenderWake: input.prerenderWakeEntry } : {},
-			navigation: input.navigationEntry
+			navigation: input.navigationEntry,
+			...input.fragmentEntry ? { fragment: input.fragmentEntry } : {},
+			...input.fragmentImports?.length ? { fragmentImports: input.fragmentImports } : {}
 		},
 		routes: {
 			navigation: sortRouteMap(input.routes.navigation),
@@ -436,6 +522,16 @@ function createClientAssetsManifest(input) {
 		}
 	};
 }
+function renameClientAssetChunks(manifest, renames) {
+	const urls = new Map([...renames].map(([previous, next]) => [joinURL(manifest.base, previous), joinURL(manifest.base, next)]));
+	return renameUrls(manifest, (url) => urls.get(url) ?? url);
+}
+function renameUrls(value, rename) {
+	if (typeof value === "string") return rename(value);
+	if (Array.isArray(value)) return value.map((item) => renameUrls(item, rename));
+	if (value && typeof value === "object") return Object.fromEntries(Object.entries(value).map(([key, item]) => [key, key === "base" ? item : renameUrls(item, rename)]));
+	return value;
+}
 async function removeClientAssetsManifest(clientOutDir) {
 	const path = clientAssetsManifestPath(clientOutDir);
 	await Promise.all([rm(path, { force: true }), rm(clientAssetsManifestTemporaryPath(clientOutDir), { force: true })]);
@@ -489,8 +585,9 @@ function clientAssetFileName(href, base) {
 	if (href !== joinURL(base, fileName)) throw clientAssetsManifestError(`contains a non-canonical asset URL ${JSON.stringify(href)} for base ${JSON.stringify(base)}`);
 	return fileName;
 }
+/** Where the client build leaves this manifest for the server build: outside the served client output. */
 function clientAssetsManifestPath(clientOutDir) {
-	return join(clientOutDir, MARKLESS_ROUTER_CLIENT_ASSETS_MANIFEST);
+	return join(marklessBuildManifestDir(clientOutDir), MARKLESS_ROUTER_CLIENT_ASSETS_MANIFEST);
 }
 function clientAssetsManifestTemporaryPath(clientOutDir) {
 	return `${clientAssetsManifestPath(clientOutDir)}.tmp`;
@@ -504,7 +601,9 @@ async function validateClientAssetsManifest(input, base, clientOutDir) {
 	const entries = {
 		resume: requiredString(input.entries.resume, "entries.resume"),
 		...input.entries.prerenderWake !== void 0 ? { prerenderWake: requiredString(input.entries.prerenderWake, "entries.prerenderWake") } : {},
-		navigation: requiredString(input.entries.navigation, "entries.navigation")
+		navigation: requiredString(input.entries.navigation, "entries.navigation"),
+		...input.entries.fragment !== void 0 ? { fragment: requiredString(input.entries.fragment, "entries.fragment") } : {},
+		...input.entries.fragmentImports !== void 0 ? { fragmentImports: requiredStrings(input.entries.fragmentImports, "entries.fragmentImports") } : {}
 	};
 	const routes = {
 		navigation: routeMap(input.routes.navigation, "routes.navigation"),
@@ -512,16 +611,21 @@ async function validateClientAssetsManifest(input, base, clientOutDir) {
 		styles: routeMap(input.routes.styles, "routes.styles")
 	};
 	assertMatchingRouteKeys(routes);
-	const hrefs = new Set([
+	const importMap = input.importMap === void 0 ? void 0 : importMapImports(input.importMap);
+	const hrefs = /* @__PURE__ */ new Set([
 		entries.resume,
 		...entries.prerenderWake !== void 0 ? [entries.prerenderWake] : [],
 		entries.navigation,
+		...entries.fragment !== void 0 ? [entries.fragment] : [],
+		...entries.fragmentImports ?? [],
 		...Object.values(routes.navigation).flat(),
 		...Object.values(routes.ssr).flat(),
-		...Object.values(routes.styles).flat()
+		...Object.values(routes.styles).flat(),
+		...Object.values(importMap?.imports ?? {})
 	]);
 	for (const href of hrefs) {
-		const assetPath = join(clientOutDir, clientAssetFileName(href, base));
+		const fileName = clientAssetFileName(href, base);
+		const assetPath = join(clientOutDir, fileName);
 		const relativeAssetPath = relative(clientOutDir, assetPath);
 		if (relativeAssetPath === ".." || relativeAssetPath.startsWith("../") || isAbsolute(relativeAssetPath)) throw clientAssetsManifestError(`contains an unsafe asset path ${JSON.stringify(href)}`);
 		try {
@@ -534,9 +638,14 @@ async function validateClientAssetsManifest(input, base, clientOutDir) {
 		version: MARKLESS_ROUTER_CLIENT_ASSETS_MANIFEST_VERSION,
 		base,
 		entries,
-		routes
+		routes,
+		...importMap ? { importMap } : {}
 	};
 }
+function requiredStrings(input, label) {
+	if (!Array.isArray(input)) throw clientAssetsManifestError(`has invalid ${label}`);
+	return input.map((item, index) => requiredString(item, `${label}[${index}]`));
+}
 function routeMap(input, label) {
 	if (!isRecord$1(input)) throw clientAssetsManifestError(`has invalid ${label}`);
 	const routes = {};
@@ -580,10 +689,15 @@ function isRecord$1(input) {
 function clientAssetsManifestError(message, cause) {
 	return new Error(`Markless Router client-assets manifest ${message}.`, { cause });
 }
+function importMapImports(input) {
+	const imports = isRecord$1(input) ? input.imports : void 0;
+	if (!isRecord$1(imports) || !Object.values(imports).every((href) => typeof href === "string")) throw clientAssetsManifestError("has an invalid import map");
+	return { imports };
+}
 //#endregion
 //#region src/vite/html-transform.ts
 const HELPER = "__marklessRouterHtmlAttributes";
-const SAFE_GLOBALS = new Set([
+const SAFE_GLOBALS = /* @__PURE__ */ new Set([
 	"String",
 	"Number",
 	"Boolean",
@@ -609,41 +723,42 @@ function htmlTransformPlugin() {
 	};
 }
 function transformHtmlSource(code, astInput) {
-	const ast = node(astInput);
+	const ast = node$1(astInput);
 	if (!ast) fail(`MarklessRouter could not read ${DOCUMENT_FILE_LABEL}. Check it for syntax errors.`);
 	const fn = findDefaultDocumentFunction(ast);
 	if (fn?.type !== "ArrowFunctionExpression" && fn?.type !== "FunctionExpression") fail(`MarklessRouter needs to see your document body in ${DOCUMENT_FILE_LABEL}. Write \`export default (props) => <Html>...</Html>\` instead of passing a named function.`);
-	const props = first(nodes(fn.params));
+	const props = first(nodes$1(fn.params));
 	const propsName = props?.type === "Identifier" ? string(props.name) : void 0;
 	const propsSource = props ? slice(code, props) : "";
-	const attrs = nodes(node(findReturnedHtml(fn).openingElement)?.attributes).map((attr) => htmlAttr(code, attr, propsName));
-	const helper = `export function ${HELPER}(${propsSource}) {\n  return ${attrs.length ? `{\n${attrs.map(([name, value]) => `    ${JSON.stringify(name)}: ${value}`).join(",\n")}\n  }` : "{}"};\n}\n`;
+	const attrs = nodes$1(node$1(findReturnedHtml(fn).openingElement)?.attributes).map((attr) => htmlAttr(code, attr, propsName));
+	const body = attrs.length ? `{\n${attrs.map(([name, value]) => `    ${JSON.stringify(name)}: ${value}`).join(",\n")}\n  }` : "{}";
+	const helper = `export function ${HELPER}(${propsSource}) {\n  return ${body};\n}\n`;
 	return code.endsWith("\n") ? `${code}\n${helper}` : `${code}\n\n${helper}`;
 }
 function findDefaultDocumentFunction(ast) {
-	for (const statement of nodes(ast.body)) {
-		const declaration = node(statement.declaration);
+	for (const statement of nodes$1(ast.body)) {
+		const declaration = node$1(statement.declaration);
 		if (statement.type !== "ExportDefaultDeclaration") continue;
 		if (declaration?.type === "ArrowFunctionExpression" || declaration?.type === "FunctionExpression") return declaration;
 	}
 	fail(`MarklessRouter could not find the document function. ${DOCUMENT_FILE_LABEL} must default export \`() => <Html>...</Html>\`.`);
 }
 function findReturnedHtml(fn) {
-	const body = unwrap(node(fn.body));
-	const returned = body?.type === "BlockStatement" ? unwrap(node(nodes(body.body).find((item) => item.type === "ReturnStatement")?.argument)) : body;
+	const body = unwrap(node$1(fn.body));
+	const returned = body?.type === "BlockStatement" ? unwrap(node$1(nodes$1(body.body).find((item) => item.type === "ReturnStatement")?.argument)) : body;
 	if (returned?.type !== "JSXElement") fail(`MarklessRouter expected ${DOCUMENT_FILE_LABEL} to return <Html> at the top level. Wrap your document shell in \`<Html>...</Html>\`.`);
-	if (jsxName(node(node(returned.openingElement)?.name)) !== "Html") fail(`MarklessRouter expected ${DOCUMENT_FILE_LABEL} to return <Html> at the top level. Put <head> and <body> inside \`<Html>...</Html>\`.`);
+	if (jsxName(node$1(node$1(returned.openingElement)?.name)) !== "Html") fail(`MarklessRouter expected ${DOCUMENT_FILE_LABEL} to return <Html> at the top level. Put <head> and <body> inside \`<Html>...</Html>\`.`);
 	return returned;
 }
 function htmlAttr(code, attr, propsName) {
 	if (attr.type === "JSXSpreadAttribute") fail("MarklessRouter does not support spreading props onto <Html> yet. Write each html attribute directly, like `<Html lang=\"en\">`.");
-	const name = jsxName(node(attr.name));
+	const name = jsxName(node$1(attr.name));
 	if (!name) fail("MarklessRouter found an unsupported <Html> attribute name. Use plain html attributes like `lang`, `class`, or `data-theme`.");
-	const value = node(attr.value);
+	const value = node$1(attr.value);
 	if (!value) return [name, "true"];
 	if (value.type === "Literal") return [name, JSON.stringify(value.value)];
 	if (value.type !== "JSXExpressionContainer") fail(`MarklessRouter could not understand the <Html> "${name}" attribute. Use a string or JSX expression, like \`${name}="value"\` or \`${name}={props.url.pathname}\`.`);
-	const expression = unwrap(node(value.expression));
+	const expression = unwrap(node$1(value.expression));
 	if (!expression || expression.type === "JSXEmptyExpression") fail(`MarklessRouter found an empty <Html> "${name}" attribute expression. Add a value or remove the attribute.`);
 	const ref = unsupportedIdentifier(expression, propsName);
 	if (ref) fail(`MarklessRouter cannot use "${ref}" in <Html ${name}={...}> because html attributes are read before Markless renders ${DOCUMENT_FILE_LABEL}. Use props directly, like \`${name}={props.url.pathname}\`, or a literal value.`);
@@ -652,7 +767,7 @@ function htmlAttr(code, attr, propsName) {
 function unsupportedIdentifier(root, propsName) {
 	const stack = [root];
 	while (stack.length > 0) {
-		const current = node(stack.pop());
+		const current = node$1(stack.pop());
 		if (!current) continue;
 		if (current.type === "Identifier") {
 			const name = string(current.name);
@@ -678,7 +793,7 @@ function jsxName(name) {
 }
 function unwrap(value) {
 	let current = value;
-	while (current?.type === "ParenthesizedExpression" || current?.type === "TSAsExpression" || current?.type === "TSNonNullExpression") current = node(current.expression);
+	while (current?.type === "ParenthesizedExpression" || current?.type === "TSAsExpression" || current?.type === "TSNonNullExpression") current = node$1(current.expression);
 	return current;
 }
 function slice(code, value) {
@@ -686,10 +801,10 @@ function slice(code, value) {
 	if (range) return code.slice(range[0], range[1]);
 	return code.slice(value.start, value.end);
 }
-function nodes(value) {
-	return Array.isArray(value) ? value.filter((item) => !!node(item)) : [];
+function nodes$1(value) {
+	return Array.isArray(value) ? value.filter((item) => !!node$1(item)) : [];
 }
-function node(value) {
+function node$1(value) {
 	return typeof value === "object" && value !== null ? value : void 0;
 }
 function first(items) {
@@ -702,11 +817,72 @@ function fail(message) {
 	throw new Error(message);
 }
 //#endregion
+//#region ../bundler/src/scalar-plan-source.ts
+const MARKLESS_SCALAR_PLAN_SOURCE_QUERY = "markless-scalar-plans";
+function scalarPlanSourceReference(source) {
+	return withQuery(source, {
+		"markless-symbols": null,
+		[MARKLESS_SCALAR_PLAN_SOURCE_QUERY]: null
+	});
+}
+/**
+* The same one line for the live roster, gated on the same fact the reconcile
+* plane is gated on: a payload with no computed nodes can hold no roster
+* derivation, so it never names the module and never emits its chunk.
+*
+* Both call sites (the start-up wiring and a sync computed's re-derive) sit in
+* modules every resumed page runs, which is why neither may write the specifier.
+* A composed MDX route writes it too: it cannot see its islands' computeds.
+*/
+function emitRosterResumeLoaderInstall() {
+	return "globalThis.__marklessRosterResume ??= () => import('@markless/web/fns/roster-resume');";
+}
+function emitQueuedResumeContainerEvent(source, { censusRepair = true } = {}) {
+	const implementation = source.replace("export async function resumeContainerEvent", "async function marklessResumeContainerEvent");
+	if (implementation === source) throw new Error("MARKLESS_RESUME_DISPATCH_EXPORT_MISSING");
+	return [
+		implementation,
+		"export function resumeContainerEvent(input) {",
+		"	const root = input.root;",
+		censusRepair ? "	if (root.__marklessShifted) return import('@markless/web/fns/served-census-repair').then((census) => (census.marklessRepairCensus(root), resumeContainerEvent(input)));" : "",
+		"	if (!root.__marklessDispatch) {",
+		"		let handler = marklessResumeContainerEvent, tail = Promise.resolve(), done = tail, lastEvent = null, lastEventTime = undefined, seen = new WeakMap();",
+		"		root.__marklessRegisterDispatch = next => {",
+		"			const fallback = handler;",
+		"			handler = input => next(input, fallback);",
+		"		};",
+		"		root.__marklessDispatch = next => {",
+		"			const event = next.event, eventTime = event?.timeStamp;",
+		"			if (event && next.eventRecord && next.element) event.__marklessPressHost ??= next.element;",
+		"			if ((event === lastEvent && eventTime === lastEventTime) || (seen.has(event) && seen.get(event) === eventTime)) return done;",
+		"			if (Object(event) === event) seen.set(event, eventTime);",
+		"			lastEvent = event;",
+		"			lastEventTime = eventTime;",
+		"			let release;",
+		"			const started = new Promise(resolve => release = resolve);",
+		"			const run = () => (root.__marklessReleaseDispatch = release, handler(next));",
+		"			done = tail.then(run, run);",
+		"			done.then(release, release);",
+		"			tail = started;",
+		"			return done;",
+		"		};",
+		"	}",
+		"	return root.__marklessDispatch(input);",
+		"}"
+	].join("\n");
+}
+//#endregion
 //#region src/vite/mdx.ts
+const MDX_ROUTE_RUNTIME_SPECIFIER = "@markless/router/vite/runtime/mdx-route";
 function mdxTransformPlugin() {
 	return {
 		name: "markless-router:mdx",
 		enforce: "pre",
+		config(config, env) {
+			if (env.command !== "serve") return void 0;
+			const include = optimizedDepsToInclude([MDX_ROUTE_RUNTIME_SPECIFIER], config);
+			return include.length > 0 ? { optimizeDeps: { include } } : void 0;
+		},
 		transform: {
 			order: "pre",
 			async handler(code, id) {
@@ -723,7 +899,7 @@ async function transformMdxRoute(source, id) {
 	const route = parseMdxRoute(source, id);
 	const html = route.parts.map((part) => part.kind === "html" ? part.html : "").join("");
 	if (route.components.length === 0) return [
-		`import { createMdxRenderDataSurface } from '@markless/router/vite/runtime/mdx-route';`,
+		`import { createMdxRenderDataSurface } from '${MDX_ROUTE_RUNTIME_SPECIFIER}';`,
 		`const marklessMdxParts = ${JSON.stringify(route.parts)};`,
 		"const marklessMdxRenderData = createMdxRenderDataSurface(marklessMdxParts, []);",
 		"const marklessMdxPage = {",
@@ -736,24 +912,52 @@ async function transformMdxRoute(source, id) {
 		"export default marklessMdxPage;",
 		""
 	].join("\n");
+	const query = new URLSearchParams(parsePath(id).search);
+	if (query.has("markless-route") || query.has("markless-resume")) return emitMdxClientRoute(route, id, query.has("markless-resume"));
 	return emitComposedMdxRoute(route, id);
 }
+function emitMdxClientRoute(route, id, resume) {
+	return [
+		`import { createMdxRenderDataSurface, loadMdxSymbol${resume ? ", tryResumeMdxScalar" : ""} } from '${MDX_ROUTE_RUNTIME_SPECIFIER}';`,
+		`const marklessMdxSymbolLoaders = ${renderSymbolLoaders(route.components)};`,
+		`const marklessMdxRenderData = ${renderMdxRenderDataLoader(route.components, id, route.parts)};`,
+		renderOverlayLoader(),
+		emitRosterResumeLoaderInstall(),
+		"const marklessMdxPage = {",
+		"  renderData: marklessMdxRenderData,",
+		"  loadSymbol: marklessMdxLoadSymbol,",
+		"};",
+		"export default marklessMdxPage;",
+		...resume ? renderMdxResumeHandler() : [],
+		"function marklessMdxLoadSymbol(symbolId, children = []) {",
+		"  return loadMdxSymbol(symbolId, children, marklessMdxSymbolLoaders);",
+		"}",
+		""
+	].join("\n");
+}
+function renderOverlayLoader() {
+	return "globalThis.__marklessOverlay ??= (root) => root.querySelector('[overlay]') ? import('@markless/web/fns/overlay').then((m) => m.installOverlayBehavior(root)) : undefined;";
+}
 function emitComposedMdxRoute(route, id) {
 	return [
-		`import { resumeFromPayloadDocument } from '@markless/core/web/resume';`,
-		`import { composeMdxState, composeMdxView, createMdxRenderDataSurface, loadMdxSymbol, renderMdxChild } from '@markless/router/vite/runtime/mdx-route';`,
+		`import { composeMdxState, composeMdxView, createMdxRenderDataSurface, loadMdxSymbol, renderMdxChild, tryResumeMdxScalar } from '${MDX_ROUTE_RUNTIME_SPECIFIER}';`,
 		...route.imports,
 		"",
 		`const marklessMdxParts = ${JSON.stringify(route.parts)};`,
 		`const marklessMdxSymbolLoaders = ${renderSymbolLoaders(route.components)};`,
 		`const marklessMdxRenderData = ${renderMdxRenderDataLoader(route.components, id)};`,
 		`const marklessMdxStorageSeeds = ${renderStorageSeeds(route.components)};`,
+		`const marklessMdxHeadInjections = ${renderHeadInjections(route.components)};`,
+		"",
+		renderOverlayLoader(),
+		emitRosterResumeLoaderInstall(),
 		"",
 		"const marklessMdxPage = {",
 		"  renderData: marklessMdxRenderData,",
 		"  storageSeeds: marklessMdxStorageSeeds,",
+		"  headInjections: marklessMdxHeadInjections,",
 		"  loadSymbol: marklessMdxLoadSymbol,",
-		"  async renderSsr(props = {}) {",
+		"  async renderSsr(props = {}, marklessMdxRenderContext) {",
 		"    const marklessMdxChildren = [];",
 		`    const html = ${renderHtmlExpression(route)};`,
 		"    const state = composeMdxState(marklessMdxChildren);",
@@ -764,15 +968,7 @@ function emitComposedMdxRoute(route, id) {
 		"};",
 		"export default marklessMdxPage;",
 		"",
-		"export async function resumeContainerEvent(input) {",
-		"  input.root.__asyncResumeRuntimeStarted = true;",
-		"  const { runtime } = await resumeFromPayloadDocument({",
-		"    document: input.root,",
-		"    root: input.root,",
-		"    loadSymbol: marklessMdxLoadSymbol,",
-		"  });",
-		"  await runtime.dispatch(input.event, { syncPolicyAlreadyApplied: true });",
-		"}",
+		...renderMdxResumeHandler(),
 		"",
 		"function marklessMdxLoadSymbol(symbolId, children = []) {",
 		"  return loadMdxSymbol(symbolId, children, marklessMdxSymbolLoaders);",
@@ -780,6 +976,32 @@ function emitComposedMdxRoute(route, id) {
 		""
 	].join("\n");
 }
+function renderMdxResumeHandler() {
+	return [
+		"let marklessResumeModule;",
+		emitQueuedResumeContainerEvent([
+			"export async function resumeContainerEvent(input) {",
+			"  if (await tryResumeMdxScalar(input, marklessMdxLoadScalarPlan, marklessMdxLoadSymbol)) return;",
+			"  input.root.__asyncResumeRuntimeStarted = true;",
+			"  const { resumeFromPayloadDocument } = await (marklessResumeModule ??= import('@markless/core/web/resume').catch(error => { marklessResumeModule = undefined; throw error; }));",
+			"  const { runtime } = await resumeFromPayloadDocument({",
+			"    document: input.root,",
+			"    root: input.root,",
+			"    loadSymbol: marklessMdxLoadSymbol,",
+			"    handoffDispatchOptions: marklessMdxDispatchOptions,",
+			"    renderData: marklessMdxRenderData,",
+			"  });",
+			"  await runtime.dispatch(input.event, marklessMdxDispatchOptions(input));",
+			"}",
+			"function marklessMdxDispatchOptions(input) {",
+			"  return { syncPolicyAlreadyApplied: true, propagationStopped: input.propagationStopped, ignoreUnmatched: input.eventRecord == null };",
+			"}"
+		].join("\n")),
+		"function marklessMdxLoadScalarPlan(symbolId) {",
+		"  return marklessMdxSymbolLoaders.find(loader => symbolId.startsWith(loader.prefix))?.loadScalarActionPlan(symbolId);",
+		"}"
+	];
+}
 function renderMdxPreload(components) {
 	return [
 		"  preload() {",
@@ -828,7 +1050,8 @@ function tsrxImportsFromProgram(program, id) {
 		if (statement.type !== "ImportDeclaration") throw new Error(`Markless Router MDX only supports importing TSRX components before content: ${id}`);
 		const specifier = statement.source.value;
 		const defaultImport = statement.specifiers.find((importSpecifier) => importSpecifier.type === "ImportDefaultSpecifier");
-		if (typeof specifier !== "string" || !specifier.endsWith(".tsrx") || !defaultImport || statement.specifiers.length !== 1) throw new Error(`Markless Router MDX currently supports default imports from .tsrx files only: ${id}`);
+		if (typeof specifier !== "string" || !specifier.endsWith(".tsrx")) throw new Error(`Markless Router MDX currently supports default imports from .tsrx files only: ${id}`);
+		if (!defaultImport || statement.specifiers.length !== 1) throw new Error(tsrxImportShapeMessage(statement.specifiers, specifier, id));
 		imports.push({
 			localName: defaultImport.local.name,
 			specifier
@@ -836,20 +1059,32 @@ function tsrxImportsFromProgram(program, id) {
 	}
 	return imports;
 }
+function tsrxImportShapeMessage(specifiers, specifier, id) {
+	const intro = `Markless Router MDX imports a .tsrx component as that file's default export, one component per import: ${id}.`;
+	const source = JSON.stringify(specifier).slice(1, -1);
+	const defaultImport = specifiers.find((entry) => entry.type === "ImportDefaultSpecifier");
+	if (defaultImport) return `${intro} Write \`import ${defaultImport.local.name} from '${source}';\` alone.`;
+	const named = specifiers.find((entry) => entry.type === "ImportSpecifier");
+	if (named) {
+		const exported = named.imported.type === "Identifier" ? named.imported.name : String(named.imported.value);
+		return `${intro} Write \`import ${named.local.name} from '${source}';\` and make ${exported} the file's \`export default\`.`;
+	}
+	return `${intro} Write \`import Component from '${source}';\` and make the component the file's \`export default\`.`;
+}
 function routePartsFromHast(nodes, context) {
 	const parts = [];
 	let staticNodes = [];
 	for (const node of nodes) {
 		if (isMdxEsm(node)) continue;
-		if (isMdxJsxFlowElement(node)) {
-			appendHtmlPart(parts, staticNodes, context.id);
+		if (isMdxJsxFlowElement(node) && !isIntrinsicElement(node, context)) {
+			appendHtmlPart(parts, staticNodes, context);
 			staticNodes = [];
 			parts.push(componentPart(node, context));
 			continue;
 		}
 		staticNodes.push(node);
 	}
-	appendHtmlPart(parts, staticNodes, context.id);
+	appendHtmlPart(parts, staticNodes, context);
 	return parts;
 }
 function componentPart(node, context) {
@@ -858,10 +1093,15 @@ function componentPart(node, context) {
 	if (!imported) throw new Error(`Markless Router MDX component is not imported from .tsrx: ${name}`);
 	const componentIndex = context.components.length;
 	const props = componentProps(node, context.id);
-	const children = renderStaticHtml(node.children, context.id);
+	const childNodes = normalizeStaticHastNodes(node.children, context);
+	const children = childNodes.length ? toHtml({
+		type: "root",
+		children: childNodes
+	}, { allowDangerousHtml: true }) : "";
 	context.components.push({
 		...imported,
-		prefix: `m${componentIndex}:`,
+		prefix: protocolIslandSegment(componentIndex),
+		childrenElementTags: children ? hastElementTags(childNodes) : [],
 		props: children ? [...props, {
 			name: "children",
 			value: children,
@@ -873,50 +1113,72 @@ function componentPart(node, context) {
 		componentIndex
 	};
 }
-function appendHtmlPart(parts, nodes, id) {
+function appendHtmlPart(parts, nodes, context) {
 	if (nodes.length === 0) return;
-	const staticNodes = normalizeStaticHastNodes(nodes, id);
+	const staticNodes = normalizeStaticHastNodes(nodes, context);
 	const html = toHtml({
 		type: "root",
 		children: staticNodes
 	}, { allowDangerousHtml: true });
 	if (html) {
 		const elementTags = hastElementTags(staticNodes);
+		const commentCount = hastCommentCount(staticNodes);
 		parts.push({
 			kind: "html",
 			html,
 			elementCount: elementTags.length,
+			...commentCount > 0 ? { commentCount } : {},
 			elementTags
 		});
 	}
 }
-function renderStaticHtml(nodes, id) {
-	if (nodes.length === 0) return "";
-	return toHtml({
-		type: "root",
-		children: normalizeStaticHastNodes(nodes, id)
-	}, { allowDangerousHtml: true });
-}
-function normalizeStaticHastNodes(nodes, id) {
-	return nodes.flatMap((node) => normalizeStaticHastNode(node, id));
+function normalizeStaticHastNodes(nodes, context) {
+	return nodes.flatMap((node) => normalizeStaticHastNode(node, context));
 }
-function normalizeStaticHastNode(node, id) {
+function normalizeStaticHastNode(node, context) {
+	const { id } = context;
 	if (isMdxEsm(node)) return [];
-	if (isMdxJsxFlowElement(node) || isMdxJsxTextElement(node)) throw new Error(`Markless Router MDX only supports imported TSRX components as route-level MDX elements or static markdown children: ${id}`);
+	if (isMdxJsxFlowElement(node) || isMdxJsxTextElement(node)) {
+		if (!isIntrinsicElement(node, context)) throw new Error(`Markless Router MDX only supports imported TSRX components as route-level MDX elements or static markdown children: ${id}`);
+		return [intrinsicElement(node, context)];
+	}
 	if (isMdxExpression(node)) {
+		if (isEmptyMdxExpression(node.value)) return [];
 		const value = literalSafeExpressionValue(node.value, id);
 		return [{
 			type: "text",
 			value: value == null ? "" : String(value)
 		}];
 	}
-	if (node.type === "root") return normalizeStaticHastNodes(node.children, id);
+	if (node.type === "root") return normalizeStaticHastNodes(node.children, context);
 	if ("children" in node && Array.isArray(node.children)) return [{
 		...node,
-		children: normalizeStaticHastNodes(node.children, id)
+		children: normalizeStaticHastNodes(node.children, context)
 	}];
 	return [node];
 }
+function isIntrinsicElement(node, context) {
+	const name = node.name;
+	return typeof name === "string" && /^[a-z][a-z0-9-]*$/.test(name) && !context.importedComponents.has(name);
+}
+const JSX_ATTRIBUTE_NAMES = {
+	className: "class",
+	htmlFor: "for"
+};
+function intrinsicElement(node, context) {
+	const properties = {};
+	for (const { name, value } of componentProps(node, context.id)) {
+		if (value === false || value == null) continue;
+		if (typeof value !== "string" && typeof value !== "number" && value !== true) throw literalExpressionError(context.id);
+		properties[JSX_ATTRIBUTE_NAMES[name] ?? name.toLowerCase()] = value === true ? true : String(value);
+	}
+	return {
+		type: "element",
+		tagName: node.name,
+		properties,
+		children: normalizeStaticHastNodes(node.children, context)
+	};
+}
 function componentProps(node, id) {
 	return node.attributes.map((attribute) => componentProp(attribute, id));
 }
@@ -947,6 +1209,9 @@ function literalSafeExpressionValue(source, id) {
 	if (program.body.length !== 1 || statement?.type !== "ExpressionStatement") throw new Error(`Markless Router MDX only supports literal-safe expressions in attributes and markdown: ${id}`);
 	return evaluateLiteralExpression(statement.expression, id);
 }
+function isEmptyMdxExpression(source) {
+	return source.replace(/\/\*[\s\S]*?\*\/|\/\/[^\n]*/g, "").trim() === "";
+}
 function parseMdxExpressionValue(source, id) {
 	const handle = createMdxHastHandle(`{${source}}`);
 	let program = null;
@@ -1015,9 +1280,12 @@ function renderHtmlExpression(route) {
 	return joinExpressions(route.parts.map((part) => {
 		if (part.kind === "html") return JSON.stringify(part.html);
 		const component = route.components[part.componentIndex];
-		return `(await renderMdxChild(marklessMdxChildren, ${component.localName}, ${componentPropsExpression(component)}, { componentIndex: ${part.componentIndex}, hostPrefix: ${JSON.stringify(component.prefix)}, symbolPrefix: ${JSON.stringify(component.prefix)} }))`;
+		return `(await renderMdxChild(marklessMdxChildren, ${component.localName}, ${componentPropsExpression(component)}, { componentIndex: ${part.componentIndex}, hostPrefix: ${JSON.stringify(component.prefix)}, symbolPrefix: ${JSON.stringify(component.prefix)}${childrenElementTagsField(component)} }, marklessMdxRenderContext))`;
 	}));
 }
+function childrenElementTagsField(component) {
+	return component.childrenElementTags.length > 0 ? `, childrenElementTags: ${JSON.stringify(component.childrenElementTags)}` : "";
+}
 function componentPropsExpression(component) {
 	if (component.props.length === 0) return "{}";
 	return `{ ${component.props.map((prop) => `${JSON.stringify(prop.name)}: ${prop.valueExpression}`).join(", ")} }`;
@@ -1034,14 +1302,26 @@ function hastElementTags(nodes) {
 	}
 	return tags;
 }
+function hastCommentCount(nodes) {
+	let comments = 0;
+	for (const node of nodes) {
+		if (node.type === "comment") comments++;
+		if ("children" in node && Array.isArray(node.children)) comments += hastCommentCount(node.children);
+	}
+	return comments;
+}
 function renderStorageSeeds(components) {
 	const localNames = [...new Set(components.map((component) => component.localName))];
 	return localNames.length === 0 ? "[]" : `[${localNames.map((localName) => `...(${localName}.storageSeeds ?? [])`).join(", ")}]`;
 }
+function renderHeadInjections(components) {
+	const localNames = [...new Set(components.map((component) => component.localName))];
+	return localNames.length === 0 ? "[]" : `[...new Map([${localNames.map((localName) => `...(${localName}.headInjections ?? [])`).join(", ")}].map((injection) => [JSON.stringify(injection), injection])).values()]`;
+}
 function renderSymbolLoaders(components) {
-	return `[${components.map((component) => `{ prefix: ${JSON.stringify(component.prefix)}, loadSymbol(symbolId) { return import(${JSON.stringify(`${component.specifier}?markless-symbols`)}).then((mod) => mod.loadSymbol(symbolId.slice(${component.prefix.length}))); } }`).join(", ")}]`;
+	return `[${components.map((component) => `(() => { let module; const loadModule = () => module ??= import(${JSON.stringify(scalarPlanSourceReference(component.specifier))}).catch(error => { module = undefined; throw error; }); return { prefix: ${JSON.stringify(component.prefix)}, loadSymbol(symbolId) { return loadModule().then((mod) => mod.loadSymbol(symbolId.slice(${component.prefix.length}))); }, loadScalarActionPlan(symbolId) { return loadModule().then(mod => mod.loadScalarActionPlan?.(symbolId.slice(${component.prefix.length}))).then(action => action && ({ ...action, scope: ${JSON.stringify(component.prefix)} + action.scope })); } }; })()`).join(", ")}]`;
 }
-function renderMdxRenderDataLoader(components, id) {
+function renderMdxRenderDataLoader(components, id, parts) {
 	const reachedFrom = mdxMaterializedReachRoot(id);
 	const imports = components.map((component) => {
 		const source = withQuery(component.specifier, {
@@ -1052,7 +1332,8 @@ function renderMdxRenderDataLoader(components, id) {
 	});
 	const exportName = reachedFrom ? "marklessPrerenderData" : "marklessRenderData";
 	const children = components.map((component, index) => `{ componentIndex: ${index}, hostPrefix: ${JSON.stringify(component.prefix)}, symbolPrefix: ${JSON.stringify(component.prefix)}, props: ${componentPropsExpression(component)}, surface: modules[${index}].${exportName} }`);
-	return `() => Promise.all([${imports.join(", ")}]).then(modules => createMdxRenderDataSurface(marklessMdxParts, [${children.join(", ")}]))`;
+	const load = `Promise.all([${imports.join(", ")}]).then(modules => createMdxRenderDataSurface(marklessMdxParts, [${children.join(", ")}]))`;
+	return parts ? `() => {\nconst marklessMdxParts = ${JSON.stringify(parts)};\nreturn ${load};\n}` : `() => ${load}`;
 }
 function mdxMaterializedReachRoot(id) {
 	const query = new URLSearchParams(parsePath(id).search);
@@ -1073,7 +1354,166 @@ function isMdxExpression(node) {
 	return node.type === "mdxFlowExpression" || node.type === "mdxTextExpression";
 }
 //#endregion
+//#region src/vite/route-preload-data.ts
+function compactRoutePreloadData(data) {
+	const urls = [];
+	const indices = /* @__PURE__ */ new Map();
+	const encode = (routes) => Object.fromEntries(Object.keys(routes).sort().map((route) => [route, routes[route].map((href) => {
+		let index = indices.get(href);
+		if (index === void 0) {
+			index = urls.length;
+			urls.push(href);
+			indices.set(href, index);
+		}
+		return index;
+	})]));
+	return [
+		urls,
+		encode(data.navigation),
+		encode(data.ssr)
+	];
+}
+function routePreloadDecoderSource(chunkSpecifiers) {
+	return [
+		"if (Array.isArray(routePreloadData)) {",
+		"  const [urls, navigation, ssr] = routePreloadData;",
+		...chunkSpecifiers ? [`  const imports = Object.assign({}, ...[...(globalThis.document?.querySelectorAll('script[type="importmap"]') ?? [])].map((script) => { try { return JSON.parse(script.textContent).imports; } catch { return {}; } }));`, `  const href = (url) => (url.startsWith(${JSON.stringify(MARKLESS_CHUNK_SPECIFIER_PREFIX)}) && imports[url]) || url;`] : [],
+		`  const decode = (routes) => Object.fromEntries(Object.entries(routes).map(([file, indices]) => [file, indices.map((index) => ${chunkSpecifiers ? "href(urls[index])" : "urls[index]"})]));`,
+		"  routePreloadData = { navigation: decode(navigation), ssr: decode(ssr) };",
+		"}"
+	].join("\n");
+}
+//#endregion
+//#region src/navigation-polyfill.ts
+const NAVIGATION_POLYFILL_MODULE = "@virtualstate/navigation";
+//#endregion
+//#region src/vite/document-navigation.ts
+const ROUTE_INVARIANT_DOCUMENT_PROPS = /* @__PURE__ */ new Set(["children"]);
+function documentNavigationFor(source, id) {
+	if (source === void 0) return "client";
+	let program;
+	try {
+		program = parseModule(source, id);
+	} catch {
+		return "document";
+	}
+	const body = nodes(program.body);
+	if (body.some(exportsHtmlAttributesHook)) return "document";
+	const component = defaultExportedFunction(body);
+	if (!component) return "document";
+	return readsOnlyRouteInvariantProps(nodes(component.params)) ? "client" : "document";
+}
+function readsOnlyRouteInvariantProps(params) {
+	if (params.length === 0) return true;
+	if (params.length > 1) return false;
+	const [param] = params;
+	const pattern = param?.type === "AssignmentPattern" ? node(param.left) : param;
+	if (pattern?.type !== "ObjectPattern") return false;
+	return nodes(pattern.properties).every((property) => {
+		if (property.type !== "Property" || property.computed === true) return false;
+		const key = node(property.key);
+		const name = key?.type === "Identifier" ? key.name : key?.value;
+		return typeof name === "string" && ROUTE_INVARIANT_DOCUMENT_PROPS.has(name);
+	});
+}
+function defaultExportedFunction(body) {
+	const declaration = node(node(body.find((statement) => statement.type === "ExportDefaultDeclaration"))?.declaration);
+	if (isFunction(declaration)) return declaration;
+	if (declaration?.type !== "Identifier") return void 0;
+	const name = declaration.name;
+	for (const statement of body) {
+		const local = statement.type === "ExportNamedDeclaration" ? node(statement.declaration) : statement;
+		if (local?.type === "FunctionDeclaration" && node(local.id)?.name === name) return local;
+		if (local?.type !== "VariableDeclaration") continue;
+		for (const declarator of nodes(local.declarations)) {
+			if (node(declarator.id)?.name !== name) continue;
+			const init = node(declarator.init);
+			return isFunction(init) ? init : void 0;
+		}
+	}
+}
+function exportsHtmlAttributesHook(statement) {
+	if (statement.type !== "ExportNamedDeclaration") return false;
+	const declaration = node(statement.declaration);
+	return [
+		node(declaration?.id)?.name,
+		...nodes(declaration?.declarations).map((declarator) => node(declarator.id)?.name),
+		...nodes(statement.specifiers).map((specifier) => node(specifier.exported)?.name)
+	].includes("__marklessRouterHtmlAttributes");
+}
+function isFunction(value) {
+	return value?.type === "FunctionDeclaration" || value?.type === "FunctionExpression" || value?.type === "ArrowFunctionExpression";
+}
+function node(value) {
+	return typeof value === "object" && value !== null ? value : void 0;
+}
+function nodes(value) {
+	return Array.isArray(value) ? value.filter((item) => node(item)) : [];
+}
+//#endregion
+//#region src/vite/nitro-fragment-requests.ts
+function fragmentRequestModule() {
+	return {
+		name: "markless-router:fragment-requests",
+		async setup(nitro) {
+			const dir = join(nitro.options.buildDir, "markless-router");
+			const plugin = join(dir, "fragment-requests.mjs");
+			await mkdir(dir, { recursive: true });
+			await writeFile(plugin, [
+				`const prefix = ${JSON.stringify(`${FRAGMENT_PATH_PREFIX}/`)};`,
+				"export default function fragmentRequests(nitroApp) {",
+				"	nitroApp.hooks?.hook('request', (event) => {",
+				"		const { pathname } = event.url;",
+				"		if (!pathname.startsWith(prefix)) return;",
+				"		const page = new URL(event.url.href);",
+				"		page.pathname = pathname.slice(prefix.length - 1);",
+				"		event.url = page;",
+				"	});",
+				"}",
+				""
+			].join("\n"));
+			nitro.options.plugins.push(plugin);
+		}
+	};
+}
+//#endregion
+//#region src/vite/nitro-prerender.ts
+function serverBuildState() {
+	return { entry: void 0 };
+}
+function recordServerEntry(state, outDir, bundle, isServerEntry) {
+	if (!outDir) return;
+	const entries = Object.values(bundle).filter((item) => item.type === "chunk" && item.isEntry);
+	const entry = entries.find((chunk) => chunk.facadeModuleId && isServerEntry(chunk.facadeModuleId)) ?? (entries.length === 1 ? entries[0] : void 0);
+	if (entry) state.entry = resolve(outDir, entry.fileName);
+}
+function prerenderRendererModule(state) {
+	return {
+		name: "markless-router:prerender-renderer",
+		setup(nitro) {
+			nitro.hooks.hook("prerender:config", async (config) => {
+				if (!state.entry) return;
+				const dir = join(nitro.options.buildDir, "markless-router");
+				const handler = join(dir, "prerender-renderer.mjs");
+				await mkdir(dir, { recursive: true });
+				await writeFile(handler, [
+					`import * as service from ${JSON.stringify(state.entry)};`,
+					"const server = service.default ?? service;",
+					"export default ({ req }) => server.fetch(req);",
+					""
+				].join("\n"));
+				config.renderer = { handler };
+			});
+		}
+	};
+}
+//#endregion
 //#region src/vite/index.ts
+const PAGE_SERVER_ONLY_PROPS = [{
+	exportName: "default",
+	propName: "http",
+	description: "the request with its cookies and headers, the locals middleware set, and the response being written"
+}];
 const ROUTE_DISCOVERY_ID = "virtual:markless-router/routes";
 const CLIENT_ENTRY_ID = "virtual:markless-router/client-entry";
 const RESUME_ENTRY_ID = "virtual:markless-router/resume-entry";
@@ -1085,12 +1525,17 @@ const PRERENDER_WAKE_ENTRY_PATH_ID = "virtual:markless-router/prerender-wake-ent
 const NAVIGATION_ENTRY_ID = "virtual:markless-router/navigation-entry";
 const NAVIGATION_ENTRY_ORIGIN = "/entries/client-entry.ts";
 const NAVIGATION_ENTRY_PATH_ID = "virtual:markless-router/navigation-entry-path";
+const FRAGMENT_ENTRY_ID = "virtual:markless-router/fragment-entry";
+const FRAGMENT_ENTRY_ORIGIN = "/entries/fragment-entry.ts";
+const FRAGMENT_ENTRY_PATH_ID = "virtual:markless-router/fragment-entry-path";
 const ROUTE_PRELOADS_ID = "virtual:markless-router/route-preloads";
 const ROUTE_PRELOADS_PLACEHOLDER = "__MARKLESS_ROUTER_ROUTE_PRELOADS__";
+const DOCUMENT_STYLESHEETS_PLACEHOLDER = "__MARKLESS_ROUTER_DOCUMENT_STYLESHEETS__";
+const LINK_BRIDGE_PATHS_PLACEHOLDER = "__MARKLESS_ROUTER_LINK_BRIDGE_PATHS__";
 const SERVER_ENTRY_ID = "virtual:markless-router/server-entry";
 const ROUTE_HREF_ID = "virtual:markless-router/route-href";
 const ROUTER_OPTIONS_ID = "virtual:markless-router/options";
-const PUBLIC_VIRTUAL_MODULE_ID_RE = /^virtual:markless-router\/(?:routes|client-entry|resume-entry|resume-entry-path|prerender-wake-entry|prerender-wake-entry-path|navigation-entry|navigation-entry-path|route-preloads|server-entry|route-href|options)(?:\?.*)?$/;
+const PUBLIC_VIRTUAL_MODULE_ID_RE = /^virtual:markless-router\/(?:routes|client-entry|resume-entry|resume-entry-path|prerender-wake-entry|prerender-wake-entry-path|navigation-entry|navigation-entry-path|fragment-entry|fragment-entry-path|route-preloads|server-entry|route-href|options)(?:\?.*)?$/;
 const VITE_PLUGIN_FILE = decodePath(parseURL(import.meta.url).pathname);
 const VIRTUAL_ENTRY_DIR = VITE_PLUGIN_FILE.endsWith(".ts") ? join(dirname(VITE_PLUGIN_FILE), "entries") : join(dirname(dirname(VITE_PLUGIN_FILE)), "src/vite/entries");
 const DEFAULT_WATCH_IGNORES = [
@@ -1105,36 +1550,51 @@ const virtualEntryFiles = {
 	[RESUME_ENTRY_ID]: "resume-entry.ts",
 	[PRERENDER_WAKE_ENTRY_ID]: "prerender-wake-entry.ts",
 	[NAVIGATION_ENTRY_ID]: "client-entry.ts",
+	[FRAGMENT_ENTRY_ID]: "fragment-entry.ts",
 	[SERVER_ENTRY_ID]: "server-entry.ts",
 	[ROUTE_HREF_ID]: "route-href.ts"
 };
 function router(options = {}) {
 	prerenderWakeChannelCaptured = process.env.MARKLESS_PRERENDER_WAKE === "1";
 	if (options.nitro === false) return [
+		pageServerOnlyPropsPlugin(),
 		mdxTransformPlugin(),
 		requestFileTransformPlugin(),
 		routeTypegenPlugin(),
 		anchorTransformPlugin(),
 		htmlTransformPlugin(),
-		virtualModulesPlugin()
+		virtualModulesPlugin(void 0, void 0, void 0, void 0, options)
 	];
 	const nitroPlugins = nitro();
 	const resumeEntry = resumeEntryState();
 	const prerenderWakeEntry = resumeEntryState();
 	const navigationEntry = resumeEntryState();
+	const fragmentEntry = resumeEntryState();
 	const routePreloads = routePreloadState();
 	return [
-		routerConfigPlugin(nitroPlugins, resumeEntry, prerenderWakeEntry, navigationEntry, routePreloads),
+		routerConfigPlugin(nitroPlugins, resumeEntry, prerenderWakeEntry, navigationEntry, routePreloads, fragmentEntry, serverBuildState()),
 		devSourceModuleRequestPlugin(),
+		pageServerOnlyPropsPlugin(),
 		mdxTransformPlugin(),
 		requestFileTransformPlugin(),
 		routeTypegenPlugin(),
 		anchorTransformPlugin(),
 		htmlTransformPlugin(),
-		virtualModulesPlugin(resumeEntry, prerenderWakeEntry, navigationEntry, routePreloads),
+		virtualModulesPlugin(resumeEntry, prerenderWakeEntry, navigationEntry, routePreloads, options, fragmentEntry),
+		linkBridgeFilesPlugin(navigationEntry, fragmentEntry, options),
 		nitroPlugins
 	];
 }
+function pageServerOnlyPropsPlugin() {
+	return {
+		name: "markless-router:page-server-only-props",
+		configResolved(config) {
+			const markless = config.plugins.find((plugin) => typeof plugin.api?.declareServerOnlyProps === "function");
+			markless?.api.declareServerOnlyProps((moduleId) => isPageModuleFile(normalizeRouteFileId(moduleId)) ? PAGE_SERVER_ONLY_PROPS : void 0);
+			markless?.api.declareRouteModules?.((moduleId) => isPageModuleFile(normalizeRouteFileId(moduleId)));
+		}
+	};
+}
 function devSourceModuleRequestPlugin() {
 	let root = "";
 	return {
@@ -1155,18 +1615,32 @@ function devSourceModuleRequestPlugin() {
 		}
 	};
 }
-function routerConfigPlugin(nitroPluginsFromRouter, resumeEntry, prerenderWakeEntry, navigationEntry, routePreloads) {
+function routerConfigPlugin(nitroPluginsFromRouter, resumeEntry, prerenderWakeEntry, navigationEntry, routePreloads, fragmentEntry = resumeEntryState(), serverBuild = serverBuildState()) {
 	let clientOutDir = "";
 	let clientEnvironmentName = "";
 	let clientEnvironmentConfig;
 	let serverEnvironmentConfig;
 	let productionBuild = false;
 	let pendingClientAssets;
+	let capturedChunkNames = /* @__PURE__ */ new Map();
+	const navigationPolyfillIds = /* @__PURE__ */ new Set();
 	return {
 		name: "markless-router:vite",
 		enforce: "pre",
 		sharedDuringBuild: true,
-		config(config) {
+		resolveId: {
+			filter: { id: new RegExp(`^${escapeRegExp(NAVIGATION_POLYFILL_MODULE)}$`) },
+			async handler(source, importer, options) {
+				if (source !== "@virtualstate/navigation") return null;
+				const resolved = await this.resolve(source, importer, {
+					...options,
+					skipSelf: true
+				});
+				if (resolved) navigationPolyfillIds.add(resolved.id);
+				return resolved;
+			}
+		},
+		config(config, env) {
 			throwIfUserAddedNitro(config.plugins, nitroPluginsFromRouter);
 			config.environments ??= {};
 			const ssrEnvironment = config.environments.ssr ??= {};
@@ -1175,7 +1649,7 @@ function routerConfigPlugin(nitroPluginsFromRouter, resumeEntry, prerenderWakeEn
 			ssrEnvironment.build.rolldownOptions.input ??= scopedVirtualEntryId(SERVER_ENTRY_ID, config.root);
 			const serverWatch = withWatchIgnores(config.server?.watch);
 			return {
-				nitro: createNitroConfig(config.nitro, config.root, serverWatch.ignored),
+				nitro: createNitroConfig(config.nitro, config.root, serverWatch.ignored, env?.command === "build", serverBuild),
 				server: {
 					...config.server,
 					watch: serverWatch
@@ -1197,9 +1671,13 @@ function routerConfigPlugin(nitroPluginsFromRouter, resumeEntry, prerenderWakeEn
 				resumeEntry,
 				prerenderWakeEntry,
 				navigationEntry,
+				fragmentEntry,
 				routePreloads
 			]) entry.base = config.base;
 			routePreloads.root = config.root;
+			const markless = (config.plugins ?? []).find((plugin) => typeof plugin.api?.chunkImportMap === "function");
+			markless?.api.enableChunkImportMap?.();
+			routePreloads.chunkSpecifiers = markless?.api.chunkImportMap() === true;
 		},
 		configEnvironment(_name, config) {
 			configureRouteInputs(config);
@@ -1215,12 +1693,14 @@ function routerConfigPlugin(nitroPluginsFromRouter, resumeEntry, prerenderWakeEn
 				resumeEntry.fileName = void 0;
 				prerenderWakeEntry.fileName = void 0;
 				navigationEntry.fileName = void 0;
+				fragmentEntry.fileName = void 0;
 				routePreloads.routes = {
 					navigation: {},
 					ssr: {},
 					styles: {}
 				};
 				routePreloads.persisted = false;
+				routePreloads.importMap = void 0;
 				await removeClientAssetsManifest(clientOutDir);
 				return;
 			}
@@ -1229,28 +1709,48 @@ function routerConfigPlugin(nitroPluginsFromRouter, resumeEntry, prerenderWakeEn
 			resumeEntry.fileName = clientAssetFileName(manifest.entries.resume, manifest.base);
 			prerenderWakeEntry.fileName = manifest.entries.prerenderWake ? clientAssetFileName(manifest.entries.prerenderWake, manifest.base) : void 0;
 			navigationEntry.fileName = clientAssetFileName(manifest.entries.navigation, manifest.base);
+			fragmentEntry.fileName = manifest.entries.fragment ? clientAssetFileName(manifest.entries.fragment, manifest.base) : void 0;
+			fragmentEntry.imports = manifest.entries.fragmentImports;
 			routePreloads.routes = manifest.routes;
 			routePreloads.persisted = true;
+			routePreloads.importMap = manifest.importMap;
 		},
 		generateBundle: {
 			order: "post",
 			handler(_options, bundle) {
-				if (this.environment?.config.consumer !== "client") return;
+				if (this.environment?.config.consumer !== "client") {
+					if (this.environment?.config.consumer === "server") patchDocumentStylesheetsInBundle(bundle, documentStylesheetsFromBundle(bundle, routePreloads.root, routePreloads.base));
+					return;
+				}
 				const resumeChunk = Object.values(bundle).find((item) => item.type === "chunk" && isVirtualEntryChunk(item, RESUME_ENTRY_ORIGIN));
 				if (resumeChunk) resumeEntry.fileName = resumeChunk.fileName;
 				const prerenderWakeChunk = Object.values(bundle).find((item) => item.type === "chunk" && isVirtualEntryChunk(item, PRERENDER_WAKE_ENTRY_ORIGIN));
 				if (prerenderWakeChunk) prerenderWakeEntry.fileName = prerenderWakeChunk.fileName;
 				const navigationChunk = Object.values(bundle).find((item) => item.type === "chunk" && isVirtualEntryChunk(item, NAVIGATION_ENTRY_ORIGIN));
 				if (navigationChunk) navigationEntry.fileName = navigationChunk.fileName;
+				const fragmentChunk = Object.values(bundle).find((item) => item.type === "chunk" && isVirtualEntryChunk(item, FRAGMENT_ENTRY_ORIGIN));
+				if (fragmentChunk) {
+					fragmentEntry.fileName = fragmentChunk.fileName;
+					const everyChunk = new Map(outputChunks(bundle).map((chunk) => [chunk.fileName, chunk]));
+					const closure = /* @__PURE__ */ new Set();
+					includeChunk(closure, {
+						chunks: everyChunk,
+						everyChunk
+					}, fragmentChunk.fileName);
+					closure.delete(fragmentChunk.fileName);
+					fragmentEntry.imports = [...closure].map((fileName) => joinURL(routePreloads.base, fileName));
+				}
 				routePreloads.routes = routeModulePreloadsFromBundle({
 					base: routePreloads.base,
 					bundle,
 					navigationChunk,
+					navigationPolyfillIds,
 					prerenderWakeChunk,
 					resumeChunk,
 					root: routePreloads.root
 				});
 				patchRoutePreloadsInBundle(bundle, routePreloads.routes);
+				capturedChunkNames = new Map(outputChunks(bundle).map((chunk) => [chunk.fileName, chunk.preliminaryFileName]));
 				if (productionBuild) {
 					const wakeRequired = prerenderWakeChannelEnabled();
 					if (!resumeEntry.fileName || wakeRequired && !prerenderWakeEntry.fileName || !navigationEntry.fileName) throw new Error(wakeRequired ? "Markless Router client build did not emit its resume, prerender-wake, and navigation entries." : "Markless Router client build did not emit its resume and navigation entries.");
@@ -1259,16 +1759,38 @@ function routerConfigPlugin(nitroPluginsFromRouter, resumeEntry, prerenderWakeEn
 						resumeEntry: joinURL(routePreloads.base, resumeEntry.fileName),
 						...prerenderWakeEntry.fileName ? { prerenderWakeEntry: joinURL(routePreloads.base, prerenderWakeEntry.fileName) } : {},
 						navigationEntry: joinURL(routePreloads.base, navigationEntry.fileName),
+						...fragmentEntry.fileName ? {
+							fragmentEntry: joinURL(routePreloads.base, fragmentEntry.fileName),
+							fragmentImports: fragmentEntry.imports
+						} : {},
 						routes: routePreloads.routes
 					});
 				}
 			}
 		},
-		async writeBundle() {
+		async writeBundle(options, bundle) {
 			const environment = this.environment;
 			const isClientEnvironment = environment?.name ? environment.name === clientEnvironmentName : environment?.config === clientEnvironmentConfig;
+			if (productionBuild && environment?.name === "ssr") recordServerEntry(serverBuild, options.dir, bundle, (id) => id.startsWith(`\0${SERVER_ENTRY_ID}`));
 			if (!productionBuild || !isClientEnvironment) return;
 			if (!pendingClientAssets) throw new Error("Markless Router client build finished without a client-assets manifest.");
+			const renames = bundle ? chunkRenamesSince(capturedChunkNames, bundle) : /* @__PURE__ */ new Map();
+			if (renames.size > 0) {
+				pendingClientAssets = renameClientAssetChunks(pendingClientAssets, renames);
+				routePreloads.routes = pendingClientAssets.routes;
+				for (const entry of [
+					resumeEntry,
+					prerenderWakeEntry,
+					navigationEntry,
+					fragmentEntry
+				]) if (entry.fileName) entry.fileName = renames.get(entry.fileName) ?? entry.fileName;
+				fragmentEntry.imports = pendingClientAssets.entries.fragmentImports;
+			}
+			const importMap = bundle?.[MARKLESS_IMPORT_MAP_ASSET];
+			if (importMap?.type === "asset") pendingClientAssets = {
+				...pendingClientAssets,
+				importMap: JSON.parse(String(importMap.source))
+			};
 			await writeClientAssetsManifest(clientOutDir, pendingClientAssets);
 		}
 	};
@@ -1279,16 +1801,7 @@ function configureRouteInputs(config) {
 	if (config.consumer === "client") {
 		config.build.rolldownOptions.input = routerClientInput(config.build.rolldownOptions.input, configRoot(config));
 		config.build.rolldownOptions.preserveEntrySignatures ??= "exports-only";
-	} else {
-		config.build.rolldownOptions.input ??= scopedVirtualEntryId(SERVER_ENTRY_ID, configRoot(config));
-		config.build.rolldownOptions.external = withExternal(config.build.rolldownOptions.external, "nitro");
-	}
-}
-function withExternal(external, id) {
-	if (Array.isArray(external)) return external.includes(id) ? external : [...external, id];
-	if (typeof external === "string") return external === id ? external : [external, id];
-	if (external === void 0) return [id];
-	return external;
+	} else config.build.rolldownOptions.input ??= scopedVirtualEntryId(SERVER_ENTRY_ID, configRoot(config));
 }
 function requestFileTransformPlugin() {
 	let root = "";
@@ -1315,6 +1828,7 @@ function requestFileIdForTransform(root, id) {
 	if (!isAbsolute(pathname)) return;
 	const relativeFileId = root ? withoutLeadingSlash(normalize(relative(root, pathname))) : withoutLeadingSlash(normalize(pathname));
 	if (relativeFileId.startsWith("api/") || relativeFileId.startsWith("middleware/")) return relativeFileId;
+	if (relativeFileId.startsWith("pages/")) return void 0;
 	return relativeFileId.match(/(?:^|\/)((?:api|middleware)\/.+\.ts)$/)?.[1];
 }
 function requestFileBuildTransformPlugin(root) {
@@ -1331,7 +1845,7 @@ function requestFileBuildTransformPlugin(root) {
 		}
 	};
 }
-function createNitroConfig(nitroConfig, root = ".", serverWatchIgnored = []) {
+function createNitroConfig(nitroConfig, root = ".", serverWatchIgnored = [], isBuild = false, serverBuild = serverBuildState()) {
 	const scanDirs = Array.isArray(nitroConfig?.scanDirs) ? nitroConfig.scanDirs.filter((dir) => typeof dir === "string") : [];
 	const watchOptions = withWatchIgnores(nitroConfig?.watchOptions, serverWatchIgnored);
 	const publicAssets = Array.isArray(nitroConfig?.publicAssets) ? nitroConfig.publicAssets : [];
@@ -1351,9 +1865,20 @@ function createNitroConfig(nitroConfig, root = ".", serverWatchIgnored = []) {
 			...publicAssets
 		],
 		routesDir: nitroConfig?.routesDir ?? ".output/markless/router/nitro-routes",
+		modules: [
+			...nitroConfig?.modules ?? [],
+			fragmentRequestModule(),
+			...isBuild ? [prerenderRendererModule(serverBuild)] : []
+		],
+		...isBuild && { routeRules: {
+			[`/${MARKLESS_BUILD_PREFIX}**`]: { headers: { "cache-control": "public, max-age=31536000, immutable" } },
+			[`/_markless/links/**`]: { headers: { "cache-control": "public, max-age=31536000, immutable" } },
+			...Object.fromEntries(MARKLESS_PUBLIC_BUILD_METADATA_FILES.map((file) => [`/${file}`, { headers: { "cache-control": "public, max-age=0, must-revalidate" } }])),
+			...nitroConfig?.routeRules
+		} },
 		rolldownConfig: withRequestFileBuildPlugin(nitroConfig?.rolldownConfig, root),
 		rollupConfig: withRequestFileBuildPlugin(nitroConfig?.rollupConfig, root),
-		scanDirs: [...new Set([".", ...scanDirs])],
+		scanDirs: [.../* @__PURE__ */ new Set([".", ...scanDirs])],
 		watchOptions
 	};
 }
@@ -1400,6 +1925,7 @@ function resumeEntryState() {
 function routePreloadState() {
 	return {
 		base: "/",
+		chunkSpecifiers: false,
 		persisted: false,
 		root: ".",
 		routes: {
@@ -1417,33 +1943,40 @@ function routerClientInput(input, root) {
 	const resumeEntryId = scopedVirtualEntryId(RESUME_ENTRY_ID, root);
 	const prerenderWakeEntryId = scopedVirtualEntryId(PRERENDER_WAKE_ENTRY_ID, root);
 	const navigationEntryId = scopedVirtualEntryId(NAVIGATION_ENTRY_ID, root);
+	const fragmentEntryId = scopedVirtualEntryId(FRAGMENT_ENTRY_ID, root);
 	const wakeEntries = prerenderWakeChannelEnabled() ? [prerenderWakeEntryId] : [];
 	if (input === void 0) return [
 		resumeEntryId,
 		...wakeEntries,
-		navigationEntryId
+		navigationEntryId,
+		fragmentEntryId
 	];
 	if (typeof input === "string" || Array.isArray(input)) return [
 		resumeEntryId,
 		...wakeEntries,
 		navigationEntryId,
+		fragmentEntryId,
 		...Array.isArray(input) ? input : [input]
 	];
 	if (isRecord(input)) return {
 		...input,
 		"markless-router-resume": resumeEntryId,
 		...prerenderWakeChannelEnabled() ? { "markless-router-prerender-wake": prerenderWakeEntryId } : {},
-		"markless-router-navigation": navigationEntryId
+		"markless-router-navigation": navigationEntryId,
+		"markless-router-fragment": fragmentEntryId
 	};
 	return input;
 }
 function isVirtualEntryChunk(chunk, origin) {
 	return [chunk.facadeModuleId, ...chunk.moduleIds ?? []].some((id) => id ? decodePath(parseURL(id).pathname).endsWith(origin) : false);
 }
-function virtualModulesPlugin(resumeEntry = resumeEntryState(), prerenderWakeEntry = resumeEntryState(), navigationEntry = resumeEntryState(), routePreloads = routePreloadState()) {
+function virtualModulesPlugin(resumeEntry = resumeEntryState(), prerenderWakeEntry = resumeEntryState(), navigationEntry = resumeEntryState(), routePreloads = routePreloadState(), options = {}, fragmentEntry = resumeEntryState()) {
 	let root = "";
 	return {
 		name: "markless-router:routes",
+		config() {
+			return { define: { __MARKLESS_ROUTER_LINK_INTENT__: JSON.stringify(linkIntentEnabled(options)) } };
+		},
 		sharedDuringBuild: true,
 		configResolved(config) {
 			root = config.root;
@@ -1452,48 +1985,148 @@ function virtualModulesPlugin(resumeEntry = resumeEntryState(), prerenderWakeEnt
 			filter: { id: PUBLIC_VIRTUAL_MODULE_ID_RE },
 			handler(id) {
 				const baseId = virtualModuleBaseId(id);
-				if (baseId === SERVER_ENTRY_ID || baseId === RESUME_ENTRY_PATH_ID || baseId === PRERENDER_WAKE_ENTRY_PATH_ID || baseId === NAVIGATION_ENTRY_PATH_ID || baseId === ROUTE_PRELOADS_ID || baseId === ROUTER_OPTIONS_ID) return `\0${baseId}${rootScopeQuery(root, id)}`;
+				if (baseId === ROUTER_OPTIONS_ID) return {
+					id: `\0${baseId}${rootScopeQuery(root, id)}`,
+					moduleSideEffects: false
+				};
+				if (baseId === SERVER_ENTRY_ID || baseId === RESUME_ENTRY_PATH_ID || baseId === PRERENDER_WAKE_ENTRY_PATH_ID || baseId === NAVIGATION_ENTRY_PATH_ID || baseId === FRAGMENT_ENTRY_PATH_ID || baseId === ROUTE_PRELOADS_ID) return `\0${baseId}${rootScopeQuery(root, id)}`;
 				const entryFile = virtualEntryFiles[baseId];
 				if (!entryFile) return;
+				if (baseId === ROUTE_HREF_ID) return join(VIRTUAL_ENTRY_DIR, entryFile);
 				return `${join(VIRTUAL_ENTRY_DIR, entryFile)}${rootScopeQuery(root, id)}`;
 			}
 		},
 		load(id) {
-			if (id.startsWith(`\0${SERVER_ENTRY_ID}`)) return serverEntrySource(root);
+			if (id.startsWith(`\0${SERVER_ENTRY_ID}`)) return serverEntrySource(root, options);
 			if (id.startsWith(`\0${RESUME_ENTRY_PATH_ID}`)) return entryPathSource("resumeEntryPath", resumeEntry, RESUME_ENTRY_ID, root);
 			if (id.startsWith(`\0${PRERENDER_WAKE_ENTRY_PATH_ID}`)) {
 				if (!prerenderWakeChannelEnabled() || !prerenderWakeEntry.fileName) return "export const prerenderWakeEntryPath = undefined;";
 				return entryPathSource("prerenderWakeEntryPath", prerenderWakeEntry, PRERENDER_WAKE_ENTRY_ID, root);
 			}
 			if (id.startsWith(`\0${NAVIGATION_ENTRY_PATH_ID}`)) return entryPathSource("navigationEntryPath", navigationEntry, NAVIGATION_ENTRY_ID, root);
+			if (id.startsWith(`\0${FRAGMENT_ENTRY_PATH_ID}`)) return entryPathSource("fragmentEntryPath", fragmentEntry, FRAGMENT_ENTRY_ID, root);
 			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";
+			if (id.startsWith(`\0${ROUTER_OPTIONS_ID}`)) {
+				const documentFile = join(root, "document.tsrx");
+				this?.addWatchFile?.(documentFile);
+				return routerOptionsSource(options, documentFile);
+			}
 		}
 	};
 }
+async function routerOptionsSource(options, documentFile) {
+	const documentSource = await readFile(documentFile, "utf8").catch(() => void 0);
+	return [
+		"export const routerMode = \"path\";",
+		`export const documentNavigation = ${JSON.stringify(documentNavigationFor(documentSource, documentFile))};`,
+		linkIntentEnabled(options) ? `export const startLinkIntentPreloading = (root, preload) => (${listenForLinkIntent.toString()})(root, ${JSON.stringify(LINK_ATTRIBUTE)}, preload, ${JSON.stringify(PREFETCH_ATTRIBUTE)});` : "export const startLinkIntentPreloading = () => () => {};"
+	].join("\n");
+}
+function linkIntentEnabled(options) {
+	return options.prefetch !== false;
+}
 function entryPathSource(exportName, entry, entryId, root) {
-	const path = entry.fileName ? joinURL(entry.base, entry.fileName) : joinURL(entry.base, "@id", scopedVirtualEntryId(entryId, root));
-	return `export const ${exportName} = ${JSON.stringify(path)};`;
+	return `export const ${exportName} = ${JSON.stringify(entryPath(entry, entryId, root))};`;
+}
+function entryPath(entry, entryId, root) {
+	return entry.fileName ? joinURL(entry.base, entry.fileName) : joinURL(entry.base, "@id", scopedVirtualEntryId(entryId, root));
 }
-function serverEntrySource(root) {
+function linkBridgeFilesPlugin(navigationEntry, fragmentEntry, options) {
+	let root = "";
+	let base = "/";
+	let clientOutDir = "";
+	let debug = false;
+	let modules = [];
+	return {
+		name: "markless-router:link-bridge-files",
+		apply: "build",
+		sharedDuringBuild: true,
+		configResolved(config) {
+			root = config.root;
+			base = config.base;
+			debug = config.define?.__MARKLESS_DEBUG_ENABLED__ === "true";
+			const client = Object.values(config.environments).find((environment) => environment.consumer === "client");
+			if (client) clientOutDir = resolve(config.root, client.build.outDir);
+		},
+		generateBundle: {
+			order: "post",
+			async handler(_options, bundle) {
+				if (this.environment?.name !== "ssr") return;
+				const chunks = outputChunks(bundle);
+				const target = chunks.find((chunk) => chunk.code?.includes(LINK_BRIDGE_PATHS_PLACEHOLDER));
+				if (!target) return;
+				if (!navigationEntry.fileName) throw new Error("Markless Router built its server entry before its navigation entry.");
+				const documentFile = join(root, "document.tsrx");
+				const documentSource = await readFile(documentFile, "utf8").catch(() => void 0);
+				const built = routerLinkBridgeModules({
+					base,
+					navigationEntryPath: entryPath(navigationEntry, NAVIGATION_ENTRY_ID, root),
+					fragmentEntryPath: entryPath(fragmentEntry, FRAGMENT_ENTRY_ID, root),
+					fragmentEntryImports: fragmentEntry.imports,
+					fragmentNavigationSource: minifiedFragmentNavigationSource(),
+					fragmentNavigationRunSource: minifiedFragmentNavigationSource(runFragmentNavigation),
+					prefetch: options.prefetch,
+					documentNavigation: documentNavigationFor(documentSource, documentFile),
+					routeFileIds: bundledPageFileIds(chunks, root),
+					debug
+				});
+				modules = built;
+				target.code = target.code.replace(LINK_BRIDGE_PATHS_PLACEHOLDER, jsStringLiteralContent(JSON.stringify(built.slice(0, 2).map((module) => module.path))));
+			}
+		},
+		async writeBundle() {
+			if (this.environment?.name !== "ssr" || modules.length === 0) return;
+			const prefix = base.replace(/\/?$/, "/");
+			for (const module of modules) {
+				const file = join(clientOutDir, module.path.slice(prefix.length));
+				await mkdir(dirname(file), { recursive: true });
+				await writeFile(file, module.source, "utf8");
+			}
+		}
+	};
+}
+function bundledPageFileIds(chunks, root) {
+	const files = /* @__PURE__ */ new Set();
+	for (const chunk of chunks) for (const id of chunk.moduleIds ?? []) {
+		if (id.startsWith("\0")) continue;
+		const pathname = decodePath(parseURL(id).pathname);
+		if (!isAbsolute(pathname)) continue;
+		const file = normalizeRouteFileId(relative(root, pathname));
+		if (isPageModuleFile(file)) files.add(file);
+	}
+	return [...files];
+}
+function serverEntrySource(root, options) {
 	const query = rootScopeQuery(root);
 	return [
 		`import { createServerEntry } from '@markless/router/vite/runtime/create-server-entry';`,
 		`import { resumeEntryPath } from '${RESUME_ENTRY_PATH_ID}${query}';`,
 		`import { prerenderWakeEntryPath } from '${PRERENDER_WAKE_ENTRY_PATH_ID}${query}';`,
 		`import { navigationEntryPath } from '${NAVIGATION_ENTRY_PATH_ID}${query}';`,
-		`import { routeModulePreloads, routeSsrModulePreloads, routeStylesheets } from '${ROUTE_PRELOADS_ID}${query}';`,
+		`import { fragmentEntryPath } from '${FRAGMENT_ENTRY_PATH_ID}${query}';`,
+		`import { documentStylesheets, routeModulePreloads, routeSsrModulePreloads, routeStylesheets, documentImportMap } from '${ROUTE_PRELOADS_ID}${query}';`,
 		`import { pageModuleLoaders, routeFileIds } from '${ROUTE_DISCOVERY_ID}${query}';`,
+		`import { documentNavigation } from '${ROUTER_OPTIONS_ID}${query}';`,
 		`const documentModuleLoaders = import.meta.glob(['/document.tsrx']);`,
+		`const linkBridgePathsJson = globalThis.__marklessRouterLinkBridgePathsJson ?? ${JSON.stringify(LINK_BRIDGE_PATHS_PLACEHOLDER)};`,
 		`const entry = createServerEntry({`,
 		`  dev: import.meta.env.DEV,`,
+		`  linkBridgePaths: linkBridgePathsJson === ${JSON.stringify(LINK_BRIDGE_PATHS_PLACEHOLDER)} ? undefined : JSON.parse(linkBridgePathsJson),`,
+		`  base: import.meta.env.BASE_URL,`,
 		`  resumeEntryPath,`,
 		`  prerenderWakeEntryPath,`,
 		`  navigationEntryPath,`,
+		`  fragmentEntryPath,`,
+		`  fragmentNavigationSource: ${JSON.stringify(minifiedFragmentNavigationSource())},`,
+		`  fragmentNavigationRunSource: ${JSON.stringify(minifiedFragmentNavigationSource(runFragmentNavigation))},`,
+		...options.prefetch === false ? ["  prefetch: false,"] : [],
 		`  routeModulePreloads,`,
 		`  routeSsrModulePreloads,`,
 		`  routeStylesheets,`,
+		`  documentStylesheets,`,
+		`  importMap: documentImportMap,`,
 		`  documentModuleLoader: documentModuleLoaders['/document.tsrx'],`,
+		`  documentNavigation,`,
 		`  pageModuleLoaders,`,
 		`  routeFileIds,`,
 		`});`,
@@ -1501,9 +2134,21 @@ function serverEntrySource(root) {
 		`export default entry;`
 	].join("\n");
 }
+function minifiedFragmentNavigationSource(source = startFragmentNavigation) {
+	const result = minifySync("markless-fragment-navigation.js", `export default (${source.toString()});`, {
+		compress: true,
+		mangle: true,
+		module: true
+	});
+	const prefix = "export default";
+	const code = result.code.trim();
+	if (result.errors.length > 0 || !code.startsWith(prefix)) throw new Error(`MARKLESS_ROUTER_FRAGMENT_MINIFY_FAILED: ${result.errors.map((error) => error.message).join("\n")}`);
+	return code.slice(14).replace(/;$/, "").trim();
+}
 function rootScopeQuery(root, id = "") {
+	const parsed = parsePath(id);
 	const query = stringifyQuery({
-		...parseQuery(parsePath(id).search),
+		...parseQuery(parsed.search),
 		"markless-router-root": root || "."
 	});
 	return query ? `?${query}&lang.ts` : "";
@@ -1513,10 +2158,16 @@ function routePreloadsSource(state, client) {
 		navigation: state.routes.navigation,
 		ssr: state.routes.ssr
 	} : state.routes;
-	const routeStylesheetExport = client ? [] : [`export const routeStylesheets = ${state.persisted ? "routePreloadData.styles ?? {}" : "undefined"};`];
+	const routeStylesheetExport = client ? [] : [
+		`export const routeStylesheets = ${state.persisted ? "routePreloadData.styles ?? {}" : "undefined"};`,
+		`const documentStylesheetsJson = globalThis.__marklessRouterDocumentStylesheetsJson ?? ${JSON.stringify(DOCUMENT_STYLESHEETS_PLACEHOLDER)};`,
+		`export const documentStylesheets = documentStylesheetsJson === ${JSON.stringify(DOCUMENT_STYLESHEETS_PLACEHOLDER)} ? [] : JSON.parse(documentStylesheetsJson);`,
+		`export const documentImportMap = ${JSON.stringify(state.persisted && state.importMap ? importMapScript(state.importMap) : "")};`
+	];
 	return [
 		`const routePreloadsJson = globalThis.__marklessRouterRoutePreloadsJson ?? ${JSON.stringify(ROUTE_PRELOADS_PLACEHOLDER)};`,
-		`const routePreloadData = routePreloadsJson === ${JSON.stringify(ROUTE_PRELOADS_PLACEHOLDER)} ? ${JSON.stringify(routes)} : JSON.parse(routePreloadsJson);`,
+		`let routePreloadData = routePreloadsJson === ${JSON.stringify(ROUTE_PRELOADS_PLACEHOLDER)} ? ${JSON.stringify(routes)} : JSON.parse(routePreloadsJson);`,
+		routePreloadDecoderSource(client && state.chunkSpecifiers),
 		`export const routeModulePreloads = routePreloadData.navigation ?? {};`,
 		`export const routeSsrModulePreloads = routePreloadData.ssr ?? {};`,
 		...routeStylesheetExport,
@@ -1540,21 +2191,51 @@ function routePreloadsSource(state, client) {
 	].join("\n");
 }
 function patchRoutePreloadsInBundle(bundle, routes) {
-	const replacement = jsStringLiteralContent(JSON.stringify({
-		navigation: routes.navigation,
-		ssr: routes.ssr
-	}));
+	const replacement = jsStringLiteralContent(JSON.stringify(compactRoutePreloadData(routes)));
 	for (const chunk of outputChunks(bundle)) {
 		if (!chunk.code?.includes(ROUTE_PRELOADS_PLACEHOLDER)) continue;
 		chunk.code = chunk.code.replace(ROUTE_PRELOADS_PLACEHOLDER, replacement);
 	}
 }
+function documentStylesheetsFromBundle(bundle, root, base) {
+	const chunks = outputChunks(bundle);
+	const chunksByFileName = new Map(chunks.map((chunk) => [chunk.fileName, chunk]));
+	const documentFile = join(root, "document.tsrx");
+	const documentChunks = chunks.filter((chunk) => [chunk.facadeModuleId, ...chunk.moduleIds ?? []].some((id) => id !== null && id !== void 0 && decodePath(parseURL(id).pathname) === documentFile));
+	if (documentChunks.length === 0) return [];
+	return routeStylesheetsForChunks(documentChunks, new Set(documentChunks.map((chunk) => chunk.fileName)), chunksByFileName, base);
+}
+function patchDocumentStylesheetsInBundle(bundle, stylesheets) {
+	const replacement = jsStringLiteralContent(JSON.stringify(stylesheets));
+	for (const chunk of outputChunks(bundle)) {
+		if (!chunk.code?.includes(DOCUMENT_STYLESHEETS_PLACEHOLDER)) continue;
+		chunk.code = chunk.code.replace(DOCUMENT_STYLESHEETS_PLACEHOLDER, replacement);
+	}
+}
 function jsStringLiteralContent(value) {
 	return value.replaceAll("\\", "\\\\").replaceAll("\"", "\\\"").replaceAll("'", "\\'").replaceAll("`", "\\`").replaceAll("${", "\\${");
 }
 function routeModulePreloadsFromBundle(input) {
-	const chunks = outputChunks(input.bundle);
-	const chunksByFileName = new Map(chunks.map((chunk) => [chunk.fileName, chunk]));
+	const allChunks = outputChunks(input.bundle).filter((chunk) => !isExecutionLogChunk(chunk));
+	const deferred = marklessDeferredChunkFileNames(allChunks);
+	const chunks = allChunks.filter((chunk) => !deferred.has(chunk.fileName));
+	const deferredChunks = allChunks.filter((chunk) => deferred.has(chunk.fileName));
+	const everyChunk = new Map(allChunks.map((chunk) => [chunk.fileName, chunk]));
+	const plannedLanding = plannedLandingFiles(input.bundle);
+	const deferredFileNames = new Set(deferredChunks.map((chunk) => chunk.fileName));
+	const resumeRuntimeFileNames = /* @__PURE__ */ new Set();
+	for (const entry of [input.resumeChunk, input.prerenderWakeChunk]) if (entry) includeChunk(resumeRuntimeFileNames, {
+		chunks: everyChunk,
+		everyChunk
+	}, entry.fileName);
+	const lazyRuntimePacks = new Set([...resumeRuntimeFileNames].flatMap((fileName) => {
+		const name = everyChunk.get(fileName)?.name;
+		return name && lazyStartupPackName(name) !== name ? [lazyStartupPackName(name)] : [];
+	}));
+	for (const chunk of allChunks) if (chunk.name && lazyRuntimePacks.has(chunk.name)) includeChunk(resumeRuntimeFileNames, {
+		chunks: everyChunk,
+		everyChunk
+	}, chunk.fileName);
 	const routeChunks = /* @__PURE__ */ new Map();
 	const routeChunkFileNames = /* @__PURE__ */ new Set();
 	for (const chunk of chunks) {
@@ -1566,40 +2247,86 @@ function routeModulePreloadsFromBundle(input) {
 		routeChunkFileNames.add(chunk.fileName);
 	}
 	const symbolChunks = symbolChunksBySourceFile(chunks);
+	const resolverSourceFiles = new Set(allChunks.flatMap((chunk) => (chunk.moduleIds ?? []).flatMap((moduleId) => {
+		const sourceFile = resolverVirtualModuleSourceFile(moduleId.startsWith("\0") ? moduleId.slice(1) : moduleId);
+		return sourceFile ? [sourceModulePathname(sourceFile)] : [];
+	})));
+	const polyfillFileNames = new Set(chunks.filter((chunk) => chunk.facadeModuleId && input.navigationPolyfillIds?.has(chunk.facadeModuleId)).map((chunk) => chunk.fileName));
 	const navigation = {};
 	const ssr = {};
 	const styles = {};
 	for (const [routeFile, routeFileChunks] of routeChunks) {
+		const currentRouteFiles = new Set(routeFileChunks.map((chunk) => chunk.fileName));
+		const chunksByFileName = new Map(chunks.filter((chunk) => !routeChunkFileNames.has(chunk.fileName) || currentRouteFiles.has(chunk.fileName)).map((chunk) => [chunk.fileName, chunk]));
+		const scope = {
+			chunks: chunksByFileName,
+			everyChunk
+		};
+		const landingScope = {
+			chunks: new Map([...chunksByFileName].filter(([, chunk]) => !isMarklessNavigationPack(chunk.name))),
+			everyChunk
+		};
 		const routeChunk = primaryRouteChunk(input.root, routeFile, routeFileChunks);
+		const landingChunks = routeFileChunks.filter((chunk) => !isMarklessNavigationPack(chunk.name) && !isNavigationOnlyRouteChunk(input.root, routeFile, chunk));
+		const landingChunk = landingChunks.length ? primaryRouteChunk(input.root, routeFile, landingChunks) : routeChunk;
 		const navigationFileNames = /* @__PURE__ */ new Set();
 		if (input.navigationChunk) {
-			includeChunk(navigationFileNames, chunksByFileName, input.navigationChunk.fileName);
-			for (const fileName of input.navigationChunk.dynamicImports) if (!routeChunkFileNames.has(fileName)) includeChunk(navigationFileNames, chunksByFileName, fileName);
+			includeChunk(navigationFileNames, scope, input.navigationChunk.fileName);
+			const renderPathChunks = new Map(chunksByFileName);
+			for (const chunk of deferredChunks) renderPathChunks.set(chunk.fileName, chunk);
+			const renderPath = /* @__PURE__ */ new Set();
+			for (const fileName of input.navigationChunk.dynamicImports) if (!routeChunkFileNames.has(fileName) && !polyfillFileNames.has(fileName)) includeChunk(renderPath, scope, fileName, true);
+			for (const fileName of renderPath) {
+				navigationFileNames.add(fileName);
+				if (resumeRuntimeFileNames.has(fileName)) continue;
+				const chunk = everyChunk.get(fileName);
+				for (const target of [...chunk.dynamicImports, ...codeDynamicImports(chunk)]) if (deferredFileNames.has(target)) includeChunk(navigationFileNames, {
+					chunks: renderPathChunks,
+					everyChunk
+				}, target, true);
+			}
 		}
-		includeChunk(navigationFileNames, chunksByFileName, routeChunk.fileName);
-		includeChunk(navigationFileNames, chunksByFileName, routeChunk.fileName, true);
-		if (input.navigationChunk) for (const fileName of routeScopedDynamicImports(input.navigationChunk, routeFile)) includeChunk(navigationFileNames, chunksByFileName, fileName, true);
+		includeChunk(navigationFileNames, scope, routeChunk.fileName);
+		includeChunk(navigationFileNames, scope, routeChunk.fileName, true);
+		if (input.navigationChunk) for (const fileName of routeScopedDynamicImports(input.navigationChunk, routeFile)) includeChunk(navigationFileNames, scope, fileName, true);
 		const ssrFileNames = /* @__PURE__ */ new Set();
 		if (input.resumeChunk) {
-			includeChunk(ssrFileNames, chunksByFileName, input.resumeChunk.fileName);
-			for (const fileName of routeScopedDynamicImports(input.resumeChunk, routeFile)) includeChunk(ssrFileNames, chunksByFileName, fileName, true);
+			includeChunk(ssrFileNames, landingScope, input.resumeChunk.fileName);
+			for (const fileName of routeScopedDynamicImports(input.resumeChunk, routeFile)) includeChunk(ssrFileNames, landingScope, fileName, true);
 		}
 		if (input.prerenderWakeChunk) {
-			includeChunk(ssrFileNames, chunksByFileName, input.prerenderWakeChunk.fileName);
-			for (const fileName of routeScopedDynamicImports(input.prerenderWakeChunk, routeFile)) includeChunk(ssrFileNames, chunksByFileName, fileName, true);
+			includeChunk(ssrFileNames, landingScope, input.prerenderWakeChunk.fileName);
+			for (const fileName of routeScopedDynamicImports(input.prerenderWakeChunk, routeFile)) includeChunk(ssrFileNames, landingScope, fileName, true);
 		}
-		includeChunk(ssrFileNames, chunksByFileName, routeChunk.fileName, true);
-		const routeSourceFiles = sourceFilesForChunks(new Set([...navigationFileNames, ...ssrFileNames]), chunksByFileName);
+		includeChunk(ssrFileNames, landingScope, landingChunk.fileName, true);
+		const routeSourceFiles = sourceFilesForChunks(/* @__PURE__ */ new Set([...navigationFileNames, ...ssrFileNames]), chunksByFileName);
+		let routeHasSymbols = false;
 		for (const [sourceFile, symbolFileNames] of symbolChunks) {
 			if (!routeSourceFiles.has(sourceFile)) continue;
+			routeHasSymbols = true;
 			for (const fileName of symbolFileNames) {
-				includeChunk(navigationFileNames, chunksByFileName, fileName, true);
-				includeChunk(ssrFileNames, chunksByFileName, fileName, true);
+				includeChunk(navigationFileNames, scope, fileName, true);
+				includeChunk(ssrFileNames, landingScope, fileName, true);
 			}
 		}
+		const styleFileNames = /* @__PURE__ */ new Set([...navigationFileNames, ...ssrFileNames]);
+		const planned = plannedLanding?.get(routeFile);
+		if (planned) narrowToPlanned(ssrFileNames, planned, landingScope, [input.resumeChunk, input.prerenderWakeChunk]);
+		for (const fileName of ssrFileNames) for (const specifier of warmEvaluatedImports(everyChunk.get(fileName)?.code ?? "")) includeChunk(ssrFileNames, landingScope, normalize(join(dirname(fileName), specifier)));
 		navigation[routeFile] = [...navigationFileNames].map((fileName) => joinURL(input.base, fileName));
-		ssr[routeFile] = [...ssrFileNames].map((fileName) => joinURL(input.base, fileName));
-		styles[routeFile] = routeStylesheetsForChunks(routeFileChunks, chunksByFileName, input.base);
+		const firstEventPath = /* @__PURE__ */ new Set();
+		const lazySiblings = [...ssrFileNames].filter((fileName) => {
+			const name = everyChunk.get(fileName)?.name;
+			return !!name && startupPackOfLazy(name) !== name;
+		});
+		for (const entry of lazySiblings.length ? [input.resumeChunk, input.prerenderWakeChunk] : []) {
+			if (!entry) continue;
+			includeChunk(firstEventPath, landingScope, entry.fileName);
+			for (const fileName of routeScopedDynamicImports(entry, routeFile)) includeChunk(firstEventPath, landingScope, fileName);
+		}
+		for (const fileName of lazySiblings) includeChunk(firstEventPath, landingScope, fileName);
+		ssr[routeFile] = !routeHasSymbols && [...routeSourceFiles].some((file) => resolverSourceFiles.has(file)) ? [] : [...[...firstEventPath].filter((fileName) => ssrFileNames.has(fileName)), ...[...ssrFileNames].filter((fileName) => !firstEventPath.has(fileName))].map((fileName) => joinURL(input.base, fileName));
+		styles[routeFile] = routeStylesheetsForChunks(routeFileChunks, styleFileNames, chunksByFileName, input.base);
 	}
 	return {
 		navigation,
@@ -1607,7 +2334,7 @@ function routeModulePreloadsFromBundle(input) {
 		styles
 	};
 }
-function routeStylesheetsForChunks(routeFileChunks, chunksByFileName, base) {
+function routeStylesheetsForChunks(routeFileChunks, closureFileNames, chunksByFileName, base) {
 	const styles = /* @__PURE__ */ new Set();
 	const visited = /* @__PURE__ */ new Set();
 	const visit = (chunk) => {
@@ -1619,18 +2346,25 @@ function routeStylesheetsForChunks(routeFileChunks, chunksByFileName, base) {
 		}
 		for (const stylesheet of chunk.viteMetadata?.importedCss ?? []) styles.add(joinURL(base, stylesheet));
 	};
+	for (const fileName of closureFileNames) {
+		const chunk = chunksByFileName.get(fileName);
+		if (chunk) visit(chunk);
+	}
 	for (const chunk of routeFileChunks) visit(chunk);
 	return [...styles];
 }
 function symbolChunksBySourceFile(chunks) {
 	const bySourceFile = /* @__PURE__ */ new Map();
-	for (const chunk of chunks) for (const moduleId of chunk.moduleIds ?? []) {
-		const sourceFile = symbolVirtualModuleSourceFile(moduleId);
-		if (!sourceFile) continue;
-		const key = sourceModulePathname(sourceFile);
-		const fileNames = bySourceFile.get(key) ?? [];
-		if (!fileNames.includes(chunk.fileName)) fileNames.push(chunk.fileName);
-		bySourceFile.set(key, fileNames);
+	for (const chunk of chunks) {
+		const moduleIds = chunk.facadeModuleId ? [...chunk.moduleIds ?? [], chunk.facadeModuleId] : chunk.moduleIds ?? [];
+		for (const moduleId of moduleIds) {
+			const sourceFile = symbolVirtualModuleSourceFile(moduleId);
+			if (!sourceFile) continue;
+			const key = sourceModulePathname(sourceFile);
+			const fileNames = bySourceFile.get(key) ?? [];
+			if (!fileNames.includes(chunk.fileName)) fileNames.push(chunk.fileName);
+			bySourceFile.set(key, fileNames);
+		}
 	}
 	return bySourceFile;
 }
@@ -1646,22 +2380,23 @@ function sourceFilesForChunks(fileNames, chunksByFileName) {
 function sourceModulePathname(moduleId) {
 	return decodePath(parseURL(moduleId).pathname);
 }
-function includeChunk(fileNames, chunksByFileName, fileName, includeDynamic = false, visitedDynamic = /* @__PURE__ */ new Set()) {
-	if (!fileNames.has(fileName)) fileNames.add(fileName);
-	const chunk = chunksByFileName.get(fileName);
+function includeChunk(fileNames, scope, fileName, includeDynamic = false, visited = /* @__PURE__ */ new Set(), requiredByStaticImport = false) {
+	if (visited.has(fileName)) return;
+	const chunk = (requiredByStaticImport ? scope.everyChunk : scope.chunks).get(fileName);
 	if (!chunk) return;
-	for (const imported of chunk.imports) includeChunk(fileNames, chunksByFileName, imported, includeDynamic, visitedDynamic);
-	for (const imported of codeStaticImports(chunk)) {
-		if (!chunksByFileName.has(imported)) continue;
-		includeChunk(fileNames, chunksByFileName, imported, includeDynamic, visitedDynamic);
-	}
-	if (!includeDynamic || visitedDynamic.has(fileName)) return;
-	visitedDynamic.add(fileName);
-	for (const imported of chunk.dynamicImports) includeChunk(fileNames, chunksByFileName, imported, true, visitedDynamic);
-	for (const imported of codeDynamicImports(chunk)) {
-		if (!chunksByFileName.has(imported)) continue;
-		includeChunk(fileNames, chunksByFileName, imported, true, visitedDynamic);
-	}
+	visited.add(fileName);
+	fileNames.add(fileName);
+	for (const imported of /* @__PURE__ */ new Set([...chunk.imports, ...codeStaticImports(chunk)])) includeChunk(fileNames, scope, imported, includeDynamic, visited, true);
+	if (!includeDynamic) return;
+	for (const imported of /* @__PURE__ */ new Set([...chunk.dynamicImports, ...codeDynamicImports(chunk)])) includeChunk(fileNames, scope, imported, true, visited);
+}
+function narrowToPlanned(fileNames, planned, scope, entries) {
+	const kept = /* @__PURE__ */ new Set();
+	for (const entry of entries) if (entry) includeChunk(kept, scope, entry.fileName);
+	for (const fileName of fileNames) if (planned.has(fileName)) includeChunk(kept, scope, fileName, false, /* @__PURE__ */ new Set(), true);
+	const ordered = [...fileNames].filter((fileName) => kept.has(fileName));
+	fileNames.clear();
+	for (const fileName of [...ordered, ...kept]) fileNames.add(fileName);
 }
 function routeScopedDynamicImports(chunk, routeFile) {
 	if (!chunk.code) return [];
@@ -1675,10 +2410,23 @@ function routeScopedDynamicImports(chunk, routeFile) {
 	return [...imports];
 }
 function codeStaticImports(chunk) {
-	return codeImportSpecifiers(chunk, /(?:import\s*(?:[^('"`]*?\bfrom\s*)?|export\s*[^('"`]*?\bfrom\s*)["'](\.\/[^"']+\.js)["']/g);
+	return cachedCodeImports(chunk).static;
 }
 function codeDynamicImports(chunk) {
-	return codeDynamicImportSpecifiers(chunk.code ?? "").map((specifier) => normalize(join(dirname(chunk.fileName), specifier)));
+	return cachedCodeImports(chunk).dynamic;
+}
+const chunkCodeImports = /* @__PURE__ */ new WeakMap();
+function cachedCodeImports(chunk) {
+	const cached = chunkCodeImports.get(chunk);
+	if (cached?.code === chunk.code && cached?.fileName === chunk.fileName) return cached;
+	const imports = {
+		code: chunk.code,
+		fileName: chunk.fileName,
+		static: codeImportSpecifiers(chunk, /(?:import\s*(?:[^('"`]*?\bfrom\s*)?|export\s*[^('"`]*?\bfrom\s*)["'](\.\/[^"']+\.js)["']/g),
+		dynamic: codeDynamicImportSpecifiers(chunk.code ?? "").map((specifier) => normalize(join(dirname(chunk.fileName), specifier)))
+	};
+	chunkCodeImports.set(chunk, imports);
+	return imports;
 }
 function codeDynamicImportSpecifiers(code) {
 	const imports = /* @__PURE__ */ new Set();
@@ -1697,6 +2445,15 @@ function codeImportSpecifiers(chunk, pattern) {
 	}
 	return [...imports];
 }
+function chunkRenamesSince(captured, bundle) {
+	const finalNames = new Map(outputChunks(bundle).map((chunk) => [chunk.preliminaryFileName, chunk.fileName]));
+	const renames = /* @__PURE__ */ new Map();
+	for (const [fileName, preliminary] of captured) {
+		const next = preliminary === void 0 ? void 0 : finalNames.get(preliminary);
+		if (next !== void 0 && next !== fileName) renames.set(fileName, next);
+	}
+	return renames;
+}
 function outputChunks(bundle) {
 	return Object.values(bundle).filter((item) => {
 		return isRecord(item) && item.type === "chunk" && typeof item.fileName === "string" && Array.isArray(item.imports) && Array.isArray(item.dynamicImports);
@@ -1709,24 +2466,26 @@ function routeFileForChunk(root, chunk) {
 	}
 }
 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;
+	const ranked = chunks.map((chunk) => ({
+		chunk,
+		rank: routeChunkRank(root, routeFile, chunk)
+	}));
+	const highestRank = Math.max(...ranked.map(({ rank }) => rank));
+	const candidates = ranked.filter(({ rank }) => rank === highestRank);
+	if (candidates.length !== 1) throw new Error(`Markless Router found ambiguous primary chunks for ${routeFile}: ${candidates.map(({ chunk }) => chunk.fileName).sort().join(", ")}`);
+	return candidates[0].chunk;
+}
+function isNavigationOnlyRouteChunk(root, routeFile, chunk) {
+	const owned = [chunk.facadeModuleId, ...chunk.moduleIds ?? []].filter((moduleId) => !!moduleId && routeFileForModuleId(root, moduleId) === routeFile);
+	return owned.length > 0 && owned.every(isRouteNavigationSourceRequest);
 }
 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;
+		if (!moduleId || routeFileForModuleId(root, moduleId) !== routeFile) continue;
+		const role = isClientPrimarySourceRequest(moduleId) ? 5 : isRenderDataSourceRequest(moduleId) ? 4 : isSymbolOnlySourceRequest(moduleId) ? 1 : isResumeSourceRequest(moduleId) ? 2 : 3;
+		const ownsModule = chunk.moduleIds?.includes(moduleId) ? 1 : 0;
+		rank = Math.max(rank, role * 2 + ownsModule);
 	}
 	return rank;
 }
@@ -1747,5 +2506,8 @@ function configRoot(config) {
 	const root = config.root;
 	return typeof root === "string" ? root : ".";
 }
+function escapeRegExp(value) {
+	return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
 //#endregion
 export { router };