@finesoft/front 0.1.39 → 0.1.41

package/dist/index.mjs

@@ -0,0 +1,2749 @@
+import "./server-peer-modules-BSSsxBaF.d.mts";
+import { a as SSR_PLACEHOLDERS, i as createInternalFetch, n as createSSRApp, o as injectCSRShell, s as injectSSRContent } from "./app-re7jUCuM.mjs";
+import { n as parseAcceptLanguage } from "./locale-D2Bu7w47.mjs";
+import { Hono } from "hono";
+//#region ../core/src/actions/types.ts
+/**
+* Action 类型定义
+*
+* FlowAction — SPA 内部导航
+* ExternalUrlAction — 打开外部链接
+* CompoundAction — 组合多个 Action
+*/
+/** Action Kind 常量 */
+const ACTION_KINDS = {
+	FLOW: "flow",
+	EXTERNAL_URL: "externalUrl",
+	COMPOUND: "compound"
+};
+function isFlowAction(action) {
+	return action.kind === ACTION_KINDS.FLOW;
+}
+function isExternalUrlAction(action) {
+	return action.kind === ACTION_KINDS.EXTERNAL_URL;
+}
+function isCompoundAction(action) {
+	return action.kind === ACTION_KINDS.COMPOUND;
+}
+function makeFlowAction(url, presentationContext) {
+	return {
+		kind: ACTION_KINDS.FLOW,
+		url,
+		presentationContext
+	};
+}
+function makeExternalUrlAction(url) {
+	return {
+		kind: ACTION_KINDS.EXTERNAL_URL,
+		url
+	};
+}
+//#endregion
+//#region ../core/src/actions/dispatcher.ts
+var ActionDispatcher = class {
+	handlers = /* @__PURE__ */ new Map();
+	wiredActions = /* @__PURE__ */ new Set();
+	/** 注册指定 kind 的 handler（防止重复注册） */
+	onAction(kind, handler) {
+		if (this.wiredActions.has(kind)) {
+			console.warn(`[ActionDispatcher] kind="${kind}" already registered, skipping`);
+			return;
+		}
+		this.wiredActions.add(kind);
+		this.handlers.set(kind, handler);
+	}
+	/** 执行一个 Action（CompoundAction 递归展开） */
+	async perform(action) {
+		if (isCompoundAction(action)) {
+			for (const subAction of action.actions) await this.perform(subAction);
+			return;
+		}
+		const handler = this.handlers.get(action.kind);
+		if (!handler) {
+			console.warn(`[ActionDispatcher] No handler for kind="${action.kind}"`);
+			return;
+		}
+		await handler(action);
+	}
+};
+//#endregion
+//#region ../core/src/intents/dispatcher.ts
+var IntentDispatcher = class {
+	controllers = /* @__PURE__ */ new Map();
+	/** 注册一个 IntentController */
+	register(controller) {
+		this.controllers.set(controller.intentId, controller);
+	}
+	/** 分发 Intent 到对应 Controller */
+	async dispatch(intent, container) {
+		const controller = this.controllers.get(intent.id);
+		if (!controller) throw new Error(`[IntentDispatcher] No controller for "${intent.id}". Registered: [${Array.from(this.controllers.keys()).join(", ")}]`);
+		return controller.perform(intent, container);
+	}
+	/** 检查是否已注册某个 Intent */
+	has(intentId) {
+		return this.controllers.has(intentId);
+	}
+};
+//#endregion
+//#region ../core/src/dependencies/container.ts
+var Container = class {
+	registrations = /* @__PURE__ */ new Map();
+	/** 注册依赖（默认单例） */
+	register(key, factory, singleton = true) {
+		this.registrations.set(key, {
+			factory,
+			singleton
+		});
+		return this;
+	}
+	/** 解析依赖 */
+	resolve(key) {
+		const reg = this.registrations.get(key);
+		if (!reg) throw new Error(`[Container] No registration for key: "${key}"`);
+		if (reg.singleton) {
+			if (reg.instance === void 0) reg.instance = reg.factory();
+			return reg.instance;
+		}
+		return reg.factory();
+	}
+	/** 检查是否已注册 */
+	has(key) {
+		return this.registrations.has(key);
+	}
+	/** 销毁容器，清除所有缓存 */
+	dispose() {
+		for (const reg of this.registrations.values()) reg.instance = void 0;
+		this.registrations.clear();
+	}
+};
+//#endregion
+//#region ../core/src/logger/base.ts
+var BaseLogger = class {
+	category;
+	constructor(category) {
+		this.category = category;
+	}
+};
+//#endregion
+//#region ../core/src/logger/local-storage-filter.ts
+const LEVEL_TO_NUM = {
+	"*": 4,
+	debug: 4,
+	info: 3,
+	warn: 2,
+	error: 1,
+	off: 0,
+	"": 0
+};
+let cachedRules;
+let cachedRaw;
+function parseRules() {
+	if (typeof globalThis.localStorage === "undefined") return {};
+	let raw;
+	try {
+		raw = globalThis.localStorage.getItem("onyxLog");
+	} catch {
+		return {};
+	}
+	if (!raw) return {};
+	if (raw === cachedRaw && cachedRules) return cachedRules;
+	cachedRaw = raw;
+	const rules = {};
+	const parts = raw.split(",");
+	for (const part of parts) {
+		const [name, level] = part.trim().split("=");
+		if (!name || level === void 0) continue;
+		const num = LEVEL_TO_NUM[level.toLowerCase()] ?? void 0;
+		if (num === void 0) continue;
+		if (name === "*") rules.defaultLevel = num;
+		else {
+			rules.named ??= {};
+			rules.named[name] = num;
+		}
+	}
+	cachedRules = rules;
+	return rules;
+}
+function shouldLog(name, level) {
+	const rules = parseRules();
+	if (rules.defaultLevel === void 0 && !rules.named) return true;
+	const currentNum = LEVEL_TO_NUM[level] ?? 4;
+	if (rules.named?.[name] !== void 0) return currentNum <= rules.named[name];
+	if (rules.defaultLevel !== void 0) return currentNum <= rules.defaultLevel;
+	return true;
+}
+function resetFilterCache() {
+	cachedRules = void 0;
+	cachedRaw = void 0;
+}
+//#endregion
+//#region ../core/src/logger/console.ts
+/**
+* ConsoleLogger — 基于 console 的日志实现
+*/
+var ConsoleLogger = class extends BaseLogger {
+	debug(...args) {
+		if (shouldLog(this.category, "debug")) console.debug(`[${this.category}]`, ...args);
+		return "";
+	}
+	info(...args) {
+		if (shouldLog(this.category, "info")) console.info(`[${this.category}]`, ...args);
+		return "";
+	}
+	warn(...args) {
+		if (shouldLog(this.category, "warn")) console.warn(`[${this.category}]`, ...args);
+		return "";
+	}
+	error(...args) {
+		console.error(`[${this.category}]`, ...args);
+		return "";
+	}
+};
+var ConsoleLoggerFactory = class {
+	loggerFor(category) {
+		return new ConsoleLogger(category);
+	}
+};
+//#endregion
+//#region ../core/src/dependencies/make-dependencies.ts
+/**
+* 依赖工厂 — 创建所有基础依赖
+*/
+const DEP_KEYS = {
+	LOGGER: "logger",
+	LOGGER_FACTORY: "loggerFactory",
+	NET: "net",
+	LOCALE: "locale",
+	STORAGE: "storage",
+	FEATURE_FLAGS: "featureFlags",
+	METRICS: "metrics",
+	FETCH: "fetch"
+};
+var DefaultLocale = class {
+	language = "en";
+	storefront = "us";
+	setActiveLocale(language, storefront) {
+		this.language = language;
+		this.storefront = storefront;
+	}
+};
+var MemoryStorage = class {
+	store = /* @__PURE__ */ new Map();
+	get(key) {
+		return this.store.get(key);
+	}
+	set(key, value) {
+		this.store.set(key, value);
+	}
+	delete(key) {
+		this.store.delete(key);
+	}
+};
+var DefaultFeatureFlags = class {
+	flags;
+	constructor(flags = {}) {
+		this.flags = flags;
+	}
+	isEnabled(key) {
+		return this.flags[key] === true;
+	}
+	getString(key) {
+		const v = this.flags[key];
+		return typeof v === "string" ? v : void 0;
+	}
+	getNumber(key) {
+		const v = this.flags[key];
+		return typeof v === "number" ? v : void 0;
+	}
+};
+var ConsoleMetrics = class {
+	recordPageView(page, fields) {
+		console.info(`[Metrics:PageView] ${page}`, fields ?? "");
+	}
+	recordEvent(name, fields) {
+		console.info(`[Metrics:Event] ${name}`, fields ?? "");
+	}
+};
+function makeDependencies(container, options = {}) {
+	const { fetch: fetchFn = globalThis.fetch?.bind(globalThis), language = "en", storefront = "us", featureFlags = {} } = options;
+	const loggerFactory = new ConsoleLoggerFactory();
+	container.register(DEP_KEYS.LOGGER_FACTORY, () => loggerFactory);
+	container.register(DEP_KEYS.LOGGER, () => loggerFactory.loggerFor("framework"));
+	container.register(DEP_KEYS.NET, () => ({ fetch: (url, opts) => fetchFn(url, opts) }));
+	container.register(DEP_KEYS.LOCALE, () => {
+		const locale = new DefaultLocale();
+		locale.setActiveLocale(language, storefront);
+		return locale;
+	});
+	container.register(DEP_KEYS.STORAGE, () => new MemoryStorage());
+	container.register(DEP_KEYS.FEATURE_FLAGS, () => new DefaultFeatureFlags(featureFlags));
+	container.register(DEP_KEYS.METRICS, () => new ConsoleMetrics());
+	container.register(DEP_KEYS.FETCH, () => fetchFn);
+}
+//#endregion
+//#region ../core/src/router/router.ts
+/**
+* URL 路由器 — URL pattern → Intent + FlowAction
+*/
+var Router = class {
+	routes = [];
+	/** 添加路由规则 */
+	add(pattern, intentId, renderModeOrOptions) {
+		const opts = typeof renderModeOrOptions === "string" ? { renderMode: renderModeOrOptions } : renderModeOrOptions ?? {};
+		const paramNames = [];
+		const regexStr = pattern.split(/(\/:[\w]+\??)/).map((segment) => {
+			const paramMatch = segment.match(/^\/:(\w+)(\?)?$/);
+			if (paramMatch) {
+				paramNames.push(paramMatch[1]);
+				return paramMatch[2] ? "(?:/([^/]+))?" : "/([^/]+)";
+			}
+			return segment.replace(/[.+?^${}()|[\]\\]/g, "\\$&");
+		}).join("");
+		this.routes.push({
+			pattern,
+			intentId,
+			regex: new RegExp(`^${regexStr}/?$`),
+			paramNames,
+			renderMode: opts.renderMode,
+			beforeGuards: opts.beforeGuards,
+			afterGuards: opts.afterGuards
+		});
+		return this;
+	}
+	/** 解析 URL → RouteMatch */
+	resolve(urlOrPath) {
+		const path = this.extractPath(urlOrPath);
+		const queryParams = this.extractQueryParams(urlOrPath);
+		for (const route of this.routes) {
+			const match = path.match(route.regex);
+			if (match) {
+				const params = {};
+				route.paramNames.forEach((name, index) => {
+					const value = match[index + 1];
+					if (value) params[name] = value;
+				});
+				for (const [k, v] of Object.entries(queryParams)) if (!(k in params)) params[k] = v;
+				return {
+					intent: {
+						id: route.intentId,
+						params
+					},
+					action: makeFlowAction(urlOrPath),
+					renderMode: route.renderMode,
+					beforeGuards: route.beforeGuards,
+					afterGuards: route.afterGuards
+				};
+			}
+		}
+		return null;
+	}
+	/** 获取所有已注册的路由 */
+	getRoutes() {
+		return this.routes.map((r) => `${r.pattern} → ${r.intentId}`);
+	}
+	extractPath(url) {
+		try {
+			return new URL(url, "http://localhost").pathname;
+		} catch {
+			return url.split("?")[0].split("#")[0];
+		}
+	}
+	extractQueryParams(url) {
+		try {
+			const parsed = new URL(url, "http://localhost");
+			const params = {};
+			parsed.searchParams.forEach((v, k) => {
+				params[k] = v;
+			});
+			return params;
+		} catch {
+			return {};
+		}
+	}
+};
+//#endregion
+//#region ../core/src/logger/composite.ts
+var CompositeLoggerFactory = class {
+	constructor(factories) {
+		this.factories = factories;
+	}
+	loggerFor(name) {
+		return new CompositeLogger(this.factories.map((f) => f.loggerFor(name)));
+	}
+};
+var CompositeLogger = class {
+	constructor(loggers) {
+		this.loggers = loggers;
+	}
+	debug(...args) {
+		return this.callAll("debug", args);
+	}
+	info(...args) {
+		return this.callAll("info", args);
+	}
+	warn(...args) {
+		return this.callAll("warn", args);
+	}
+	error(...args) {
+		return this.callAll("error", args);
+	}
+	callAll(method, args) {
+		for (const logger of this.loggers) logger[method](...args);
+		return "";
+	}
+};
+//#endregion
+//#region ../core/src/middleware/pipeline.ts
+/** 执行 beforeLoad 守卫链 */
+async function runBeforeLoadGuards(guards, ctx) {
+	for (const guard of guards) {
+		const result = await guard(ctx);
+		if (result.kind !== "next") return result;
+	}
+	return { kind: "next" };
+}
+/** 执行 afterLoad 守卫链 */
+async function runAfterLoadGuards(guards, ctx) {
+	for (const guard of guards) {
+		const result = await guard(ctx);
+		if (result.kind !== "next") return result;
+	}
+	return { kind: "next" };
+}
+//#endregion
+//#region ../core/src/prefetched-intents/stable-stringify.ts
+/**
+* stableStringify — 确定性 JSON 序列化（keys 按字母排序）
+*
+* 用作缓存 key：相同内容的对象始终产生相同字符串。
+*/
+function stableStringify(obj, _seen) {
+	if (obj === null || obj === void 0) return String(obj);
+	if (typeof obj !== "object") return JSON.stringify(obj);
+	const seen = _seen ?? /* @__PURE__ */ new Set();
+	if (seen.has(obj)) return "\"[Circular]\"";
+	seen.add(obj);
+	if (Array.isArray(obj)) return "[" + obj.map((v) => stableStringify(v, seen)).join(",") + "]";
+	return "{" + Object.keys(obj).sort().filter((k) => obj[k] !== void 0).map((k) => JSON.stringify(k) + ":" + stableStringify(obj[k], seen)).join(",") + "}";
+}
+//#endregion
+//#region ../core/src/prefetched-intents/prefetched-intents.ts
+var PrefetchedIntents = class PrefetchedIntents {
+	intents;
+	constructor(intents) {
+		this.intents = intents;
+	}
+	/** 从 PrefetchedIntent 数组创建缓存实例 */
+	static fromArray(items) {
+		const map = /* @__PURE__ */ new Map();
+		for (const item of items) if (item.intent && item.data !== void 0) {
+			const key = stableStringify(item.intent);
+			map.set(key, item.data);
+		}
+		return new PrefetchedIntents(map);
+	}
+	/** 创建空缓存实例 */
+	static empty() {
+		return new PrefetchedIntents(/* @__PURE__ */ new Map());
+	}
+	/**
+	* 获取缓存的 Intent 结果（一次性使用）。
+	* 命中后从缓存中删除。
+	*/
+	get(intent) {
+		const key = stableStringify(intent);
+		const data = this.intents.get(key);
+		if (data !== void 0) {
+			this.intents.delete(key);
+			return data;
+		}
+	}
+	/** 检查缓存中是否有某个 Intent 的数据 */
+	has(intent) {
+		return this.intents.has(stableStringify(intent));
+	}
+	/** 缓存中的条目数 */
+	get size() {
+		return this.intents.size;
+	}
+};
+//#endregion
+//#region ../core/src/framework.ts
+/**
+* Framework — 框架核心类
+*
+* 对应原版 Jet 类，统一管理: DI 容器、Intent 分发、Action 分发、路由、Metrics。
+* 纯 TypeScript，不依赖任何 UI 框架。
+*/
+var Framework = class Framework {
+	container;
+	intentDispatcher;
+	actionDispatcher;
+	router;
+	prefetchedIntents;
+	beforeGuards = [];
+	afterGuards = [];
+	constructor(container, prefetchedIntents) {
+		this.container = container;
+		this.intentDispatcher = new IntentDispatcher();
+		this.actionDispatcher = new ActionDispatcher();
+		this.router = new Router();
+		this.prefetchedIntents = prefetchedIntents;
+	}
+	/** 创建并初始化 Framework 实例 */
+	static create(config = {}) {
+		const container = new Container();
+		makeDependencies(container, config);
+		const fw = new Framework(container, config.prefetchedIntents ?? PrefetchedIntents.empty());
+		config.setupRoutes?.(fw.router);
+		return fw;
+	}
+	/** 分发 Intent — 获取页面数据 */
+	async dispatch(intent) {
+		const logger = this.container.resolve(DEP_KEYS.LOGGER);
+		const cached = this.prefetchedIntents.get(intent);
+		if (cached !== void 0) {
+			logger.debug(`[Framework] re-using prefetched intent response for: ${intent.id}`, intent.params);
+			return cached;
+		}
+		logger.debug(`[Framework] dispatch intent: ${intent.id}`, intent.params);
+		return this.intentDispatcher.dispatch(intent, this.container);
+	}
+	/** 执行 Action — 处理用户交互 */
+	async perform(action) {
+		this.container.resolve(DEP_KEYS.LOGGER).debug(`[Framework] perform action: ${action.kind}`);
+		return this.actionDispatcher.perform(action);
+	}
+	/** 路由 URL — 将 URL 解析为 Intent + Action */
+	routeUrl(url) {
+		return this.router.resolve(url);
+	}
+	/** 记录页面访问事件 */
+	didEnterPage(page) {
+		this.container.resolve(DEP_KEYS.METRICS).recordPageView(page.pageType, {
+			pageId: page.id,
+			title: page.title
+		});
+	}
+	/** 注册 Action 处理器 */
+	onAction(kind, handler) {
+		this.actionDispatcher.onAction(kind, handler);
+	}
+	/** 注册 Intent Controller */
+	registerIntent(controller) {
+		this.intentDispatcher.register(controller);
+	}
+	/** 注册 beforeLoad 守卫（路由匹配后、数据加载前） */
+	beforeLoad(guard) {
+		this.beforeGuards.push(guard);
+	}
+	/** 注册 afterLoad 守卫（数据加载后、渲染前） */
+	afterLoad(guard) {
+		this.afterGuards.push(guard);
+	}
+	/** 执行所有 beforeLoad 守卫（全局 → 路由级） */
+	runBeforeLoad(ctx, routeGuards) {
+		return runBeforeLoadGuards(routeGuards?.length ? [...this.beforeGuards, ...routeGuards] : this.beforeGuards, ctx);
+	}
+	/** 执行所有 afterLoad 守卫（全局 → 路由级） */
+	runAfterLoad(ctx, routeGuards) {
+		return runAfterLoadGuards(routeGuards?.length ? [...this.afterGuards, ...routeGuards] : this.afterGuards, ctx);
+	}
+	/** 销毁 Framework 实例 */
+	dispose() {
+		this.container.dispose();
+	}
+};
+//#endregion
+//#region ../core/src/http/client.ts
+/**
+* HttpClient — 通用 HTTP 客户端基类
+*
+* 为 API Client 提供标准化的 HTTP 请求能力。
+* 子类继承后只需关注业务端点定义，不需要重复实现 fetch / JSON 解析 / 错误处理。
+*/
+/** HTTP 请求错误 */
+var HttpError = class extends Error {
+	constructor(status, statusText, body) {
+		super(`HTTP ${status}: ${statusText}`);
+		this.status = status;
+		this.statusText = statusText;
+		this.body = body;
+		this.name = "HttpError";
+	}
+};
+/**
+* 通用 HTTP 客户端基类
+*
+* 使用方式: 创建子类继承 HttpClient，定义业务方法调用 this.get() / this.post() 等。
+*
+* @example
+* ```ts
+* class MyApiClient extends HttpClient {
+*   async getUser(id: string) {
+*     return this.get<User>(`/users/${id}`);
+*   }
+* }
+* ```
+*/
+var HttpClient = class {
+	baseUrl;
+	defaultHeaders;
+	fetchFn;
+	constructor(config) {
+		this.baseUrl = config.baseUrl;
+		this.defaultHeaders = config.defaultHeaders ?? {};
+		this.fetchFn = config.fetch ?? globalThis.fetch.bind(globalThis);
+	}
+	/** GET 请求，返回解析后的 JSON */
+	async get(path, params) {
+		return this.request("GET", path, { params });
+	}
+	/** POST 请求，自动序列化 body 为 JSON */
+	async post(path, body, params) {
+		return this.request("POST", path, {
+			body,
+			params
+		});
+	}
+	/** PUT 请求 */
+	async put(path, body, params) {
+		return this.request("PUT", path, {
+			body,
+			params
+		});
+	}
+	/** DELETE 请求 */
+	async del(path, params) {
+		return this.request("DELETE", path, { params });
+	}
+	/**
+	* 底层请求方法 — 子类可覆写以自定义行为
+	*
+	* 自动处理:
+	* - URL 拼接 (baseUrl + path + params)
+	* - 默认 headers 合并
+	* - JSON body 序列化
+	* - 响应 JSON 解析
+	* - 非 2xx 状态码抛出 HttpError
+	*/
+	async request(method, path, options) {
+		const url = this.buildUrl(path, options?.params);
+		const headers = {
+			...this.defaultHeaders,
+			...options?.headers
+		};
+		const init = {
+			method,
+			headers
+		};
+		if (options?.body !== void 0) {
+			headers["Content-Type"] = headers["Content-Type"] ?? "application/json";
+			init.body = JSON.stringify(options.body);
+		}
+		const response = await this.fetchFn(url, init);
+		if (!response.ok) {
+			const body = await response.text().catch(() => void 0);
+			throw new HttpError(response.status, response.statusText, body);
+		}
+		return response.json();
+	}
+	/** 构建完整 URL — 子类可覆写以自定义 URL 拼接逻辑 */
+	buildUrl(path, params) {
+		const base = this.baseUrl.endsWith("/") ? this.baseUrl.slice(0, -1) : this.baseUrl;
+		const normalizedPath = path.startsWith("/") ? path : `/${path}`;
+		const url = new URL(`${base}${normalizedPath}`, "http://placeholder");
+		if (params) for (const [k, v] of Object.entries(params)) url.searchParams.set(k, v);
+		if (this.baseUrl.startsWith("http")) return url.toString();
+		return `${url.pathname}${url.search}`;
+	}
+};
+//#endregion
+//#region ../core/src/intents/base-controller.ts
+/**
+* 抽象 Controller 基类
+*
+* 统一处理:
+* - 类型安全的参数提取 (TParams)
+* - 返回类型约束 (TResult)
+* - try/catch 错误处理 + 可选 fallback
+*
+* @example
+* ```ts
+* class ProductController extends BaseController<{ productId: string }, ProductPage> {
+*   readonly intentId = "product-page";
+*
+*   async execute(params: { productId: string }, container: Container) {
+*     const api = container.resolve<ApiClient>("api");
+*     return api.getProduct(params.productId);
+*   }
+*
+*   fallback(params: { productId: string }, error: Error) {
+*     return getMockProduct(params.productId);
+*   }
+* }
+* ```
+*/
+var BaseController = class {
+	/**
+	* 错误回退 — 子类可选覆写
+	*
+	* 当 execute() 抛出异常时调用。
+	* 默认行为: 重新抛出原始错误。
+	*
+	* @param params - Intent 参数
+	* @param error - execute() 抛出的错误
+	* @returns 回退数据
+	*/
+	fallback(params, error) {
+		throw error;
+	}
+	/**
+	* IntentController.perform() 实现
+	*
+	* 自动 try/catch → fallback 模式。
+	*/
+	async perform(intent, container) {
+		const params = intent.params ?? {};
+		try {
+			return await this.execute(params, container);
+		} catch (e) {
+			return this.fallback(params, e instanceof Error ? e : new Error(String(e)));
+		}
+	}
+};
+//#endregion
+//#region ../core/src/data/mapper.ts
+function pipe(...mappers) {
+	return (input) => mappers.reduce((acc, mapper) => mapper(acc), input);
+}
+function pipeAsync(...mappers) {
+	return async (input) => {
+		let acc = input;
+		for (const mapper of mappers) acc = await mapper(acc);
+		return acc;
+	};
+}
+/**
+* 将一个 Mapper 应用到数组的每个元素
+*/
+function mapEach(mapper) {
+	return (items) => items.map(mapper);
+}
+//#endregion
+//#region ../core/src/bootstrap/define-routes.ts
+/**
+* 声明式注册路由和 Controller
+*
+* - 自动去重: 同一 intentId 的 controller 只注册一次
+* - 路由和 controller 在同一个配置数组中，方便检查一致性
+*
+* @example
+* ```ts
+* defineRoutes(framework, [
+*   { path: "/",                intentId: "home",     controller: new HomeController() },
+*   { path: "/product/:id",    intentId: "product",  controller: new ProductController() },
+*   { path: "/search",         intentId: "search",   controller: new SearchController() },
+*   { path: "/charts/:type",   intentId: "charts",   controller: new ChartsController() },
+*   { path: "/charts",         intentId: "charts" },  // 同 intentId，不需要重复 controller
+* ]);
+* ```
+*/
+function defineRoutes(framework, definitions) {
+	const registeredIntents = /* @__PURE__ */ new Set();
+	for (const def of definitions) {
+		if (def.controller && !registeredIntents.has(def.intentId)) {
+			framework.registerIntent(def.controller);
+			registeredIntents.add(def.intentId);
+		}
+		framework.router.add(def.path, def.intentId, {
+			renderMode: def.renderMode,
+			beforeGuards: def.beforeLoad,
+			afterGuards: def.afterLoad
+		});
+	}
+}
+//#endregion
+//#region ../core/src/utils/lru-map.ts
+/**
+* LruMap — 固定容量的 LRU 缓存
+*/
+var LruMap = class {
+	map = /* @__PURE__ */ new Map();
+	capacity;
+	constructor(capacity) {
+		this.capacity = capacity;
+	}
+	get(key) {
+		const value = this.map.get(key);
+		if (value !== void 0) {
+			this.map.delete(key);
+			this.map.set(key, value);
+		}
+		return value;
+	}
+	set(key, value) {
+		if (this.map.has(key)) this.map.delete(key);
+		else if (this.map.size >= this.capacity) {
+			const oldest = this.map.keys().next().value;
+			if (oldest !== void 0) this.map.delete(oldest);
+		}
+		this.map.set(key, value);
+	}
+	has(key) {
+		return this.map.has(key);
+	}
+	delete(key) {
+		return this.map.delete(key);
+	}
+	get size() {
+		return this.map.size;
+	}
+	clear() {
+		this.map.clear();
+	}
+};
+//#endregion
+//#region ../core/src/utils/optional.ts
+function isSome(value) {
+	return value !== null && value !== void 0;
+}
+function isNone(value) {
+	return value === null || value === void 0;
+}
+//#endregion
+//#region ../core/src/utils/url.ts
+/**
+* URL 工具函数
+*/
+/** 移除 URL scheme (https://, http://) */
+function removeScheme(url) {
+	return url.replace(/^https?:\/\//, "");
+}
+/** 移除 URL host 部分，保留路径 */
+function removeHost(url) {
+	try {
+		const parsed = new URL(url);
+		return parsed.pathname + parsed.search + parsed.hash;
+	} catch {
+		return url;
+	}
+}
+/** 移除 query 参数 */
+function removeQueryParams(url) {
+	return url.split("?")[0];
+}
+/** 获取 URL 的基础路径（无 query、hash） */
+function getBaseUrl(url) {
+	return url.split("?")[0].split("#")[0];
+}
+/** 构建 URL（路径 + query 参数） */
+function buildUrl(path, params) {
+	if (!params) return path;
+	const searchParams = new URLSearchParams();
+	for (const [key, value] of Object.entries(params)) if (value !== void 0) searchParams.set(key, value);
+	const qs = searchParams.toString();
+	return qs ? `${path}?${qs}` : path;
+}
+//#endregion
+//#region ../core/src/utils/uuid.ts
+/**
+* UUID v4 生成器
+*/
+function generateUuid() {
+	if (typeof crypto !== "undefined" && crypto.randomUUID) return crypto.randomUUID();
+	return "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, (c) => {
+		const r = Math.random() * 16 | 0;
+		return (c === "x" ? r : r & 3 | 8).toString(16);
+	});
+}
+//#endregion
+//#region ../core/src/middleware/context.ts
+function parseCookieString(str) {
+	const map = /* @__PURE__ */ new Map();
+	if (!str) return map;
+	for (const pair of str.split(";")) {
+		const idx = pair.indexOf("=");
+		if (idx === -1) continue;
+		const key = pair.slice(0, idx).trim();
+		const val = pair.slice(idx + 1).trim();
+		if (key) map.set(key, val);
+	}
+	return map;
+}
+/** 从 Request 对象构建服务端上下文 */
+function createServerContext(options) {
+	const { url, intent, container, request } = options;
+	const parsed = new URL(url, "http://localhost");
+	const cookies = parseCookieString(request?.headers.get("cookie") ?? "");
+	return {
+		url,
+		path: parsed.pathname,
+		params: intent.params ?? {},
+		intent,
+		isServer: true,
+		container,
+		getCookie: (name) => cookies.get(name),
+		getHeader: (name) => request?.headers.get(name) ?? void 0
+	};
+}
+/** 从 document.cookie 构建浏览器端上下文 */
+function createBrowserContext(options) {
+	const { url, intent, container } = options;
+	return {
+		url,
+		path: new URL(url, window.location.origin).pathname,
+		params: intent.params ?? {},
+		intent,
+		isServer: false,
+		container,
+		getCookie: (name) => parseCookieString(document.cookie).get(name),
+		getHeader: () => void 0
+	};
+}
+//#endregion
+//#region ../core/src/middleware/types.ts
+/** 继续执行 */
+function next() {
+	return { kind: "next" };
+}
+/** 重定向到新 URL */
+function redirect(url, status = 302) {
+	return {
+		kind: "redirect",
+		url,
+		status
+	};
+}
+/** URL 重写（不重新加载数据） */
+function rewrite(url) {
+	return {
+		kind: "rewrite",
+		url
+	};
+}
+/** 拒绝访问 */
+function deny(status = 403, message = "Forbidden") {
+	return {
+		kind: "deny",
+		status,
+		message
+	};
+}
+//#endregion
+//#region ../browser/src/action-handlers/external-url-action.ts
+function registerExternalUrlHandler(deps) {
+	const { framework, log } = deps;
+	framework.onAction(ACTION_KINDS.EXTERNAL_URL, (action) => {
+		log.debug(`ExternalUrlAction → ${action.url}`);
+		window.open(action.url, "_blank", "noopener,noreferrer");
+	});
+}
+//#endregion
+//#region ../browser/src/utils/try-scroll.ts
+const MAX_TRIES = 100;
+const FUDGE = 16;
+let pendingFrame = null;
+function tryScroll(log, getScrollableElement, scrollY) {
+	if (pendingFrame !== null) {
+		cancelAnimationFrame(pendingFrame);
+		pendingFrame = null;
+	}
+	let tries = 0;
+	pendingFrame = requestAnimationFrame(function attempt() {
+		if (++tries >= MAX_TRIES) {
+			log.warn(`tryScroll: gave up after ${MAX_TRIES} frames, target=${scrollY}`);
+			pendingFrame = null;
+			return;
+		}
+		const el = getScrollableElement();
+		if (!el) {
+			log.warn("could not restore scroll: the scrollable element is missing");
+			return;
+		}
+		const { scrollHeight, offsetHeight } = el;
+		if (!(scrollY + offsetHeight <= scrollHeight + FUDGE)) {
+			log.info("page is not tall enough for scroll yet", {
+				scrollHeight,
+				offsetHeight
+			});
+			pendingFrame = requestAnimationFrame(attempt);
+			return;
+		}
+		el.scrollTop = scrollY;
+		log.info("scroll restored to", scrollY);
+		pendingFrame = null;
+	});
+}
+//#endregion
+//#region ../browser/src/utils/history.ts
+const HISTORY_SIZE_LIMIT = 10;
+var History = class {
+	entries;
+	log;
+	getScrollablePageElement;
+	currentStateId;
+	constructor(log, options, sizeLimit = HISTORY_SIZE_LIMIT) {
+		this.entries = new LruMap(sizeLimit);
+		this.log = log;
+		this.getScrollablePageElement = options.getScrollablePageElement;
+	}
+	replaceState(state, url) {
+		const id = generateUuid();
+		window.history.replaceState({ id }, "", url);
+		this.currentStateId = id;
+		this.entries.set(id, {
+			state,
+			scrollY: 0
+		});
+		this.scrollTop = 0;
+		this.log.info("replaceState", state, url, id);
+	}
+	pushState(state, url) {
+		const id = generateUuid();
+		window.history.pushState({ id }, "", url);
+		this.currentStateId = id;
+		this.entries.set(id, {
+			state,
+			scrollY: 0
+		});
+		this.scrollTop = 0;
+		this.log.info("pushState", state, url, id);
+	}
+	beforeTransition() {
+		const { state } = window.history;
+		if (!state) return;
+		const oldEntry = this.entries.get(state.id);
+		if (!oldEntry) {
+			this.log.info("current history state evicted from LRU, not saving scroll position");
+			return;
+		}
+		const { scrollTop } = this;
+		this.entries.set(state.id, {
+			...oldEntry,
+			scrollY: scrollTop
+		});
+		this.log.info("saving scroll position", scrollTop);
+	}
+	onPopState(listener) {
+		window.addEventListener("popstate", async (event) => {
+			this.currentStateId = event.state?.id;
+			if (!this.currentStateId) this.log.warn("encountered a null event.state.id in onPopState event:", window.location.href);
+			this.log.info("popstate", this.entries, this.currentStateId);
+			const entry = this.currentStateId ? this.entries.get(this.currentStateId) : void 0;
+			await listener(window.location.href, entry?.state);
+			if (!entry) return;
+			const { scrollY } = entry;
+			this.log.info("restoring scroll to", scrollY);
+			tryScroll(this.log, () => this.getScrollablePageElement(), scrollY);
+		});
+	}
+	/** 仅推入 URL，不缓存页面状态（用于页面加载失败场景） */
+	pushUrl(url) {
+		const id = generateUuid();
+		window.history.pushState({ id }, "", url);
+		this.currentStateId = id;
+		this.scrollTop = 0;
+		this.log.info("pushUrl (no state)", url, id);
+	}
+	/** 仅替换 URL，不缓存页面状态（用于页面加载失败场景） */
+	replaceUrl(url) {
+		const id = generateUuid();
+		window.history.replaceState({ id }, "", url);
+		this.currentStateId = id;
+		this.scrollTop = 0;
+		this.log.info("replaceUrl (no state)", url, id);
+	}
+	updateState(update) {
+		if (!this.currentStateId) {
+			this.log.warn("failed: encountered a null currentStateId inside updateState");
+			return;
+		}
+		const currentState = this.entries.get(this.currentStateId);
+		const newState = update(currentState?.state);
+		this.log.info("updateState", newState, this.currentStateId);
+		this.entries.set(this.currentStateId, {
+			...currentState,
+			state: newState
+		});
+	}
+	get scrollTop() {
+		return this.getScrollablePageElement()?.scrollTop || 0;
+	}
+	set scrollTop(scrollTop) {
+		const element = this.getScrollablePageElement();
+		if (element) element.scrollTop = scrollTop;
+	}
+};
+//#endregion
+//#region ../browser/src/action-handlers/flow-action.ts
+function registerFlowActionHandler(deps) {
+	const { framework, log, callbacks, updateApp } = deps;
+	let isFirstPage = true;
+	let navigationId = 0;
+	/** 重定向循环保护计数器 */
+	const MAX_REDIRECTS = 5;
+	const defaultGetScrollable = () => document.getElementById("scrollable-page-override") || document.getElementById("scrollable-page") || document.documentElement;
+	const history = new History(log, { getScrollablePageElement: deps.getScrollablePageElement ?? defaultGetScrollable });
+	/**
+	* 核心导航逻辑（支持递归重定向）
+	* @param redirectCount 当前重定向次数，用于循环保护
+	*/
+	async function navigateTo(url, redirectCount, thisNav) {
+		if (redirectCount >= MAX_REDIRECTS) {
+			log.error(`Navigation redirect loop detected (${MAX_REDIRECTS} redirects), stopping at: ${url}`);
+			return;
+		}
+		const shouldReplace = isFirstPage || url === window.location.pathname + window.location.search;
+		const match = framework.routeUrl(url);
+		if (!match) {
+			log.warn(`FlowAction: no route for ${url}`);
+			return;
+		}
+		const navCtx = createBrowserContext({
+			url,
+			intent: match.intent,
+			container: framework.container
+		});
+		const beforeResult = await framework.runBeforeLoad(navCtx, match.beforeGuards);
+		if (beforeResult.kind === "redirect") {
+			log.debug(`beforeLoad → redirect to ${beforeResult.url}`);
+			await navigateTo(beforeResult.url, redirectCount + 1, thisNav);
+			return;
+		}
+		if (beforeResult.kind === "deny") {
+			log.warn(`beforeLoad → denied (${beforeResult.status}): ${beforeResult.message}`);
+			return;
+		}
+		if (beforeResult.kind === "rewrite") {
+			log.debug(`beforeLoad → rewrite to ${beforeResult.url}`);
+			await navigateTo(beforeResult.url, redirectCount + 1, thisNav);
+			return;
+		}
+		const pagePromise = framework.dispatch(match.intent);
+		await Promise.race([pagePromise, new Promise((r) => setTimeout(r, 500))]).catch(() => {});
+		if (thisNav !== navigationId) {
+			log.info("FlowAction superseded by newer navigation", url);
+			return;
+		}
+		history.beforeTransition();
+		updateApp({
+			page: pagePromise.then(async (page) => {
+				if (thisNav !== navigationId) {
+					log.info("FlowAction commit superseded", url);
+					return page;
+				}
+				const postCtx = {
+					...navCtx,
+					page
+				};
+				const afterResult = await framework.runAfterLoad(postCtx, match.afterGuards);
+				if (afterResult.kind === "redirect") {
+					log.debug(`afterLoad → redirect to ${afterResult.url}`);
+					navigateTo(afterResult.url, redirectCount + 1, thisNav);
+					return page;
+				}
+				let canonicalURL = url;
+				if (afterResult.kind === "rewrite") {
+					canonicalURL = afterResult.url;
+					log.debug(`afterLoad → rewrite URL to ${canonicalURL}`);
+				}
+				if (afterResult.kind === "deny") {
+					log.warn(`afterLoad → denied (${afterResult.status})`);
+					return page;
+				}
+				if (shouldReplace) history.replaceState({ page }, canonicalURL);
+				else history.pushState({ page }, canonicalURL);
+				callbacks.onNavigate(new URL(canonicalURL, window.location.origin).pathname);
+				didEnterPage(page);
+				return page;
+			}, (error) => {
+				if (thisNav === navigationId) {
+					const canonicalURL = url;
+					if (shouldReplace) history.replaceUrl(canonicalURL);
+					else history.pushUrl(canonicalURL);
+					callbacks.onNavigate(new URL(canonicalURL, window.location.origin).pathname);
+				}
+				throw error;
+			}),
+			isFirstPage
+		});
+		isFirstPage = false;
+	}
+	framework.onAction(ACTION_KINDS.FLOW, async (action) => {
+		const flowAction = action;
+		const url = flowAction.url;
+		log.debug(`FlowAction → ${url}`);
+		if (flowAction.presentationContext === "modal") {
+			const match = framework.routeUrl(url);
+			if (match) {
+				const page = await framework.dispatch(match.intent);
+				callbacks.onModal(page);
+			}
+			return;
+		}
+		await navigateTo(url, 0, ++navigationId);
+	});
+	history.onPopState(async (url, cachedState) => {
+		log.debug(`popstate → ${url}, cached=${!!cachedState}`);
+		callbacks.onNavigate(new URL(url).pathname);
+		if (cachedState) {
+			const { page } = cachedState;
+			didEnterPage(page);
+			updateApp({
+				page,
+				isFirstPage
+			});
+			return;
+		}
+		const parsed = new URL(url);
+		const routeMatch = framework.routeUrl(parsed.pathname + parsed.search);
+		if (!routeMatch) {
+			log.error("received popstate without data, but URL was unroutable:", url);
+			didEnterPage(null);
+			updateApp({
+				page: Promise.reject(/* @__PURE__ */ new Error("404")),
+				isFirstPage
+			});
+			return;
+		}
+		const navCtx = createBrowserContext({
+			url: parsed.pathname + parsed.search,
+			intent: routeMatch.intent,
+			container: framework.container
+		});
+		const beforeResult = await framework.runBeforeLoad(navCtx, routeMatch.beforeGuards);
+		if (beforeResult.kind === "redirect") {
+			log.debug(`popstate beforeLoad → redirect to ${beforeResult.url}`);
+			const thisNav = ++navigationId;
+			await navigateTo(beforeResult.url, 0, thisNav);
+			return;
+		}
+		if (beforeResult.kind === "deny" || beforeResult.kind === "rewrite") {
+			if (beforeResult.kind === "deny") log.warn(`popstate beforeLoad → denied`);
+			else {
+				const thisNav = ++navigationId;
+				await navigateTo(beforeResult.url, 0, thisNav);
+			}
+			return;
+		}
+		const pagePromise = framework.dispatch(routeMatch.intent);
+		await Promise.race([pagePromise, new Promise((r) => setTimeout(r, 500))]).catch(() => {});
+		updateApp({
+			page: pagePromise.then((page) => {
+				didEnterPage(page);
+				return page;
+			}),
+			isFirstPage
+		});
+	});
+	function didEnterPage(page) {
+		(async () => {
+			try {
+				if (page) framework.didEnterPage(page);
+			} catch (e) {
+				log.error("didEnterPage error:", e);
+			}
+		})();
+	}
+}
+//#endregion
+//#region ../browser/src/action-handlers/register.ts
+function registerActionHandlers(deps) {
+	const { framework, log, callbacks, updateApp } = deps;
+	registerFlowActionHandler({
+		framework,
+		log,
+		callbacks,
+		updateApp,
+		getScrollablePageElement: deps.getScrollablePageElement
+	});
+	registerExternalUrlHandler({
+		framework,
+		log
+	});
+}
+//#endregion
+//#region ../browser/src/server-data.ts
+/**
+* Server Data (browser side) — 从 DOM 反序列化服务端嵌入数据
+*/
+/** DOM 中嵌入数据的 script 标签 ID */
+const SERVER_DATA_ID = "serialized-server-data";
+/**
+* 从 DOM 反序列化服务端嵌入的数据。
+* 读取 `<script id="serialized-server-data">` 的内容并移除标签。
+*/
+function deserializeServerData() {
+	const script = document.getElementById(SERVER_DATA_ID);
+	if (!script?.textContent) return void 0;
+	script.parentNode?.removeChild(script);
+	try {
+		return JSON.parse(script.textContent);
+	} catch {
+		return;
+	}
+}
+/**
+* 从 DOM 提取 SSR 数据并构建 PrefetchedIntents 实例。
+* 替代原来的 PrefetchedIntents.fromDom()。
+*/
+function createPrefetchedIntentsFromDom() {
+	const data = deserializeServerData();
+	if (!data || !Array.isArray(data)) return PrefetchedIntents.empty();
+	return PrefetchedIntents.fromArray(data);
+}
+//#endregion
+//#region ../browser/src/start-app.ts
+/**
+* 启动客户端应用
+*
+* 自动执行 hydration 全流程。
+*/
+async function startBrowserApp(config) {
+	const { bootstrap, defaultLocale = "en", mountId = "app", mount, callbacks } = config;
+	const prefetchedIntents = createPrefetchedIntentsFromDom();
+	const framework = Framework.create({ prefetchedIntents });
+	bootstrap(framework);
+	const log = framework.container.resolve(DEP_KEYS.LOGGER_FACTORY).loggerFor("browser");
+	const initialAction = framework.routeUrl(window.location.pathname + window.location.search);
+	const locale = document.documentElement.lang || defaultLocale;
+	const updateApp = mount(document.getElementById(mountId), {
+		framework,
+		locale
+	});
+	registerActionHandlers({
+		framework,
+		log,
+		callbacks,
+		updateApp,
+		getScrollablePageElement: config.getScrollablePageElement
+	});
+	if (initialAction) await framework.perform(initialAction.action);
+	else updateApp({
+		page: Promise.reject(/* @__PURE__ */ new Error("404")),
+		isFirstPage: true
+	});
+}
+//#endregion
+//#region ../ssr/src/render.ts
+/**
+* ssrRender — 通用 SSR 渲染管线
+*
+* 1. 创建 Framework + 注册 Controllers
+* 2. routeUrl → Intent
+* 3. dispatch → Page 数据
+* 4. 调用应用层提供的渲染函数
+*/
+async function ssrRender(options) {
+	const { url, frameworkConfig, bootstrap, getErrorPage, renderApp, ssrContext } = options;
+	const mergedConfig = ssrContext?.fetch ? {
+		...frameworkConfig,
+		fetch: ssrContext.fetch
+	} : frameworkConfig;
+	const framework = Framework.create(mergedConfig);
+	bootstrap(framework);
+	try {
+		const parsed = new URL(url, "http://localhost");
+		const fullPath = parsed.pathname + parsed.search;
+		const match = framework.routeUrl(fullPath);
+		if (match?.renderMode === "csr") return {
+			html: "",
+			head: "",
+			css: "",
+			serverData: [],
+			renderMode: "csr"
+		};
+		let page;
+		let serverData = [];
+		if (match) {
+			const navCtx = createServerContext({
+				url: fullPath,
+				intent: match.intent,
+				container: framework.container,
+				request: ssrContext?.request
+			});
+			const beforeResult = await framework.runBeforeLoad(navCtx, match.beforeGuards);
+			if (beforeResult.kind !== "next") {
+				const earlyReturn = handleMiddlewareResult(beforeResult, getErrorPage, renderApp, framework);
+				if (earlyReturn) return earlyReturn;
+			}
+			try {
+				page = await framework.dispatch(match.intent);
+				serverData = [{
+					intent: match.intent,
+					data: page
+				}];
+			} catch (e) {
+				console.error(`[SSR] dispatch failed for intent "${match.intent.id}":`, e);
+				page = getErrorPage(500, "Internal error");
+			}
+			const postCtx = {
+				...navCtx,
+				page
+			};
+			const afterResult = await framework.runAfterLoad(postCtx, match.afterGuards);
+			if (afterResult.kind !== "next") {
+				const lateReturn = handleMiddlewareResult(afterResult, getErrorPage, renderApp, framework);
+				if (lateReturn) return lateReturn;
+			}
+		} else page = getErrorPage(404, "Page not found");
+		const result = renderApp(page, framework);
+		return {
+			html: result.html,
+			head: result.head,
+			css: result.css,
+			serverData,
+			renderMode: match?.renderMode
+		};
+	} finally {
+		framework.dispose();
+	}
+}
+/**
+* 将中间件结果转换为 SSRRenderResult（如果需要短路返回）。
+* 返回 null 表示继续正常流程。
+*/
+function handleMiddlewareResult(result, getErrorPage, renderApp, framework) {
+	switch (result.kind) {
+		case "next": return null;
+		case "redirect": return {
+			html: "",
+			head: "",
+			css: "",
+			serverData: [],
+			redirect: {
+				url: result.url,
+				status: result.status
+			}
+		};
+		case "rewrite": return {
+			html: "",
+			head: "",
+			css: "",
+			serverData: [],
+			redirect: {
+				url: result.url,
+				status: 301
+			}
+		};
+		case "deny": {
+			const rendered = renderApp(getErrorPage(result.status, result.message), framework);
+			return {
+				html: rendered.html,
+				head: rendered.head,
+				css: rendered.css,
+				serverData: []
+			};
+		}
+	}
+}
+//#endregion
+//#region ../ssr/src/create-render.ts
+/**
+* 创建 render 函数
+*
+* @returns `render(url, locale, ssrContext?)` — 供 @finesoft/server SSRModule 使用
+*/
+function createSSRRender(config) {
+	const { bootstrap, getErrorPage, renderApp, frameworkConfig } = config;
+	return (url, locale, ssrContext) => ssrRender({
+		url,
+		frameworkConfig: frameworkConfig ?? {},
+		bootstrap,
+		getErrorPage,
+		renderApp: (page) => renderApp(page, locale),
+		ssrContext
+	});
+}
+//#endregion
+//#region ../ssr/src/server-data.ts
+const HTML_REPLACEMENTS = {
+	"<": "\\u003C",
+	">": "\\u003E",
+	"/": "\\u002F",
+	"\u2028": "\\u2028",
+	"\u2029": "\\u2029"
+};
+const HTML_ESCAPE_PATTERN = /[<>/\u2028\u2029]/g;
+function serializeServerData(data) {
+	return JSON.stringify(data).replace(HTML_ESCAPE_PATTERN, (match) => HTML_REPLACEMENTS[match] ?? match);
+}
+//#endregion
+//#region ../server/src/proxy.ts
+/**
+* 校验代理路径，防止 SSRF（协议相对 URL 绕过）。
+* 返回规范化的路径，或 null 表示非法。
+*/
+function sanitizeProxyPath(raw) {
+	if (raw.startsWith("//")) return null;
+	return raw.startsWith("/") ? raw : `/${raw}`;
+}
+/**
+* 校验代理配置合法性。
+* 在注册时（启动阶段）调用，非法配置直接抛错阻止启动。
+*/
+function validateConfig(config) {
+	if (!config.prefix.startsWith("/")) throw new Error(`[proxy] prefix must start with "/": "${config.prefix}"`);
+	if (!config.target.startsWith("https://")) throw new Error(`[proxy] target must use HTTPS: "${config.target}"`);
+}
+/**
+* 注册声明式代理路由到 Hono app（运行时使用：dev / preview / createServer）
+*/
+function registerProxyRoutes(app, configs) {
+	for (const config of configs) {
+		validateConfig(config);
+		const methods = config.methods ?? ["all"];
+		const pattern = `${config.prefix}/*`;
+		const handler = async (c) => {
+			const subPath = sanitizeProxyPath(c.req.path.replace(config.prefix, ""));
+			if (!subPath) return c.text("Invalid path", 400);
+			const targetUrl = new URL(subPath, config.target);
+			new URL(c.req.url).searchParams.forEach((v, k) => targetUrl.searchParams.set(k, v));
+			const headers = { ...config.headers };
+			if (config.auth) {
+				const token = process.env[config.auth.envKey] ?? "";
+				if (token) headers.Authorization = config.auth.type === "bearer" ? `Bearer ${token}` : `Basic ${token}`;
+			}
+			try {
+				const resp = await fetch(targetUrl.toString(), {
+					headers,
+					redirect: config.followRedirects ? "follow" : "manual"
+				});
+				const body = await resp.text();
+				const respHeaders = { "Content-Type": resp.headers.get("Content-Type") ?? "application/json" };
+				if (config.cache) respHeaders["Cache-Control"] = config.cache;
+				return c.newResponse(body, resp.status, respHeaders);
+			} catch (e) {
+				console.error(`[Proxy ${config.prefix}]`, e);
+				return c.json({ error: "Proxy request failed" }, 502);
+			}
+		};
+		for (const method of methods) app[method](pattern, handler);
+	}
+}
+/**
+* 生成代理路由的内联代码（用于 serverless/edge 入口，避免运行时依赖）
+*/
+function generateProxyCode(configs) {
+	if (!configs || configs.length === 0) return "";
+	for (const config of configs) validateConfig(config);
+	const blocks = [];
+	blocks.push(`
+// ─── 框架声明式代理路由 ───
+function _sanitizeProxyPath(raw) {
+  if (raw.startsWith("//")) return null;
+  return raw.startsWith("/") ? raw : "/" + raw;
+}
+`);
+	for (const config of configs) {
+		const methods = config.methods ?? ["all"];
+		const pattern = `"${config.prefix}/*"`;
+		const headersJson = JSON.stringify(config.headers ?? {});
+		const cacheStr = config.cache ? JSON.stringify(config.cache) : "null";
+		const redirect = config.followRedirects ? "\"follow\"" : "\"manual\"";
+		let authCode = "";
+		if (config.auth) authCode = `
+  const _token = (typeof process !== "undefined" && process.env && process.env[${JSON.stringify(config.auth.envKey)}]) || "";
+  if (_token) _headers.Authorization = "${config.auth.type === "bearer" ? "Bearer " : "Basic "}" + _token;`;
+		const handlerCode = `async (c) => {
+  const _sub = _sanitizeProxyPath(c.req.path.replace(${JSON.stringify(config.prefix)}, ""));
+  if (!_sub) return c.text("Invalid path", 400);
+  const _target = new URL(_sub, ${JSON.stringify(config.target)});
+  const _reqUrl = new URL(c.req.url);
+  _reqUrl.searchParams.forEach((v, k) => _target.searchParams.set(k, v));
+  const _headers = ${headersJson};${authCode}
+  try {
+    const _resp = await fetch(_target.toString(), { headers: _headers, redirect: ${redirect} });
+    const _body = await _resp.text();
+    const _rh = { "Content-Type": _resp.headers.get("Content-Type") || "application/json" };
+    if (${cacheStr}) _rh["Cache-Control"] = ${cacheStr};
+    return c.newResponse(_body, _resp.status, _rh);
+  } catch (_e) {
+    console.error("[Proxy ${config.prefix}]", _e);
+    return c.json({ error: "Proxy request failed" }, 502);
+  }
+}`;
+		for (const method of methods) blocks.push(`app.${method}(${pattern}, ${handlerCode});`);
+	}
+	return blocks.join("\n");
+}
+//#endregion
+//#region ../server/src/adapters/shared.ts
+/**
+* 适配器共享工具函数
+*
+* 提供 generateSSREntry / buildBundle / copyStaticAssets 三个方法，
+* 避免各适配器重复实现相同逻辑。
+*/
+const BUILD_TOOL_EXTERNALS = [
+	"vite",
+	"esbuild",
+	"rollup",
+	"fsevents",
+	"lightningcss"
+];
+/**
+* 生成 SSR serverless/edge 入口源码
+*
+* 内联 parseAcceptLanguage / injectSSR 以避免
+* @finesoft/front → @finesoft/server → vite-plugin → import("vite") 依赖链。
+*/
+function generateSSREntry(ctx, opts) {
+	const setupImport = ctx.setupPath ? `import _setupDefault from "./${ctx.setupPath}";` : ``;
+	const setupCall = ctx.setupPath ? `if (typeof _setupDefault === "function") await _setupDefault(app);` : ``;
+	const locales = JSON.stringify(ctx.locales);
+	const defaultLocale = JSON.stringify(ctx.defaultLocale);
+	const renderModes = JSON.stringify(ctx.renderModes ?? {});
+	const cacheImpl = opts.platformCache ? opts.platformCache : `
+const ISR_CACHE_MAX = 1000;
+const _isrMap = new Map();
+async function platformCacheGet(url) {
+  return _isrMap.get(url) ?? null;
+}
+async function platformCacheSet(url, html) {
+  if (_isrMap.size >= ISR_CACHE_MAX) {
+    const first = _isrMap.keys().next().value;
+    _isrMap.delete(first);
+  }
+  _isrMap.set(url, html);
+}`;
+	return `
+import { Hono } from "hono";
+${opts.platformImport}
+import { render, serializeServerData } from "./${ctx.ssrEntry}";
+${setupImport}
+
+const TEMPLATE = ${JSON.stringify(ctx.templateHtml)};
+const LOCALES = ${locales};
+const DEFAULT_LOCALE = ${defaultLocale};
+const RENDER_MODES = ${renderModes};
+${cacheImpl}
+
+function parseAcceptLanguage(header) {
+  if (!header) return DEFAULT_LOCALE;
+  const langs = header.split(",").map(p => {
+    const [l, q] = p.trim().split(";q=");
+    return { l: l.trim().toLowerCase(), q: q ? (+q || 0) : 1 };
+  }).sort((a, b) => b.q - a.q);
+  for (const { l } of langs) {
+    const prefix = l.split("-")[0];
+    if (LOCALES.includes(prefix)) return prefix;
+  }
+  return DEFAULT_LOCALE;
+}
+
+function injectSSR(t, locale, head, css, html, data) {
+  return t
+    .replace("<!--ssr-lang-->", locale)
+    .replace("<!--ssr-head-->", head + "\\n<style>" + css + "</style>")
+    .replace("<!--ssr-body-->", html)
+    .replace("<!--ssr-data-->", '<script id="serialized-server-data" type="application/json">' + data + "<\/script>");
+}
+
+function injectCSRShell(t, locale) {
+  return t
+    .replace("<!--ssr-lang-->", locale)
+    .replace("<!--ssr-head-->", "")
+    .replace("<!--ssr-body-->", "")
+    .replace("<!--ssr-data-->", "");
+}
+
+function matchRenderMode(url) {
+  const path = url.split("?")[0];
+  if (RENDER_MODES[path]) return RENDER_MODES[path];
+  for (const [pattern, mode] of Object.entries(RENDER_MODES)) {
+    if (pattern.includes("*")) {
+      const escaped = pattern.replace(/[.+?^\${}()|[\\]\\\\]/g, "\\\\$&");
+      const re = new RegExp("^" + escaped.replace(/\\*/g, ".*") + "$");
+      if (re.test(path)) return mode;
+    }
+  }
+  return null;
+}
+
+const app = new Hono();
+${generateProxyCode(ctx.proxies ?? [])}
+${setupCall}
+${opts.platformMiddleware ?? ""}
+
+// 内部 fetch 回环：SSR 控制器的 fetch 请求直接走 Hono 内存路由
+// 深度通过请求头传递，并发安全且能跨渲染正确追踪递归
+const _SSR_DEPTH_HEADER = "x-ssr-depth";
+const _MAX_SSR_DEPTH = 5;
+
+function _createInternalFetch(depth) {
+  return function(input, init) {
+    if (typeof input === "string" && input.startsWith("/")) {
+      const req = new Request("http://localhost" + input, init);
+      req.headers.set(_SSR_DEPTH_HEADER, String(depth));
+      return app.fetch(req);
+    }
+    return globalThis.fetch(input, init);
+  };
+}
+
+app.get("*", async (c) => {
+  // 递归深度保护：从请求头读取 SSR 深度
+  const _ssrDepth = parseInt(c.req.header(_SSR_DEPTH_HEADER) || "0", 10);
+  if (_ssrDepth >= _MAX_SSR_DEPTH) {
+    return c.text("SSR recursion loop detected", 508);
+  }
+
+  const url = c.req.path + (c.req.url.includes("?") ? "?" + c.req.url.split("?")[1] : "");
+  try {
+    const locale = parseAcceptLanguage(c.req.header("accept-language"));
+
+    // Vite 配置级别覆盖: CSR 直接返回空壳
+    const overrideMode = matchRenderMode(url);
+    if (overrideMode === "csr") {
+      return c.html(injectCSRShell(TEMPLATE, locale));
+    }
+
+    // ISR 缓存命中（key 含 locale，避免跨语言缓存污染）
+    const _cacheKey = locale + ":" + url;
+    const cached = await platformCacheGet(_cacheKey);
+    if (cached) return c.html(cached);
+
+    const { html: appHtml, head, css, serverData, renderMode } = await render(url, locale, { fetch: _createInternalFetch(_ssrDepth + 1) });
+
+    // 路由级 CSR
+    if (renderMode === "csr") {
+      return c.html(injectCSRShell(TEMPLATE, locale));
+    }
+
+    const serializedData = serializeServerData(serverData);
+    const finalHtml = injectSSR(TEMPLATE, locale, head, css, appHtml, serializedData);
+
+    // Prerender ISR 缓存（包括 Vite 配置覆盖和路由级）
+    if (renderMode === "prerender" || overrideMode === "prerender") {
+      await platformCacheSet(_cacheKey, finalHtml);
+      ${opts.platformPrerenderResponseHook ?? ""}
+    }
+
+    return c.html(finalHtml);
+  } catch (e) {
+    console.error("[SSR Error]", e);
+    return c.text("Internal Server Error", 500);
+  }
+});
+
+${opts.platformExport}
+`;
+}
+/** 用 Vite SSR 模式构建 bundle */
+async function buildBundle(ctx, opts) {
+	await ctx.vite.build({
+		root: ctx.root,
+		build: {
+			ssr: opts.entry,
+			outDir: opts.outDir,
+			emptyOutDir: true,
+			target: opts.target ?? "node18",
+			rollupOptions: { output: { entryFileNames: opts.fileName ?? "index.mjs" } }
+		},
+		ssr: {
+			noExternal: opts.noExternal !== false,
+			external: opts.external ?? BUILD_TOOL_EXTERNALS
+		},
+		resolve: ctx.resolvedResolve,
+		css: ctx.resolvedCss
+	});
+}
+/** 复制 dist/client 静态资源到目标目录 */
+function copyStaticAssets(ctx, destDir, opts) {
+	const { fs, path } = ctx;
+	fs.cpSync(path.resolve(ctx.root, "dist/client"), destDir, { recursive: true });
+	if (opts?.excludeHtml !== false) fs.rmSync(path.join(destDir, "index.html"), { force: true });
+}
+/**
+* 构建时预渲染 prerender 路由。
+*
+* 1. 加载路由定义文件，找出 renderMode === "prerender" 的路由
+* 2. 合并 ctx.renderModes 配置覆盖
+* 3. 渲染每个 URL × locale
+*/
+async function prerenderRoutes(ctx) {
+	const { fs, path, root, vite } = ctx;
+	const { pathToFileURL } = await import(
+		/* @vite-ignore */
+		"node:url"
+);
+	const routesExport = ctx.bootstrapEntry ?? "src/lib/bootstrap.ts";
+	let routes = [];
+	if (fs.existsSync(path.resolve(root, routesExport))) {
+		await vite.build({
+			root,
+			build: {
+				ssr: routesExport,
+				outDir: path.resolve(root, "dist/server"),
+				emptyOutDir: false,
+				rollupOptions: { output: { entryFileNames: "_routes_prerender.mjs" } }
+			},
+			resolve: ctx.resolvedResolve
+		});
+		const routesMod = await import(pathToFileURL(path.resolve(root, "dist/server/_routes_prerender.mjs")).href);
+		routes = routesMod.routes ?? routesMod.default ?? [];
+		fs.rmSync(path.resolve(root, "dist/server/_routes_prerender.mjs"), { force: true });
+	}
+	const prerenderPaths = /* @__PURE__ */ new Set();
+	for (const r of routes) if (r.renderMode === "prerender" && r.path && !r.path.includes(":")) prerenderPaths.add(r.path);
+	if (ctx.renderModes) {
+		for (const [pattern, mode] of Object.entries(ctx.renderModes)) if (mode === "prerender" && !pattern.includes("*") && !pattern.includes(":")) prerenderPaths.add(pattern);
+	}
+	if (prerenderPaths.size === 0) return [];
+	const ssrModule = await import(pathToFileURL(path.resolve(root, "dist/server/ssr.js")).href);
+	const results = [];
+	for (const routePath of prerenderPaths) for (const locale of ctx.locales) {
+		const url = locale === ctx.defaultLocale ? routePath : `/${locale}${routePath === "/" ? "" : routePath}`;
+		try {
+			const { html: appHtml, head, css, serverData } = await ssrModule.render(url, locale);
+			const serializedData = ssrModule.serializeServerData(serverData);
+			const finalHtml = ctx.templateHtml.replace("<!--ssr-lang-->", locale).replace("<!--ssr-head-->", head + "\n<style>" + css + "</style>").replace("<!--ssr-body-->", appHtml).replace("<!--ssr-data-->", "<script id=\"serialized-server-data\" type=\"application/json\">" + serializedData + "<\/script>");
+			results.push({
+				url,
+				html: finalHtml
+			});
+		} catch (e) {
+			console.warn(`  [prerender] Failed to render ${url}:`, e);
+		}
+	}
+	if (results.length > 0) console.log(`  Pre-rendered ${results.length} pages (${prerenderPaths.size} routes × ${ctx.locales.length} locales)\n`);
+	return results;
+}
+//#endregion
+//#region ../server/src/adapters/cloudflare.ts
+/**
+* Cloudflare Pages 适配器
+*
+* 生成 dist/cloudflare/ 目录：
+* - _worker.js — Workers 入口（Hono 原生支持 CF fetch 接口）
+* - assets/    — 静态资源
+*
+* 注意：Cloudflare Workers 不支持原生 Node.js API。
+* 若 setup 代理使用了 process.env，需在 wrangler.toml 启用 nodejs_compat。
+*/
+function cloudflareAdapter() {
+	return {
+		name: "cloudflare",
+		async build(ctx) {
+			const { fs, path, root } = ctx;
+			const outputDir = path.resolve(root, "dist/cloudflare");
+			fs.rmSync(outputDir, {
+				recursive: true,
+				force: true
+			});
+			const entrySource = generateSSREntry(ctx, {
+				platformImport: ``,
+				platformExport: `export default app;`,
+				platformCache: `
+const ISR_CACHE_TTL = 3600; // 1 hour
+async function platformCacheGet(url) {
+  try {
+    const cache = caches.default;
+    const cacheKey = new Request("https://isr-cache/" + encodeURIComponent(url));
+    const resp = await cache.match(cacheKey);
+    if (resp) return await resp.text();
+  } catch {}
+  return null;
+}
+async function platformCacheSet(url, html) {
+  try {
+    const cache = caches.default;
+    const cacheKey = new Request("https://isr-cache/" + encodeURIComponent(url));
+    const resp = new Response(html, {
+      headers: { "Content-Type": "text/html; charset=utf-8", "Cache-Control": "public, max-age=" + ISR_CACHE_TTL },
+    });
+    await cache.put(cacheKey, resp);
+  } catch {}
+}`
+			});
+			const tempEntry = path.resolve(root, ".cf-entry.tmp.mjs");
+			fs.writeFileSync(tempEntry, entrySource);
+			try {
+				await buildBundle(ctx, {
+					entry: ".cf-entry.tmp.mjs",
+					outDir: outputDir,
+					target: "es2022",
+					fileName: "_worker.js"
+				});
+				copyStaticAssets(ctx, path.resolve(outputDir, "assets"));
+				const prerendered = await prerenderRoutes(ctx);
+				for (const { url, html } of prerendered) {
+					const filePath = url === "/" ? path.join(outputDir, "assets", "index.html") : path.join(outputDir, "assets", url, "index.html");
+					fs.mkdirSync(path.resolve(filePath, ".."), { recursive: true });
+					fs.writeFileSync(filePath, html);
+				}
+			} finally {
+				fs.rmSync(tempEntry, { force: true });
+			}
+			console.log("  Cloudflare output → dist/cloudflare/\n");
+		}
+	};
+}
+//#endregion
+//#region ../server/src/adapters/netlify.ts
+/**
+* Netlify 适配器 — Netlify Functions v2
+*
+* 生成：
+* - .netlify/functions-internal/ssr/index.mjs — Serverless Function
+* - dist/client/_redirects — 路由重写规则
+*/
+function netlifyAdapter() {
+	return {
+		name: "netlify",
+		async build(ctx) {
+			const { fs, path, root } = ctx;
+			const funcDir = path.resolve(root, ".netlify/functions-internal/ssr");
+			fs.rmSync(path.resolve(root, ".netlify"), {
+				recursive: true,
+				force: true
+			});
+			const entrySource = generateSSREntry(ctx, {
+				platformImport: `import { handle } from "hono/netlify";`,
+				platformExport: `export default handle(app);
+export const config = { path: "/*", preferStatic: true };`,
+				platformCache: `
+const ISR_SWR_TTL = 3600;
+const ISR_CACHE_MAX = 1000;
+const _isrMap = new Map();
+async function platformCacheGet(url) {
+  return _isrMap.get(url) ?? null;
+}
+async function platformCacheSet(url, html) {
+  if (_isrMap.size >= ISR_CACHE_MAX) {
+    const first = _isrMap.keys().next().value;
+    _isrMap.delete(first);
+  }
+  _isrMap.set(url, html);
+}`,
+				platformPrerenderResponseHook: `c.header("Cache-Control", "public, max-age=0, must-revalidate");
+      c.header("Netlify-CDN-Cache-Control", "public, max-age=" + ISR_SWR_TTL + ", stale-while-revalidate=" + ISR_SWR_TTL + ", durable");`
+			});
+			const tempEntry = path.resolve(root, ".netlify-entry.tmp.mjs");
+			fs.writeFileSync(tempEntry, entrySource);
+			try {
+				await buildBundle(ctx, {
+					entry: ".netlify-entry.tmp.mjs",
+					outDir: funcDir,
+					target: "node18"
+				});
+			} finally {
+				fs.rmSync(tempEntry, { force: true });
+			}
+			fs.writeFileSync(path.resolve(root, "dist/client/_redirects"), `/* /.netlify/functions/ssr 200\n`);
+			const prerendered = await prerenderRoutes(ctx);
+			const clientDir = path.resolve(root, "dist/client");
+			for (const { url, html } of prerendered) {
+				const filePath = url === "/" ? path.join(clientDir, "index.html") : path.join(clientDir, url, "index.html");
+				fs.mkdirSync(path.resolve(filePath, ".."), { recursive: true });
+				fs.writeFileSync(filePath, html);
+			}
+			console.log("  Netlify output → .netlify/functions-internal/ssr/\n  Publish dir: dist/client/\n");
+		}
+	};
+}
+//#endregion
+//#region ../server/src/adapters/node.ts
+/**
+* Node 适配器 — 独立 HTTP 服务器
+*
+* 生成 dist/server/index.mjs，使用 @hono/node-server 监听端口。
+* 运行：node dist/server/index.mjs
+*/
+function nodeAdapter() {
+	return {
+		name: "node",
+		async build(ctx) {
+			const { fs, path, root } = ctx;
+			const entrySource = generateSSREntry(ctx, {
+				platformImport: `import { serve } from "@hono/node-server";
+import { readFileSync, existsSync } from "node:fs";
+import { resolve, dirname } from "node:path";
+import { fileURLToPath } from "node:url";`,
+				platformMiddleware: `
+// 预渲染文件中间件：检查 dist/prerender/ 下是否有对应的静态 HTML
+const __entry_dirname = dirname(fileURLToPath(import.meta.url));
+const prerenderDir = resolve(__entry_dirname, "../prerender");
+
+app.use("*", async (c, next) => {
+  const urlPath = c.req.path;
+  const candidates = [
+    resolve(prerenderDir, "." + urlPath, "index.html"),
+    resolve(prerenderDir, "." + urlPath + ".html"),
+  ];
+  if (urlPath === "/") candidates.unshift(resolve(prerenderDir, "index.html"));
+  for (const f of candidates) {
+    if (existsSync(f)) {
+      const html = readFileSync(f, "utf-8");
+      return c.html(html);
+    }
+  }
+  await next();
+});
+`,
+				platformExport: `
+const port = +(process.env.PORT || 3000);
+serve({ fetch: app.fetch, port }, (info) => {
+  console.log(\`Server running at http://localhost:\${info.port}\`);
+});
+`
+			});
+			const tempEntry = path.resolve(root, ".node-entry.tmp.mjs");
+			fs.writeFileSync(tempEntry, entrySource);
+			try {
+				await buildBundle(ctx, {
+					entry: ".node-entry.tmp.mjs",
+					outDir: path.resolve(root, "dist/server"),
+					target: "node18"
+				});
+			} finally {
+				fs.rmSync(tempEntry, { force: true });
+			}
+			const prerendered = await prerenderRoutes(ctx);
+			if (prerendered.length > 0) {
+				const prerenderDir = path.resolve(root, "dist/prerender");
+				fs.mkdirSync(prerenderDir, { recursive: true });
+				for (const { url, html } of prerendered) {
+					const filePath = url === "/" ? path.join(prerenderDir, "index.html") : path.join(prerenderDir, url, "index.html");
+					fs.mkdirSync(path.resolve(filePath, ".."), { recursive: true });
+					fs.writeFileSync(filePath, html);
+				}
+			}
+			console.log("  Node output → dist/server/index.mjs\n  Run: node dist/server/index.mjs\n");
+		}
+	};
+}
+//#endregion
+//#region ../server/src/adapters/static.ts
+function staticAdapter(opts = {}) {
+	return {
+		name: "static",
+		async build(ctx) {
+			const { fs, path, root } = ctx;
+			const outputDir = path.resolve(root, "dist/static");
+			fs.rmSync(outputDir, {
+				recursive: true,
+				force: true
+			});
+			fs.mkdirSync(outputDir, { recursive: true });
+			const { pathToFileURL } = await import(
+				/* @vite-ignore */
+				"node:url"
+);
+			const ssrModule = await import(pathToFileURL(path.resolve(root, "dist/server/ssr.js")).href);
+			ctx.copyStaticAssets(outputDir, { excludeHtml: true });
+			const { paths: routePaths, defs: routeDefs } = await extractRoutesWithModes(ctx, opts);
+			const allUrls = [];
+			for (const routePath of routePaths) for (const locale of ctx.locales) {
+				const url = locale === ctx.defaultLocale ? routePath : `/${locale}${routePath === "/" ? "" : routePath}`;
+				allUrls.push(url);
+			}
+			console.log(`  Pre-rendering ${allUrls.length} pages (${routePaths.length} routes × ${ctx.locales.length} locales)...\n`);
+			for (const url of allUrls) try {
+				const locale = inferLocale(url, ctx.locales, ctx.defaultLocale);
+				const routeDef = routeDefs.find((r) => r.path === stripLocalePrefix(url, ctx.locales));
+				const mode = resolveRenderMode(stripLocalePrefix(url, ctx.locales), routeDef?.renderMode, ctx.renderModes);
+				let finalHtml;
+				if (mode === "csr") finalHtml = injectCSRShellForStatic(ctx.templateHtml, locale);
+				else {
+					const { html: appHtml, head, css, serverData } = await ssrModule.render(url, locale);
+					const serializedData = ssrModule.serializeServerData(serverData);
+					finalHtml = injectSSRForStatic(ctx.templateHtml, locale, head, css, appHtml, serializedData);
+				}
+				const filePath = url === "/" ? path.join(outputDir, "index.html") : path.join(outputDir, url, "index.html");
+				fs.mkdirSync(path.resolve(filePath, ".."), { recursive: true });
+				fs.writeFileSync(filePath, finalHtml);
+			} catch (e) {
+				console.warn(`  [static] Failed to render ${url}:`, e);
+			}
+			console.log(`  Static output → dist/static/\n`);
+		}
+	};
+}
+/** 从路由文件提取无参数路由 + 合并 dynamicRoutes（含 renderMode） */
+async function extractRoutesWithModes(ctx, opts) {
+	const routesFile = opts.routesExport ?? "src/lib/bootstrap.ts";
+	const paths = [];
+	const defs = [];
+	try {
+		const { pathToFileURL } = await import(
+			/* @vite-ignore */
+			"node:url"
+);
+		await ctx.vite.build({
+			root: ctx.root,
+			build: {
+				ssr: routesFile,
+				outDir: ctx.path.resolve(ctx.root, "dist/server"),
+				emptyOutDir: false,
+				rollupOptions: { output: { entryFileNames: "_routes.mjs" } }
+			},
+			resolve: ctx.resolvedResolve
+		});
+		const routesMod = await import(pathToFileURL(ctx.path.resolve(ctx.root, "dist/server/_routes.mjs")).href);
+		const routes = routesMod.routes ?? routesMod.default;
+		if (Array.isArray(routes)) {
+			for (const r of routes) if (r.path && !r.path.includes(":")) {
+				paths.push(r.path);
+				defs.push({
+					path: r.path,
+					renderMode: r.renderMode
+				});
+			}
+		}
+		ctx.fs.rmSync(ctx.path.resolve(ctx.root, "dist/server/_routes.mjs"), { force: true });
+	} catch (e) {
+		console.warn(`  [static] Could not load routes from "${routesFile}". Using "/" only.`, e);
+		if (paths.length === 0) paths.push("/");
+	}
+	if (opts.dynamicRoutes) {
+		for (const r of opts.dynamicRoutes) if (!paths.includes(r)) paths.push(r);
+	}
+	if (paths.length === 0) paths.push("/");
+	return {
+		paths,
+		defs
+	};
+}
+/** 从 URL 推断 locale */
+function inferLocale(url, locales, defaultLocale) {
+	const segments = url.split("/").filter(Boolean);
+	if (segments.length > 0 && locales.includes(segments[0])) return segments[0];
+	return defaultLocale;
+}
+/** 内联 SSR 注入（同 shared 中的逻辑） */
+function injectSSRForStatic(template, locale, head, css, html, serializedData) {
+	return template.replace("<!--ssr-lang-->", locale).replace("<!--ssr-head-->", head + "\n<style>" + css + "</style>").replace("<!--ssr-body-->", html).replace("<!--ssr-data-->", "<script id=\"serialized-server-data\" type=\"application/json\">" + serializedData + "<\/script>");
+}
+/** CSR 空壳注入 */
+function injectCSRShellForStatic(template, locale) {
+	return template.replace("<!--ssr-lang-->", locale).replace("<!--ssr-head-->", "").replace("<!--ssr-body-->", "").replace("<!--ssr-data-->", "");
+}
+/** 从 URL 去除 locale 前缀，还原路由路径 */
+function stripLocalePrefix(url, locales) {
+	const segments = url.split("/").filter(Boolean);
+	if (segments.length > 0 && locales.includes(segments[0])) {
+		const rest = segments.slice(1).join("/");
+		return rest ? `/${rest}` : "/";
+	}
+	return url;
+}
+/** 解析最终渲染模式：Vite 配置覆盖 > 路由级 > 默认 "ssr" */
+function resolveRenderMode(routePath, routeRenderMode, renderModes) {
+	if (renderModes) {
+		if (renderModes[routePath]) return renderModes[routePath];
+		for (const [pattern, mode] of Object.entries(renderModes)) if (pattern.includes("*")) {
+			const escaped = pattern.replace(/[.+?^${}()|[\]\\]/g, "\\$&");
+			if (new RegExp("^" + escaped.replace(/\*/g, ".*") + "$").test(routePath)) return mode;
+		}
+	}
+	return routeRenderMode ?? "ssr";
+}
+//#endregion
+//#region ../server/src/adapters/vercel.ts
+/**
+* Vercel 适配器 — Build Output API v3
+*
+* 生成 .vercel/output/ 目录：
+* - config.json — 路由规则
+* - static/     — 静态资源
+* - functions/ssr.func/ — Serverless Function
+*/
+function vercelAdapter() {
+	return {
+		name: "vercel",
+		async build(ctx) {
+			const { fs, path, root } = ctx;
+			const outputDir = path.resolve(root, ".vercel/output");
+			fs.rmSync(outputDir, {
+				recursive: true,
+				force: true
+			});
+			const entrySource = generateSSREntry(ctx, {
+				platformImport: `import { getRequestListener } from "@hono/node-server";`,
+				platformExport: [
+					`const _listener = getRequestListener(app.fetch);`,
+					`export default (req, res) => {`,
+					`  const m = req.headers["x-now-route-matches"];`,
+					`  if (typeof m === "string") {`,
+					`    try {`,
+					`      const p = new URLSearchParams(m);`,
+					`      const c = p.get("1");`,
+					`      if (c != null) {`,
+					`        const qi = (req.url || "").indexOf("?");`,
+					`        const qs = qi !== -1 ? req.url.slice(qi) : "";`,
+					`        req.url = "/" + decodeURIComponent(c) + qs;`,
+					`      }`,
+					`    } catch {}`,
+					`  }`,
+					`  return _listener(req, res);`,
+					`};`
+				].join("\n")
+			});
+			const tempEntry = path.resolve(root, ".vercel-entry.tmp.mjs");
+			fs.writeFileSync(tempEntry, entrySource);
+			try {
+				const funcDir = path.resolve(root, ".vercel/output/functions/ssr.func");
+				await buildBundle(ctx, {
+					entry: ".vercel-entry.tmp.mjs",
+					outDir: funcDir,
+					target: "node18"
+				});
+				fs.writeFileSync(path.resolve(funcDir, ".vc-config.json"), JSON.stringify({
+					runtime: "nodejs20.x",
+					handler: "index.mjs",
+					launcherType: "Nodejs"
+				}, null, 2));
+				copyStaticAssets(ctx, path.resolve(root, ".vercel/output/static"));
+				fs.writeFileSync(path.resolve(root, ".vercel/output/config.json"), JSON.stringify({
+					version: 3,
+					routes: [{ handle: "filesystem" }, {
+						src: "/(.*)",
+						dest: "/ssr"
+					}]
+				}, null, 2));
+			} finally {
+				fs.rmSync(tempEntry, { force: true });
+			}
+			const prerendered = await prerenderRoutes(ctx);
+			const staticDir = path.resolve(root, ".vercel/output/static");
+			for (const { url, html } of prerendered) {
+				const filePath = url === "/" ? path.join(staticDir, "index.html") : path.join(staticDir, url, "index.html");
+				fs.mkdirSync(path.resolve(filePath, ".."), { recursive: true });
+				fs.writeFileSync(filePath, html);
+			}
+			if (prerendered.length > 0) {
+				const configPath = path.resolve(root, ".vercel/output/config.json");
+				const config = JSON.parse(fs.readFileSync(configPath, "utf-8"));
+				config.overrides = config.overrides ?? {};
+				for (const { url } of prerendered) {
+					const key = url === "/" ? "index.html" : `${url.replace(/^\//, "")}/index.html`;
+					config.overrides[key] = {
+						path: url === "/" ? "/" : url,
+						contentType: "text/html; charset=utf-8"
+					};
+				}
+				fs.writeFileSync(configPath, JSON.stringify(config, null, 2));
+			}
+			console.log("  Vercel output → .vercel/output/\n");
+		}
+	};
+}
+//#endregion
+//#region ../server/src/adapters/resolve.ts
+/**
+* resolveAdapter — 字符串 → Adapter 映射
+*/
+function resolveAdapter(value) {
+	if (typeof value !== "string") return value;
+	switch (value) {
+		case "vercel": return vercelAdapter();
+		case "cloudflare": return cloudflareAdapter();
+		case "netlify": return netlifyAdapter();
+		case "node": return nodeAdapter();
+		case "static": return staticAdapter();
+		case "auto": return autoAdapter();
+		default: throw new Error(`[finesoft] Unknown adapter: "${value}". Available: vercel, cloudflare, netlify, node, static, auto`);
+	}
+}
+//#endregion
+//#region ../server/src/adapters/auto.ts
+/**
+* Auto 适配器 — 根据环境变量自动选择目标平台
+*
+* 检测顺序：
+*   VERCEL       → vercel
+*   CF_PAGES     → cloudflare
+*   NETLIFY      → netlify
+*   (default)    → node
+*/
+function autoAdapter() {
+	return {
+		name: "auto",
+		async build(ctx) {
+			const detected = detectPlatform();
+			console.log(`  [auto] Detected platform: ${detected}\n`);
+			return resolveAdapter(detected).build(ctx);
+		}
+	};
+}
+function detectPlatform() {
+	if (process.env.VERCEL) return "vercel";
+	if (process.env.CF_PAGES) return "cloudflare";
+	if (process.env.NETLIFY) return "netlify";
+	return "node";
+}
+//#endregion
+//#region ../server/src/runtime.ts
+/** 检测当前运行时环境 */
+function detectRuntime() {
+	return {
+		isDeno: typeof globalThis.Deno !== "undefined",
+		isBun: typeof globalThis.Bun !== "undefined",
+		isVercel: !!process.env.VERCEL,
+		isProduction: process.env.NODE_ENV === "production"
+	};
+}
+/**
+* 从 `import.meta.url` 推导项目根路径
+*
+* @param importMetaUrl - 调用方的 `import.meta.url`
+* @param levelsUp - 向上移动多少级（默认 0，即调用方所在目录就是项目根）
+*/
+async function resolveRoot(importMetaUrl, levelsUp = 0) {
+	if (typeof globalThis.Deno !== "undefined") {
+		let url = new URL(importMetaUrl);
+		for (let i = 0; i < levelsUp; i++) url = new URL("..", url);
+		return url.pathname;
+	}
+	const path = await import(
+		/* @vite-ignore */
+		"node:path"
+);
+	const { fileURLToPath } = await import(
+		/* @vite-ignore */
+		"node:url"
+);
+	let dir = path.normalize(path.dirname(fileURLToPath(importMetaUrl)));
+	for (let i = 0; i < levelsUp; i++) dir = path.resolve(dir, "..");
+	return dir;
+}
+//#endregion
+//#region ../server/src/start.ts
+/**
+* startServer — 多运行时自动启动
+*
+* 支持 Node.js (dev HMR + prod)、Deno、Bun、Vercel。
+*/
+async function startServer(options) {
+	const { app, root, port = 3e3, isProduction, vite, routes, locales, ssrEntryPath } = options;
+	const { isDeno, isBun, isVercel } = options.runtime ?? detectRuntime();
+	function printStartupBanner() {
+		const lines = [`\n  Server running at http://localhost:${port}\n`];
+		if (routes && routes.length > 0) {
+			lines.push("  Routes:");
+			for (const r of routes) lines.push(`    ${r}`);
+			lines.push("");
+		}
+		if (locales && locales.length > 0) lines.push(`  Locales: ${locales.join(", ")}`);
+		if (ssrEntryPath) lines.push(`  SSR Entry: ${ssrEntryPath}`);
+		if (locales?.length || ssrEntryPath) lines.push("");
+		console.log(lines.join("\n"));
+	}
+	if (isVercel) return { vite };
+	if (!isProduction) {
+		let devVite = vite;
+		if (!devVite) {
+			const { createServer: createViteServer } = await import(
+				/* @vite-ignore */
+				"vite"
+);
+			devVite = await createViteServer({
+				root,
+				server: { middlewareMode: true },
+				appType: "custom"
+			});
+		}
+		const { getRequestListener } = await import(
+			/* @vite-ignore */
+			"@hono/node-server"
+);
+		const { createServer } = await import(
+			/* @vite-ignore */
+			"node:http"
+);
+		const listener = getRequestListener(app.fetch);
+		createServer((req, res) => {
+			devVite.middlewares(req, res, () => listener(req, res));
+		}).listen(port, () => {
+			printStartupBanner();
+		});
+		return { vite: devVite };
+	}
+	if (isDeno) globalThis.Deno.serve({ port }, app.fetch);
+	else if (isBun) {} else {
+		const { serveStatic } = await import(
+			/* @vite-ignore */
+			"@hono/node-server/serve-static"
+);
+		const path = await import(
+			/* @vite-ignore */
+			"node:path"
+);
+		const prodApp = new Hono();
+		const clientDir = path.resolve(root, "dist/client");
+		prodApp.use("/*", serveStatic({
+			root: clientDir,
+			rewriteRequestPath: (path) => path.endsWith("/") ? "/__nosuchfile__" : path
+		}));
+		prodApp.route("/", app);
+		const { serve } = await import(
+			/* @vite-ignore */
+			"@hono/node-server"
+);
+		serve({
+			fetch: prodApp.fetch,
+			port
+		}, () => {
+			printStartupBanner();
+		});
+	}
+	return { vite };
+}
+//#endregion
+//#region ../server/src/create-server.ts
+/**
+* createServer — 一站式服务器工厂
+*
+* 封装 env 加载、运行时检测、Vite 创建、Hono app、SSR、启动。
+* 保留 setup() 钩子用于注册业务路由。
+*/
+/**
+* 创建并启动 SSR 服务器
+*
+* @example
+* ```ts
+* const { app } = await createServer({
+*   locales: ["zh", "en"],
+*   setup: (app) => registerProxies(app),
+* });
+* export { app };
+* ```
+*/
+async function createServer(config = {}) {
+	const { root: rootOverride, locales, defaultLocale, port = Number(process.env.PORT) || 3e3, setup, proxies, ssr } = config;
+	const root = rootOverride ?? process.cwd();
+	const { existsSync } = await import(
+		/* @vite-ignore */
+		"node:fs"
+);
+	const envPath = (await import(
+		/* @vite-ignore */
+		"node:path"
+)).resolve(root, ".env");
+	if (existsSync(envPath)) try {
+		const { config: dotenvConfig } = await import(
+			/* @vite-ignore */
+			"dotenv"
+);
+		dotenvConfig({ path: envPath });
+	} catch {}
+	const runtime = detectRuntime();
+	let vite;
+	if (!runtime.isProduction && !runtime.isVercel) {
+		const { createServer: createViteServer } = await import(
+			/* @vite-ignore */
+			"vite"
+);
+		vite = await createViteServer({
+			root,
+			server: { middlewareMode: true },
+			appType: "custom"
+		});
+	}
+	const app = new Hono();
+	if (proxies?.length) registerProxyRoutes(app, proxies);
+	if (setup) await setup(app);
+	const ssrApp = createSSRApp({
+		root,
+		vite,
+		isProduction: runtime.isProduction,
+		supportedLocales: locales,
+		defaultLocale,
+		parentFetch: app.fetch.bind(app),
+		...ssr
+	});
+	app.route("/", ssrApp);
+	await startServer({
+		app,
+		root,
+		port,
+		isProduction: runtime.isProduction,
+		vite,
+		runtime,
+		locales,
+		ssrEntryPath: ssr?.ssrEntryPath
+	});
+	return {
+		app,
+		vite,
+		runtime
+	};
+}
+//#endregion
+//#region ../server/src/vite-plugin.ts
+/**
+* 从 setup 模块中查找 setup 函数：优先 default，其次 setup 命名导出。
+*/
+function resolveSetupFn(mod) {
+	if (typeof mod.default === "function") return mod.default;
+	if (typeof mod.setup === "function") return mod.setup;
+	return Object.values(mod).find((v) => typeof v === "function") ?? null;
+}
+/**
+* 匹配 Vite 配置级别的 renderMode 覆盖。
+* 精确路径优先，然后 glob 模式。
+*/
+function matchRenderModeConfig(url, renderModes) {
+	if (!renderModes) return null;
+	const path = url.split("?")[0];
+	if (renderModes[path]) return renderModes[path];
+	for (const [pattern, mode] of Object.entries(renderModes)) if (pattern.includes("*")) {
+		const escaped = pattern.replace(/[.+?^${}()|[\]\\]/g, "\\$&");
+		if (new RegExp("^" + escaped.replace(/\*/g, ".*") + "$").test(path)) return mode;
+	}
+	return null;
+}
+function finesoftFrontViteConfig(options = {}) {
+	const ssrEntry = options.ssr?.entry ?? "src/ssr.ts";
+	let root = process.cwd();
+	let resolvedCommand;
+	let resolvedResolve;
+	let resolvedCss;
+	const CSS_EXTENSIONS = /\.(css|scss|less|sass|styl|stylus|pcss|postcss)($|\?)/;
+	return {
+		name: "finesoft-front",
+		config(userConfig, env) {
+			const overrides = { appType: "custom" };
+			if (env.command === "build" && !process.env.__FINESOFT_SUB_BUILD__) overrides.build = { outDir: userConfig.build?.outDir ?? "dist/client" };
+			return overrides;
+		},
+		configResolved(config) {
+			resolvedCommand = config.command;
+			resolvedResolve = config.resolve;
+			resolvedCss = config.css;
+			root = config.root;
+		},
+		transformIndexHtml: {
+			order: "pre",
+			async handler(html, ctx) {
+				const server = ctx.server;
+				if (!server) return;
+				const urlPath = (ctx.originalUrl || ctx.path || "").split("?")[0];
+				if (/\.\w+$/.test(urlPath) && !urlPath.endsWith(".html")) return;
+				const appEntry = [...html.matchAll(/<script\b[^>]*\bsrc=["']([^"']+)["'][^>]*>/g)].find((m) => !m[1].startsWith("/@"));
+				if (!appEntry) return;
+				const browserEntry = appEntry[1];
+				try {
+					await server.transformRequest(browserEntry);
+				} catch {
+					return;
+				}
+				const cssUrls = [];
+				const visited = /* @__PURE__ */ new Set();
+				function walk(mod) {
+					if (!mod?.url || visited.has(mod.url)) return;
+					visited.add(mod.url);
+					if (CSS_EXTENSIONS.test(mod.url) && !mod.url.includes(".svelte")) cssUrls.push(mod.url);
+					if (mod.importedModules) for (const imported of mod.importedModules) walk(imported);
+				}
+				const browserMod = await server.moduleGraph.getModuleByUrl(browserEntry);
+				if (browserMod) walk(browserMod);
+				if (cssUrls.length === 0) return;
+				const tags = [];
+				for (const url of cssUrls) try {
+					const css = (await server.ssrLoadModule(url))?.default;
+					if (typeof css === "string" && css.length > 0) tags.push({
+						tag: "style",
+						attrs: { "data-vite-dev-id": url },
+						children: css,
+						injectTo: "head"
+					});
+				} catch {}
+				return tags;
+			}
+		},
+		configureServer(server) {
+			return async () => {
+				const { Hono: HonoClass } = await import(
+					/* @vite-ignore */
+					"hono"
+);
+				const { createSSRApp } = await import("./app-re7jUCuM.mjs").then((n) => n.t);
+				const { getRequestListener } = await import(
+					/* @vite-ignore */
+					"@hono/node-server"
+);
+				const app = new HonoClass();
+				if (options.proxies?.length) registerProxyRoutes(app, options.proxies);
+				if (typeof options.setup === "function") await options.setup(app);
+				else if (typeof options.setup === "string") {
+					const fn = resolveSetupFn(await server.ssrLoadModule("/" + options.setup));
+					if (fn) await fn(app);
+				}
+				const ssrApp = createSSRApp({
+					root,
+					vite: server,
+					isProduction: false,
+					ssrEntryPath: "/" + ssrEntry,
+					supportedLocales: options.locales,
+					defaultLocale: options.defaultLocale,
+					parentFetch: app.fetch.bind(app),
+					renderModes: options.renderModes
+				});
+				app.route("/", ssrApp);
+				const listener = getRequestListener(app.fetch);
+				server.middlewares.use((req, res) => {
+					listener(req, res);
+				});
+			};
+		},
+		configurePreviewServer(server) {
+			return async () => {
+				const { readFileSync } = await import(
+					/* @vite-ignore */
+					"node:fs"
+);
+				const path = await import(
+					/* @vite-ignore */
+					"node:path"
+);
+				const { pathToFileURL } = await import(
+					/* @vite-ignore */
+					"node:url"
+);
+				const { Hono: HonoClass } = await import(
+					/* @vite-ignore */
+					"hono"
+);
+				const { injectSSRContent, injectCSRShell } = await import(
+					/* @vite-ignore */
+					"@finesoft/ssr"
+);
+				const { parseAcceptLanguage } = await import("./locale-D2Bu7w47.mjs").then((n) => n.t);
+				const { getRequestListener } = await import(
+					/* @vite-ignore */
+					"@hono/node-server"
+);
+				const app = new HonoClass();
+				const isrCache = /* @__PURE__ */ new Map();
+				if (options.proxies?.length) registerProxyRoutes(app, options.proxies);
+				if (typeof options.setup === "function") await options.setup(app);
+				else if (typeof options.setup === "string") try {
+					const fn = resolveSetupFn(await import(pathToFileURL(path.resolve(root, "dist/server/setup.mjs")).href));
+					if (fn) await fn(app);
+				} catch {
+					console.warn("[finesoft] Could not load setup module for preview. API routes disabled.");
+				}
+				const template = readFileSync(path.resolve(root, "dist/client/index.html"), "utf-8");
+				const ssrModule = await import(pathToFileURL(path.resolve(root, "dist/server/ssr.js")).href);
+				app.get("*", async (c) => {
+					const ssrDepth = parseInt(c.req.header("x-ssr-depth") ?? "0", 10);
+					if (ssrDepth >= 5) return c.text("SSR recursion loop detected", 508);
+					const url = c.req.path + (c.req.url.includes("?") ? "?" + c.req.url.split("?")[1] : "");
+					try {
+						const locale = parseAcceptLanguage(c.req.header("accept-language"), options.locales, options.defaultLocale);
+						const overrideMode = matchRenderModeConfig(url, options.renderModes);
+						if (overrideMode === "csr") return c.html(injectCSRShell(template, locale));
+						const cacheKey = `${locale}:${url}`;
+						const cached = isrCache.get(cacheKey);
+						if (cached) return c.html(cached);
+						const { html: appHtml, head, css, serverData, renderMode } = await ssrModule.render(url, locale, { fetch: createInternalFetch(app.fetch.bind(app), ssrDepth + 1) });
+						if (renderMode === "csr") return c.html(injectCSRShell(template, locale));
+						const finalHtml = injectSSRContent({
+							template,
+							locale,
+							head,
+							css,
+							html: appHtml,
+							serializedData: ssrModule.serializeServerData(serverData)
+						});
+						if (renderMode === "prerender" || overrideMode === "prerender") isrCache.set(cacheKey, finalHtml);
+						return c.html(finalHtml);
+					} catch (e) {
+						console.error("[SSR Preview Error]", e);
+						return c.text("Internal Server Error", 500);
+					}
+				});
+				const listener = getRequestListener(app.fetch);
+				server.middlewares.use((req, res) => {
+					listener(req, res);
+				});
+			};
+		},
+		async closeBundle() {
+			if (process.env.__FINESOFT_SUB_BUILD__) return;
+			if (resolvedCommand !== "build") return;
+			process.env.__FINESOFT_SUB_BUILD__ = "1";
+			try {
+				const vite = await import(
+					/* @vite-ignore */
+					"vite"
+);
+				const fs = await import(
+					/* @vite-ignore */
+					"node:fs"
+);
+				const path = await import(
+					/* @vite-ignore */
+					"node:path"
+);
+				console.log("\n  Building SSR bundle...\n");
+				await vite.build({
+					root,
+					build: {
+						ssr: ssrEntry,
+						outDir: "dist/server"
+					},
+					resolve: resolvedResolve,
+					css: resolvedCss
+				});
+				if (typeof options.setup === "string") {
+					console.log("  Building setup module...\n");
+					await vite.build({
+						root,
+						build: {
+							ssr: options.setup,
+							outDir: "dist/server",
+							emptyOutDir: false,
+							rollupOptions: { output: { entryFileNames: "setup.mjs" } }
+						},
+						resolve: resolvedResolve
+					});
+				}
+				if (options.adapter) {
+					const adapter = resolveAdapter(options.adapter);
+					const locales = options.locales ?? ["zh", "en"];
+					const defaultLocale = options.defaultLocale ?? locales[0] ?? "en";
+					const templateHtml = fs.readFileSync(path.resolve(root, "dist/client/index.html"), "utf-8");
+					const ctx = {
+						root,
+						ssrEntry,
+						setupPath: typeof options.setup === "string" ? options.setup : void 0,
+						bootstrapEntry: options.bootstrapEntry,
+						locales,
+						defaultLocale,
+						templateHtml,
+						renderModes: options.renderModes,
+						proxies: options.proxies,
+						resolvedResolve,
+						resolvedCss,
+						vite,
+						fs,
+						path,
+						generateSSREntry(opts) {
+							return generateSSREntry(ctx, opts);
+						},
+						buildBundle(opts) {
+							return buildBundle(ctx, opts);
+						},
+						copyStaticAssets(destDir, opts) {
+							return copyStaticAssets(ctx, destDir, opts);
+						}
+					};
+					console.log(`  Running adapter: ${adapter.name}...\n`);
+					await adapter.build(ctx);
+				}
+			} finally {
+				delete process.env.__FINESOFT_SUB_BUILD__;
+			}
+		}
+	};
+}
+//#endregion
+export { ACTION_KINDS, ActionDispatcher, BaseController, BaseLogger, CompositeLogger, CompositeLoggerFactory, ConsoleLogger, ConsoleLoggerFactory, Container, DEP_KEYS, Framework, History, HttpClient, HttpError, IntentDispatcher, LruMap, PrefetchedIntents, Router, SSR_PLACEHOLDERS, autoAdapter, buildUrl, cloudflareAdapter, createBrowserContext, createPrefetchedIntentsFromDom, createSSRApp, createSSRRender, createServer, createServerContext, defineRoutes, deny, deserializeServerData, detectRuntime, finesoftFrontViteConfig, generateProxyCode, generateUuid, getBaseUrl, injectCSRShell, injectSSRContent, isCompoundAction, isExternalUrlAction, isFlowAction, isNone, isSome, makeDependencies, makeExternalUrlAction, makeFlowAction, mapEach, netlifyAdapter, next, nodeAdapter, parseAcceptLanguage, pipe, pipeAsync, redirect, registerActionHandlers, registerExternalUrlHandler, registerFlowActionHandler, registerProxyRoutes, removeHost, removeQueryParams, removeScheme, resetFilterCache, resolveAdapter, resolveRoot, rewrite, runAfterLoadGuards, runBeforeLoadGuards, serializeServerData, shouldLog, ssrRender, stableStringify, startBrowserApp, startServer, staticAdapter, tryScroll, vercelAdapter };
+
+//# sourceMappingURL=index.mjs.map