@markless/router 0.5.0 → 0.7.0

package/dist/vite/runtime/mdx-route.d.ts

@@ -368,9 +368,23 @@ type ProtocolViewPayload = {
      * Element children of the parent that stand before the rows. Rows occupy
      * `[rowStartOffset, rowStartOffset + items.length)` among the parent's child
      * elements; a repeat whose rows begin at 0 omits the field. A repeat whose
-     * prefix has no compile-time element count ships no record at all.
+     * prefix has no compile-time element count says `rowEndOffset` instead, or
+     * ships no record at all when its suffix has none either.
      */
     readonly rowStartOffset?: number;
+    /**
+     * Element children of the parent that stand after the rows, set only when
+     * the prefix has no compile-time element count. Rows then occupy the
+     * `items.length` element children ending `rowEndOffset` before the last.
+     */
+    readonly rowEndOffset?: number;
+    /**
+     * The browser can never change these rows: the collection and every value a
+     * row shows are fixed once the page is served, so the record carries no row
+     * markup and resume neither follows the collection nor loads row-building
+     * code. Pay-per-use: a repeat whose rows can change omits the field.
+     */
+    readonly fixed?: true;
     /**
      * The `@empty` arm's finished markup, for the mint that raises it when the
      * collection empties after resume and takes it back out when a row returns.
@@ -756,11 +770,13 @@ type RuntimeGraphDelete = {
   readonly graphNodeId: string;
   readonly path: ReadonlyArray<string>;
 };
+/** DOM work a subscription holds back until its whole pass has run, so it lands in one task with that pass's journal. */
+type RuntimeGraphCommit = () => void | Promise<void>;
 type RuntimeGraphSubscription = {
   readonly id: string;
   readonly graphNodeId: string;
   readonly path?: ReadonlyArray<string>;
-  readonly run: (value: unknown) => DomJournalResult | void | Promise<DomJournalResult | void>;
+  readonly run: (value: unknown) => DomJournalResult | RuntimeGraphCommit | void | Promise<DomJournalResult | RuntimeGraphCommit | void>;
 };
 /**
  * Told about a write the moment it lands, before the flush that write schedules.
@@ -820,6 +836,8 @@ type RuntimeGraph = {
   readonly settleWriteObservers?: () => Promise<void> | undefined;
   /** Whether a write is waiting on a flush that has not yet reached the journal. */
   readonly hasPendingFlush?: () => boolean;
+  /** Keeps the scheduled flush back until each returned release has run once; `flush()` itself still runs. */
+  readonly holdFlush?: () => () => void;
   readonly subscribeJournal: (listener: DomJournalListener) => () => void;
   readonly flush: () => Promise<void>;
   readonly takeJournal: () => DomJournalEntry[];
@@ -897,6 +915,7 @@ type ResumeDomEvent = {
   readonly bubbles?: boolean;
   readonly preventDefault?: () => void;
   readonly stopPropagation?: () => void;
+  readonly composedPath?: () => ReadonlyArray<ResumeDomElement>;
   __marklessPressHost?: ResumeDomElement;
 };
 type ResumeSharedPatchEvent = {

package/dist/vite/runtime/mdx-route.js

@@ -1,4 +1,64 @@
 import { i as protocolStateVersion, n as protocolInstanceQualifies, t as protocolInstancePath } from "../../protocol-constants-B4WxrZAS.js";
+//#endregion
+//#region ../serializer/src/protocol-record-keys.ts
+/** The field names each templated record list may spell, in the order its templates index them. */
+const PROTOCOL_RECORD_KEYS = {
+	"markless/state": {
+		computed: "graphNodeId name async deriveSymbolId value version root $type $ref source flags records id type fields items entries values bytes arrayType buffer byteOffset length byteLength directValue dependencies path snapshot status key error",
+		sharedSeeds: "graphNodeId deriveSymbolId dependencies path reads",
+		sharedDefinitions: "id name exportedName scope version graphNodeIds projectionIds dependencies definitionId definitionName returnProperties kind graphNodeId path"
+	},
+	"markless/view": {
+		domUpdates: "hostNodeId source graphNodeId path target kind prefix suffix trueValue falseValue textNode name constantClass leadingClass symbolId",
+		behaviors: "hostNodeId source functionSource inputSources inputValues inputGraphReads inputIndex graphNodeId path symbolId usesGraph",
+		elementHandles: "hostNodeId handleId name plural"
+	}
+};
+//#endregion
+//#region ../serializer/src/protocol-templated-lists.ts
+/**
+* The record lists a payload script may serve as record templates instead of a plain array. The
+* inline resumer reads the others at page load, before any decoder has loaded, so they stay plain.
+*/
+const PROTOCOL_TEMPLATED_LISTS = {
+	"markless/state": [
+		"computed",
+		"sharedSeeds",
+		"sharedDefinitions"
+	],
+	"markless/view": [
+		"domUpdates",
+		"behaviors",
+		"elementHandles"
+	]
+};
+//#endregion
+//#region ../serializer/src/protocol-record-templates.ts
+function expandRecordTemplates(list, keys = "") {
+	if (Array.isArray(list)) return list;
+	const { t, r } = list;
+	const names = keys.split(" ");
+	const parts = t.map((text) => text.replace(/~(\d+):/g, (_, at) => `"${names[+at]}":`).split(/\^(\d+)/));
+	return r.map((ref) => {
+		if (typeof ref === "number") return JSON.parse(parts[ref][0]);
+		if (!Array.isArray(ref)) return ref;
+		const part = parts[ref[0]];
+		let text = part[0];
+		for (let at = 1; at < part.length; at += 2) text += ref[+part[at] + 1] + part[at + 1];
+		return JSON.parse(text);
+	});
+}
+/** Expands, in place, every templated list of a freshly parsed payload script. */
+function decodeProtocolPayloadLists(type, payload) {
+	const record = payload;
+	const keys = PROTOCOL_RECORD_KEYS[type];
+	if (record) for (const key of PROTOCOL_TEMPLATED_LISTS[type]) {
+		const list = record[key];
+		if (list && !Array.isArray(list)) record[key] = expandRecordTemplates(list, keys[key]);
+	}
+	return payload;
+}
+//#endregion
 //#region ../serializer/src/storage-cookie.ts
 const STORAGE_RENDER_CONTEXT_READER = "storageValue";
 //#endregion
@@ -582,9 +642,11 @@ const marklessDecodeScalarCell = (c, g, s) => {
 const marklessFindElementAtDomOrderIndex = (r, i) => {
 	let c = r.__marklessCensus;
 	if (!c) {
-		const w = document.createTreeWalker(r, 1);
+		const w = document.createTreeWalker(r, 129);
 		c = r.__marklessCensus = r.nodeType === 1 ? [r] : [];
-		for (let n; n = w.nextNode();) c.push(n);
+		for (let n; n = w.nextNode();) if (n.nodeType !== 8) c.push(n);
+		else if (n.data === "markless:page-start") c.length = 1;
+		else if (n.data === "markless:page-end") break;
 	}
 	return c[i];
 };
@@ -744,7 +806,7 @@ function locate(root, view, host) {
 }
 function readScript(root, type) {
 	const text = root.querySelector(`script[type="${type}"]`)?.textContent;
-	return text ? JSON.parse(text) : void 0;
+	return text ? decodeProtocolPayloadLists(type, JSON.parse(text)) : void 0;
 }
 function references(value, id) {
 	return value === id || !!value && typeof value === "object" && Object.values(value).some((child) => references(child, id));

package/dist/vite.js

@@ -1,17 +1,16 @@
-import { i as SCROLL_ATTRIBUTE, n as PREFETCH_ATTRIBUTE, r as REPLACE_ATTRIBUTE, t as LINK_ATTRIBUTE } from "./link-attributes-nY1Qkmx2.js";
-import { a as normalizeRouteFileId, n as isPageModuleFile, t as buildRouteManifestFromFileIds } from "./route-manifest-Bw_nFohL.js";
-import { r as transformRequestFileSource } from "./request-files-Ca8E0FOo.js";
+import { d as REPLACE_ATTRIBUTE, f as SCROLL_ATTRIBUTE, l as LINK_ATTRIBUTE, u as PREFETCH_ATTRIBUTE } from "./request-locals-BDAhNpEa.js";
+import { i as matchRouteManifest, 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 startFragmentNavigation, s as listenForLinkIntent } from "./fragment-navigation-CIiNnFFc.js";
+import { a as runFragmentNavigation, i as FRAGMENT_PATH_PREFIX, n as routerLinkBridgeModules, o as startFragmentNavigation, s as listenForLinkIntent } from "./create-server-entry-yboa-2m6.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 { decodePath, joinURL, parsePath, parseQuery, parseURL, stringifyQuery, withLeadingSlash, withQuery, withoutBase, withoutLeadingSlash } from "ufo";
+import { existsSync, readdirSync } from "node:fs";
 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, startupPackOfLazy, symbolVirtualModuleSourceFile } from "@markless/bundler/preload";
-import { MARKLESS_BUILD_METADATA_FILES, MARKLESS_BUILD_PREFIX, MARKLESS_CHUNK_SPECIFIER_PREFIX, MARKLESS_IMPORT_MAP_ASSET, importMapScript, marklessBuildManifestDir } from "@markless/bundler/rolldown";
+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";
@@ -119,6 +118,7 @@ function createLinkTypes() {
 //#endregion
 //#region src/vite/route-typegen.ts
 const PAGE_EXTENSIONS = /* @__PURE__ */ new Set([".tsrx", ".mdx"]);
+const ENDPOINT_EXTENSIONS = /* @__PURE__ */ new Set([".ts"]);
 function routeTypegenPlugin() {
 	let root = "";
 	return {
@@ -137,26 +137,25 @@ function routeTypegenPlugin() {
 async function writeRouteTypes(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 {
@@ -513,7 +512,8 @@ function createClientAssetsManifest(input) {
 			resume: input.resumeEntry,
 			...input.prerenderWakeEntry ? { prerenderWake: input.prerenderWakeEntry } : {},
 			navigation: input.navigationEntry,
-			...input.fragmentEntry ? { fragment: input.fragmentEntry } : {}
+			...input.fragmentEntry ? { fragment: input.fragmentEntry } : {},
+			...input.fragmentImports?.length ? { fragmentImports: input.fragmentImports } : {}
 		},
 		routes: {
 			navigation: sortRouteMap(input.routes.navigation),
@@ -602,7 +602,8 @@ async function validateClientAssetsManifest(input, base, clientOutDir) {
 		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"),
-		...input.entries.fragment !== void 0 ? { fragment: requiredString(input.entries.fragment, "entries.fragment") } : {}
+		...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"),
@@ -616,6 +617,7 @@ async function validateClientAssetsManifest(input, base, clientOutDir) {
 		...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(),
@@ -640,6 +642,10 @@ async function validateClientAssetsManifest(input, base, clientOutDir) {
 		...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 = {};
@@ -840,7 +846,7 @@ function emitQueuedResumeContainerEvent(source, { censusRepair = true } = {}) {
 		"	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;",
+		"		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);",
@@ -848,7 +854,8 @@ function emitQueuedResumeContainerEvent(source, { censusRepair = true } = {}) {
 		"		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) return done;",
+		"			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;",
@@ -1444,6 +1451,63 @@ 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",
@@ -1467,6 +1531,7 @@ 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";
@@ -1507,8 +1572,9 @@ function router(options = {}) {
 	const fragmentEntry = resumeEntryState();
 	const routePreloads = routePreloadState();
 	return [
-		routerConfigPlugin(nitroPlugins, resumeEntry, prerenderWakeEntry, navigationEntry, routePreloads, fragmentEntry),
+		routerConfigPlugin(nitroPlugins, resumeEntry, prerenderWakeEntry, navigationEntry, routePreloads, fragmentEntry, serverBuildState()),
 		devSourceModuleRequestPlugin(),
+		devPageForUrlPlugin(options),
 		pageServerOnlyPropsPlugin(),
 		mdxTransformPlugin(),
 		requestFileTransformPlugin(),
@@ -1516,6 +1582,7 @@ function router(options = {}) {
 		anchorTransformPlugin(),
 		htmlTransformPlugin(),
 		virtualModulesPlugin(resumeEntry, prerenderWakeEntry, navigationEntry, routePreloads, options, fragmentEntry),
+		linkBridgeFilesPlugin(navigationEntry, fragmentEntry, options),
 		nitroPlugins
 	];
 }
@@ -1523,10 +1590,43 @@ function pageServerOnlyPropsPlugin() {
 	return {
 		name: "markless-router:page-server-only-props",
 		configResolved(config) {
-			config.plugins.find((plugin) => typeof plugin.api?.declareServerOnlyProps === "function")?.api.declareServerOnlyProps((moduleId) => isPageModuleFile(normalizeRouteFileId(moduleId)) ? PAGE_SERVER_ONLY_PROPS : void 0);
+			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 devPageForUrlPlugin(options) {
+	return {
+		name: "markless-router:dev-page-for-url",
+		apply: "serve",
+		configResolved(config) {
+			config.plugins.find((plugin) => typeof plugin.api?.declarePageForUrl === "function")?.api.declarePageForUrl((href) => devPageForUrl(config.root, config.base, options.mode, href));
 		}
 	};
 }
+function devPageForUrl(root, base, mode, href) {
+	let url;
+	try {
+		url = new URL(href);
+	} catch {
+		return;
+	}
+	const pagesDir = join(root, "pages");
+	if (!existsSync(pagesDir)) return void 0;
+	const fileIds = readdirSync(pagesDir, {
+		recursive: true,
+		encoding: "utf8"
+	}).map((file) => join("pages", file));
+	let manifest;
+	try {
+		manifest = buildRouteManifestFromFileIds(fileIds);
+	} catch {
+		return;
+	}
+	const pathname = mode === "hash" && url.hash.startsWith("#/") ? url.hash.slice(1) : withoutBase(url.pathname, base);
+	return matchRouteManifest(pathname, manifest)?.route.file ?? manifest.statusPages.notFound;
+}
 function devSourceModuleRequestPlugin() {
 	let root = "";
 	return {
@@ -1547,7 +1647,7 @@ function devSourceModuleRequestPlugin() {
 		}
 	};
 }
-function routerConfigPlugin(nitroPluginsFromRouter, resumeEntry, prerenderWakeEntry, navigationEntry, routePreloads, fragmentEntry = resumeEntryState()) {
+function routerConfigPlugin(nitroPluginsFromRouter, resumeEntry, prerenderWakeEntry, navigationEntry, routePreloads, fragmentEntry = resumeEntryState(), serverBuild = serverBuildState()) {
 	let clientOutDir = "";
 	let clientEnvironmentName = "";
 	let clientEnvironmentConfig;
@@ -1581,7 +1681,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, env?.command === "build"),
+				nitro: createNitroConfig(config.nitro, config.root, serverWatch.ignored, env?.command === "build", serverBuild),
 				server: {
 					...config.server,
 					watch: serverWatch
@@ -1642,6 +1742,7 @@ function routerConfigPlugin(nitroPluginsFromRouter, resumeEntry, prerenderWakeEn
 			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;
@@ -1660,7 +1761,17 @@ function routerConfigPlugin(nitroPluginsFromRouter, resumeEntry, prerenderWakeEn
 				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;
+				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,
@@ -1680,15 +1791,19 @@ 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) } : {},
+						...fragmentEntry.fileName ? {
+							fragmentEntry: joinURL(routePreloads.base, fragmentEntry.fileName),
+							fragmentImports: fragmentEntry.imports
+						} : {},
 						routes: routePreloads.routes
 					});
 				}
 			}
 		},
-		async writeBundle(_options, bundle) {
+		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();
@@ -1701,6 +1816,7 @@ function routerConfigPlugin(nitroPluginsFromRouter, resumeEntry, prerenderWakeEn
 					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 = {
@@ -1744,6 +1860,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) {
@@ -1760,7 +1877,7 @@ function requestFileBuildTransformPlugin(root) {
 		}
 	};
 }
-function createNitroConfig(nitroConfig, root = ".", serverWatchIgnored = [], isBuild = false) {
+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 : [];
@@ -1780,9 +1897,15 @@ function createNitroConfig(nitroConfig, root = ".", serverWatchIgnored = [], isB
 			...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" } },
-			...Object.fromEntries(MARKLESS_BUILD_METADATA_FILES.map((file) => [`/${file}`, { headers: { "cache-control": "public, max-age=0, must-revalidate" } }])),
+			[`/_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),
@@ -1935,8 +2058,75 @@ 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 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);
@@ -1950,14 +2140,17 @@ function serverEntrySource(root, options) {
 		`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,`,
@@ -1973,8 +2166,8 @@ function serverEntrySource(root, options) {
 		`export default entry;`
 	].join("\n");
 }
-function minifiedFragmentNavigationSource() {
-	const result = minifySync("markless-fragment-navigation.js", `export default (${startFragmentNavigation.toString()});`, {
+function minifiedFragmentNavigationSource(source = startFragmentNavigation) {
+	const result = minifySync("markless-fragment-navigation.js", `export default (${source.toString()});`, {
 		compress: true,
 		mangle: true,
 		module: true
@@ -2086,6 +2279,10 @@ 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 = {};
@@ -2135,8 +2332,10 @@ function routeModulePreloadsFromBundle(input) {
 		}
 		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, scope, fileName, true);
 				includeChunk(ssrFileNames, landingScope, fileName, true);
@@ -2145,6 +2344,7 @@ function routeModulePreloadsFromBundle(input) {
 		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));
 		const firstEventPath = /* @__PURE__ */ new Set();
 		const lazySiblings = [...ssrFileNames].filter((fileName) => {
@@ -2157,7 +2357,7 @@ function routeModulePreloadsFromBundle(input) {
 			for (const fileName of routeScopedDynamicImports(entry, routeFile)) includeChunk(firstEventPath, landingScope, fileName);
 		}
 		for (const fileName of lazySiblings) includeChunk(firstEventPath, landingScope, fileName);
-		ssr[routeFile] = [...[...firstEventPath].filter((fileName) => ssrFileNames.has(fileName)), ...[...ssrFileNames].filter((fileName) => !firstEventPath.has(fileName))].map((fileName) => joinURL(input.base, 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 {