@moku-labs/web 1.13.0 → 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,
@@ -6108,7 +6150,7 @@ async function readWranglerConfig(cwd) {
 /** Relative path of the generated wrangler config. */
 const WRANGLER_PATH = "wrangler.jsonc";
 /** Relative path of the generated GitHub Actions workflow. */
-const WORKFLOW_PATH = ".github/workflows/deploy.yml";
+const WORKFLOW_PATH$1 = ".github/workflows/deploy.yml";
 /** Wrangler `compatibility_date` used when the deploy config does not pin one. */
 const DEFAULT_COMPATIBILITY_DATE = "2024-01-01";
 /**
@@ -6166,12 +6208,12 @@ async function writeScaffolding(input) {
 		result
 	});
 	if (ci) await reconcile({
-		relativePath: WORKFLOW_PATH,
+		relativePath: WORKFLOW_PATH$1,
 		expected: generateGithubWorkflow({
 			slug,
 			...options.workflowTrigger ? { trigger: options.workflowTrigger } : {}
 		}),
-		existing: await readMaybe(cwd, WORKFLOW_PATH),
+		existing: await readMaybe(cwd, WORKFLOW_PATH$1),
 		cwd,
 		check,
 		result
@@ -6869,30 +6911,39 @@ async function resolveTrigger(ctx, choice) {
 	if (choice === 0) return "auto";
 	return await ctx.state.select("How should the versioned deploy be triggered?", ["On a version tag push (v*) + the manual Run-workflow button", "Manual Run-workflow button only (workflow_dispatch)"]) === 0 ? "versioned-tag" : "dispatch";
 }
+/** Relative path of the GitHub Actions workflow the deploy plugin scaffolds. */
+const WORKFLOW_PATH = ".github/workflows/deploy.yml";
 /**
 * Offer to scaffold a GitHub Actions deploy workflow, letting the user choose how it is
-* triggered, then remind them which repo secrets to add. A no-op past a "skip" choice.
+* triggered, then remind them which repo secrets to add. Short-circuits WITHOUT prompting
+* when {@link WORKFLOW_PATH} already exists — CI is already wired and the scaffold is
+* idempotent (a second setup would only no-op), so there is nothing to ask; it just
+* confirms the file and re-shows the secrets reminder. A no-op past a "skip" choice.
 *
 * @param ctx - The cli plugin context.
+* @param cwd - The project root (where `.github/workflows/deploy.yml` lives).
 * @returns Resolves once any chosen workflow has been scaffolded.
 * @example
-* await offerWorkflowSetup(ctx);
+* await offerWorkflowSetup(ctx, process.cwd());
 */
-async function offerWorkflowSetup(ctx) {
+async function offerWorkflowSetup(ctx, cwd) {
 	ctx.state.render.heading("Automate future deploys (GitHub Actions)");
+	if ((0, node_fs.existsSync)(node_path$1.default.join(cwd, WORKFLOW_PATH))) {
+		ctx.state.render.check(true, `${WORKFLOW_PATH} already exists (left unchanged)`);
+		ctx.state.render.info(SECRETS_HELP);
+		return;
+	}
 	const trigger = await resolveTrigger(ctx, await ctx.state.select("Set up a deploy workflow?", [
 		"Auto-deploy on every push to main",
 		"Manual / versioned deploy (choose trigger)",
 		"Skip for now"
 	]));
 	if (trigger === null) return;
-	const result = await ctx.require(deployPlugin).init({
+	const wrote = (await ctx.require(deployPlugin).init({
 		ci: true,
 		workflowTrigger: trigger
-	});
-	const workflowPath = ".github/workflows/deploy.yml";
-	const wrote = result.written.includes(workflowPath);
-	ctx.state.render.check(true, wrote ? `wrote ${workflowPath}` : `${workflowPath} already exists (left unchanged)`);
+	})).written.includes(WORKFLOW_PATH);
+	ctx.state.render.check(true, wrote ? `wrote ${WORKFLOW_PATH}` : `${WORKFLOW_PATH} already exists (left unchanged)`);
 	ctx.state.render.info(SECRETS_HELP);
 }
 /**
@@ -7088,7 +7139,7 @@ async function runDeployWizard(ctx, options) {
 	ctx.state.render.check(notFoundOk, `${ctx.config.notFoundFile} present`, notFoundOk ? void 0 : "Set build.notFound so the SSG emits it (CF Pages else flips to SPA mode).");
 	ctx.state.render.info("Tip: run `bun run preview` to eyeball the built site before deploying.");
 	const outcome = await runDeployStep(ctx, options);
-	if (!(outcome.deployed === false && outcome.reason === "failed")) await offerWorkflowSetup(ctx);
+	if (!(outcome.deployed === false && outcome.reason === "failed")) await offerWorkflowSetup(ctx, cwd);
 	return outcome;
 }
 //#endregion
@@ -9980,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,
@@ -10067,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
@@ -10111,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,
@@ -6095,7 +6137,7 @@ async function readWranglerConfig(cwd) {
 /** Relative path of the generated wrangler config. */
 const WRANGLER_PATH = "wrangler.jsonc";
 /** Relative path of the generated GitHub Actions workflow. */
-const WORKFLOW_PATH = ".github/workflows/deploy.yml";
+const WORKFLOW_PATH$1 = ".github/workflows/deploy.yml";
 /** Wrangler `compatibility_date` used when the deploy config does not pin one. */
 const DEFAULT_COMPATIBILITY_DATE = "2024-01-01";
 /**
@@ -6153,12 +6195,12 @@ async function writeScaffolding(input) {
 		result
 	});
 	if (ci) await reconcile({
-		relativePath: WORKFLOW_PATH,
+		relativePath: WORKFLOW_PATH$1,
 		expected: generateGithubWorkflow({
 			slug,
 			...options.workflowTrigger ? { trigger: options.workflowTrigger } : {}
 		}),
-		existing: await readMaybe(cwd, WORKFLOW_PATH),
+		existing: await readMaybe(cwd, WORKFLOW_PATH$1),
 		cwd,
 		check,
 		result
@@ -6856,30 +6898,39 @@ async function resolveTrigger(ctx, choice) {
 	if (choice === 0) return "auto";
 	return await ctx.state.select("How should the versioned deploy be triggered?", ["On a version tag push (v*) + the manual Run-workflow button", "Manual Run-workflow button only (workflow_dispatch)"]) === 0 ? "versioned-tag" : "dispatch";
 }
+/** Relative path of the GitHub Actions workflow the deploy plugin scaffolds. */
+const WORKFLOW_PATH = ".github/workflows/deploy.yml";
 /**
 * Offer to scaffold a GitHub Actions deploy workflow, letting the user choose how it is
-* triggered, then remind them which repo secrets to add. A no-op past a "skip" choice.
+* triggered, then remind them which repo secrets to add. Short-circuits WITHOUT prompting
+* when {@link WORKFLOW_PATH} already exists — CI is already wired and the scaffold is
+* idempotent (a second setup would only no-op), so there is nothing to ask; it just
+* confirms the file and re-shows the secrets reminder. A no-op past a "skip" choice.
 *
 * @param ctx - The cli plugin context.
+* @param cwd - The project root (where `.github/workflows/deploy.yml` lives).
 * @returns Resolves once any chosen workflow has been scaffolded.
 * @example
-* await offerWorkflowSetup(ctx);
+* await offerWorkflowSetup(ctx, process.cwd());
 */
-async function offerWorkflowSetup(ctx) {
+async function offerWorkflowSetup(ctx, cwd) {
 	ctx.state.render.heading("Automate future deploys (GitHub Actions)");
+	if (existsSync(path.join(cwd, WORKFLOW_PATH))) {
+		ctx.state.render.check(true, `${WORKFLOW_PATH} already exists (left unchanged)`);
+		ctx.state.render.info(SECRETS_HELP);
+		return;
+	}
 	const trigger = await resolveTrigger(ctx, await ctx.state.select("Set up a deploy workflow?", [
 		"Auto-deploy on every push to main",
 		"Manual / versioned deploy (choose trigger)",
 		"Skip for now"
 	]));
 	if (trigger === null) return;
-	const result = await ctx.require(deployPlugin).init({
+	const wrote = (await ctx.require(deployPlugin).init({
 		ci: true,
 		workflowTrigger: trigger
-	});
-	const workflowPath = ".github/workflows/deploy.yml";
-	const wrote = result.written.includes(workflowPath);
-	ctx.state.render.check(true, wrote ? `wrote ${workflowPath}` : `${workflowPath} already exists (left unchanged)`);
+	})).written.includes(WORKFLOW_PATH);
+	ctx.state.render.check(true, wrote ? `wrote ${WORKFLOW_PATH}` : `${WORKFLOW_PATH} already exists (left unchanged)`);
 	ctx.state.render.info(SECRETS_HELP);
 }
 /**
@@ -7075,7 +7126,7 @@ async function runDeployWizard(ctx, options) {
 	ctx.state.render.check(notFoundOk, `${ctx.config.notFoundFile} present`, notFoundOk ? void 0 : "Set build.notFound so the SSG emits it (CF Pages else flips to SPA mode).");
 	ctx.state.render.info("Tip: run `bun run preview` to eyeball the built site before deploying.");
 	const outcome = await runDeployStep(ctx, options);
-	if (!(outcome.deployed === false && outcome.reason === "failed")) await offerWorkflowSetup(ctx);
+	if (!(outcome.deployed === false && outcome.reason === "failed")) await offerWorkflowSetup(ctx, cwd);
 	return outcome;
 }
 //#endregion
@@ -9967,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,
@@ -10054,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
@@ -10098,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.0"
+  "version": "1.13.2"
 }