@markless/router 0.2.2 → 0.3.1

package/README.md

@@ -4,4 +4,4 @@ Markless router: client-side navigation with SSR streaming and build-time
 preload maps. Used through `@markless/core/router` and the
 `@markless/router/vite` plugin.
 
-See the repository for documentation: https://github.com/markless-dev/markless
+See the repository for documentation: https://github.com/compiled-run/markless

package/dist/{debug-channel-C7v9u5SM.js → debug-channel-CSzo-Zj8.js}

@@ -28,6 +28,7 @@ function installDebugChannelLayer(root, initialPhase, initiallyActive = true) {
 	const rootKey = priorContainer?.root.key ?? `root:${seed}`;
 	const rootRef = new WeakRef(root);
 	const events = /* @__PURE__ */ new WeakMap();
+	const delegatedEvents = /* @__PURE__ */ new Set();
 	const keys = /* @__PURE__ */ new WeakMap();
 	const invalidated = /* @__PURE__ */ new WeakSet();
 	const routerSources = global[Symbol.for("markless.debug.channel.v1.router-sources")] ??= /* @__PURE__ */ new Set();
@@ -99,6 +100,13 @@ function installDebugChannelLayer(root, initialPhase, initiallyActive = true) {
 		}
 		const interaction = events.get(element)?.get(eventName);
 		if (interaction) return freeze({ ...interaction });
+		if (delegatedEvents.has(eventName)) return freeze({
+			kind: "inline-resumer",
+			source: "ssr-inline",
+			containerId: id,
+			elementKey: keyFor(element),
+			eventName
+		});
 		if (invalidated.has(element)) return none(element, eventName, "not-registered");
 		try {
 			const prior = previous?.explainInteraction(element, eventName);
@@ -209,6 +217,10 @@ function installDebugChannelLayer(root, initialPhase, initiallyActive = true) {
 				eventName
 			}));
 		},
+		delegated(eventNames) {
+			if (lifecycle === "disposed") return;
+			for (const eventName of eventNames) delegatedEvents.add(eventName);
+		},
 		violation: pushViolation,
 		router: (source) => void routerSources.add(source),
 		boundaries(value) {
@@ -236,7 +248,7 @@ function safely(run) {
 	}
 }
 function __marklessDebugBootstrapSource() {
-	return `((root,phase,active)=>{const controls=(${installDebugChannelLayer.toString()})(root,phase,active);return Object.freeze({record:(element,eventName,input)=>controls.record(element,eventName,input),router:(source)=>controls.router(source),activate:()=>controls.activate()})})`;
+	return `((root,phase,active)=>{const controls=(${installDebugChannelLayer.toString()})(root,phase,active);return Object.freeze({record:(element,eventName,input)=>controls.record(element,eventName,input),delegated:(eventNames)=>controls.delegated(eventNames),router:(source)=>controls.router(source),activate:()=>controls.activate()})})`;
 }
 function __marklessDebugRegisterRouter(root, source) {
 	if (root) safely(() => (moduleRoots.get(root) ?? controlsFor(root, "ssr-resume")).router(source));

package/dist/index.d.ts

@@ -1,3 +1,5 @@
+import { createExternalDelegateStructureTokens, createExternalDelegateView } from "@markless/web/fns/external-delegate";
+
 //#region src/route-manifest.d.ts
 interface RouteManifestRoute {
   readonly pathname: string;
@@ -186,15 +188,25 @@ declare const Html: ((props: {
     readonly children?: unknown;
   }): {
     html: string;
+    elementCount: number;
   };
 };
-declare const Link: ((props?: LinkProps) => unknown) & {
+type LinkComponent = {
+  (props?: LinkProps): unknown;
   renderCsr(props?: LinkProps): {
     root: HTMLAnchorElement;
+    view: ReturnType<typeof createExternalDelegateView>;
+    liveHostNodes: Map<string, HTMLAnchorElement>;
   };
-  renderSsr(props?: LinkProps): {
+  renderSsr(props?: LinkProps, renderContext?: {
+    readonly idPrefix?: string;
+  }): {
     html: string;
+    elementCount: number;
+    structureTokens: ReturnType<typeof createExternalDelegateStructureTokens>;
+    view: ReturnType<typeof createExternalDelegateView>;
   };
 };
+declare const Link: LinkComponent;
 //#endregion
 export { type ApiRequestFileCache, type ApiRequestFileMethod, type ApiRequestFileRoute, AppLocals, DefaultLinkProps, EndpointHttpContext, Html, HttpContext, HttpResponse, Link, LinkNavigationProps, LinkProps, MARKLESS_ROUTER_ROUTE_EVENT, MarklessRouterGeneratedRoutes, MiddlewareHttpContext, PageProps, type RequestFileDefaultExport, type RequestFileDiagnostic, type RequestFileDiagnosticCode, type RequestFileParam, type RequestFileParseResult, type RequestFileTransformResult, type RouteDocumentModule, type RouteManifest, type RouteManifestMatch, type RouteManifestParam, type RouteManifestRoute, type RouteManifestStatusPages, type RoutePageModule, type RouteState, type RouteUpdate, __marklessCreateHttpContext, __marklessRouterStartSpaNavigation, buildRouteManifestFromFileIds, dispatchRouteUpdate, ensureNavigationRuntime, matchRouteManifest, normalizeRequestFileId, normalizeRequestPathname, normalizeRouteFileId, parseRequestFile, routePageProps, startRouteUpdateRenderer, transformRequestFileSource };

package/dist/index.js

@@ -1,5 +1,6 @@
 import { i as normalizeRouteFileId, n as matchRouteManifest, r as normalizeRequestPathname, t as buildRouteManifestFromFileIds } from "./route-manifest-DPgGIyrS.js";
 import { n as parseRequestFile, r as transformRequestFileSource, t as normalizeRequestFileId } from "./request-files-C-0LLSsx.js";
+import { createExternalDelegateStructureTokens, createExternalDelegateView } from "@markless/web/fns/external-delegate";
 import { render } from "@markless/web/render";
 import { MARKLESS_PENDING_MIN_VISIBLE_MS as MARKLESS_NAV_PENDING_MIN_MS, settleOrPendingDeadline } from "@markless/web";
 //#region src/navigation-hold.ts
@@ -31,6 +32,7 @@ function dispatchRouteUpdate(document, update) {
 }
 //#endregion
 //#region src/route-renderer.ts
+const CURRENT_ROUTE_CONTAINER = "__marklessRouterCurrentRouteContainer";
 function startRouteUpdateRenderer(document = window.document) {
 	const state = document;
 	if (state["__marklessRouterRouteRendererStarted"]) return;
@@ -43,18 +45,25 @@ async function renderRouteUpdate(document, update) {
 	try {
 		const artifact = update.page.default;
 		if (!artifact || update.signal?.aborted) return;
+		if (!artifact.renderData) throw new Error(`MARKLESS_ROUTER_RENDER_DATA_MISSING: Navigated route ${JSON.stringify(update.route.file)} has no linked render-data module.`);
 		const props = routePageProps(update.route);
-		if (typeof artifact.renderCsr === "function") {
-			await render({ renderCsr: () => artifact.renderCsr?.(props) }, {
-				target: document.body,
-				beforeMount: (container) => holdNavigationSwapUntilSettled({
-					runtime: container.runtime,
+		const state = document;
+		const container = await render({
+			renderData: artifact.renderData,
+			loadSymbol: artifact.loadSymbol,
+			props
+		}, {
+			target: document.body,
+			beforeMount: async (incoming) => {
+				if (await holdNavigationSwapUntilSettled({
+					runtime: incoming.runtime,
 					signal: update.signal
-				})
-			});
-			return;
-		}
-		if (typeof artifact.renderSsr === "function") document.body.innerHTML = (await artifact.renderSsr(props)).html;
+				}) === false) return false;
+				state[CURRENT_ROUTE_CONTAINER]?.runtime?.dispose?.();
+				return true;
+			}
+		});
+		if (!update.signal?.aborted) state[CURRENT_ROUTE_CONTAINER] = container;
 	} finally {
 		update.onRendered?.();
 	}
@@ -89,8 +98,8 @@ async function __marklessRouterStartSpaNavigation(options) {
 	navigation.addEventListener("navigate", (event) => {
 		handleNavigateEvent(event, context);
 	});
-	if (typeof __MARKLESS_DEBUG_ENABLED__ !== "undefined" && __MARKLESS_DEBUG_ENABLED__) await import("./debug-channel-C7v9u5SM.js").then((n) => n.n).then((debug) => debug.__marklessDebugRegisterRouter(void 0, "spa-click-listener")).catch(() => {});
-	if (typeof __MARKLESS_DEBUG_ENABLED__ !== "undefined" && __MARKLESS_DEBUG_ENABLED__) await import("./debug-channel-C7v9u5SM.js").then((n) => n.n).then((debug) => debug.__marklessDebugRegisterRouter(void 0, "navigation-event")).catch(() => {});
+	if (typeof __MARKLESS_DEBUG_ENABLED__ !== "undefined" && __MARKLESS_DEBUG_ENABLED__) await import("./debug-channel-CSzo-Zj8.js").then((n) => n.n).then((debug) => debug.__marklessDebugRegisterRouter(void 0, "spa-click-listener")).catch(() => {});
+	if (typeof __MARKLESS_DEBUG_ENABLED__ !== "undefined" && __MARKLESS_DEBUG_ENABLED__) await import("./debug-channel-CSzo-Zj8.js").then((n) => n.n).then((debug) => debug.__marklessDebugRegisterRouter(void 0, "navigation-event")).catch(() => {});
 	{
 		const bootUrl = parseSameOriginUrl(runtimeWindow.location.href, runtimeWindow.location.href);
 		const bootHashPath = bootUrl ? hashRoutePath(bootUrl) : void 0;
@@ -228,7 +237,10 @@ function __marklessCreateHttpContext(event) {
 const Html = Object.assign(function Html(props) {
 	return props.children;
 }, { renderSsr(props = {}) {
-	return { html: props.children == null ? "" : String(props.children) };
+	return {
+		html: props.children == null ? "" : String(props.children),
+		elementCount: 0
+	};
 } });
 const Link = Object.assign(function Link(props = {}) {
 	return props.children;
@@ -237,12 +249,33 @@ const Link = Object.assign(function Link(props = {}) {
 		const anchor = document.createElement("a");
 		for (const [name, value] of linkAnchorAttributes(props)) anchor.setAttribute(name, value);
 		anchor.innerHTML = linkChildrenHtml(props);
-		return { root: anchor };
+		return {
+			root: anchor,
+			view: linkExternalDelegateView(),
+			liveHostNodes: new Map([["router:link", anchor]])
+		};
 	},
-	renderSsr(props = {}) {
-		return { html: `<a ${linkAnchorAttributes(props).map(([name, value]) => value === "" ? name : `${name}="${escapeHtml(value)}"`).join(" ")}>${linkChildrenHtml(props)}</a>` };
+	renderSsr(props = {}, renderContext) {
+		return {
+			html: `<a ${linkAnchorAttributes(props).map(([name, value]) => value === "" ? name : `${name}="${escapeHtml(value)}"`).join(" ")}>${linkChildrenHtml(props)}</a>`,
+			elementCount: 1,
+			structureTokens: createExternalDelegateStructureTokens({
+				hostNodeId: "router:link",
+				idPrefix: renderContext?.idPrefix,
+				tagName: "a"
+			}),
+			view: linkExternalDelegateView()
+		};
 	}
 });
+function linkExternalDelegateView() {
+	return createExternalDelegateView({
+		eventName: "click",
+		hostNodeId: "router:link",
+		owner: "router",
+		tagName: "a"
+	});
+}
 function linkAnchorAttributes(props) {
 	const attributes = /* @__PURE__ */ new Map();
 	const input = props;

package/dist/vite/runtime/create-server-entry.d.ts

@@ -5,6 +5,7 @@ interface ServerEntryOptions {
   readonly dev?: boolean;
   readonly navigationEntryPath?: string;
   readonly resumeEntryPath?: string;
+  readonly prerenderWakeEntryPath?: string;
   readonly routeModulePreloads?: Record<string, readonly ModulePreloadInput[]>;
   readonly routeSsrModulePreloads?: Record<string, readonly ModulePreloadInput[]>;
   readonly routeStylesheets?: Record<string, readonly string[]>;

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

@@ -1,4 +1,4 @@
-import { t as __marklessDebugBootstrapSource } from "../../debug-channel-C7v9u5SM.js";
+import { t as __marklessDebugBootstrapSource } from "../../debug-channel-CSzo-Zj8.js";
 import { i as normalizeRouteFileId, n as matchRouteManifest, t as buildRouteManifestFromFileIds } from "../../route-manifest-DPgGIyrS.js";
 import { renderToString } from "@markless/web/render-to-string";
 import { renderToStream } from "@markless/web/render-to-stream";
@@ -80,20 +80,24 @@ function createServerEntry(options) {
 			});
 		}
 		const pageArtifact = routedPageArtifact(renderSsr, baseArtifact, pageProps, file, options.navigationEntryPath, options.routeStylesheets?.[file]);
+		const routedArtifact = options.prerenderWakeEntryPath ? {
+			...pageArtifact,
+			prerenderWakeModuleUrl: options.prerenderWakeEntryPath
+		} : pageArtifact;
 		const renderOptions = {
 			props: pageProps,
 			resumeModuleUrl: options.resumeEntryPath ?? baseArtifact?.resumeModuleUrl,
 			modulePreloads: (html) => modulePreloadsForPage(file, html, pageProps.url.href, manifest, options.routeModulePreloads, options.routeSsrModulePreloads)
 		};
 		if (options.render === "blocking") {
-			const pageHtml = splitLeadingHeadHtml(await renderToString(pageArtifact, renderOptions));
+			const pageHtml = splitLeadingHeadHtml(await renderToString(routedArtifact, renderOptions));
 			const shell = await renderDocumentShell(documentModule, pageProps, pageHtml.headHtml);
 			return new Response(fillDocumentChildren(shell, pageHtml.bodyHtml), {
 				status,
 				headers
 			});
 		}
-		const stream = await renderToStream(pageArtifact, renderOptions);
+		const stream = await renderToStream(routedArtifact, renderOptions);
 		const pageHtml = splitLeadingHeadHtml(stream.shell);
 		const shell = await renderDocumentShell(documentModule, pageProps, pageHtml.headHtml);
 		if (stream.pendingArmCount === 0) return new Response(fillDocumentChildren(shell, pageHtml.bodyHtml), {
@@ -104,18 +108,34 @@ function createServerEntry(options) {
 		const prefix = placeholderAt === -1 ? shell : shell.slice(0, placeholderAt) + pageHtml.bodyHtml;
 		const suffix = placeholderAt === -1 ? "" : shell.slice(placeholderAt + 37);
 		const encoder = new TextEncoder();
-		const body = new ReadableStream({ async start(controller) {
-			controller.enqueue(encoder.encode(prefix));
-			try {
-				for await (const chunk of stream.appends()) controller.enqueue(encoder.encode(chunk));
-			} catch (error) {
-				console.error("[markless-router] streaming settle failed:", error);
-				controller.error(error);
-				return;
+		let cancelled = false;
+		let completed = false;
+		const body = new ReadableStream({
+			async start(controller) {
+				controller.enqueue(encoder.encode(prefix));
+				try {
+					for await (const chunk of stream.appends()) {
+						if (cancelled) return;
+						controller.enqueue(encoder.encode(chunk));
+					}
+				} catch (error) {
+					if (cancelled) return;
+					console.error("[markless-router] streaming settle failed:", error);
+					controller.error(error);
+					completed = true;
+					return;
+				}
+				if (cancelled) return;
+				controller.enqueue(encoder.encode(suffix));
+				controller.close();
+				completed = true;
+			},
+			cancel(reason) {
+				if (completed) return;
+				cancelled = true;
+				stream.cancel(reason);
 			}
-			controller.enqueue(encoder.encode(suffix));
-			controller.close();
-		} });
+		});
 		return new Response(body, {
 			status,
 			headers
@@ -261,7 +281,20 @@ function fillDocumentChildren(documentShell, children) {
 	return documentShell.slice(0, at) + children + documentShell.slice(at + 37);
 }
 async function renderDocumentModule(documentModule, props) {
-	return (await documentModule?.default?.renderSsr?.(props))?.html;
+	const output = await documentModule?.default?.renderSsr?.(props);
+	assertDocumentStorageFree(output);
+	return output?.html;
+}
+function assertDocumentStorageFree(output) {
+	const storage = documentStorageRecords(output?.state);
+	if (storage.length === 0) return;
+	const keys = storage.map((record) => record.key).join(", ");
+	throw new Error(`MARKLESS_ROUTER_DOCUMENT_STORAGE_UNSUPPORTED: the document declares storage cells (${keys}), but the router serves only the document's HTML, so their state payload never reaches the browser and they can never resume. Declare storage() at module scope in a component the page renders instead.`);
+}
+function documentStorageRecords(state) {
+	if (!state || typeof state !== "object") return [];
+	const storage = state.storage;
+	return Array.isArray(storage) ? storage : [];
 }
 function insertHeadHtml(documentHtml, headHtml) {
 	if (!headHtml) return documentHtml;

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

@@ -2,6 +2,8 @@
 type MdxRoutePart = {
   readonly kind: 'html';
   readonly elementCount: number;
+  readonly html?: string;
+  readonly elementTags?: ReadonlyArray<string>;
 } | {
   readonly kind: 'component';
   readonly componentIndex: number;
@@ -12,7 +14,6 @@ type MdxRenderOutput = {
   readonly state?: MdxStatePayload;
   readonly view?: MdxViewPayload;
   readonly loadSymbol?: (symbolId: string) => unknown;
-  readonly connectRuntime?: (context: unknown) => unknown;
 };
 type MdxChild = {
   readonly componentIndex: number;
@@ -28,11 +29,34 @@ type MdxSymbolLoader = {
   readonly prefix: string;
   readonly loadSymbol: (symbolId: string) => unknown;
 };
+type MdxRenderDataSurface = {
+  readonly rootComponentName: string | null;
+  readonly renderData: Readonly<Record<string, unknown>>;
+  readonly components: Readonly<Record<string, unknown>>;
+  readonly imports: Readonly<Record<string, MdxRenderDataSurface>>;
+};
+type MdxRenderDataChild = {
+  readonly componentIndex: number;
+  readonly hostPrefix: string;
+  readonly symbolPrefix: string;
+  readonly props: Readonly<Record<string, unknown>>;
+  readonly surface: MdxRenderDataSurface;
+};
+declare function createMdxRenderDataSurface(parts: ReadonlyArray<MdxRoutePart>, children: ReadonlyArray<MdxRenderDataChild>): MdxRenderDataSurface;
+type MdxComputedRecord = {
+  readonly deriveSymbolId?: string;
+  readonly [key: string]: unknown;
+};
+type MdxStorageRecord = {
+  readonly graphNodeId: string;
+  readonly key: string;
+};
 type MdxStatePayload = {
   readonly version: unknown;
   readonly cells?: readonly unknown[];
-  readonly computed?: readonly unknown[];
+  readonly computed?: readonly MdxComputedRecord[];
   readonly sharedDefinitions?: readonly unknown[];
+  readonly storage?: readonly MdxStorageRecord[];
 };
 type MdxLocator = {
   readonly hostNodeId: string;
@@ -59,10 +83,8 @@ type MdxViewPayload = {
   readonly asyncBoundaries?: readonly unknown[];
 };
 declare function renderMdxChild(children: MdxChild[], component: MdxComponentArtifact, props: unknown, child: Omit<MdxChild, 'output'>): Promise<string>;
-declare function rootFromMdxHtml(html: string): Element;
-declare function replaceMdxChild(root: ParentNode, index: number, child: ChildNode | undefined): void;
 declare function composeMdxState(children: readonly MdxChild[]): MdxStatePayload | undefined;
 declare function composeMdxView(parts: readonly MdxRoutePart[], children: readonly MdxChild[], initialElementOffset: number): MdxViewPayload | undefined;
 declare function loadMdxSymbol(symbolId: string, children: readonly MdxChild[], loaders: readonly MdxSymbolLoader[]): unknown;
 //#endregion
-export { MdxChild, MdxComponentArtifact, MdxRenderOutput, MdxRoutePart, MdxSymbolLoader, composeMdxState, composeMdxView, loadMdxSymbol, renderMdxChild, replaceMdxChild, rootFromMdxHtml };
+export { MdxChild, MdxComponentArtifact, MdxRenderOutput, MdxRoutePart, MdxSymbolLoader, composeMdxState, composeMdxView, createMdxRenderDataSurface, loadMdxSymbol, renderMdxChild };

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

@@ -1,4 +1,125 @@
+function protocolStateVersion(storage) {
+	return (storage?.length ?? 0) > 0 ? 2 : 1;
+}
+//#endregion
 //#region src/vite/runtime/mdx-route.ts
+function createMdxRenderDataSurface(parts, children) {
+	const componentName = "MarklessMdxRoute";
+	const rootChunkId = `template:${componentName}`;
+	const childrenByIndex = new Map(children.map((child) => [child.componentIndex, child]));
+	const statics = [];
+	const slots = [];
+	const hosts = [{
+		hostNodeId: "__mdx:root",
+		tagName: "main",
+		coordinate: {
+			kind: "child-index",
+			path: [0]
+		}
+	}];
+	const edges = [];
+	let staticHtml = "<main data-markless-mdx-root>";
+	let slotIndex = 0;
+	for (const [partIndex, part] of parts.entries()) {
+		if (part.kind === "html") {
+			staticHtml += part.html ?? "";
+			for (const [tagIndex, tagName] of (part.elementTags ?? []).entries()) hosts.push({
+				hostNodeId: `__mdx:static:${partIndex}:${tagIndex}`,
+				tagName,
+				coordinate: {
+					kind: "child-index",
+					path: [
+						0,
+						partIndex,
+						tagIndex
+					]
+				}
+			});
+			continue;
+		}
+		const child = childrenByIndex.get(part.componentIndex);
+		if (!child) throw new Error(`MARKLESS_MDX_RENDER_DATA_CHILD_MISSING: ${part.componentIndex}`);
+		const childComponentName = child.surface.rootComponentName;
+		if (!childComponentName) throw new Error(`MARKLESS_MDX_RENDER_DATA_ROOT_MISSING: ${part.componentIndex}`);
+		const edgeId = `mdx:edge:${part.componentIndex}`;
+		staticHtml += `<!--markless-slot:${slotIndex}-->`;
+		statics.push(staticHtml);
+		staticHtml = "";
+		slots.push({
+			kind: "child-component",
+			componentEdgeId: edgeId,
+			childComponentName,
+			childTemplateId: `template:${childComponentName}`,
+			coordinate: {
+				kind: "comment-anchor",
+				path: [0, partIndex]
+			},
+			staticIndex: slotIndex
+		});
+		edges.push({
+			id: edgeId,
+			childComponentName,
+			hostPrefix: child.hostPrefix,
+			symbolPrefix: child.symbolPrefix,
+			props: Object.entries(child.props).map(([name, value]) => ({
+				name,
+				kind: "serializable",
+				value
+			}))
+		});
+		slotIndex++;
+	}
+	statics.push(`${staticHtml}</main>`);
+	const state = {
+		version: 1,
+		cells: [],
+		computed: []
+	};
+	const view = {
+		version: 1,
+		locators: [],
+		events: [],
+		domUpdates: [],
+		behaviors: [],
+		elementHandles: [],
+		asyncBoundaries: []
+	};
+	return {
+		rootComponentName: componentName,
+		renderData: {
+			root: {
+				componentName,
+				templateId: rootChunkId
+			},
+			chunks: [{
+				id: rootChunkId,
+				kind: "template",
+				componentName,
+				statics,
+				hosts,
+				slots
+			}],
+			initialValues: [],
+			branches: [],
+			repeats: [],
+			boundaries: [],
+			interactions: []
+		},
+		components: { [componentName]: {
+			name: componentName,
+			state,
+			view,
+			rootChunkId,
+			stateGraphNodeIds: [],
+			initialValues: [],
+			branches: [],
+			boundaries: [],
+			edges,
+			propCellId: null
+		} },
+		imports: Object.fromEntries(children.flatMap((child) => child.surface.rootComponentName ? [[child.surface.rootComponentName, child.surface]] : []))
+	};
+}
 async function renderMdxChild(children, component, props, child) {
 	const output = await component.renderSsr?.(props);
 	if (output) children.push({
@@ -7,29 +128,19 @@ async function renderMdxChild(children, component, props, child) {
 	});
 	return output?.html ?? "";
 }
-function rootFromMdxHtml(html) {
-	const template = document.createElement("template");
-	template.innerHTML = html;
-	const root = template.content.firstElementChild;
-	if (!root) throw new Error("Markless Router MDX render did not produce a root element.");
-	return root;
-}
-function replaceMdxChild(root, index, child) {
-	const placeholder = root.querySelector?.(`[data-markless-mdx-child="${index}"]`);
-	if (placeholder && child) {
-		placeholder.replaceWith(child);
-		return;
-	}
-	placeholder?.remove();
-}
 function composeMdxState(children) {
-	const childStates = children.map((child) => child.output?.state).filter(isDefined);
+	const childStates = children.map((child) => ({
+		child,
+		state: child.output?.state
+	})).filter((entry) => isDefined(entry.state));
 	if (childStates.length === 0) return;
+	const storage = childStates.flatMap(({ state }) => state.storage ?? []);
 	return {
-		version: childStates[0].version,
-		cells: childStates.flatMap((state) => state.cells ?? []),
-		computed: childStates.flatMap((state) => state.computed ?? []),
-		...childStates.some((state) => state.sharedDefinitions?.length) ? { sharedDefinitions: childStates.flatMap((state) => state.sharedDefinitions ?? []) } : {}
+		version: protocolStateVersion(storage),
+		cells: childStates.flatMap(({ state }) => state.cells ?? []),
+		computed: childStates.flatMap(({ child, state }) => (state.computed ?? []).map((record) => prefixMdxComputedRecord(record, child))),
+		...childStates.some(({ state }) => state.sharedDefinitions?.length) ? { sharedDefinitions: childStates.flatMap(({ state }) => state.sharedDefinitions ?? []) } : {},
+		...storage.length > 0 ? { storage } : {}
 	};
 }
 function composeMdxView(parts, children, initialElementOffset) {
@@ -99,6 +210,12 @@ function appendMdxChildView(context) {
 		hostNodeId: context.child.hostPrefix + handle.hostNodeId
 	});
 }
+function prefixMdxComputedRecord(record, child) {
+	return {
+		...record,
+		...record.deriveSymbolId ? { deriveSymbolId: child.symbolPrefix + record.deriveSymbolId } : {}
+	};
+}
 function prefixMdxSymbolRecord(record, child) {
 	return {
 		...record,
@@ -110,4 +227,4 @@ function isDefined(value) {
 	return value !== void 0;
 }
 //#endregion
-export { composeMdxState, composeMdxView, loadMdxSymbol, renderMdxChild, replaceMdxChild, rootFromMdxHtml };
+export { composeMdxState, composeMdxView, createMdxRenderDataSurface, loadMdxSymbol, renderMdxChild };

package/dist/vite.d.ts

@@ -1,4 +1,4 @@
-import { PluginOption } from "vite";
+import { PluginOption, UserConfig } from "vite";
 
 //#region src/vite/index.d.ts
 interface MarklessRouterOptions {
@@ -6,5 +6,6 @@ interface MarklessRouterOptions {
   nitro?: boolean;
 }
 declare function router(options?: MarklessRouterOptions): PluginOption[];
+type WatchIgnorePattern = Extract<NonNullable<NonNullable<NonNullable<UserConfig['server']>['watch']>['ignored']>, readonly unknown[]>[number];
 //#endregion
-export { MarklessRouterOptions, router };
+export { MarklessRouterOptions, WatchIgnorePattern, router };

package/dist/vite.js

@@ -1,7 +1,8 @@
 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 { dirname, extname, isAbsolute, join, normalize, relative, resolve } from "pathe";
-import { decodePath, joinURL, parsePath, parseQuery, parseURL, stringifyQuery, withLeadingSlash, withoutLeadingSlash } from "ufo";
+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";
@@ -229,6 +230,7 @@ function transformAnchorSource(code, astInput, routePatterns) {
 	const ast = node$1(astInput);
 	if (!ast) return code;
 	const edits = [];
+	let needsHrefHelper = false;
 	const linkNames = marklessRouterLinkImportNames(ast);
 	walk(ast, (current) => {
 		if (current.type !== "JSXOpeningElement") return;
@@ -245,17 +247,58 @@ function transformAnchorSource(code, astInput, routePatterns) {
 		const paramsExpression = jsxExpression(node$1(params.value));
 		if (!paramsExpression) fail$1(missingParamsMessage(hrefValue, routeParams));
 		validateObjectLiteralParams(hrefValue, routeParams, paramsExpression);
-		edits.push({
+		const staticParams = staticObjectValue(paramsExpression);
+		if (staticParams) edits.push({
 			...rangeOf(href),
-			text: `href={__marklessRouteHref(${JSON.stringify(hrefValue)}, ${slice$1(code, paramsExpression)})}`
+			text: `href=${JSON.stringify(__marklessRouteHref(hrefValue, staticParams))}`
 		});
+		else {
+			needsHrefHelper = true;
+			edits.push({
+				...rangeOf(href),
+				text: `href={__marklessRouteHref(${JSON.stringify(hrefValue)}, ${slice$1(code, paramsExpression)})}`
+			});
+		}
 		edits.push({
 			...attributeRemovalRange(code, params),
 			text: ""
 		});
 	});
 	if (edits.length === 0) return code;
-	return `${helperImport()}${applyEdits(code, edits)}`;
+	return `${needsHrefHelper ? helperImport() : ""}${applyEdits(code, edits)}`;
+}
+function staticObjectValue(expression) {
+	if (expression.type !== "ObjectExpression") return void 0;
+	const value = {};
+	for (const property of nodes$1(expression.properties)) {
+		if (property.type !== "Property" || property.computed === true) return void 0;
+		const key = node$1(property.key);
+		const name = key?.type === "Identifier" ? string$1(key.name) : literalString(key);
+		const propertyValue = staticExpressionValue(node$1(property.value));
+		if (!name || !propertyValue.known) return void 0;
+		value[name] = propertyValue.value;
+	}
+	return value;
+}
+function staticExpressionValue(expression) {
+	if (!expression) return { known: false };
+	if (expression.type === "Literal") return {
+		known: true,
+		value: expression.value
+	};
+	if (expression.type === "ArrayExpression") {
+		const values = [];
+		for (const element of nodes$1(expression.elements)) {
+			const value = staticExpressionValue(element);
+			if (!value.known) return { known: false };
+			values.push(value.value);
+		}
+		return {
+			known: true,
+			value: values
+		};
+	}
+	return { known: false };
 }
 function marklessRouterLinkImportNames(ast) {
 	const names = /* @__PURE__ */ new Set();
@@ -383,6 +426,7 @@ function createClientAssetsManifest(input) {
 		base: input.base,
 		entries: {
 			resume: input.resumeEntry,
+			...input.prerenderWakeEntry ? { prerenderWake: input.prerenderWakeEntry } : {},
 			navigation: input.navigationEntry
 		},
 		routes: {
@@ -459,6 +503,7 @@ async function validateClientAssetsManifest(input, base, clientOutDir) {
 	if (!isRecord$1(input.routes)) throw clientAssetsManifestError("has invalid route maps");
 	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")
 	};
 	const routes = {
@@ -469,6 +514,7 @@ async function validateClientAssetsManifest(input, base, clientOutDir) {
 	assertMatchingRouteKeys(routes);
 	const hrefs = new Set([
 		entries.resume,
+		...entries.prerenderWake !== void 0 ? [entries.prerenderWake] : [],
 		entries.navigation,
 		...Object.values(routes.navigation).flat(),
 		...Object.values(routes.ssr).flat(),
@@ -677,7 +723,12 @@ 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';`,
+		`const marklessMdxParts = ${JSON.stringify(route.parts)};`,
+		"const marklessMdxRenderData = createMdxRenderDataSurface(marklessMdxParts, []);",
 		"const marklessMdxPage = {",
+		"  renderData: marklessMdxRenderData,",
+		"  storageSeeds: marklessMdxStorageSeeds,",
 		"  renderSsr() {",
 		`    return { html: ${JSON.stringify(html)} };`,
 		"  }",
@@ -685,43 +736,30 @@ async function transformMdxRoute(source, id) {
 		"export default marklessMdxPage;",
 		""
 	].join("\n");
-	return emitComposedMdxRoute(route);
+	return emitComposedMdxRoute(route, id);
 }
-function emitComposedMdxRoute(route) {
+function emitComposedMdxRoute(route, id) {
 	return [
 		`import { resumeFromPayloadDocument } from '@markless/core/web/resume';`,
-		`import { composeMdxState, composeMdxView, loadMdxSymbol, renderMdxChild, replaceMdxChild, rootFromMdxHtml } from '@markless/router/vite/runtime/mdx-route';`,
+		`import { composeMdxState, composeMdxView, createMdxRenderDataSurface, loadMdxSymbol, renderMdxChild } from '@markless/router/vite/runtime/mdx-route';`,
 		...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 marklessMdxPage = {",
+		"  renderData: marklessMdxRenderData,",
+		"  storageSeeds: marklessMdxStorageSeeds,",
+		"  loadSymbol: marklessMdxLoadSymbol,",
 		"  async renderSsr(props = {}) {",
 		"    const marklessMdxChildren = [];",
-		`    const html = ${renderHtmlExpression(route, "ssr")};`,
+		`    const html = ${renderHtmlExpression(route)};`,
 		"    const state = composeMdxState(marklessMdxChildren);",
 		"    const view = composeMdxView(marklessMdxParts, marklessMdxChildren, 0);",
 		"    return { html, ...(state ? { state } : {}), ...(view ? { view } : {}) };",
 		"  },",
-		"  renderCsr(props = {}) {",
-		"    const marklessMdxChildren = [];",
-		`    const root = rootFromMdxHtml(${renderCsrHtml(route)});`,
-		...route.components.flatMap((component, index) => [
-			`    const marklessMdxChild${index} = ${component.localName}.renderCsr?.(${componentPropsExpression(component)});`,
-			`    replaceMdxChild(root, ${index}, marklessMdxChild${index}?.root);`,
-			`    if (marklessMdxChild${index}) marklessMdxChildren.push({ componentIndex: ${index}, hostPrefix: ${JSON.stringify(component.prefix)}, symbolPrefix: ${JSON.stringify(component.prefix)}, output: marklessMdxChild${index} });`
-		]),
-		"    const state = composeMdxState(marklessMdxChildren);",
-		"    const view = composeMdxView(marklessMdxParts, marklessMdxChildren, 1);",
-		"    return {",
-		"      root,",
-		"      ...(state ? { state } : {}),",
-		"      ...(view ? { view } : {}),",
-		"      loadSymbol(symbolId) { return marklessMdxLoadSymbol(symbolId, marklessMdxChildren); },",
-		"      connectRuntime(context) { for (const child of marklessMdxChildren) child.output?.connectRuntime?.(context); },",
-		"    };",
-		"  },",
 		...renderMdxPreload(route.components),
 		"};",
 		"export default marklessMdxPage;",
@@ -776,7 +814,7 @@ function parseMdxRoute(source, id) {
 	return {
 		imports,
 		components,
-		parts: routePartsFromHast(root.children ?? [], {
+		parts: routePartsFromHast("children" in root ? root.children : [], {
 			components,
 			id,
 			importedComponents
@@ -826,6 +864,7 @@ function componentPart(node, context) {
 		prefix: `m${componentIndex}:`,
 		props: children ? [...props, {
 			name: "children",
+			value: children,
 			valueExpression: JSON.stringify(children)
 		}] : props
 	});
@@ -841,11 +880,15 @@ function appendHtmlPart(parts, nodes, id) {
 		type: "root",
 		children: staticNodes
 	}, { allowDangerousHtml: true });
-	if (html) parts.push({
-		kind: "html",
-		html,
-		elementCount: countHastElements(staticNodes)
-	});
+	if (html) {
+		const elementTags = hastElementTags(staticNodes);
+		parts.push({
+			kind: "html",
+			html,
+			elementCount: elementTags.length,
+			elementTags
+		});
+	}
 }
 function renderStaticHtml(nodes, id) {
 	if (nodes.length === 0) return "";
@@ -867,6 +910,7 @@ function normalizeStaticHastNode(node, id) {
 			value: value == null ? "" : String(value)
 		}];
 	}
+	if (node.type === "root") return normalizeStaticHastNodes(node.children, id);
 	if ("children" in node && Array.isArray(node.children)) return [{
 		...node,
 		children: normalizeStaticHastNodes(node.children, id)
@@ -881,15 +925,19 @@ function componentProp(attribute, id) {
 	const value = attribute.value;
 	if (value == null) return {
 		name: attribute.name,
+		value: true,
 		valueExpression: "true"
 	};
 	if (typeof value === "string") return {
 		name: attribute.name,
+		value,
 		valueExpression: JSON.stringify(value)
 	};
+	const literal = literalSafeExpressionValue(value.value, id);
 	return {
 		name: attribute.name,
-		valueExpression: literalValueExpression(literalSafeExpressionValue(value.value, id), id)
+		value: literal,
+		valueExpression: literalValueExpression(literal, id)
 	};
 }
 function literalSafeExpressionValue(source, id) {
@@ -918,8 +966,15 @@ function parseMdxExpressionValue(source, id) {
 		dropHandle(handle);
 	}
 }
+function literalPropertyName(key) {
+	if (key.type === "Identifier" && typeof key.name === "string") return key.name;
+	if (key.type === "Literal" && typeof key.value === "string") return key.value;
+}
+function isEstreeNode(value) {
+	return typeof value === "object" && value !== null && typeof value.type === "string";
+}
 function evaluateLiteralExpression(node, id) {
-	if (!node) throw literalExpressionError(id);
+	if (!isEstreeNode(node)) throw literalExpressionError(id);
 	if (node.type === "Literal") {
 		const value = node.value;
 		if (typeof value === "string" || typeof value === "number" || typeof value === "boolean" || value === null) return value;
@@ -938,7 +993,7 @@ function evaluateLiteralExpression(node, id) {
 		for (const property of node.properties) {
 			if (property.type !== "Property" || property.kind !== "init" || property.method || property.computed) throw literalExpressionError(id);
 			const key = property.key;
-			const name = key.type === "Identifier" ? key.name : key.type === "Literal" && typeof key.value === "string" ? key.value : void 0;
+			const name = isEstreeNode(key) ? literalPropertyName(key) : void 0;
 			if (!name) throw literalExpressionError(id);
 			value[name] = evaluateLiteralExpression(property.value, id);
 		}
@@ -956,10 +1011,9 @@ function literalValueExpression(value, id) {
 function literalExpressionError(id) {
 	return /* @__PURE__ */ new Error(`Markless Router MDX only supports literal-safe expressions in attributes and markdown: ${id}`);
 }
-function renderHtmlExpression(route, mode) {
+function renderHtmlExpression(route) {
 	return joinExpressions(route.parts.map((part) => {
 		if (part.kind === "html") return JSON.stringify(part.html);
-		if (mode === "csr") return JSON.stringify(`<span data-markless-mdx-child="${part.componentIndex}"></span>`);
 		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)} }))`;
 	}));
@@ -968,24 +1022,44 @@ function componentPropsExpression(component) {
 	if (component.props.length === 0) return "{}";
 	return `{ ${component.props.map((prop) => `${JSON.stringify(prop.name)}: ${prop.valueExpression}`).join(", ")} }`;
 }
-function renderCsrHtml(route) {
-	return `"<main data-markless-mdx-root>" + ${renderHtmlExpression(route, "csr")} + "</main>"`;
-}
 function joinExpressions(expressions) {
 	const filtered = expressions.filter((expression) => expression !== "\"\"");
 	return filtered.length === 0 ? "\"\"" : filtered.join(" + ");
 }
-function countHastElements(nodes) {
-	let count = 0;
+function hastElementTags(nodes) {
+	const tags = [];
 	for (const node of nodes) {
-		if (node.type === "element") count += 1;
-		if ("children" in node && Array.isArray(node.children)) count += countHastElements(node.children);
+		if (node.type === "element") tags.push(String(node.tagName));
+		if ("children" in node && Array.isArray(node.children)) tags.push(...hastElementTags(node.children));
 	}
-	return count;
+	return tags;
+}
+function renderStorageSeeds(components) {
+	const localNames = [...new Set(components.map((component) => component.localName))];
+	return localNames.length === 0 ? "[]" : `[${localNames.map((localName) => `...(${localName}.storageSeeds ?? [])`).join(", ")}]`;
 }
 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(", ")}]`;
 }
+function renderMdxRenderDataLoader(components, id) {
+	const reachedFrom = mdxMaterializedReachRoot(id);
+	const imports = components.map((component) => {
+		const source = withQuery(component.specifier, {
+			"markless-render-data": null,
+			...reachedFrom ? { "markless-reached-from": reachedFrom } : {}
+		});
+		return `import(${JSON.stringify(source)})`;
+	});
+	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(", ")}]))`;
+}
+function mdxMaterializedReachRoot(id) {
+	const query = new URLSearchParams(parsePath(id).search);
+	const reachedFrom = query.get("markless-reached-from");
+	if (reachedFrom) return reachedFrom;
+	return query.has("markless-route") ? decodePath(parseURL(id).pathname) : void 0;
+}
 function isMdxEsm(node) {
 	return node.type === "mdxjsEsm";
 }
@@ -1005,6 +1079,9 @@ const CLIENT_ENTRY_ID = "virtual:markless-router/client-entry";
 const RESUME_ENTRY_ID = "virtual:markless-router/resume-entry";
 const RESUME_ENTRY_ORIGIN = "/entries/resume-entry.ts";
 const RESUME_ENTRY_PATH_ID = "virtual:markless-router/resume-entry-path";
+const PRERENDER_WAKE_ENTRY_ID = "virtual:markless-router/prerender-wake-entry";
+const PRERENDER_WAKE_ENTRY_ORIGIN = "/entries/prerender-wake-entry.ts";
+const PRERENDER_WAKE_ENTRY_PATH_ID = "virtual:markless-router/prerender-wake-entry-path";
 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";
@@ -1013,7 +1090,7 @@ const ROUTE_PRELOADS_PLACEHOLDER = "__MARKLESS_ROUTER_ROUTE_PRELOADS__";
 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|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|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 = [
@@ -1026,11 +1103,13 @@ const virtualEntryFiles = {
 	[ROUTE_DISCOVERY_ID]: "route-discovery.ts",
 	[CLIENT_ENTRY_ID]: "client-entry.ts",
 	[RESUME_ENTRY_ID]: "resume-entry.ts",
+	[PRERENDER_WAKE_ENTRY_ID]: "prerender-wake-entry.ts",
 	[NAVIGATION_ENTRY_ID]: "client-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 [
 		mdxTransformPlugin(),
 		requestFileTransformPlugin(),
@@ -1041,17 +1120,18 @@ function router(options = {}) {
 	];
 	const nitroPlugins = nitro();
 	const resumeEntry = resumeEntryState();
+	const prerenderWakeEntry = resumeEntryState();
 	const navigationEntry = resumeEntryState();
 	const routePreloads = routePreloadState();
 	return [
-		routerConfigPlugin(nitroPlugins, resumeEntry, navigationEntry, routePreloads),
+		routerConfigPlugin(nitroPlugins, resumeEntry, prerenderWakeEntry, navigationEntry, routePreloads),
 		devSourceModuleRequestPlugin(),
 		mdxTransformPlugin(),
 		requestFileTransformPlugin(),
 		routeTypegenPlugin(),
 		anchorTransformPlugin(),
 		htmlTransformPlugin(),
-		virtualModulesPlugin(resumeEntry, navigationEntry, routePreloads),
+		virtualModulesPlugin(resumeEntry, prerenderWakeEntry, navigationEntry, routePreloads),
 		nitroPlugins
 	];
 }
@@ -1075,7 +1155,7 @@ function devSourceModuleRequestPlugin() {
 		}
 	};
 }
-function routerConfigPlugin(nitroPluginsFromRouter, resumeEntry, navigationEntry, routePreloads) {
+function routerConfigPlugin(nitroPluginsFromRouter, resumeEntry, prerenderWakeEntry, navigationEntry, routePreloads) {
 	let clientOutDir = "";
 	let clientEnvironmentName = "";
 	let clientEnvironmentConfig;
@@ -1115,6 +1195,7 @@ function routerConfigPlugin(nitroPluginsFromRouter, resumeEntry, navigationEntry
 			}
 			for (const entry of [
 				resumeEntry,
+				prerenderWakeEntry,
 				navigationEntry,
 				routePreloads
 			]) entry.base = config.base;
@@ -1132,6 +1213,7 @@ function routerConfigPlugin(nitroPluginsFromRouter, resumeEntry, navigationEntry
 			if (isClientEnvironment) {
 				pendingClientAssets = void 0;
 				resumeEntry.fileName = void 0;
+				prerenderWakeEntry.fileName = void 0;
 				navigationEntry.fileName = void 0;
 				routePreloads.routes = {
 					navigation: {},
@@ -1145,6 +1227,7 @@ function routerConfigPlugin(nitroPluginsFromRouter, resumeEntry, navigationEntry
 			if (!isRouterServerEnvironment) return;
 			const manifest = await readClientAssetsManifest(clientOutDir, routePreloads.base);
 			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);
 			routePreloads.routes = manifest.routes;
 			routePreloads.persisted = true;
@@ -1155,21 +1238,26 @@ function routerConfigPlugin(nitroPluginsFromRouter, resumeEntry, navigationEntry
 				if (this.environment?.config.consumer !== "client") return;
 				const resumeChunk = Object.values(bundle).find((item) => item.type === "chunk" && isVirtualEntryChunk(item, RESUME_ENTRY_ORIGIN));
 				if (resumeChunk) resumeEntry.fileName = resumeChunk.fileName;
+				const 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;
 				routePreloads.routes = routeModulePreloadsFromBundle({
 					base: routePreloads.base,
 					bundle,
 					navigationChunk,
+					prerenderWakeChunk,
 					resumeChunk,
 					root: routePreloads.root
 				});
 				patchRoutePreloadsInBundle(bundle, routePreloads.routes);
 				if (productionBuild) {
-					if (!resumeEntry.fileName || !navigationEntry.fileName) throw new Error("Markless Router client build did not emit its resume and navigation entries.");
+					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.");
 					pendingClientAssets = createClientAssetsManifest({
 						base: routePreloads.base,
 						resumeEntry: joinURL(routePreloads.base, resumeEntry.fileName),
+						...prerenderWakeEntry.fileName ? { prerenderWakeEntry: joinURL(routePreloads.base, prerenderWakeEntry.fileName) } : {},
 						navigationEntry: joinURL(routePreloads.base, navigationEntry.fileName),
 						routes: routePreloads.routes
 					});
@@ -1275,15 +1363,18 @@ function withWatchIgnores(watchOptions, extraIgnored = []) {
 		...watchOptionsObject,
 		followSymlinks: watchOptionsObject.followSymlinks ?? false,
 		ignored: [
-			...toArray(watchOptionsObject.ignored),
+			...toWatchIgnores(watchOptionsObject.ignored),
 			...extraIgnored,
 			...DEFAULT_WATCH_IGNORES
 		]
 	};
 }
-function toArray(value) {
+function toWatchIgnores(value) {
 	if (value === void 0) return [];
-	return Array.isArray(value) ? value : [value];
+	return isPatternList(value) ? [...value] : [value];
+}
+function isPatternList(value) {
+	return Array.isArray(value);
 }
 function withRequestFileBuildPlugin(config, root) {
 	const configObject = isRecord(config) ? config : {};
@@ -1318,18 +1409,30 @@ function routePreloadState() {
 		}
 	};
 }
+let prerenderWakeChannelCaptured = false;
+function prerenderWakeChannelEnabled() {
+	return prerenderWakeChannelCaptured;
+}
 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);
-	if (input === void 0) return [resumeEntryId, navigationEntryId];
+	const wakeEntries = prerenderWakeChannelEnabled() ? [prerenderWakeEntryId] : [];
+	if (input === void 0) return [
+		resumeEntryId,
+		...wakeEntries,
+		navigationEntryId
+	];
 	if (typeof input === "string" || Array.isArray(input)) return [
 		resumeEntryId,
+		...wakeEntries,
 		navigationEntryId,
 		...Array.isArray(input) ? input : [input]
 	];
 	if (isRecord(input)) return {
 		...input,
 		"markless-router-resume": resumeEntryId,
+		...prerenderWakeChannelEnabled() ? { "markless-router-prerender-wake": prerenderWakeEntryId } : {},
 		"markless-router-navigation": navigationEntryId
 	};
 	return input;
@@ -1337,7 +1440,7 @@ function routerClientInput(input, root) {
 function isVirtualEntryChunk(chunk, origin) {
 	return [chunk.facadeModuleId, ...chunk.moduleIds ?? []].some((id) => id ? decodePath(parseURL(id).pathname).endsWith(origin) : false);
 }
-function virtualModulesPlugin(resumeEntry = resumeEntryState(), navigationEntry = resumeEntryState(), routePreloads = routePreloadState()) {
+function virtualModulesPlugin(resumeEntry = resumeEntryState(), prerenderWakeEntry = resumeEntryState(), navigationEntry = resumeEntryState(), routePreloads = routePreloadState()) {
 	let root = "";
 	return {
 		name: "markless-router:routes",
@@ -1349,7 +1452,7 @@ function virtualModulesPlugin(resumeEntry = resumeEntryState(), navigationEntry
 			filter: { id: PUBLIC_VIRTUAL_MODULE_ID_RE },
 			handler(id) {
 				const baseId = virtualModuleBaseId(id);
-				if (baseId === SERVER_ENTRY_ID || baseId === RESUME_ENTRY_PATH_ID || baseId === NAVIGATION_ENTRY_PATH_ID || baseId === ROUTE_PRELOADS_ID || baseId === ROUTER_OPTIONS_ID) return `\0${baseId}${rootScopeQuery(root, 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)}`;
 				const entryFile = virtualEntryFiles[baseId];
 				if (!entryFile) return;
 				return `${join(VIRTUAL_ENTRY_DIR, entryFile)}${rootScopeQuery(root, id)}`;
@@ -1358,6 +1461,10 @@ function virtualModulesPlugin(resumeEntry = resumeEntryState(), navigationEntry
 		load(id) {
 			if (id.startsWith(`\0${SERVER_ENTRY_ID}`)) return serverEntrySource(root);
 			if (id.startsWith(`\0${RESUME_ENTRY_PATH_ID}`)) return entryPathSource("resumeEntryPath", resumeEntry, RESUME_ENTRY_ID, root);
+			if (id.startsWith(`\0${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${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";
@@ -1373,6 +1480,7 @@ function serverEntrySource(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 { pageModuleLoaders, routeFileIds } from '${ROUTE_DISCOVERY_ID}${query}';`,
@@ -1380,6 +1488,7 @@ function serverEntrySource(root) {
 		`const entry = createServerEntry({`,
 		`  dev: import.meta.env.DEV,`,
 		`  resumeEntryPath,`,
+		`  prerenderWakeEntryPath,`,
 		`  navigationEntryPath,`,
 		`  routeModulePreloads,`,
 		`  routeSsrModulePreloads,`,
@@ -1475,6 +1584,10 @@ function routeModulePreloadsFromBundle(input) {
 			includeChunk(ssrFileNames, chunksByFileName, input.resumeChunk.fileName);
 			for (const fileName of routeScopedDynamicImports(input.resumeChunk, routeFile)) includeChunk(ssrFileNames, chunksByFileName, 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, chunksByFileName, routeChunk.fileName, true);
 		const routeSourceFiles = sourceFilesForChunks(new Set([...navigationFileNames, ...ssrFileNames]), chunksByFileName);
 		for (const [sourceFile, symbolFileNames] of symbolChunks) {
@@ -1486,7 +1599,7 @@ function routeModulePreloadsFromBundle(input) {
 		}
 		navigation[routeFile] = [...navigationFileNames].map((fileName) => joinURL(input.base, fileName));
 		ssr[routeFile] = [...ssrFileNames].map((fileName) => joinURL(input.base, fileName));
-		styles[routeFile] = routeStylesheetsForChunk(routeChunk, chunksByFileName, input.base);
+		styles[routeFile] = routeStylesheetsForChunks(routeFileChunks, chunksByFileName, input.base);
 	}
 	return {
 		navigation,
@@ -1494,7 +1607,7 @@ function routeModulePreloadsFromBundle(input) {
 		styles
 	};
 }
-function routeStylesheetsForChunk(routeChunk, chunksByFileName, base) {
+function routeStylesheetsForChunks(routeFileChunks, chunksByFileName, base) {
 	const styles = /* @__PURE__ */ new Set();
 	const visited = /* @__PURE__ */ new Set();
 	const visit = (chunk) => {
@@ -1506,7 +1619,7 @@ function routeStylesheetsForChunk(routeChunk, chunksByFileName, base) {
 		}
 		for (const stylesheet of chunk.viteMetadata?.importedCss ?? []) styles.add(joinURL(base, stylesheet));
 	};
-	visit(routeChunk);
+	for (const chunk of routeFileChunks) visit(chunk);
 	return [...styles];
 }
 function symbolChunksBySourceFile(chunks) {

package/package.json

@@ -1,11 +1,11 @@
 {
   "name": "@markless/router",
-  "version": "0.2.2",
+  "version": "0.3.1",
   "description": "Markless router: client-side navigation with SSR streaming and build-time preload maps.",
   "license": "MIT",
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/markless-dev/markless.git",
+    "url": "git+https://github.com/compiled-run/markless.git",
     "directory": "packages/router"
   },
   "files": [
@@ -57,18 +57,18 @@
     "provenance": true
   },
   "dependencies": {
-    "@tsrx/core": "^0.1.32",
+    "@tsrx/core": "^0.1.58",
     "@virtualstate/navigation": "1.0.1-alpha.212",
     "hast-util-to-html": "^9.0.5",
     "nitro": "3.0.260429-beta",
     "pathe": "^2.0.3",
     "satteri": "0.6.3",
     "ufo": "^1.6.4",
-    "@markless/bundler": "0.2.2",
-    "@markless/web": "0.2.2"
+    "@markless/web": "0.3.1",
+    "@markless/bundler": "0.3.1"
   },
   "devDependencies": {
-    "@markless/analyzer": "0.2.2"
+    "@markless/analyzer": "0.3.1"
   },
   "peerDependencies": {
     "vite": "8.0.16"

package/src/vite/entries/client-entry.ts

@@ -12,7 +12,9 @@ import {
 import { preloadRouteModule } from 'virtual:markless-router/route-preloads';
 
 const routeDiscovery = createRouteDiscovery(
-	import.meta.glob(['/pages/**/*.tsrx', '/pages/**/*.mdx']),
+	import.meta.glob(['/pages/**/*.tsrx', '/pages/**/*.mdx'], {
+		query: '?markless-route',
+	}),
 );
 
 export const pageModules = routeDiscovery.pageModuleLoaders;

package/src/vite/entries/prerender-wake-entry.ts

@@ -0,0 +1,40 @@
+const mdxPageModuleLoaders = import.meta.glob('/pages/**/*.mdx');
+const tsrxPrerenderWakeModuleLoaders = import.meta.glob('/pages/**/*.tsrx', {
+	query: '?markless-prerender-wake',
+});
+
+export async function resumeContainerEvent(input: {
+	readonly root: ParentNode;
+	readonly [key: string]: unknown;
+}) {
+	const file = routeFileFromRoot(input.root);
+	const loadRouteWakeModule = file && routeWakeModuleLoader(file);
+	const routeWakeModule = loadRouteWakeModule ? await loadRouteWakeModule() : undefined;
+	const resume = (routeWakeModule as RouteWakeModule | undefined)?.resumeContainerEvent;
+	if (typeof resume !== 'function') {
+		throw new Error(`Markless Router could not wake prerendered route module: ${file ?? '<unknown>'}`);
+	}
+	await resume(input);
+}
+
+interface RouteWakeModule {
+	readonly resumeContainerEvent?: (input: unknown) => unknown;
+}
+
+function routeWakeModuleLoader(file: string): (() => Promise<unknown>) | undefined {
+	const loaders = file.endsWith('.mdx') ? mdxPageModuleLoaders : tsrxPrerenderWakeModuleLoaders;
+	return loaders[file] ?? loaders[`/${file}`];
+}
+
+function routeFileFromRoot(root: ParentNode): string | undefined {
+	const script = root.querySelector?.('script[type="@markless/core/route"]');
+	const text = script?.textContent;
+	if (!text) return undefined;
+
+	try {
+		const route = JSON.parse(text) as { readonly file?: unknown };
+		return typeof route.file === 'string' ? route.file : undefined;
+	} catch {
+		return undefined;
+	}
+}

package/src/vite/entries/server-entry.ts

@@ -1,5 +1,6 @@
 import { createServerEntry } from '@markless/router/vite/runtime/create-server-entry';
 import { resumeEntryPath } from 'virtual:markless-router/resume-entry-path';
+import { prerenderWakeEntryPath } from 'virtual:markless-router/prerender-wake-entry-path';
 import { navigationEntryPath } from 'virtual:markless-router/navigation-entry-path';
 import {
 	routeModulePreloads,
@@ -12,6 +13,7 @@ const documentModuleLoaders = import.meta.glob(['/document.tsrx']);
 const entry = createServerEntry({
 	dev: import.meta.env.DEV,
 	resumeEntryPath,
+	prerenderWakeEntryPath,
 	navigationEntryPath,
 	routeModulePreloads,
 	routeSsrModulePreloads,