@ubean/routes 0.2.1 → 0.3.0

package/dist/index.js

@@ -1,8 +1,9 @@
+import { C as registerAction, E as isValidActionId, S as listActions, T as createActionId, _ as parseActionInput, a as ACTION_RESPONSE_HEADER, b as getAction, c as unwrapServerFnResult, d as getActionContext, f as runWithActionContext, g as normalizeActionResult, h as defineServerFn, i as ACTIONS_ENDPOINT, l as bindActionContextStorage, m as defineAction, n as hasFormAction, o as invokeServerFn, p as buildActionContext, r as parseFormActionName, s as unwrapActionResult, t as buildFormActionUrl, u as createDetachedActionContext, v as validateActionInput, w as registerActions, x as hasAction, y as clearActions } from "./form-action-CZA0dSMO.js";
 import { addRoute, createRouter, findRoute } from "rou3";
+import { compileLocalePaths } from "@ubean/i18n";
 import { validateParams } from "@ubean/scan";
-import { isServerAction, matchAnyGlob } from "@ubean/shared";
-import { parseFormActionName, runAction } from "@ubean/actions";
-import { openAPIRouteHandler } from "hono-openapi";
+import { ACTION_BRAND, ActionError, fail, isActionFailure, isServerAction, isServerAction as isServerAction$1, matchAnyGlob } from "@ubean/shared";
+import { generateSpecs } from "hono-openapi";
 //#region src/handler.ts
 function isResponse(value) {
 	return value instanceof Response;
@@ -195,47 +196,80 @@ function isBotUserAgent(ua) {
 	return BOT_PATTERN.test(ua);
 }
 //#endregion
-//#region src/page-actions.ts
+//#region src/path-transform.ts
 /**
-* Shared redirect/non-redirect Response handling for both the legacy
-* `mod.action(c)` path and the `mod.actions` map path.
+* Apply a rewrite/proxy target to a request path (Nuxt-style wildcards).
 *
-* Returns a `Response` to return to the client, or `null` to fall through
-* (caller leaves `actionResult` as the Response for downstream handling).
+* - `/old` + `/new` → `/new`
+* - rule `/blog/**`, request `/blog/a/b`, target `/news/**` → `/news/a/b`
+* - target containing `$1` receives the captured suffix without a leading slash
+* - absolute `https://…` targets keep the origin and transform the pathname
 */
-function handleActionResponse(c, response, isPagesReq) {
-	if (response.status >= 300 && response.status < 400) {
-		const redirectUrl = response.headers.get("Location");
-		if (redirectUrl) {
-			if (isPagesReq(c)) return c.json({ redirect: redirectUrl }, {
-				status: 200,
-				headers: { "X-Ubean-Redirect": redirectUrl }
-			});
-			return response;
-		}
+function applyPathTransform(requestPath, rulePath, target) {
+	const suffix = captureWildcardSuffix(requestPath, rulePath);
+	const absolute = parseAbsoluteTarget(target);
+	if (absolute) {
+		const nextPath = substitutePath(absolute.pathname || "/", suffix);
+		return `${absolute.origin}${nextPath}${absolute.search}`;
 	}
-	if (isPagesReq(c)) return response;
-	return null;
+	return substitutePath(target, suffix);
 }
-/**
-* Run a `ServerAction` (from a page module's `actions` map) against the
-* current Hono context via `runAction` from `@ubean/actions`.
-*
-* Returns one of:
-*  - `{ response }` — handler returned/threw a `Response` (redirect)
-*  - `{ errors }` — validation failure, `fail()` from the handler, or a
-*    thrown error (mapped to `{ _error: message }`)
-*  - `{ data }` — successful return value (merged into page props)
-*/
-async function runServerAction(action, c) {
-	const result = await runAction(action, c);
-	if (result.response) return { response: result.response };
-	if (result.errors) return { errors: result.errors ?? {} };
-	if (result.error) return { errors: { _error: result.error.message } };
-	return { data: result.data };
+function parseAbsoluteTarget(target) {
+	if (!/^https?:\/\//.test(target)) return void 0;
+	try {
+		const url = new URL(target);
+		return {
+			origin: url.origin,
+			pathname: url.pathname,
+			search: url.search
+		};
+	} catch {
+		return;
+	}
+}
+function captureWildcardSuffix(requestPath, rulePath) {
+	const doubleIdx = rulePath.indexOf("/**");
+	if (doubleIdx !== -1) {
+		const prefix = rulePath.slice(0, doubleIdx);
+		if (requestPath === prefix || requestPath === `${prefix}/`) return "";
+		if (requestPath.startsWith(`${prefix}/`)) return requestPath.slice(prefix.length);
+		return "";
+	}
+	const singleIdx = rulePath.indexOf("/*");
+	if (singleIdx !== -1 && !rulePath.includes("**")) {
+		const prefix = rulePath.slice(0, singleIdx);
+		if (requestPath.startsWith(`${prefix}/`)) return `/${requestPath.slice(prefix.length + 1).split("/")[0] ?? ""}`;
+	}
+	return "";
+}
+function substitutePath(targetPath, suffix) {
+	const trimmedSuffix = suffix.replace(/^\//, "");
+	if (targetPath.includes("$1")) return targetPath.replaceAll("$1", trimmedSuffix);
+	if (targetPath.includes("/**")) return normalizePath(targetPath.replace("/**", suffix || ""));
+	if (targetPath.includes("/*")) {
+		const first = suffix.split("/").filter(Boolean)[0];
+		return normalizePath(targetPath.replace("/*", first ? `/${first}` : ""));
+	}
+	return normalizePath(targetPath);
+}
+function normalizePath(path) {
+	if (!path) return "/";
+	return (path.startsWith("/") ? path : `/${path}`).replace(/\/{2,}/g, "/");
 }
 //#endregion
 //#region src/route-rules.ts
+const REWRITE_GUARD = "x-ubean-rewrite";
+const HOP_BY_HOP = /* @__PURE__ */ new Set([
+	"connection",
+	"keep-alive",
+	"proxy-authenticate",
+	"proxy-authorization",
+	"te",
+	"trailers",
+	"transfer-encoding",
+	"upgrade",
+	"host"
+]);
 function compileRulePath(pattern) {
 	const DOUBLE = "__DWC__";
 	const SINGLE = "__SWC__";
@@ -256,7 +290,7 @@ function compileRulePath(pattern) {
 * P9-04 扩展:`ppr` 字段同样参与 specificity 计算。
 */
 function ruleSpecificity(rule) {
-	return (rule.redirect ? 3 : 0) + (rule.rewrite ? 2 : 0) + (rule.headers ? 1 : 0) + (rule.ssr !== void 0 ? 1 : 0) + (rule.isr !== void 0 ? 1 : 0) + (rule.prerender !== void 0 ? 1 : 0) + (rule.ppr !== void 0 ? 1 : 0);
+	return (rule.redirect ? 3 : 0) + (rule.rewrite ? 2 : 0) + (rule.proxy ? 2 : 0) + (rule.headers ? 1 : 0) + (rule.ssr !== void 0 ? 1 : 0) + (rule.isr !== void 0 ? 1 : 0) + (rule.prerender !== void 0 ? 1 : 0) + (rule.ppr !== void 0 ? 1 : 0);
 }
 /**
 * 路径特异性计算:作为 rule specificity 的 tiebreaker。
@@ -303,6 +337,7 @@ function matchRouteRules(path, compiledRules) {
 		};
 		if (rule.redirect && !matched.redirect) matched.redirect = rule.redirect;
 		if (rule.rewrite && !matched.rewrite) matched.rewrite = rule.rewrite;
+		if (rule.proxy && !matched.proxy) matched.proxy = rule.proxy;
 		if (rule.cache) matched.cache = {
 			...matched.cache,
 			...rule.cache
@@ -314,6 +349,9 @@ function matchRouteRules(path, compiledRules) {
 	}
 	return matched;
 }
+function findFirstRulePath(path, compiledRules, field) {
+	for (const { pattern, rule, path: rulePath } of compiledRules) if (pattern.test(path) && rule[field]) return rulePath;
+}
 function resolveRedirectUrl(redirect, currentPath) {
 	if (typeof redirect === "string") return {
 		url: redirect,
@@ -338,7 +376,28 @@ function buildCacheControlHeader(cache) {
 	}
 	return parts.length > 0 ? parts.join(", ") : null;
 }
-function createRouteRulesMiddleware(rules) {
+function cloneForwardHeaders(source) {
+	const headers = new Headers();
+	source.forEach((value, key) => {
+		if (!HOP_BY_HOP.has(key.toLowerCase())) headers.set(key, value);
+	});
+	return headers;
+}
+function buildForwardRequest(c, dest, extraHeaders) {
+	const headers = cloneForwardHeaders(c.req.raw.headers);
+	if (extraHeaders) new Headers(extraHeaders).forEach((value, key) => headers.set(key, value));
+	const init = {
+		method: c.req.method,
+		headers,
+		redirect: "manual"
+	};
+	if (c.req.method !== "GET" && c.req.method !== "HEAD" && c.req.raw.body) {
+		init.body = c.req.raw.body;
+		init.duplex = "half";
+	}
+	return new Request(dest, init);
+}
+function createRouteRulesMiddleware(rules, options = {}) {
 	const compiled = compileRouteRules(rules);
 	return async function routeRulesMiddleware(c, next) {
 		const path = c.req.path;
@@ -355,6 +414,23 @@ function createRouteRulesMiddleware(rules) {
 		if (matched.headers) for (const [key, value] of Object.entries(matched.headers)) c.header(key, value);
 		const cacheHeader = buildCacheControlHeader(matched.cache);
 		if (cacheHeader) c.header("Cache-Control", cacheHeader);
+		if (matched.proxy) {
+			const dest = applyPathTransform(path, findFirstRulePath(path, compiled, "proxy") ?? path, matched.proxy);
+			const upstream = await fetch(buildForwardRequest(c, dest));
+			return new Response(upstream.body, {
+				status: upstream.status,
+				statusText: upstream.statusText,
+				headers: upstream.headers
+			});
+		}
+		if (matched.rewrite && options.dispatch && !c.req.header(REWRITE_GUARD)) {
+			const dest = applyPathTransform(path, findFirstRulePath(path, compiled, "rewrite") ?? path, matched.rewrite);
+			if (dest !== path) {
+				const url = new URL(c.req.url);
+				url.pathname = dest;
+				return options.dispatch(buildForwardRequest(c, url.toString(), { [REWRITE_GUARD]: "1" }));
+			}
+		}
 		await next();
 	};
 }
@@ -439,7 +515,7 @@ function isIsrEntryStale(pathname, store) {
 	if (!memStore.store) return false;
 	const entry = memStore.store.get(buildIsrCacheKey(pathname));
 	if (!entry?.expiresAt) return false;
-	return Date.now() > entry.expiresAt;
+	return Date.now() >= entry.expiresAt;
 }
 /**
 * ISR 主入口:检查缓存 → 命中则返回,未命中/过期则调用 render 重新生成。
@@ -457,7 +533,7 @@ async function serveIsr(_c, options) {
 	const key = buildIsrCacheKey(pathname);
 	const rawEntry = store.peek ? await store.peek(key) : await store.get(key);
 	if (rawEntry) {
-		const isStale = Date.now() > rawEntry.expiresAt;
+		const isStale = Date.now() >= rawEntry.expiresAt;
 		const html = new TextDecoder().decode(rawEntry.body);
 		if (!isStale) {
 			const headers = new Headers(rawEntry.headers);
@@ -514,6 +590,268 @@ function getIsrRuleFromContext(c) {
 	return normalizeIsrRule(rule.isr);
 }
 //#endregion
+//#region src/actions/openapi.ts
+/**
+* Optional OpenAPI fragment for the shared `POST /__actions` RPC.
+*
+* Per-action operations stay on the same endpoint (id in the body) so this
+* does not create a second RPC surface.
+*/
+function describeActionsOpenApi() {
+	const names = listActions().map((action) => `${action.name} (${action.id})`);
+	return { paths: { "/__actions": { post: {
+		summary: "Server Actions / server functions RPC",
+		operationId: "ubeanActionsRpc",
+		description: names.length > 0 ? `Registered functions: ${names.join(", ")}.` : "No server functions registered yet. Define them with defineAction / defineServerFn."
+	} } } };
+}
+//#endregion
+//#region src/actions/dispatch.ts
+/**
+* Dispatch a registered server action by ID.
+*
+* Used by the `/__actions` POST endpoint (RPC-style invocation from the
+* client). The action ID is looked up in the global registry; the request
+* body is parsed as JSON or FormData depending on `Content-Type`.
+*
+* When `preParsedInput` is provided (RPC path — the middleware has already
+* read the body to extract the `{ id, args }` envelope), body parsing is
+* skipped and `preParsedInput` is used as the handler input directly.
+*
+* Returns an `ActionResult` (serializable). When the action ID is unknown
+* or invalid, returns a 404 error result without throwing.
+*/
+async function dispatchAction(actionId, c, preParsedInput) {
+	const action = getAction(actionId);
+	if (!action) return {
+		error: { message: `Action not found: ${actionId}` },
+		status: 404
+	};
+	return runAction(action, c, preParsedInput);
+}
+/**
+* Run an arbitrary `ServerAction` against the given Hono context.
+*
+* Used internally by `dispatchAction` and by `handlePageRequest` for
+* page-level form actions (which are not in the global registry but
+* are exported from the page module's `actions` map).
+*
+* When `preParsedInput` is provided, body parsing is skipped (the caller
+* has already read the request body — e.g. the RPC middleware extracting
+* the `{ id, args }` envelope).
+*/
+async function runAction(action, c, preParsedInput) {
+	const ctx = buildActionContext(c);
+	const rawInput = preParsedInput !== void 0 ? preParsedInput : await parseActionInput(c.req.raw);
+	let input = rawInput;
+	if (action.schema) {
+		const validation = validateActionInput(action.schema, rawInput);
+		if (!validation.success) return {
+			errors: validation.errors,
+			status: 400
+		};
+		input = validation.data;
+	}
+	let result;
+	let error;
+	try {
+		result = await action.handler(input, ctx);
+	} catch (err) {
+		if (err instanceof Response) return {
+			response: err,
+			status: err.status
+		};
+		error = err;
+	}
+	if (result instanceof Response) return {
+		response: result,
+		status: result.status
+	};
+	return normalizeActionResult(result, error);
+}
+/**
+* Run a page-level form action by name (SvelteKit-style `?/name` convention).
+*
+* Page modules may export an `actions` map:
+*
+* ```ts
+* export const actions = {
+*   default: defineAction(async (input, ctx) => { ... }),
+*   login: defineAction(async (input, ctx) => { ... }),
+*   register: defineAction(async (input, ctx) => { ... })
+* };
+* ```
+*
+* - `POST /page` (no `?/`) → `actions.default`
+* - `POST /page?/login` → `actions.login`
+* - `POST /page?/register` → `actions.register`
+*
+* Returns `null` when:
+*  - No `actions` export exists (caller should fall back to `mod.action`).
+*  - The named action doesn't exist (caller should return 404).
+*
+* The caller (`handlePageRequest`) is responsible for converting the
+* `ActionResult` into an HTTP response (HTML for browser navigation,
+* JSON for SPA `submit()` calls).
+*/
+async function runPageAction(actions, actionName, c) {
+	const action = actions[actionName];
+	if (!action) return null;
+	return runAction(action, c);
+}
+//#endregion
+//#region src/actions/middleware.ts
+/**
+* Create the actions middleware — a Hono handler that mounts the
+* `/__actions` POST endpoint.
+*
+* Usage:
+*
+* ```ts
+* import { createUbeanApp } from 'ubean/runtime/app';
+* import { createActionsMiddleware } from '@ubean/routes';
+*
+* const app = createUbeanApp();
+* app.on('POST', '/__actions', createActionsMiddleware());
+* ```
+*
+* The middleware is auto-registered by ubean's dev server / production
+* server setup — users don't need to mount it manually.
+*/
+function createActionsMiddleware() {
+	return async (c) => {
+		let actionId;
+		let args;
+		if ((c.req.header("Content-Type") || "").includes("application/json")) try {
+			const body = await c.req.json();
+			actionId = body?.id;
+			args = body?.args;
+		} catch {}
+		if (!actionId) actionId = c.req.query("id");
+		if (!actionId) return _jsonResult(c, {
+			error: { message: "Missing action id" },
+			status: 400
+		}, 400);
+		const preParsedInput = Array.isArray(args) && args.length > 0 ? args[0] : void 0;
+		const result = await dispatchAction(actionId, c, preParsedInput);
+		if (result.response) return result.response;
+		return _jsonResult(c, result, result.status);
+	};
+}
+/**
+* Serialize an `ActionResult` as a JSON Hono response with the action
+* response header set.
+*/
+function _jsonResult(c, result, status) {
+	return c.json(result, status, {
+		[ACTION_RESPONSE_HEADER]: "true",
+		"Cache-Control": "no-store"
+	});
+}
+/**
+* Check whether a request targets the actions endpoint.
+*
+* Used by route registrars to skip registering regular API routes for
+* the `/__actions` path.
+*/
+function isActionsRequest(c) {
+	return c.req.method === "POST" && c.req.path === "/__actions";
+}
+/**
+* Check whether a response came from the actions middleware.
+*
+* Used by the client `callAction()` to validate the response shape.
+*/
+function isActionResponse(response) {
+	return response.headers.get(ACTION_RESPONSE_HEADER) === "true";
+}
+//#endregion
+//#region src/page-actions.ts
+/**
+* Shared redirect/non-redirect Response handling for both the legacy
+* `mod.action(c)` path and the `mod.actions` map path.
+*
+* Returns a `Response` to return to the client, or `null` to fall through
+* (caller leaves `actionResult` as the Response for downstream handling).
+*/
+function handleActionResponse(c, response, isPagesReq) {
+	if (response.status >= 300 && response.status < 400) {
+		const redirectUrl = response.headers.get("Location");
+		if (redirectUrl) {
+			if (isPagesReq(c)) return c.json({ redirect: redirectUrl }, {
+				status: 200,
+				headers: { "X-Ubean-Redirect": redirectUrl }
+			});
+			return response;
+		}
+	}
+	if (isPagesReq(c)) return response;
+	return null;
+}
+/**
+* Run a `ServerAction` (from a page module's `actions` map) against the
+* current Hono context via `runAction`.
+*
+* Returns one of:
+*  - `{ response }` — handler returned/threw a `Response` (redirect)
+*  - `{ errors }` — validation failure, `fail()` from the handler, or a
+*    thrown error (mapped to `{ _error: message }`)
+*  - `{ data }` — successful return value (merged into page props)
+*/
+async function runServerAction(action, c) {
+	const result = await runAction(action, c);
+	if (result.response) return { response: result.response };
+	if (result.errors) return { errors: result.errors ?? {} };
+	if (result.error) return { errors: { _error: result.error.message } };
+	return { data: result.data };
+}
+//#endregion
+//#region src/select-ssr.ts
+/**
+* TanStack-style select SSR: page meta wins over routeRules, which win over
+* the global exclude list. Glob exclude stays backward-compatible (CSR shell
+* still runs loader). Explicit `ssr: false` skips the loader.
+*/
+function resolveSelectSsr(input) {
+	const ssr = input.pageSsr ?? input.routeRuleSsr;
+	if (ssr === false) return {
+		mode: "csr",
+		runLoader: false,
+		useRenderer: false
+	};
+	if (ssr === "data-only") return {
+		mode: "data-only",
+		runLoader: true,
+		useRenderer: false
+	};
+	if (ssr === "streaming" || input.ppr) return {
+		mode: "streaming",
+		runLoader: true,
+		useRenderer: true
+	};
+	if (ssr === true) return {
+		mode: "ssr",
+		runLoader: true,
+		useRenderer: true
+	};
+	if (input.excludedByGlob) return {
+		mode: "csr",
+		runLoader: true,
+		useRenderer: false
+	};
+	return {
+		mode: input.streaming ? "streaming" : "ssr",
+		runLoader: true,
+		useRenderer: true
+	};
+}
+function ssrModeHeader(mode) {
+	if (mode === "csr") return "csr";
+	if (mode === "data-only") return "data-only";
+	if (mode === "streaming") return "streaming";
+	return "ssr";
+}
+//#endregion
 //#region src/router.ts
 const HTTP_METHODS = [
 	"GET",
@@ -753,20 +1091,16 @@ async function registerPageRoutes(app, options) {
 	function getMatchingMiddleware(routePath) {
 		return loadedUserMiddleware.filter((mw) => matchMiddlewarePath(mw.mountPath, routePath)).map((mw) => mw.handler);
 	}
-	function getLocalePrefixedPaths(honoPath) {
-		if (!i18nConfig) return [];
-		const { strategy, defaultLocale, locales = [] } = i18nConfig;
-		if (strategy === "no_prefix") return [];
-		const result = [];
-		for (const locale of locales) {
-			if (strategy === "prefix_except_default" && locale === defaultLocale) continue;
-			const cleanPath = honoPath === "/" ? "" : honoPath;
-			result.push({
-				locale,
-				path: `/${locale}${cleanPath}`
-			});
-		}
-		return result;
+	function getHonoLocalePaths(honoPath) {
+		if (!i18nConfig?.locales?.length || i18nConfig.strategy === "no_prefix" || honoPath === "*") return [{
+			locale: i18nConfig?.defaultLocale || "en",
+			path: honoPath
+		}];
+		return compileLocalePaths(honoPath === "/" ? "/" : honoPath, {
+			defaultLocale: i18nConfig.defaultLocale || "en",
+			locales: i18nConfig.locales,
+			strategy: i18nConfig.strategy || "prefix_except_default"
+		}).hono;
 	}
 	const hasDefaultLayout = layouts.some((l) => l.isDefault);
 	const { isPagesRequest, pageJsonResponse, renderPage, renderPageToStream } = pagesMod;
@@ -800,7 +1134,7 @@ async function registerPageRoutes(app, options) {
 			const actionsExport = mod?.actions;
 			if (actionsExport && typeof actionsExport === "object") {
 				const action = actionsExport[parseFormActionName(c.req.url)];
-				if (action && isServerAction(action)) {
+				if (action && isServerAction$1(action)) {
 					const res = await runServerAction(action, c);
 					if (res.response) {
 						const handled = handleActionResponse(c, res.response, isPagesRequest);
@@ -829,7 +1163,19 @@ async function registerPageRoutes(app, options) {
 				actionErrors = { _error: err instanceof Error ? err.message : String(err) };
 			}
 		}
-		if (mod?.loader && typeof mod.loader === "function") try {
+		const routeRule = c.get("routeRule");
+		const isrRule = normalizeIsrRule(routeRule?.isr);
+		const pprEnabled = routeRule?.ppr === true;
+		const selected = resolveSelectSsr({
+			pageSsr: page.pageMeta?.ssr,
+			routeRuleSsr: routeRule?.ssr,
+			ppr: pprEnabled,
+			excludedByGlob: matchAnyGlob(page.route, ssrExclude),
+			streaming
+		});
+		const routeStreaming = selected.mode === "streaming";
+		const renderer = selected.useRenderer ? pageRenderer ?? null : null;
+		if (selected.runLoader && mod?.loader && typeof mod.loader === "function") try {
 			loaderResult = await mod.loader(c);
 			if (loaderResult instanceof Response) return loaderResult;
 		} catch {}
@@ -851,28 +1197,26 @@ async function registerPageRoutes(app, options) {
 			locale: currentLocale,
 			localeDir: "ltr"
 		};
+		if (i18nConfig) {
+			renderContext.routing = {
+				defaultLocale: i18nConfig.defaultLocale || "en",
+				locales: i18nConfig.locales || [],
+				strategy: i18nConfig.strategy || "prefix_except_default"
+			};
+			if (i18nConfig.cookieName) renderContext.cookieName = i18nConfig.cookieName;
+			if (i18nConfig.baseUrl) renderContext.baseUrl = i18nConfig.baseUrl;
+		}
 		const i18nMod = await loadI18n();
 		if (i18nMod && currentLocale) {
 			renderContext.localeDir = i18nMod.getLocaleDir(currentLocale);
 			renderContext.messages = i18nMod.getLocaleMessages(currentLocale);
+			const fallback = i18nMod.getFallbackLocale();
+			renderContext.fallbackLocale = fallback;
+			if (fallback !== currentLocale) renderContext.fallbackMessages = i18nMod.getLocaleMessages(fallback);
 			renderContext.availableLocales = i18nMod.getRegisteredLocalesMeta();
 		}
-		const routeRule = c.get("routeRule");
-		const perRouteSsr = routeRule?.ssr;
-		const isrRule = normalizeIsrRule(routeRule?.isr);
-		const pprEnabled = routeRule?.ppr === true;
-		let excluded = matchAnyGlob(page.route, ssrExclude);
-		let routeStreaming = streaming;
-		if (perRouteSsr === false) excluded = true;
-		else if (perRouteSsr === true) excluded = false;
-		else if (perRouteSsr === "streaming") {
-			excluded = false;
-			routeStreaming = true;
-		} else if (pprEnabled) {
-			excluded = false;
-			routeStreaming = true;
-		}
-		const renderer = excluded ? null : pageRenderer ?? null;
+		const htmlHeaders = { "X-SSR-Mode": ssrModeHeader(selected.mode) };
+		if (pprEnabled) htmlHeaders["X-PPR"] = "streaming";
 		if (isrRule && cacheStore && method === "GET") {
 			const pathname = new URL(c.req.url).pathname;
 			const isrResponse = await serveIsr(c, {
@@ -883,7 +1227,10 @@ async function registerPageRoutes(app, options) {
 					return {
 						html: await renderPage(pageObj, pageAssetTags ?? {}, renderer, "app", renderContext),
 						status: 200,
-						headers: { "Content-Type": "text/html; charset=utf-8" }
+						headers: {
+							"Content-Type": "text/html; charset=utf-8",
+							...htmlHeaders
+						}
 					};
 				}
 			});
@@ -893,15 +1240,19 @@ async function registerPageRoutes(app, options) {
 		const isBot = botFallback && isBotUserAgent(userAgent);
 		if (routeStreaming && renderer && !isBot) {
 			const stream = renderPageToStream(pageObj, pageAssetTags ?? {}, renderer, "app", renderContext);
-			const headers = { "Content-Type": "text/html; charset=utf-8" };
-			if (pprEnabled) headers["X-PPR"] = "true";
 			return c.body(stream, {
-				headers,
+				headers: {
+					"Content-Type": "text/html; charset=utf-8",
+					...htmlHeaders
+				},
 				...method === "POST" && actionErrors ? { status: 422 } : {}
 			});
 		}
 		const html = await renderPage(pageObj, pageAssetTags ?? {}, renderer, "app", renderContext);
-		return c.html(injectColorMode(html), method === "POST" && actionErrors ? { status: 422 } : void 0);
+		return c.html(injectColorMode(html), {
+			headers: htmlHeaders,
+			...method === "POST" && actionErrors ? { status: 422 } : {}
+		});
 	}
 	const pageByName = /* @__PURE__ */ new Map();
 	for (const p of pages) pageByName.set(p.name, p);
@@ -910,14 +1261,6 @@ async function registerPageRoutes(app, options) {
 		const honoPath = convertUbeanRoutePath(page.route);
 		const matchingMiddleware = getMatchingMiddleware(honoPath);
 		const pageMeta = { requiresAuth: page.pageMeta?.requiresAuth ?? true };
-		const metaMiddleware = async (c, next) => {
-			c.set("route", {
-				meta: pageMeta,
-				path: c.req.path,
-				method: c.req.method
-			});
-			await next();
-		};
 		const matcherMiddleware = async (c, next) => {
 			if (!page.matchers) {
 				await next();
@@ -933,9 +1276,7 @@ async function registerPageRoutes(app, options) {
 		};
 		const loaderKey = page.isReuse && page.reuseTarget ? pageByName.get(page.reuseTarget)?.relativePath ?? page.relativePath : page.relativePath;
 		const pageHandler = (method) => async (c) => handlePageRequest(c, page, method, loaderKey);
-		app.on(["GET"], honoPath, metaMiddleware, matcherMiddleware, ...matchingMiddleware, pageHandler("GET"));
-		app.on(["POST"], honoPath, metaMiddleware, matcherMiddleware, ...matchingMiddleware, pageHandler("POST"));
-		for (const { path: localePath } of getLocalePrefixedPaths(honoPath)) {
+		for (const { path: mountPath } of getHonoLocalePaths(honoPath)) {
 			const localeMetaMiddleware = async (c, next) => {
 				c.set("route", {
 					meta: pageMeta,
@@ -944,8 +1285,8 @@ async function registerPageRoutes(app, options) {
 				});
 				await next();
 			};
-			app.on(["GET"], localePath, localeMetaMiddleware, matcherMiddleware, ...matchingMiddleware, pageHandler("GET"));
-			app.on(["POST"], localePath, localeMetaMiddleware, matcherMiddleware, ...matchingMiddleware, pageHandler("POST"));
+			app.on(["GET"], mountPath, localeMetaMiddleware, matcherMiddleware, ...matchingMiddleware, pageHandler("GET"));
+			app.on(["POST"], mountPath, localeMetaMiddleware, matcherMiddleware, ...matchingMiddleware, pageHandler("POST"));
 		}
 	}
 	if (options.notFoundPage) {
@@ -978,6 +1319,9 @@ async function registerPageRoutes(app, options) {
 			if (i18nMod && currentLocale) {
 				renderContext.localeDir = i18nMod.getLocaleDir(currentLocale);
 				renderContext.messages = i18nMod.getLocaleMessages(currentLocale);
+				const fallback = i18nMod.getFallbackLocale();
+				renderContext.fallbackLocale = fallback;
+				if (fallback !== currentLocale) renderContext.fallbackMessages = i18nMod.getLocaleMessages(fallback);
 				renderContext.availableLocales = i18nMod.getRegisteredLocalesMeta();
 			}
 			const pageObj = {
@@ -1085,15 +1429,25 @@ function createInternalAdapter(c, options) {
 //#region src/openapi.ts
 function registerOpenAPIRoutes(app, options = {}) {
 	const { scalarPath = "/_scalar", openAPIPath = "/_openapi.json", title = "API Reference" } = options;
-	const openapiHandler = openAPIRouteHandler(app, { documentation: {
+	const documentation = {
 		info: {
 			title: options.title || "UBEAN API",
 			version: options.version || "1.0.0",
 			description: options.description
 		},
 		servers: options.baseURL ? [{ url: options.baseURL }] : void 0
-	} });
-	app.get(openAPIPath, openapiHandler);
+	};
+	app.get(openAPIPath, async (c) => {
+		const spec = await generateSpecs(app, { documentation });
+		const { paths } = describeActionsOpenApi();
+		return c.json({
+			...spec,
+			paths: {
+				...spec.paths,
+				...paths
+			}
+		});
+	});
 	app.get(scalarPath, (c) => {
 		const scalarHTML = `<!doctype html>
 <html>
@@ -1125,4 +1479,4 @@ function registerOpenAPIRoutes(app, options = {}) {
 	});
 }
 //#endregion
-export { UbeanRouter, buildIsrCacheKey, clearInternalFetcher, compileRouteRules, createInternalAdapter, createRouteLoader, createRouteRulesMiddleware, createServerRouter, defineHandler, defineHandlerMeta, defineMiddleware, extractRouteMeta, getInternalFetcher, getIsrCache, getIsrRuleFromContext, getStaleIsrCache, invalidateIsrCache, invalidateIsrCachePattern, isBotUserAgent, isHandlerChain, isIsrEntryStale, matchRouteRules, normalizeIsrRule, registerApiRoutes, registerOpenAPIRoutes, registerPageRoutes, registerRoutes, serveIsr, setInternalFetcher, setIsrCache, sortPagesForRegistration, useRouter };
+export { ACTIONS_ENDPOINT, ACTION_BRAND, ACTION_RESPONSE_HEADER, ActionError, UbeanRouter, applyPathTransform, bindActionContextStorage, buildActionContext, buildFormActionUrl, buildIsrCacheKey, clearActions, clearInternalFetcher, compileRouteRules, createActionId, createActionsMiddleware, createDetachedActionContext, createInternalAdapter, createRouteLoader, createRouteRulesMiddleware, createServerRouter, defineAction, defineHandler, defineHandlerMeta, defineMiddleware, defineServerFn, describeActionsOpenApi, dispatchAction, extractRouteMeta, fail, getAction, getActionContext, getInternalFetcher, getIsrCache, getIsrRuleFromContext, getStaleIsrCache, hasAction, hasFormAction, invalidateIsrCache, invalidateIsrCachePattern, invokeServerFn, isActionFailure, isActionResponse, isActionsRequest, isBotUserAgent, isHandlerChain, isIsrEntryStale, isServerAction, isValidActionId, listActions, matchRouteRules, normalizeActionResult, normalizeIsrRule, parseActionInput, parseFormActionName, registerAction, registerActions, registerApiRoutes, registerOpenAPIRoutes, registerPageRoutes, registerRoutes, resolveSelectSsr, runAction, runPageAction, runWithActionContext, serveIsr, setInternalFetcher, setIsrCache, sortPagesForRegistration, ssrModeHeader, unwrapActionResult, unwrapServerFnResult, useRouter, validateActionInput };