@moku-labs/web 1.13.1 → 1.13.2

package/dist/browser.mjs

@@ -471,6 +471,38 @@ function dynamicSegmentCount(pattern) {
 	return count;
 }
 /**
+* Whether a route is rendered ENTIRELY on the client in `spa` mode: a dynamic route
+* (≥1 non-lang param) that declares no build-time `.generate()` enumerator, so its
+* concrete param paths are unknown until runtime.
+*
+* The build SKIPS such a route — emitting a static page for it would write one
+* param-less shell whose path (`/b/{id}`) matches no file (a 404) and carries no
+* param for the islands to read. Instead the SPA client-renders it from the URL on
+* boot and on navigation. Build and client share this ONE predicate (the same way
+* `dynamicSegmentCount`/`bySpecificity` are shared) so the two sides can never
+* disagree about which routes are pre-rendered vs. client-only.
+*
+* Static routes (`/`) and dynamic routes WITH `.generate()` are pre-rendered as
+* usual and so are NOT client-only. In `ssg`/`hybrid` mode nothing is client-only
+* (the build pre-renders every route), so this is always `false` outside `spa`.
+*
+* @param mode - The global render mode (`router.mode()`).
+* @param route - The route to test (only its `pattern` + `.generate()` presence are read).
+* @param route.pattern - The route's URL pattern string.
+* @param route._handlers - The route's handler bag.
+* @param route._handlers.generate - The build-only static-paths enumerator, if any (presence only).
+* @returns `true` when the route is client-only (spa mode, dynamic, no `.generate()`).
+* @example
+* ```ts
+* isClientOnlyRoute("spa", { pattern: "/b/{id}", _handlers: {} }); // true
+* isClientOnlyRoute("spa", { pattern: "/", _handlers: {} }); // false (static)
+* isClientOnlyRoute("hybrid", { pattern: "/b/{id}", _handlers: {} }); // false (not spa)
+* ```
+*/
+function isClientOnlyRoute(mode, route) {
+	return mode === "spa" && route._handlers.generate === void 0 && dynamicSegmentCount(route.pattern) > 0;
+}
+/**
 * Comparator that orders two routes most-specific-first (fewest dynamic segments
 * first). Equal specificity yields `0` so a stable sort preserves declaration
 * order — the exact ordering the compiled matcher table uses, guaranteeing
@@ -3374,12 +3406,16 @@ function createSpaKernel(state, config, emit, deps) {
 	* const resolved = await resolveDataRender("/en/world/");
 	*/
 	const resolveDataRender = async (pathname) => {
-		if (!deps.dataAt) return false;
 		const matchPath = pathname.split("?")[0] ?? pathname;
 		const hit = deps.router.match(matchPath);
 		if (!hit?.route._handlers.render) return false;
-		const data = await deps.dataAt(pathname);
-		if (data === null) return false;
+		let data = {};
+		if (!isClientOnlyRoute(deps.router.mode(), hit.route)) {
+			if (!deps.dataAt) return false;
+			const persisted = await deps.dataAt(pathname);
+			if (persisted === null) return false;
+			data = persisted;
+		}
 		const locale = hit.params.lang ?? document.documentElement.lang ?? "";
 		const routeContext = {
 			params: hit.params,
@@ -3461,6 +3497,29 @@ function createSpaKernel(state, config, emit, deps) {
 		}
 	};
 	/**
+	* Initial-load render for a spa client-only route (dynamic, no `.generate()`): the build emitted
+	* no static HTML for it, so the host served a fallback shell. Client-render the matched route into
+	* the swap region from the URL, then mount its islands — the deep-link / refresh paint. Unlike a
+	* navigation there is nothing to unmount and no `spa:navigated` to emit. If the route cannot be
+	* resolved (defensive — a matched client-only route always resolves), fall back to mounting the
+	* served body so boot still wires up whatever islands the shell does carry.
+	*
+	* @param pathname - The current document path (pathname + search).
+	* @example
+	* await bootRender("/b/abc123");
+	*/
+	const bootRender = async (pathname) => {
+		const resolvedRender = await resolveDataRender(pathname);
+		if (resolvedRender === false) {
+			scanAndMount(state, emit, resolved.swapSelector);
+			return;
+		}
+		const { vnode, region } = resolvedRender;
+		const { renderVNode } = await import("./render-BNe0s7fr.mjs");
+		renderVNode(vnode, region);
+		scanAndMount(state, emit, resolved.swapSelector);
+	};
+	/**
 	* Unified navigation: try the client DATA path first (only when the `data`
 	* plugin is composed), then fall back to HTML-over-fetch (which itself falls
 	* back to a full `location.href` reload). Injected into the router so every
@@ -3505,7 +3564,10 @@ function createSpaKernel(state, config, emit, deps) {
 			progress = createProgressBar(resolved.progressBar);
 			state.currentUrl = currentLocationUrl();
 			state.destroyRouter = attachRouter(handlers, navigate);
-			scanAndMount(state, emit, resolved.swapSelector);
+			const matchPath = state.currentUrl.split("?")[0] ?? state.currentUrl;
+			const hit = deps.router.match(matchPath);
+			if (hit?.route._handlers.render && isClientOnlyRoute(deps.router.mode(), hit.route)) bootRender(state.currentUrl);
+			else scanAndMount(state, emit, resolved.swapSelector);
 			state.started = true;
 		},
 		/**

package/dist/index.cjs

@@ -1084,6 +1084,38 @@ function dynamicSegmentCount(pattern) {
 	return count;
 }
 /**
+* Whether a route is rendered ENTIRELY on the client in `spa` mode: a dynamic route
+* (≥1 non-lang param) that declares no build-time `.generate()` enumerator, so its
+* concrete param paths are unknown until runtime.
+*
+* The build SKIPS such a route — emitting a static page for it would write one
+* param-less shell whose path (`/b/{id}`) matches no file (a 404) and carries no
+* param for the islands to read. Instead the SPA client-renders it from the URL on
+* boot and on navigation. Build and client share this ONE predicate (the same way
+* `dynamicSegmentCount`/`bySpecificity` are shared) so the two sides can never
+* disagree about which routes are pre-rendered vs. client-only.
+*
+* Static routes (`/`) and dynamic routes WITH `.generate()` are pre-rendered as
+* usual and so are NOT client-only. In `ssg`/`hybrid` mode nothing is client-only
+* (the build pre-renders every route), so this is always `false` outside `spa`.
+*
+* @param mode - The global render mode (`router.mode()`).
+* @param route - The route to test (only its `pattern` + `.generate()` presence are read).
+* @param route.pattern - The route's URL pattern string.
+* @param route._handlers - The route's handler bag.
+* @param route._handlers.generate - The build-only static-paths enumerator, if any (presence only).
+* @returns `true` when the route is client-only (spa mode, dynamic, no `.generate()`).
+* @example
+* ```ts
+* isClientOnlyRoute("spa", { pattern: "/b/{id}", _handlers: {} }); // true
+* isClientOnlyRoute("spa", { pattern: "/", _handlers: {} }); // false (static)
+* isClientOnlyRoute("hybrid", { pattern: "/b/{id}", _handlers: {} }); // false (not spa)
+* ```
+*/
+function isClientOnlyRoute(mode, route) {
+	return mode === "spa" && route._handlers.generate === void 0 && dynamicSegmentCount(route.pattern) > 0;
+}
+/**
 * Comparator that orders two routes most-specific-first (fewest dynamic segments
 * first). Equal specificity yields `0` so a stable sort preserves declaration
 * order — the exact ordering the compiled matcher table uses, guaranteeing
@@ -4528,16 +4560,23 @@ function resolveEntry(byPattern, definition) {
 * generate context is the spec `{ locale, require, has }`, so a `.generate()` handler
 * pulls sibling APIs the spec way.
 *
+* In `spa` mode a client-only route (dynamic, no `.generate()`) is SKIPPED entirely
+* (`[]`) — it is rendered on the client from the URL, so emitting a static param-less
+* shell here would only write a file at the wrong path (a 404 for any real param path)
+* carrying no param. See {@link isClientOnlyRoute}.
+*
 * @param definition - The route definition from the manifest.
 * @param locale - The active locale to generate param sets for.
+* @param mode - The global render mode (`router.mode()`); gates the spa client-only skip.
 * @param ctx - Plugin context (provides `require`/`has` for the generate context).
-* @returns The param sets for this route+locale (`[{}]` when there is no `.generate()`).
+* @returns The param sets for this route+locale (`[{}]` when there is no `.generate()`; `[]` when client-only).
 * @example
 * ```ts
-* const paramSets = await generateParamSets(def, "en", ctx);
+* const paramSets = await generateParamSets(def, "en", "hybrid", ctx);
 * ```
 */
-async function generateParameterSets(definition, locale, ctx) {
+async function generateParameterSets(definition, locale, mode, ctx) {
+	if (isClientOnlyRoute(mode, definition)) return [];
 	const generateContext = {
 		locale,
 		require: ctx.require,
@@ -4561,21 +4600,22 @@ async function generateParameterSets(definition, locale, ctx) {
 * @param locales - Active locale codes from i18n.
 * @param defaultLocale - The i18n default locale (kept when locales collapse to one file).
 * @param byPattern - Pattern→compiled-`TypedRoute` map (see {@link makeEntryMap}).
+* @param mode - The global render mode (`router.mode()`); gates the spa client-only skip.
 * @param ctx - Plugin context (provides `require`/`has` for the generate context).
 * @returns The flattened, file-deduplicated list of page instances for this route.
 * @example
 * ```ts
-* await expandRoute(def, ["en"], "en", byPattern, ctx);
+* await expandRoute(def, ["en"], "en", byPattern, "hybrid", ctx);
 * ```
 */
-async function expandRoute(definition, locales, defaultLocale, byPattern, ctx) {
+async function expandRoute(definition, locales, defaultLocale, byPattern, mode, ctx) {
 	const entry = resolveEntry(byPattern, definition);
 	const { name } = entry;
 	const orderedLocales = [defaultLocale, ...locales.filter((locale) => locale !== defaultLocale)];
 	const instances = [];
 	const claimedFiles = /* @__PURE__ */ new Set();
 	for (const locale of orderedLocales) {
-		const parameterSets = await generateParameterSets(definition, locale, ctx);
+		const parameterSets = await generateParameterSets(definition, locale, mode, ctx);
 		for (const raw of parameterSets) {
 			const params = raw ?? {};
 			const file = entry.toFile(params);
@@ -4909,15 +4949,16 @@ async function prepareShell(ctx) {
 * @param locales - Active locale codes from i18n.
 * @param defaultLocale - The i18n default locale (kept when a route's locales collapse).
 * @param byPattern - Pattern→compiled-`TypedRoute` map (see {@link makeEntryMap}).
+* @param mode - The global render mode (`router.mode()`); gates the spa client-only skip.
 * @param ctx - Plugin context (provides `require`/`has` for generate contexts).
 * @returns The flattened list of page instances to render.
 * @example
 * ```ts
-* const instances = await expandAllInstances(manifest, ["en"], "en", byPattern, ctx);
+* const instances = await expandAllInstances(manifest, ["en"], "en", byPattern, "hybrid", ctx);
 * ```
 */
-async function expandAllInstances(manifest, locales, defaultLocale, byPattern, ctx) {
-	return (await Promise.all(manifest.map((definition) => expandRoute(definition, locales, defaultLocale, byPattern, ctx)))).flat();
+async function expandAllInstances(manifest, locales, defaultLocale, byPattern, mode, ctx) {
+	return (await Promise.all(manifest.map((definition) => expandRoute(definition, locales, defaultLocale, byPattern, mode, ctx)))).flat();
 }
 /**
 * Persist per-page client-data sidecars when the app opts into client navigation
@@ -5027,14 +5068,15 @@ async function renderInBatches(items, batchSize, worker) {
 async function renderPages(ctx, options) {
 	const reuse = options?.reuse === true;
 	const router = ctx.require(routerPlugin);
+	const mode = router.mode();
 	const manifest = router.manifest();
 	ctx.state.manifest = [...manifest];
 	const locales = ctx.require(i18nPlugin).locales();
 	const byPattern = makeEntryMap(router);
 	if (!reuse) ctx.state.renderCache.clear();
 	const shell = await prepareShell(ctx);
-	const rendered = (await renderInBatches(await expandAllInstances(manifest, locales, shell.defaultLocale, byPattern, ctx), reuse ? INCREMENTAL_BATCH_SIZE : RENDER_BATCH_SIZE, (instance) => renderInstance(ctx, instance, shell, reuse))).flat();
-	await writeDataSidecars(ctx, rendered, router.mode());
+	const rendered = (await renderInBatches(await expandAllInstances(manifest, locales, shell.defaultLocale, byPattern, mode, ctx), reuse ? INCREMENTAL_BATCH_SIZE : RENDER_BATCH_SIZE, (instance) => renderInstance(ctx, instance, shell, reuse))).flat();
+	await writeDataSidecars(ctx, rendered, mode);
 	ctx.log.debug("build:pages", { count: rendered.length });
 	return {
 		pageCount: rendered.length,
@@ -9989,12 +10031,16 @@ function createSpaKernel(state, config, emit, deps) {
 	* const resolved = await resolveDataRender("/en/world/");
 	*/
 	const resolveDataRender = async (pathname) => {
-		if (!deps.dataAt) return false;
 		const matchPath = pathname.split("?")[0] ?? pathname;
 		const hit = deps.router.match(matchPath);
 		if (!hit?.route._handlers.render) return false;
-		const data = await deps.dataAt(pathname);
-		if (data === null) return false;
+		let data = {};
+		if (!isClientOnlyRoute(deps.router.mode(), hit.route)) {
+			if (!deps.dataAt) return false;
+			const persisted = await deps.dataAt(pathname);
+			if (persisted === null) return false;
+			data = persisted;
+		}
 		const locale = hit.params.lang ?? document.documentElement.lang ?? "";
 		const routeContext = {
 			params: hit.params,
@@ -10076,6 +10122,29 @@ function createSpaKernel(state, config, emit, deps) {
 		}
 	};
 	/**
+	* Initial-load render for a spa client-only route (dynamic, no `.generate()`): the build emitted
+	* no static HTML for it, so the host served a fallback shell. Client-render the matched route into
+	* the swap region from the URL, then mount its islands — the deep-link / refresh paint. Unlike a
+	* navigation there is nothing to unmount and no `spa:navigated` to emit. If the route cannot be
+	* resolved (defensive — a matched client-only route always resolves), fall back to mounting the
+	* served body so boot still wires up whatever islands the shell does carry.
+	*
+	* @param pathname - The current document path (pathname + search).
+	* @example
+	* await bootRender("/b/abc123");
+	*/
+	const bootRender = async (pathname) => {
+		const resolvedRender = await resolveDataRender(pathname);
+		if (resolvedRender === false) {
+			scanAndMount(state, emit, resolved.swapSelector);
+			return;
+		}
+		const { vnode, region } = resolvedRender;
+		const { renderVNode } = await Promise.resolve().then(() => require("./render-DLZEOe4M.cjs"));
+		renderVNode(vnode, region);
+		scanAndMount(state, emit, resolved.swapSelector);
+	};
+	/**
 	* Unified navigation: try the client DATA path first (only when the `data`
 	* plugin is composed), then fall back to HTML-over-fetch (which itself falls
 	* back to a full `location.href` reload). Injected into the router so every
@@ -10120,7 +10189,10 @@ function createSpaKernel(state, config, emit, deps) {
 			progress = createProgressBar(resolved.progressBar);
 			state.currentUrl = currentLocationUrl();
 			state.destroyRouter = attachRouter(handlers, navigate);
-			scanAndMount(state, emit, resolved.swapSelector);
+			const matchPath = state.currentUrl.split("?")[0] ?? state.currentUrl;
+			const hit = deps.router.match(matchPath);
+			if (hit?.route._handlers.render && isClientOnlyRoute(deps.router.mode(), hit.route)) bootRender(state.currentUrl);
+			else scanAndMount(state, emit, resolved.swapSelector);
 			state.started = true;
 		},
 		/**

package/dist/index.mjs

@@ -1071,6 +1071,38 @@ function dynamicSegmentCount(pattern) {
 	return count;
 }
 /**
+* Whether a route is rendered ENTIRELY on the client in `spa` mode: a dynamic route
+* (≥1 non-lang param) that declares no build-time `.generate()` enumerator, so its
+* concrete param paths are unknown until runtime.
+*
+* The build SKIPS such a route — emitting a static page for it would write one
+* param-less shell whose path (`/b/{id}`) matches no file (a 404) and carries no
+* param for the islands to read. Instead the SPA client-renders it from the URL on
+* boot and on navigation. Build and client share this ONE predicate (the same way
+* `dynamicSegmentCount`/`bySpecificity` are shared) so the two sides can never
+* disagree about which routes are pre-rendered vs. client-only.
+*
+* Static routes (`/`) and dynamic routes WITH `.generate()` are pre-rendered as
+* usual and so are NOT client-only. In `ssg`/`hybrid` mode nothing is client-only
+* (the build pre-renders every route), so this is always `false` outside `spa`.
+*
+* @param mode - The global render mode (`router.mode()`).
+* @param route - The route to test (only its `pattern` + `.generate()` presence are read).
+* @param route.pattern - The route's URL pattern string.
+* @param route._handlers - The route's handler bag.
+* @param route._handlers.generate - The build-only static-paths enumerator, if any (presence only).
+* @returns `true` when the route is client-only (spa mode, dynamic, no `.generate()`).
+* @example
+* ```ts
+* isClientOnlyRoute("spa", { pattern: "/b/{id}", _handlers: {} }); // true
+* isClientOnlyRoute("spa", { pattern: "/", _handlers: {} }); // false (static)
+* isClientOnlyRoute("hybrid", { pattern: "/b/{id}", _handlers: {} }); // false (not spa)
+* ```
+*/
+function isClientOnlyRoute(mode, route) {
+	return mode === "spa" && route._handlers.generate === void 0 && dynamicSegmentCount(route.pattern) > 0;
+}
+/**
 * Comparator that orders two routes most-specific-first (fewest dynamic segments
 * first). Equal specificity yields `0` so a stable sort preserves declaration
 * order — the exact ordering the compiled matcher table uses, guaranteeing
@@ -4515,16 +4547,23 @@ function resolveEntry(byPattern, definition) {
 * generate context is the spec `{ locale, require, has }`, so a `.generate()` handler
 * pulls sibling APIs the spec way.
 *
+* In `spa` mode a client-only route (dynamic, no `.generate()`) is SKIPPED entirely
+* (`[]`) — it is rendered on the client from the URL, so emitting a static param-less
+* shell here would only write a file at the wrong path (a 404 for any real param path)
+* carrying no param. See {@link isClientOnlyRoute}.
+*
 * @param definition - The route definition from the manifest.
 * @param locale - The active locale to generate param sets for.
+* @param mode - The global render mode (`router.mode()`); gates the spa client-only skip.
 * @param ctx - Plugin context (provides `require`/`has` for the generate context).
-* @returns The param sets for this route+locale (`[{}]` when there is no `.generate()`).
+* @returns The param sets for this route+locale (`[{}]` when there is no `.generate()`; `[]` when client-only).
 * @example
 * ```ts
-* const paramSets = await generateParamSets(def, "en", ctx);
+* const paramSets = await generateParamSets(def, "en", "hybrid", ctx);
 * ```
 */
-async function generateParameterSets(definition, locale, ctx) {
+async function generateParameterSets(definition, locale, mode, ctx) {
+	if (isClientOnlyRoute(mode, definition)) return [];
 	const generateContext = {
 		locale,
 		require: ctx.require,
@@ -4548,21 +4587,22 @@ async function generateParameterSets(definition, locale, ctx) {
 * @param locales - Active locale codes from i18n.
 * @param defaultLocale - The i18n default locale (kept when locales collapse to one file).
 * @param byPattern - Pattern→compiled-`TypedRoute` map (see {@link makeEntryMap}).
+* @param mode - The global render mode (`router.mode()`); gates the spa client-only skip.
 * @param ctx - Plugin context (provides `require`/`has` for the generate context).
 * @returns The flattened, file-deduplicated list of page instances for this route.
 * @example
 * ```ts
-* await expandRoute(def, ["en"], "en", byPattern, ctx);
+* await expandRoute(def, ["en"], "en", byPattern, "hybrid", ctx);
 * ```
 */
-async function expandRoute(definition, locales, defaultLocale, byPattern, ctx) {
+async function expandRoute(definition, locales, defaultLocale, byPattern, mode, ctx) {
 	const entry = resolveEntry(byPattern, definition);
 	const { name } = entry;
 	const orderedLocales = [defaultLocale, ...locales.filter((locale) => locale !== defaultLocale)];
 	const instances = [];
 	const claimedFiles = /* @__PURE__ */ new Set();
 	for (const locale of orderedLocales) {
-		const parameterSets = await generateParameterSets(definition, locale, ctx);
+		const parameterSets = await generateParameterSets(definition, locale, mode, ctx);
 		for (const raw of parameterSets) {
 			const params = raw ?? {};
 			const file = entry.toFile(params);
@@ -4896,15 +4936,16 @@ async function prepareShell(ctx) {
 * @param locales - Active locale codes from i18n.
 * @param defaultLocale - The i18n default locale (kept when a route's locales collapse).
 * @param byPattern - Pattern→compiled-`TypedRoute` map (see {@link makeEntryMap}).
+* @param mode - The global render mode (`router.mode()`); gates the spa client-only skip.
 * @param ctx - Plugin context (provides `require`/`has` for generate contexts).
 * @returns The flattened list of page instances to render.
 * @example
 * ```ts
-* const instances = await expandAllInstances(manifest, ["en"], "en", byPattern, ctx);
+* const instances = await expandAllInstances(manifest, ["en"], "en", byPattern, "hybrid", ctx);
 * ```
 */
-async function expandAllInstances(manifest, locales, defaultLocale, byPattern, ctx) {
-	return (await Promise.all(manifest.map((definition) => expandRoute(definition, locales, defaultLocale, byPattern, ctx)))).flat();
+async function expandAllInstances(manifest, locales, defaultLocale, byPattern, mode, ctx) {
+	return (await Promise.all(manifest.map((definition) => expandRoute(definition, locales, defaultLocale, byPattern, mode, ctx)))).flat();
 }
 /**
 * Persist per-page client-data sidecars when the app opts into client navigation
@@ -5014,14 +5055,15 @@ async function renderInBatches(items, batchSize, worker) {
 async function renderPages(ctx, options) {
 	const reuse = options?.reuse === true;
 	const router = ctx.require(routerPlugin);
+	const mode = router.mode();
 	const manifest = router.manifest();
 	ctx.state.manifest = [...manifest];
 	const locales = ctx.require(i18nPlugin).locales();
 	const byPattern = makeEntryMap(router);
 	if (!reuse) ctx.state.renderCache.clear();
 	const shell = await prepareShell(ctx);
-	const rendered = (await renderInBatches(await expandAllInstances(manifest, locales, shell.defaultLocale, byPattern, ctx), reuse ? INCREMENTAL_BATCH_SIZE : RENDER_BATCH_SIZE, (instance) => renderInstance(ctx, instance, shell, reuse))).flat();
-	await writeDataSidecars(ctx, rendered, router.mode());
+	const rendered = (await renderInBatches(await expandAllInstances(manifest, locales, shell.defaultLocale, byPattern, mode, ctx), reuse ? INCREMENTAL_BATCH_SIZE : RENDER_BATCH_SIZE, (instance) => renderInstance(ctx, instance, shell, reuse))).flat();
+	await writeDataSidecars(ctx, rendered, mode);
 	ctx.log.debug("build:pages", { count: rendered.length });
 	return {
 		pageCount: rendered.length,
@@ -9976,12 +10018,16 @@ function createSpaKernel(state, config, emit, deps) {
 	* const resolved = await resolveDataRender("/en/world/");
 	*/
 	const resolveDataRender = async (pathname) => {
-		if (!deps.dataAt) return false;
 		const matchPath = pathname.split("?")[0] ?? pathname;
 		const hit = deps.router.match(matchPath);
 		if (!hit?.route._handlers.render) return false;
-		const data = await deps.dataAt(pathname);
-		if (data === null) return false;
+		let data = {};
+		if (!isClientOnlyRoute(deps.router.mode(), hit.route)) {
+			if (!deps.dataAt) return false;
+			const persisted = await deps.dataAt(pathname);
+			if (persisted === null) return false;
+			data = persisted;
+		}
 		const locale = hit.params.lang ?? document.documentElement.lang ?? "";
 		const routeContext = {
 			params: hit.params,
@@ -10063,6 +10109,29 @@ function createSpaKernel(state, config, emit, deps) {
 		}
 	};
 	/**
+	* Initial-load render for a spa client-only route (dynamic, no `.generate()`): the build emitted
+	* no static HTML for it, so the host served a fallback shell. Client-render the matched route into
+	* the swap region from the URL, then mount its islands — the deep-link / refresh paint. Unlike a
+	* navigation there is nothing to unmount and no `spa:navigated` to emit. If the route cannot be
+	* resolved (defensive — a matched client-only route always resolves), fall back to mounting the
+	* served body so boot still wires up whatever islands the shell does carry.
+	*
+	* @param pathname - The current document path (pathname + search).
+	* @example
+	* await bootRender("/b/abc123");
+	*/
+	const bootRender = async (pathname) => {
+		const resolvedRender = await resolveDataRender(pathname);
+		if (resolvedRender === false) {
+			scanAndMount(state, emit, resolved.swapSelector);
+			return;
+		}
+		const { vnode, region } = resolvedRender;
+		const { renderVNode } = await import("./render-BNe0s7fr.mjs");
+		renderVNode(vnode, region);
+		scanAndMount(state, emit, resolved.swapSelector);
+	};
+	/**
 	* Unified navigation: try the client DATA path first (only when the `data`
 	* plugin is composed), then fall back to HTML-over-fetch (which itself falls
 	* back to a full `location.href` reload). Injected into the router so every
@@ -10107,7 +10176,10 @@ function createSpaKernel(state, config, emit, deps) {
 			progress = createProgressBar(resolved.progressBar);
 			state.currentUrl = currentLocationUrl();
 			state.destroyRouter = attachRouter(handlers, navigate);
-			scanAndMount(state, emit, resolved.swapSelector);
+			const matchPath = state.currentUrl.split("?")[0] ?? state.currentUrl;
+			const hit = deps.router.match(matchPath);
+			if (hit?.route._handlers.render && isClientOnlyRoute(deps.router.mode(), hit.route)) bootRender(state.currentUrl);
+			else scanAndMount(state, emit, resolved.swapSelector);
 			state.started = true;
 		},
 		/**

package/package.json

@@ -126,5 +126,5 @@
     "test:build-e2e": "bun test src/plugins/build/__tests__/e2e/",
     "test:coverage": "vitest run --project unit --project integration --coverage"
   },
-  "version": "1.13.1"
+  "version": "1.13.2"
 }