@finesoft/front 0.5.0 → 0.5.2

package/dist/src-qwx7Vw8g.mjs

@@ -0,0 +1,3807 @@
+import { i as HttpError, n as classifyUrl, r as HostGuardError } from "./host-guard-DDWxLpFL.mjs";
+import { n as ExecutionError, r as executionErrorFromHttp, t as compilePath } from "./path-CGFl2w7D.mjs";
+import { t as LruMap } from "./lru-map-BKoUAySU.mjs";
+import { t as DEP_KEYS } from "./src-Ftl_0rhu.mjs";
+//#region ../core/src/dependencies/container.ts
+var Container = class Container {
+	parent;
+	children = /* @__PURE__ */ new Set();
+	providers = /* @__PURE__ */ new Map();
+	values = /* @__PURE__ */ new Map();
+	pending = /* @__PURE__ */ new Set();
+	cleanups = [];
+	closed = false;
+	disposal;
+	bindings = Object.freeze({});
+	registerProvider(provider) {
+		this.assertOpen();
+		this.providers.set(provider.token, provider);
+		if (provider.lifetime === "runtime" && Object.hasOwn(provider, "value") && provider.owned && provider.dispose) this.cleanups.push({
+			provider,
+			dispose: () => provider.dispose(provider.value)
+		});
+		return this;
+	}
+	onDispose(cleanup) {
+		this.assertOpen();
+		this.cleanups.push({ dispose: cleanup });
+	}
+	hasProvider(token) {
+		return this.providers.has(token) || this.parent?.hasProvider(token) === true;
+	}
+	assertOpen() {
+		if (this.closed) throw new Error("Container is closed");
+	}
+	async get(token) {
+		this.assertOpen();
+		return this.getProvider(token, []);
+	}
+	findProvider(token) {
+		const provider = this.providers.get(token);
+		if (provider) return {
+			provider,
+			owner: this
+		};
+		if (this.parent) return this.parent.findProvider(token);
+		throw new Error(`Unknown provider: ${token.id}`);
+	}
+	getProvider(token, path) {
+		if (path.includes(token)) return Promise.reject(/* @__PURE__ */ new Error(`Cyclic provider dependency: ${token.id}`));
+		const { provider, owner } = this.findProvider(token);
+		const target = provider.lifetime === "runtime" ? owner : this;
+		const existing = provider.lifetime !== "transient" && target.values.get(token);
+		if (existing) return existing;
+		const nextPath = [...path, token];
+		const promise = Promise.resolve().then(async () => {
+			let creating = true;
+			const dependencies = /* @__PURE__ */ new Map();
+			const context = {
+				bindings: provider.lifetime === "runtime" ? Object.freeze({}) : target.bindings,
+				get: async (dependency) => {
+					if (!creating) throw new Error(`Provider resolver is closed: ${token.id}`);
+					if (!provider.dependencies?.includes(dependency)) throw new Error(`Undeclared dependency: ${token.id} -> ${dependency.id}`);
+					const dep = target.findProvider(dependency).provider;
+					if (nextPath.some((t) => target.findProvider(t).provider.lifetime === "runtime") && dep.lifetime === "scope") throw new Error(`runtime provider cannot resolve scope: ${dependency.id}`);
+					let value = dependencies.get(dependency);
+					if (!value) {
+						value = target.getProvider(dependency, nextPath);
+						dependencies.set(dependency, value);
+					}
+					return value;
+				}
+			};
+			try {
+				for (const dependency of provider.dependencies ?? []) await context.get(dependency);
+				const value = provider.create ? await provider.create(context) : provider.value;
+				if (provider.dispose && (provider.owned ?? !!provider.create) && (provider.create || provider.lifetime !== "runtime")) target.cleanups.push({
+					provider,
+					dispose: () => provider.dispose(value)
+				});
+				return value;
+			} finally {
+				creating = false;
+			}
+		});
+		target.pending.add(promise);
+		if (provider.lifetime !== "transient") target.values.set(token, promise);
+		promise.then(() => target.pending.delete(promise), () => {
+			target.pending.delete(promise);
+			if (target.values.get(token) === promise) target.values.delete(token);
+		});
+		return promise;
+	}
+	/** Sort owned cleanup by dependencies, retaining creation order for unrelated resources. */
+	orderedCleanups() {
+		const ordered = [];
+		const visited = /* @__PURE__ */ new Set();
+		const visit = (cleanup) => {
+			if (visited.has(cleanup)) return;
+			visited.add(cleanup);
+			const dependencies = (provider, path) => {
+				for (const token of provider.dependencies ?? []) {
+					if (path.has(token)) continue;
+					path.add(token);
+					dependencies(this.findProvider(token).provider, path);
+					for (const dependency of this.cleanups) if (dependency.provider?.token === token) visit(dependency);
+				}
+			};
+			if (cleanup.provider) dependencies(cleanup.provider, /* @__PURE__ */ new Set());
+			ordered.push(cleanup);
+		};
+		for (const cleanup of this.cleanups) visit(cleanup);
+		return ordered.reverse();
+	}
+	/**
+	* 创建子容器（请求级 scope）
+	*
+	* 子容器可覆写父容器的依赖（如每请求的 locale、user），
+	* 未覆写的 key 自动回退到父容器解析。子容器会被父容器跟踪，
+	* 父容器 dispose 时一并销毁所有未独立 dispose 的子容器。
+	*/
+	createScope(bindings = {}) {
+		this.assertOpen();
+		const child = new Container();
+		child.bindings = Object.freeze({ ...bindings });
+		child.parent = this;
+		this.children.add(child);
+		return child;
+	}
+	/**
+	* 销毁容器，清除所有缓存。
+	*
+	* - 递归 dispose 所有 createScope() 创建的未 dispose 子容器
+	* - 自身被 dispose 后从父容器移除引用，允许 GC
+	* - 重复 dispose 安全（幂等）
+	*/
+	dispose() {
+		if (this.disposal) return this.disposal;
+		this.closed = true;
+		const children = [...this.children].map((child) => child.dispose());
+		this.children.clear();
+		this.disposal = (async () => {
+			const errors = [];
+			for (const result of await Promise.allSettled(children)) if (result.status === "rejected") errors.push(result.reason);
+			while (this.pending.size) await Promise.allSettled(this.pending);
+			for (const cleanup of this.orderedCleanups()) try {
+				await cleanup.dispose();
+			} catch (error) {
+				errors.push(error);
+			}
+			this.cleanups = [];
+			this.providers.clear();
+			this.values.clear();
+			this.parent?.children.delete(this);
+			this.parent = void 0;
+			if (errors.length) throw new AggregateError(errors, "Container cleanup failed");
+		})();
+		return this.disposal;
+	}
+};
+//#endregion
+//#region ../core/src/schema/multi.ts
+/** 运行时判断一个 schema 是否为多值 codec（resolve 据此决定取全部值还是单值）。 */
+function isMultiValueSchema(schema) {
+	return schema.multi === true;
+}
+/**
+* 多值 query 原语：用内部单值 codec 逐项校验/转换，产出数组。
+* 缺失（undefined）→ 空数组；任一项校验失败 → 整体失败（resolve 据此 fall-through）。
+*/
+function list(item, opts = {}) {
+	return {
+		multi: true,
+		"~standard": {
+			version: 1,
+			vendor: "finesoft",
+			validate: async (value) => {
+				const raw = value === void 0 ? [] : Array.isArray(value) ? value : [value];
+				const out = [];
+				for (const v of raw) {
+					const res = await item["~standard"].validate(v);
+					if (res.issues) return { issues: res.issues };
+					out.push(res.value);
+				}
+				if (opts.min !== void 0 && out.length < opts.min) return { issues: [{ message: `must have at least ${opts.min} item(s)` }] };
+				if (opts.max !== void 0 && out.length > opts.max) return { issues: [{ message: `must have at most ${opts.max} item(s)` }] };
+				return { value: out };
+			}
+		}
+	};
+}
+//#endregion
+//#region ../core/src/logger/composite.ts
+var CompositeLoggerFactory = class {
+	factories;
+	constructor(factories) {
+		this.factories = factories;
+	}
+	loggerFor(name) {
+		return new CompositeLogger(this.factories.map((f) => f.loggerFor(name)));
+	}
+};
+var CompositeLogger = class {
+	loggers;
+	constructor(loggers) {
+		this.loggers = loggers;
+	}
+	debug(...args) {
+		this.callAll("debug", args);
+	}
+	info(...args) {
+		this.callAll("info", args);
+	}
+	warn(...args) {
+		this.callAll("warn", args);
+	}
+	error(...args) {
+		this.callAll("error", args);
+	}
+	callAll(method, args) {
+		for (const logger of this.loggers) logger[method](...args);
+	}
+};
+//#endregion
+//#region ../core/src/logger/console.ts
+var ConsoleLogger = class {
+	category;
+	shouldLog;
+	constructor(category, shouldLog = () => true) {
+		this.category = category;
+		this.shouldLog = shouldLog;
+	}
+	debug(...args) {
+		if (this.shouldLog(this.category, "debug")) console.debug(`[${this.category}]`, ...args);
+	}
+	info(...args) {
+		if (this.shouldLog(this.category, "info")) console.info(`[${this.category}]`, ...args);
+	}
+	warn(...args) {
+		if (this.shouldLog(this.category, "warn")) console.warn(`[${this.category}]`, ...args);
+	}
+	error(...args) {
+		console.error(`[${this.category}]`, ...args);
+	}
+};
+var ConsoleLoggerFactory = class {
+	shouldLog;
+	constructor(shouldLog = () => true) {
+		this.shouldLog = shouldLog;
+	}
+	loggerFor(category) {
+		return new ConsoleLogger(category, this.shouldLog);
+	}
+};
+//#endregion
+//#region ../core/src/logger/reporting.ts
+const LEVEL_PRIORITY = {
+	debug: 0,
+	info: 1,
+	warn: 2,
+	error: 3
+};
+var ReportingLogger = class {
+	category;
+	minPriority;
+	report;
+	constructor(category, options) {
+		this.category = category;
+		this.minPriority = LEVEL_PRIORITY[options.minLevel ?? "warn"];
+		this.report = options.report;
+	}
+	debug(...args) {
+		this.maybeReport("debug", args);
+	}
+	info(...args) {
+		this.maybeReport("info", args);
+	}
+	warn(...args) {
+		this.maybeReport("warn", args);
+	}
+	error(...args) {
+		this.maybeReport("error", args);
+	}
+	maybeReport(level, args) {
+		if (LEVEL_PRIORITY[level] < this.minPriority) return;
+		try {
+			this.report(level, this.category, args);
+		} catch (e) {
+			console.error("[ReportingLogger] report callback threw:", e);
+		}
+	}
+};
+var ReportingLoggerFactory = class {
+	options;
+	constructor(options) {
+		this.options = options;
+	}
+	loggerFor(category) {
+		return new ReportingLogger(category, this.options);
+	}
+};
+//#endregion
+//#region ../core/src/utils/stable-stringify.ts
+/**
+* stableStringify — 确定性 JSON 序列化（keys 按字母排序）
+*
+* 用作缓存 key：相同内容的对象始终产生相同字符串。
+*/
+/** 最大递归深度 */
+const MAX_DEPTH = 50;
+function stableStringify(obj) {
+	return stringifyWithContext(obj, /* @__PURE__ */ new Set(), 0);
+}
+function stringifyWithContext(obj, seen, depth) {
+	if (obj === null || obj === void 0) return String(obj);
+	if (typeof obj !== "object") return JSON.stringify(obj);
+	if (depth > MAX_DEPTH) return "\"[Max Depth]\"";
+	if (seen.has(obj)) return "\"[Circular]\"";
+	seen.add(obj);
+	try {
+		let result;
+		if (Array.isArray(obj)) result = "[" + obj.map((v) => stringifyWithContext(v, seen, depth + 1)).join(",") + "]";
+		else {
+			const keys = Object.keys(obj).sort();
+			const parts = [];
+			for (const k of keys) {
+				const v = obj[k];
+				if (v !== void 0) parts.push(JSON.stringify(k) + ":" + stringifyWithContext(v, seen, depth + 1));
+			}
+			result = "{" + parts.join(",") + "}";
+		}
+		return result;
+	} finally {
+		seen.delete(obj);
+	}
+}
+//#endregion
+//#region ../core/src/http/target-guard.ts
+/** Shared target policy for HttpClient and secureFetch. */
+async function enforceHostGuard(url, options = {}) {
+	let parsed;
+	try {
+		parsed = new URL(url);
+	} catch {
+		parsed = new URL(url, "http://relative.invalid/");
+		if (parsed.origin === "http://relative.invalid") return;
+	}
+	const verdict = classifyUrl(parsed.href);
+	if (!verdict.ok) throw new HostGuardError(url, verdict.reason);
+	if (options.validateDns === false || parsed.hostname.includes(":") || /^[0-9.]+$/.test(parsed.hostname)) return;
+	if (!options.lookup) throw new HostGuardError(url, "DNS lookup capability is required");
+	let addresses;
+	try {
+		addresses = await options.lookup(parsed.hostname);
+	} catch {
+		throw new HostGuardError(url, "DNS lookup failed");
+	}
+	if (addresses.length === 0) throw new HostGuardError(url, "DNS lookup returned no addresses");
+	for (const address of addresses) {
+		const result = classifyUrl(`http://${address.includes(":") ? `[${address}]` : address}/`);
+		if (!result.ok) throw new HostGuardError(url, `host resolves to ${address} (${result.reason})`);
+	}
+}
+//#endregion
+//#region ../core/src/http/redirect-fetch.ts
+/** One redirect owner for protected clients and fixed-origin proxies. */
+async function fetchWithRedirects(fetch, input, init, validate) {
+	const request = typeof input === "object" && "url" in input ? input : void 0;
+	const mode = init?.redirect ?? request?.redirect ?? "follow";
+	let url = typeof input === "string" ? input : "url" in input ? input.url : input.href;
+	let options = init;
+	let method = (init?.method ?? request?.method ?? "GET").toUpperCase();
+	let body = init?.body ?? request?.body;
+	const signal = init?.signal ?? request?.signal;
+	for (let hop = 0;; hop++) {
+		signal?.throwIfAborted();
+		await validate(url);
+		signal?.throwIfAborted();
+		const response = await fetch(input, {
+			...options,
+			redirect: mode === "follow" ? "manual" : mode
+		});
+		if (signal?.aborted) {
+			response.body?.cancel().catch(() => {});
+			signal.throwIfAborted();
+		}
+		if (mode !== "follow") return response;
+		if (response.type === "opaqueredirect") throw new TypeError("Protected fetch cannot inspect an opaque redirect");
+		const location = response.headers.get("location");
+		if (![
+			301,
+			302,
+			303,
+			307,
+			308
+		].includes(response.status) || location === null) {
+			if (hop) Object.defineProperty(response, "redirected", { value: true });
+			return response;
+		}
+		response.body?.cancel().catch(() => {});
+		if (hop === 20) throw new TypeError("Too many redirects");
+		const base = new URL(response.url || url, "http://relative.invalid/");
+		const next = new URL(location, base);
+		if (!/^https?:$/.test(next.protocol) || next.username || next.password) throw new TypeError("Invalid redirect target");
+		const nextUrl = !URL.canParse(url) && next.origin === base.origin ? next.pathname + next.search + next.hash : next.href;
+		const headers = new Headers(options?.headers ?? request?.headers);
+		if (next.origin !== base.origin) for (const name of [
+			"authorization",
+			"proxy-authorization",
+			"cookie",
+			"cookie2",
+			"host"
+		]) headers.delete(name);
+		if ((response.status === 301 || response.status === 302) && method === "POST" || response.status === 303 && method !== "GET" && method !== "HEAD") {
+			method = "GET";
+			body = void 0;
+			for (const name of [
+				"content-encoding",
+				"content-language",
+				"content-location",
+				"content-type",
+				"content-length"
+			]) headers.delete(name);
+		} else if (body instanceof ReadableStream) throw new TypeError("Cannot replay a streamed request body after a redirect");
+		options = {
+			...request ? {
+				credentials: request.credentials,
+				cache: request.cache,
+				integrity: request.integrity,
+				keepalive: request.keepalive,
+				mode: request.mode,
+				referrer: request.referrer,
+				referrerPolicy: request.referrerPolicy
+			} : {},
+			...options,
+			method,
+			headers,
+			body,
+			signal
+		};
+		input = url = nextUrl;
+	}
+}
+//#endregion
+//#region ../core/src/http/secure-fetch.ts
+/**
+* secureFetch — `fetch` with SSRF defense baked in.
+*
+* Wraps an existing fetch implementation and refuses targets that resolve to
+* private / loopback / reserved ranges. Use when your controller fetches a
+* URL that the user can influence (image proxies, link previews, callbacks).
+*
+* Defaults to checking IP literals (sync) AND resolving hostnames via DNS
+* (requires an injected lookup; browsers explicitly select validateDns: false). Pass `allowInternalHosts: true`
+* to opt out — for example, when you have a legitimate server-to-server call
+* to 10.x or 127.0.0.1 and you trust the URL source.
+*
+* @example
+* ```ts
+* import { BaseController, DEP_KEYS, type ControllerInput } from "@finesoft/front";
+*
+* class ShareController extends BaseController<ControllerInput<{ next?: string }>, Page> {
+*     async execute({ params, context }: ControllerInput<{ next?: string }>) {
+*         // The host configures SAFE_FETCH with a DNS lookup or an explicit supported policy.
+*         const fetch = await context.get(DEP_KEYS.SAFE_FETCH);
+*         const response = await fetch(params.next ?? "https://example.com");
+*         ...
+*     }
+* }
+* ```
+*/
+/**
+* Return a `fetch`-shaped function that refuses requests to private hosts
+* before each request. DNS preflight alone cannot pin an arbitrary transport;
+* select a host connection policy when DNS rebinding protection is required.
+*/
+function secureFetch(baseFetch, options = {}) {
+	if (options.allowInternalHosts ?? false) return baseFetch;
+	const fetch = options.wrapFetch?.(baseFetch) ?? baseFetch;
+	return (input, init) => fetchWithRedirects(fetch, input, init, (url) => enforceHostGuard(url, options));
+}
+//#endregion
+//#region ../core/src/utils/platform.ts
+/**
+* 从 User-Agent 字符串解析平台信息
+*
+* @param ua - 主机显式提供的 User-Agent 字符串，默认空字符串
+* @param maxTouchPoints - 主机显式提供的触摸点数量，默认 0
+*/
+function detectPlatform(ua = "", maxTouchPoints = 0) {
+	const agent = ua;
+	const lower = agent.toLowerCase();
+	return {
+		os: detectOS(lower),
+		browser: detectBrowser(lower),
+		engine: detectEngine(lower),
+		isMobile: /mobile|android|iphone|ipad|ipod/i.test(agent),
+		isTouch: maxTouchPoints > 0
+	};
+}
+function detectOS(ua) {
+	if (/iphone|ipad|ipod/.test(ua)) return "ios";
+	if (/android/.test(ua)) return "android";
+	if (/macintosh|mac os x/.test(ua)) return "macos";
+	if (/windows/.test(ua)) return "windows";
+	if (/linux/.test(ua)) return "linux";
+	return "unknown";
+}
+function detectBrowser(ua) {
+	if (/edg\//.test(ua)) return "edge";
+	if (/opr\/|opera/.test(ua)) return "opera";
+	if (/samsungbrowser/.test(ua)) return "samsung";
+	if (/chrome|crios/.test(ua) && !/edg\//.test(ua)) return "chrome";
+	if (/firefox|fxios/.test(ua)) return "firefox";
+	if (/safari/.test(ua) && !/chrome/.test(ua)) return "safari";
+	return "unknown";
+}
+function detectEngine(ua) {
+	if (/applewebkit/.test(ua) && !/chrome/.test(ua)) return "webkit";
+	if (/applewebkit/.test(ua) && /chrome/.test(ua)) return "blink";
+	if (/gecko\//.test(ua)) return "gecko";
+	return "unknown";
+}
+//#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/i18n/interpolate.ts
+/**
+* ICU 消息格式插值
+*
+* 支持 `{name}` 占位符替换和基础复数规则。
+*/
+/** 将 `{key}` 占位符替换为 values 中的对应值 */
+function interpolate(template, values) {
+	if (!values) return template;
+	return template.replace(/\{(\w+)\}/g, (_, key) => {
+		const val = values[key];
+		return val !== void 0 ? String(val) : `{${key}}`;
+	});
+}
+/**
+* 英语复数规则（默认）
+* 0 → other, 1 → one, 2+ → other
+*/
+function englishPlural(count) {
+	return count === 1 ? "one" : "other";
+}
+/**
+* 解析带复数后缀的翻译 key
+*
+* 约定: `key.one`, `key.other`, `key.zero`, etc.
+*/
+function resolvePluralKey(key, category) {
+	return `${key}.${category}`;
+}
+//#endregion
+//#region ../core/src/i18n/locale.ts
+/** RTL 语言列表 */
+const RTL_LANGUAGES = /* @__PURE__ */ new Set([
+	"ar",
+	"arc",
+	"dv",
+	"fa",
+	"ha",
+	"he",
+	"khw",
+	"ks",
+	"ku",
+	"ps",
+	"ur",
+	"yi"
+]);
+/** 检测语言是否为 RTL */
+function isRtl(language) {
+	const primary = language.split("-")[0].toLowerCase();
+	return RTL_LANGUAGES.has(primary);
+}
+/** 获取文本方向 */
+function getTextDirection(language) {
+	return isRtl(language) ? "rtl" : "ltr";
+}
+/**
+* 从语言代码生成 HTML lang/dir 属性
+*
+* @example
+* ```ts
+* getLocaleAttributes("ar-SA") // { lang: "ar-SA", dir: "rtl" }
+* getLocaleAttributes("en-US") // { lang: "en-US", dir: "ltr" }
+* ```
+*/
+function getLocaleAttributes(language) {
+	return {
+		lang: language,
+		dir: getTextDirection(language)
+	};
+}
+/**
+* 构建 LocaleInfo
+*
+* @param language - 语言代码（如 "zh-Hans"）
+* @param region - 地区代码（如 "CN"），可选
+*/
+function makeLocaleInfo(language, region) {
+	return {
+		language,
+		region,
+		bcp47: region ? `${language}-${region}` : language,
+		dir: getTextDirection(language)
+	};
+}
+/**
+* 从 URL 前缀中提取 locale
+*
+* @param url - 请求 URL（如 "/zh/about"）
+* @param supportedLocales - 支持的 locale 列表（如 ["zh", "en", "ja"]）
+* @returns 匹配时返回 `{ locale, strippedUrl }`，不匹配返回 null
+*
+* @example
+* ```ts
+* resolveLocaleFromUrl("/zh/about", ["zh", "en"])
+* // → { locale: "zh", strippedUrl: "/about" }
+*
+* resolveLocaleFromUrl("/about", ["zh", "en"])
+* // → null
+* ```
+*/
+function resolveLocaleFromUrl(url, supportedLocales) {
+	const match = url.split("?")[0].match(/^\/([^/]+)(\/.*)?$/);
+	if (!match) return null;
+	const candidate = match[1];
+	const found = supportedLocales.find((l) => l.toLowerCase() === candidate.toLowerCase());
+	if (!found) return null;
+	return {
+		locale: found,
+		strippedUrl: match[2] || "/"
+	};
+}
+//#endregion
+//#region ../core/src/i18n/messages.ts
+/**
+* Resolve `TranslationMessages` into the flat map consumed by
+* `SimpleTranslator`.
+*/
+function resolveMessages(messages, locale) {
+	const entries = Object.entries(messages);
+	if (entries.length === 0) return void 0;
+	if (typeof entries[0][1] === "string") return messages;
+	const localeMessages = messages[locale];
+	if (!localeMessages) return void 0;
+	const flat = {};
+	for (const [key, value] of Object.entries(localeMessages)) {
+		if (typeof value === "string") {
+			flat[key] = value;
+			continue;
+		}
+		for (const [suffix, text] of Object.entries(value)) flat[`${key}.${suffix}`] = text;
+	}
+	return flat;
+}
+//#endregion
+//#region ../core/src/i18n/translator.ts
+/**
+* SimpleTranslator — 默认翻译器实现
+*
+* 从扁平的 key→string 映射提供翻译，支持 ICU 插值和复数规则。
+*/
+var SimpleTranslator = class {
+	locale;
+	messages;
+	pluralRule;
+	fallback;
+	constructor(options) {
+		this.locale = options.locale;
+		this.messages = options.messages;
+		this.pluralRule = options.pluralRule ?? englishPlural;
+		this.fallback = options.fallback ?? ((key) => key);
+	}
+	t(key, values) {
+		const template = this.messages[key];
+		if (template === void 0) return this.fallback(key);
+		return interpolate(template, values);
+	}
+	plural(key, count, values) {
+		const pluralKey = resolvePluralKey(key, this.pluralRule(count));
+		const mergedValues = {
+			count,
+			...values
+		};
+		return this.t(pluralKey, mergedValues);
+	}
+};
+//#endregion
+//#region ../core/src/application/operation.ts
+function defineOperation(operation) {
+	return Object.freeze({
+		...operation,
+		policies: Object.freeze([...operation.policies ?? []]),
+		capabilities: Object.freeze([...operation.capabilities ?? []]),
+		cache: operation.cache && Object.freeze({
+			...operation.cache,
+			tags: Object.freeze([...operation.cache.tags ?? []])
+		})
+	});
+}
+function implementOperation(operation, handler) {
+	return Object.freeze({
+		operation,
+		handler
+	});
+}
+/** A fresh controller owns each call; reusable definitions never retain request state. */
+function implementController(operation, create) {
+	return implementOperation(operation, (input, context) => create().perform(input, context));
+}
+//#endregion
+//#region ../core/src/application/definition.ts
+function freezeDefinition(value) {
+	const copy = { ...value };
+	for (const key of [
+		"operations",
+		"implementations",
+		"providers",
+		"policies",
+		"dependsOn",
+		"modules"
+	]) {
+		const values = copy[key];
+		if (Array.isArray(values)) Object.assign(copy, { [key]: Object.freeze([...values]) });
+	}
+	return Object.freeze(copy);
+}
+function defineModule(module) {
+	return freezeDefinition(module);
+}
+function defineApp(app) {
+	return freezeDefinition(app);
+}
+function configuration(message) {
+	throw new ExecutionError("configuration", message);
+}
+function analyze(app) {
+	if (!app.id) configuration("Application ID must not be empty");
+	const modules = /* @__PURE__ */ new Map();
+	for (const module of app.modules ?? []) {
+		if (!module.id || modules.has(module.id)) configuration(`Duplicate or empty module: ${module.id}`);
+		modules.set(module.id, module);
+	}
+	const ordered = [], visiting = /* @__PURE__ */ new Set(), visited = /* @__PURE__ */ new Set();
+	function visit(module) {
+		if (visiting.has(module)) configuration(`Cyclic module dependency: ${module.id}`);
+		if (visited.has(module)) return;
+		visiting.add(module);
+		for (const dependency of module.dependsOn ?? []) {
+			if (modules.get(dependency.id) !== dependency) configuration(`Unknown module: ${dependency.id}`);
+			visit(dependency);
+		}
+		visiting.delete(module);
+		visited.add(module);
+		ordered.push(module);
+	}
+	for (const module of modules.values()) visit(module);
+	const operations = /* @__PURE__ */ new Map(), implementations = /* @__PURE__ */ new Map(), providers = /* @__PURE__ */ new Map(), tokenIds = /* @__PURE__ */ new Map(), policies = /* @__PURE__ */ new Map();
+	for (const owner of [...ordered, app]) {
+		for (const op of owner.operations ?? []) {
+			if (!op.id || operations.has(op.id)) configuration(`Duplicate or empty operation: ${op.id}`);
+			if (op.kind === "command" && op.cache) configuration(`Command cannot cache: ${op.id}`);
+			if (op.cache && (!Number.isFinite(op.cache.ttlMs) || op.cache.ttlMs <= 0)) configuration(`Invalid cache ttl: ${op.id}`);
+			operations.set(op.id, op);
+			policies.set(op, [
+				...app.policies ?? [],
+				...owner === app ? [] : owner.policies ?? [],
+				...op.policies ?? []
+			]);
+			if (op.handler) implementations.set(op, {
+				operation: op,
+				handler: op.handler
+			});
+		}
+		for (const p of owner.providers ?? []) {
+			if (tokenIds.has(p.token.id)) configuration(`Duplicate provider: ${p.token.id}`);
+			tokenIds.set(p.token.id, p.token);
+			providers.set(p.token, p);
+		}
+	}
+	for (const owner of [...ordered, app]) for (const impl of owner.implementations ?? []) {
+		if (operations.get(impl.operation.id) !== impl.operation) configuration(`Unknown operation: ${impl.operation.id}`);
+		if (implementations.has(impl.operation)) configuration(`Duplicate implementation: ${impl.operation.id}`);
+		implementations.set(impl.operation, impl);
+	}
+	return {
+		operations,
+		implementations,
+		providers,
+		policies
+	};
+}
+const structures = /* @__PURE__ */ new WeakMap();
+function reusable(app) {
+	const arraysFrozen = (value, keys) => keys.every((key) => {
+		const array = value[key];
+		return array === void 0 || Object.isFrozen(array);
+	});
+	return [app, ...app.modules ?? []].every((owner) => Object.isFrozen(owner) && arraysFrozen(owner, [
+		"modules",
+		"dependsOn",
+		"operations",
+		"implementations",
+		"providers",
+		"policies"
+	]) && (owner.operations ?? []).every((op) => Object.isFrozen(op) && arraysFrozen(op, ["policies", "capabilities"]) && (!op.cache || Object.isFrozen(op.cache) && arraysFrozen(op.cache, ["tags"]))) && (owner.implementations ?? []).every(Object.isFrozen) && (owner.providers ?? []).every((provider) => Object.isFrozen(provider) && arraysFrozen(provider, ["dependencies", "capabilities"])));
+}
+/** Reuse immutable application structure; validate every host override and capability separately. */
+function normalize(options) {
+	const { app } = options;
+	let base = structures.get(app);
+	if (!base) {
+		base = analyze(app);
+		if (reusable(app)) structures.set(app, base);
+	}
+	const { operations, policies } = base;
+	const implementations = new Map(base.implementations);
+	const providers = new Map(base.providers);
+	const overrides = /* @__PURE__ */ new Set();
+	for (const impl of options.implementations ?? []) {
+		if (operations.get(impl.operation.id) !== impl.operation) configuration(`Unknown operation: ${impl.operation.id}`);
+		if (overrides.has(impl.operation)) configuration(`Duplicate override: ${impl.operation.id}`);
+		overrides.add(impl.operation);
+		implementations.set(impl.operation, impl);
+	}
+	const providerOverrides = /* @__PURE__ */ new Set();
+	for (const p of options.providers ?? []) {
+		if (!providers.has(p.token)) configuration(`Unknown provider override: ${p.token.id}`);
+		if (providerOverrides.has(p.token)) configuration(`Duplicate provider override: ${p.token.id}`);
+		providerOverrides.add(p.token);
+		providers.set(p.token, p);
+	}
+	const checkCapabilities = (names = []) => {
+		for (const name of names) if (options.capabilities?.[name] == null) throw new ExecutionError("capability", `Missing capability: ${name}`);
+	};
+	for (const op of operations.values()) {
+		if (!implementations.has(op)) configuration(`Unbound operation: ${op.id}`);
+		checkCapabilities(op.capabilities?.filter((name) => name !== "fetch" || !options.invocationCapabilities?.includes("fetch")));
+	}
+	for (const p of providers.values()) {
+		if (typeof p.create === "function" === Object.hasOwn(p, "value")) configuration(`Provider requires exactly create or value: ${p.token.id}`);
+		checkCapabilities(p.capabilities);
+		const walk = (current, path) => {
+			if (path.has(current.token)) configuration(`Cyclic provider dependency: ${current.token.id}`);
+			if (p.lifetime === "runtime" && current.lifetime === "scope") configuration(`runtime provider ${p.token.id} cannot depend on scope provider ${current.token.id}`);
+			const next = new Set(path).add(current.token);
+			for (const token of current.dependencies ?? []) {
+				const dep = providers.get(token);
+				if (!dep) configuration(`Unknown provider: ${token.id}`);
+				walk(dep, next);
+			}
+		};
+		walk(p, /* @__PURE__ */ new Set());
+	}
+	return {
+		operations,
+		implementations,
+		providers,
+		policies
+	};
+}
+//#endregion
+//#region ../core/src/application/runtime.ts
+function afterSettled(promise, callback) {
+	promise.then(callback, callback);
+}
+const MAX_CACHE_KEY_DEPTH = 50;
+/**
+* Cache identity only accepts JSON data.  A permissive serializer silently
+* aliases Dates, class instances, cycles, and over-deep values, which makes a
+* query cache return the wrong business result.  `undefined` is intentional
+* input data and therefore gets a distinct explicit representation.
+*/
+function encodeCacheIdentity(value) {
+	const seen = /* @__PURE__ */ new Set();
+	const encode = (current, depth) => {
+		if (depth > MAX_CACHE_KEY_DEPTH) throw new ExecutionError("configuration", "Cache input exceeds maximum depth");
+		if (current === void 0) return ["undefined"];
+		if (current === null) return ["null"];
+		if (typeof current === "string" || typeof current === "boolean") return [typeof current, current];
+		if (typeof current === "number") {
+			if (!Number.isFinite(current)) throw new ExecutionError("configuration", "Cache input contains a non-finite number");
+			return ["number", Object.is(current, -0) ? "-0" : current];
+		}
+		if (typeof current !== "object") throw new ExecutionError("configuration", "Cache input must contain JSON values only");
+		if (seen.has(current)) throw new ExecutionError("configuration", "Cache input is cyclic");
+		const prototype = Object.getPrototypeOf(current);
+		if (prototype !== Object.prototype && prototype !== null && !Array.isArray(current)) throw new ExecutionError("configuration", "Cache input must not contain class instances");
+		seen.add(current);
+		try {
+			if (Object.getOwnPropertySymbols(current).length) throw new ExecutionError("configuration", "Cache input must not contain symbol properties");
+			if (Array.isArray(current)) {
+				if (Object.keys(current).length !== current.length || Object.keys(current).some((key, index) => key !== String(index))) throw new ExecutionError("configuration", "Cache input arrays must be dense without extra properties");
+				return ["array", Array.from({ length: current.length }, (_, index) => {
+					const descriptor = Object.getOwnPropertyDescriptor(current, String(index));
+					if (!Object.hasOwn(descriptor, "value")) throw new ExecutionError("configuration", "Cache input must not contain accessor properties");
+					return encode(descriptor.value, depth + 1);
+				})];
+			}
+			const entries = [];
+			for (const key of Object.getOwnPropertyNames(current).sort()) {
+				const descriptor = Object.getOwnPropertyDescriptor(current, key);
+				if (!descriptor.enumerable || !Object.hasOwn(descriptor, "value")) throw new ExecutionError("configuration", "Cache input must contain enumerable data properties only");
+				entries.push([key, encode(descriptor.value, depth + 1)]);
+			}
+			return ["object", entries];
+		} finally {
+			seen.delete(current);
+		}
+	};
+	return JSON.stringify(encode(value, 0));
+}
+function createRuntime(options) {
+	const plan = normalize(options);
+	const capacity = options.cacheCapacity ?? 100;
+	if (!Number.isSafeInteger(capacity) || capacity < 1) configuration("Runtime cache capacity must be a positive finite integer");
+	const container = new Container();
+	const applicationId = options.app.id;
+	const runtimeId = generateUuid();
+	const active = /* @__PURE__ */ new Set();
+	const cache = new LruMap(capacity);
+	const scopeInvalidators = /* @__PURE__ */ new Set();
+	const invalidateListeners = /* @__PURE__ */ new Set();
+	let closed = false;
+	let disposal;
+	let runtimeGeneration = 0;
+	for (const provider of plan.providers.values()) container.registerProvider(provider);
+	const record = (type, fields = {}) => {
+		try {
+			const result = options.recorder?.record(type, {
+				...fields,
+				applicationId,
+				runtimeId
+			});
+			if (result && typeof result.then === "function") Promise.resolve(result).catch(() => {});
+		} catch {}
+	};
+	const invalidate = (inputTags) => {
+		const tags = Object.freeze([...inputTags]);
+		if (!tags.length) return;
+		runtimeGeneration++;
+		for (const [key, entry] of cache) if (entry.tags.some((tag) => tags.includes(tag))) cache.delete(key);
+		for (const invalidateScope of scopeInvalidators) invalidateScope(tags);
+		for (const listener of invalidateListeners) try {
+			const result = listener(tags);
+			if (result && typeof result.then === "function") Promise.resolve(result).catch(() => {});
+		} catch {}
+	};
+	const runtime = {
+		applicationId,
+		runtimeId,
+		invalidate,
+		onInvalidate(listener) {
+			if (closed) configuration("Runtime is closed");
+			invalidateListeners.add(listener);
+			return () => invalidateListeners.delete(listener);
+		},
+		record,
+		async execute(operation, input, invocation) {
+			const execution = runtime.createExecution(invocation);
+			let output;
+			try {
+				output = await execution.execute(operation, input);
+			} catch (error) {
+				await execution.dispose().catch(() => {});
+				throw error;
+			}
+			try {
+				await execution.dispose();
+			} catch (cause) {
+				throw new ExecutionError("failure", void 0, { cause });
+			}
+			return output;
+		},
+		createExecution(invocation = {}) {
+			if (closed) configuration("Runtime is closed");
+			invocation = Object.freeze({
+				...invocation,
+				bindings: Object.freeze({ ...invocation.bindings })
+			});
+			const abort = new AbortController();
+			const scope = container.createScope(invocation.bindings);
+			const executionId = generateUuid();
+			const traceId = invocation.traceId ?? executionId;
+			const scopeCache = new LruMap(capacity);
+			const inFlight = /* @__PURE__ */ new Map();
+			let scopeGeneration = 0;
+			const invalidateScope = (tags) => {
+				scopeGeneration++;
+				for (const [key, entry] of scopeCache) if (entry.tags.some((tag) => tags.includes(tag))) scopeCache.delete(key);
+			};
+			scopeInvalidators.add(invalidateScope);
+			const forwardAbort = () => abort.abort(invocation.signal?.reason);
+			if (invocation.signal?.aborted) forwardAbort();
+			else invocation.signal?.addEventListener("abort", forwardAbort, { once: true });
+			let disposed = false;
+			let disposing;
+			const running = /* @__PURE__ */ new Set();
+			const assertActive = () => {
+				if (disposed) configuration("Execution is closed");
+				if (abort.signal.aborted) throw new ExecutionError("cancelled");
+			};
+			const executionRecord = (type, fields = {}) => record(type, {
+				...fields,
+				executionId,
+				traceId
+			});
+			const context = Object.freeze({
+				applicationId,
+				runtimeId,
+				executionId,
+				traceId,
+				signal: abort.signal,
+				container: scope,
+				bindings: Object.freeze({ ...invocation.bindings }),
+				identity: invocation.identity,
+				locale: invocation.locale,
+				get: async (token) => {
+					assertActive();
+					return scope.get(token);
+				},
+				execute: (op, input) => execution.execute(op, input),
+				invalidate,
+				record: executionRecord,
+				onDispose: (cleanup) => {
+					assertActive();
+					scope.onDispose(cleanup);
+				},
+				fetch: async (input, init) => {
+					assertActive();
+					const fetch = invocation.fetch ?? options.capabilities?.fetch;
+					if (!fetch) throw new ExecutionError("capability", "Missing capability: fetch");
+					const supplied = init?.signal ?? (typeof Request !== "undefined" && input instanceof Request ? input.signal : void 0);
+					const signal = supplied ? AbortSignal.any([abort.signal, supplied]) : abort.signal;
+					signal.throwIfAborted();
+					const response = await fetch(input, {
+						...init,
+						signal
+					});
+					signal.throwIfAborted();
+					return response;
+				}
+			});
+			async function execute(operation, input) {
+				const start = Date.now();
+				executionRecord("operation", {
+					operationId: operation.id,
+					phase: "start"
+				});
+				const complete = (cacheHit = false) => executionRecord("operation", {
+					operationId: operation.id,
+					phase: "complete",
+					...cacheHit ? { cacheHit: true } : {},
+					durationMs: Date.now() - start
+				});
+				try {
+					assertActive();
+					if (plan.operations.get(operation.id) !== operation) configuration(`Unknown operation reference: ${operation.id}`);
+					for (const name of operation.capabilities ?? []) if ((name === "fetch" ? invocation.fetch ?? options.capabilities?.fetch : options.capabilities?.[name]) == null) throw new ExecutionError("capability", `Missing capability: ${name}`);
+					let validated = input;
+					if (operation.input) {
+						const result = await operation.input["~standard"].validate(input);
+						if (result.issues) throw new ExecutionError("validation");
+						validated = result.value;
+					}
+					for (const policy of plan.policies.get(operation) ?? []) {
+						assertActive();
+						await policy(validated, context);
+					}
+					assertActive();
+					const cachePolicy = operation.cache;
+					if (!cachePolicy) {
+						const output = await invoke(operation, validated);
+						complete();
+						return output;
+					}
+					const cacheValue = cachePolicy.key ? cachePolicy.key(validated) : validated;
+					const key = encodeCacheIdentity([
+						operation.id,
+						invocation.identity ?? null,
+						invocation.locale ?? null,
+						cacheValue
+					]);
+					const selectedCache = cachePolicy.scope === "execution" ? scopeCache : cache;
+					const cached = selectedCache.get(key);
+					if (cached && cached.expires > Date.now()) {
+						complete(true);
+						return cached.value;
+					}
+					if (cached) selectedCache.delete(key);
+					const currentRuntimeGeneration = runtimeGeneration;
+					const currentScopeGeneration = scopeGeneration;
+					const existing = inFlight.get(key);
+					const output = await (existing && existing.runtimeGeneration === currentRuntimeGeneration && existing.scopeGeneration === currentScopeGeneration ? existing.promise : startCached(operation, validated, key, cachePolicy, selectedCache, currentRuntimeGeneration, currentScopeGeneration));
+					complete();
+					return output;
+				} catch (cause) {
+					const error = abort.signal.aborted || cause instanceof Error && cause.name === "AbortError" ? new ExecutionError("cancelled", void 0, { cause }) : cause instanceof ExecutionError ? cause : cause instanceof HttpError ? executionErrorFromHttp(cause) : new ExecutionError("failure", void 0, { cause });
+					executionRecord("operation", {
+						operationId: operation.id,
+						phase: "error",
+						code: error.code,
+						durationMs: Date.now() - start
+					});
+					throw error;
+				}
+			}
+			async function invoke(operation, input) {
+				const implementation = plan.implementations.get(operation);
+				if (!implementation) configuration(`Unbound operation: ${operation.id}`);
+				let output = await implementation.handler(input, context);
+				assertActive();
+				if (operation.output) {
+					const result = await operation.output["~standard"].validate(output);
+					if (result.issues) throw new ExecutionError("failure");
+					output = result.value;
+				}
+				assertActive();
+				return output;
+			}
+			function startCached(operation, input, key, policy, selectedCache, expectedRuntimeGeneration, expectedScopeGeneration) {
+				const promise = invoke(operation, input).then((output) => {
+					if (runtimeGeneration === expectedRuntimeGeneration && scopeGeneration === expectedScopeGeneration) selectedCache.set(key, {
+						value: output,
+						expires: Date.now() + policy.ttlMs,
+						tags: policy.tags ?? []
+					});
+					return output;
+				});
+				const entry = {
+					promise,
+					runtimeGeneration: expectedRuntimeGeneration,
+					scopeGeneration: expectedScopeGeneration
+				};
+				inFlight.set(key, entry);
+				afterSettled(promise, () => {
+					if (inFlight.get(key) === entry) inFlight.delete(key);
+				});
+				return promise;
+			}
+			const execution = {
+				context,
+				cancel(reason) {
+					abort.abort(reason);
+				},
+				execute(operation, input) {
+					const promise = execute(operation, input);
+					running.add(promise);
+					afterSettled(promise, () => running.delete(promise));
+					return promise;
+				},
+				dispose() {
+					if (disposing) return disposing;
+					disposed = true;
+					abort.abort();
+					invocation.signal?.removeEventListener("abort", forwardAbort);
+					disposing = (async () => {
+						while (running.size) await Promise.allSettled(running);
+						try {
+							await scope.dispose();
+						} finally {
+							active.delete(execution);
+							scopeInvalidators.delete(invalidateScope);
+							scopeCache.clear();
+							inFlight.clear();
+						}
+					})();
+					return disposing;
+				}
+			};
+			active.add(execution);
+			return execution;
+		},
+		dispose() {
+			if (disposal) return disposal;
+			closed = true;
+			disposal = (async () => {
+				const results = await Promise.allSettled([...active].map((scope) => scope.dispose()));
+				try {
+					await container.dispose();
+				} finally {
+					cache.clear();
+					scopeInvalidators.clear();
+					invalidateListeners.clear();
+				}
+				const errors = results.filter((result) => result.status === "rejected").map((result) => result.reason);
+				if (errors.length) throw new AggregateError(errors, "Execution cleanup failed");
+			})();
+			return disposal;
+		}
+	};
+	return runtime;
+}
+//#endregion
+//#region ../core/src/dependencies/providers.ts
+function provide(provider) {
+	return Object.freeze({
+		...provider,
+		dependencies: Object.freeze([...provider.dependencies ?? []]),
+		capabilities: Object.freeze([...provider.capabilities ?? []])
+	});
+}
+//#endregion
+//#region ../web/src/actions/types.ts
+/** Action Kind 常量 */
+const ACTION_KINDS = {
+	FLOW: "flow",
+	EXTERNAL_URL: "externalUrl",
+	COMPOUND: "compound",
+	PUSH: "push",
+	POP: "pop",
+	POP_TO_ROOT: "popToRoot",
+	POP_TO: "popTo",
+	REPLACE_TOP: "replaceTop",
+	SELECT_TAB: "selectTab",
+	SELECT_COLUMN: "selectColumn",
+	SET_VISIBILITY: "setVisibility",
+	HYDRATE: "hydrate",
+	REUSE_ENTRY: "reuseEntry",
+	REFRESH: "refresh"
+};
+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 ../web/src/actions/dispatcher.ts
+/**
+* ActionDispatcher — Action 分发器
+*
+* 注册不同 kind 的 handler，按类型分发。
+* CompoundAction 自动展开递归执行。
+*/
+/** CompoundAction 最大递归展开深度 */
+const MAX_COMPOUND_DEPTH = 32;
+var ActionDispatcher = class {
+	currentResult;
+	handlers = /* @__PURE__ */ new Map();
+	closed = false;
+	epoch = 0;
+	invocations = /* @__PURE__ */ new WeakMap();
+	pendingFlow;
+	constructor(currentResult) {
+		this.currentResult = currentResult;
+	}
+	get generation() {
+		return this.epoch;
+	}
+	/** Cancel pending groups; a handler may retain its own invocation during URL admission. */
+	cancel = (invocation) => {
+		this.epoch++;
+		const current = invocation && this.invocations.get(invocation);
+		if (current) current.generation = this.epoch;
+	};
+	/**
+	* 注册指定 kind 的 handler。
+	*
+	* 重复 kind 时保留第一个注册者并发出警告——这是有意设计：
+	* framework 内部 handler 先注册，应用层意外覆盖会被记录而非静默生效。
+	* 如需显式替换，先调用 removeAction(kind)。
+	*/
+	onAction = (kind, handler) => {
+		if (this.handlers.has(kind)) {
+			console.warn(`[ActionDispatcher] kind="${kind}" already registered, skipping`);
+			return;
+		}
+		this.handlers.set(kind, handler);
+	};
+	/** 移除指定 kind 的 handler（用于显式覆盖场景） */
+	removeAction = (kind) => {
+		return this.handlers.delete(kind);
+	};
+	close() {
+		this.closed = true;
+		this.epoch++;
+		this.handlers.clear();
+		this.pendingFlow = void 0;
+	}
+	/** 执行一个 Action（CompoundAction 递归展开，有深度限制） */
+	perform = (action, invocation) => this.dispatch(action, invocation, 0);
+	async dispatch(action, invocation, depth) {
+		const existing = invocation && this.invocations.get(invocation);
+		const context = existing ? invocation : { ...invocation };
+		const group = existing ?? { generation: this.epoch };
+		if (!existing) this.invocations.set(context, group);
+		let flow = false;
+		try {
+			if (group.generation !== this.epoch) throw new ExecutionError("cancelled");
+			if (this.closed) throw new ExecutionError("configuration", "Action dispatcher is closed");
+			if (isCompoundAction(action)) {
+				if (depth >= MAX_COMPOUND_DEPTH) throw new Error(`[ActionDispatcher] CompoundAction recursion depth exceeded (max ${MAX_COMPOUND_DEPTH})`);
+				for (const subAction of action.actions) {
+					if (context.signal?.aborted) throw new ExecutionError("cancelled");
+					const result = await this.dispatch(subAction, context, depth + 1);
+					if (this.currentResult && result !== this.currentResult()) return result;
+				}
+				return this.currentResult?.();
+			}
+			const handler = this.handlers.get(action.kind);
+			if (!handler) {
+				console.warn(`[ActionDispatcher] No handler for kind="${action.kind}"`);
+				return this.currentResult?.();
+			}
+			flow = action.kind === "flow" && action.presentationContext !== "modal";
+			if ((flow || action.kind !== "flow" && action.kind !== "externalUrl") && this.pendingFlow && this.pendingFlow !== group) {
+				this.pendingFlow.generation = -1;
+				this.pendingFlow = void 0;
+			}
+			if (flow) this.pendingFlow = group;
+			const result = await handler(action, context);
+			return result === void 0 ? this.currentResult?.() : result;
+		} finally {
+			if (flow && this.pendingFlow === group) this.pendingFlow = void 0;
+			if (!existing) this.invocations.delete(context);
+		}
+	}
+};
+//#endregion
+//#region ../web/src/router/types.ts
+/** Absent and empty query values share one cache identity. */
+function routeIntent(id, params = {}, query) {
+	return {
+		id,
+		params,
+		...query && Object.keys(query).length ? { query } : {}
+	};
+}
+//#endregion
+//#region ../web/src/router/router.ts
+/** URL router — route metadata layered over Core's portable pathname matcher. */
+function createNullPrototypeRecord(source) {
+	return Object.assign(Object.create(null), source);
+}
+var Router = class {
+	debug;
+	routes = [];
+	sealed = false;
+	constructor(debug) {
+		this.debug = debug;
+	}
+	seal() {
+		this.sealed = true;
+		return this;
+	}
+	add(pattern, intentId, options = {}) {
+		if (this.sealed) throw new Error("Router is sealed");
+		const compiled = compilePath(pattern);
+		this.routes.push({
+			pattern,
+			intentId,
+			path: compiled.descriptor,
+			compiled,
+			...options
+		});
+		return this;
+	}
+	async resolve(urlOrPath) {
+		const { path, queryParams, searchParams } = this.parseUrl(urlOrPath);
+		for (const route of this.routes) {
+			const pathParams = route.compiled.match(path);
+			if (!pathParams) continue;
+			const params = createNullPrototypeRecord(pathParams);
+			const query = createNullPrototypeRecord(queryParams);
+			let valid = true;
+			for (const parameter of route.path.parameters) {
+				const codec = route.paramCodecs?.[parameter.name];
+				if (!codec) continue;
+				const result = await codec["~standard"].validate(pathParams[parameter.name]);
+				if (result.issues) {
+					this.debug?.(`[Router] route "${route.pattern}" skipped: path param "${parameter.name}" failed validation: ${result.issues[0]?.message ?? "invalid"}`);
+					valid = false;
+					break;
+				}
+				params[parameter.name] = result.value;
+			}
+			if (!valid) continue;
+			if (route.queryCodecs) for (const name of Object.keys(route.queryCodecs)) {
+				const codec = route.queryCodecs[name];
+				const raw = isMultiValueSchema(codec) ? searchParams.getAll(name) : queryParams[name];
+				const result = await codec["~standard"].validate(raw);
+				if (result.issues) {
+					this.debug?.(`[Router] route "${route.pattern}" skipped: query param "${name}" failed validation: ${result.issues[0]?.message ?? "invalid"}`);
+					valid = false;
+					break;
+				}
+				query[name] = result.value;
+			}
+			if (!valid) continue;
+			return {
+				intent: routeIntent(route.intentId, params, query),
+				action: makeFlowAction(urlOrPath),
+				renderMode: route.renderMode,
+				cache: route.cache,
+				beforeGuards: route.beforeGuards,
+				afterGuards: route.afterGuards
+			};
+		}
+		return null;
+	}
+	hasIntent(intentId) {
+		return this.routes.some((route) => route.intentId === intentId);
+	}
+	getDefinitions() {
+		return this.routes.map(({ pattern, intentId, path }) => Object.freeze({
+			pattern,
+			intentId,
+			path
+		}));
+	}
+	reverse(intentId, params, queryParams = {}) {
+		const matches = this.routes.filter((route) => route.intentId === intentId).map((route) => ({
+			route,
+			path: route.compiled.reverse(params)
+		})).filter((match) => match.path !== void 0);
+		if (matches.length > 1) throw new Error(`Ambiguous route for ${intentId}; provide the matched URL`);
+		const match = matches[0];
+		if (!match) return void 0;
+		const query = new URLSearchParams();
+		for (const key of Object.keys(queryParams).sort()) {
+			const values = Array.isArray(queryParams[key]) ? queryParams[key] : [queryParams[key]];
+			for (const value of values) if (typeof value === "string" || typeof value === "boolean" || typeof value === "number" && Number.isFinite(value)) query.append(key, String(value));
+		}
+		const serialized = query.toString();
+		return serialized ? `${match.path}?${serialized}` : match.path;
+	}
+	parseUrl(url) {
+		try {
+			const parsed = new URL(url, "http://localhost");
+			return {
+				path: parsed.pathname,
+				queryParams: createNullPrototypeRecord(Object.fromEntries(parsed.searchParams)),
+				searchParams: parsed.searchParams
+			};
+		} catch {
+			return {
+				path: url.split("?")[0].split("#")[0],
+				queryParams: createNullPrototypeRecord(),
+				searchParams: new URLSearchParams()
+			};
+		}
+	}
+};
+//#endregion
+//#region ../web/src/prefetched-intents/prefetched-intents.ts
+var PrefetchedIntents = class PrefetchedIntents {
+	entryIds;
+	intents;
+	constructor(intents, entryIds = /* @__PURE__ */ new Map()) {
+		this.entryIds = entryIds;
+		this.intents = intents;
+	}
+	/** 从 PrefetchedIntent 数组创建缓存实例 */
+	static fromArray(items) {
+		const map = /* @__PURE__ */ new Map();
+		const entries = /* @__PURE__ */ new Map();
+		for (const item of items) if (item.entryId && item.intent && item.data !== void 0) {
+			const key = stableStringify([item.entryId, item.intent]);
+			map.set(key, item.data);
+			if (item.entryId) {
+				const intentKey = stableStringify(item.intent);
+				entries.set(intentKey, [...entries.get(intentKey) ?? [], item.entryId]);
+			}
+		}
+		return new PrefetchedIntents(map, entries);
+	}
+	/** 创建空缓存实例 */
+	static empty() {
+		return new PrefetchedIntents(/* @__PURE__ */ new Map());
+	}
+	/**
+	* 获取缓存的 Intent 结果（一次性使用）。
+	* 命中后从缓存中删除。
+	*/
+	get(intent, entryId) {
+		if (!entryId) return void 0;
+		const key = stableStringify([entryId, intent]);
+		const data = this.intents.get(key);
+		if (data !== void 0) {
+			this.intents.delete(key);
+			return data;
+		}
+	}
+	/** @internal Navigation-owned staged reads; direct get remains one-shot. */
+	stage() {
+		const original = new Map(this.intents);
+		const cache = new PrefetchedIntents(new Map(original), this.entryIds);
+		return {
+			cache,
+			commit: () => {
+				for (const [key, value] of original) if (!cache.intents.has(key) && this.intents.get(key) === value) this.intents.delete(key);
+			}
+		};
+	}
+	/** Read identity metadata without consuming data or bypassing operation policies. */
+	entryIdFor(intent) {
+		const ids = (this.entryIds.get(stableStringify(intent)) ?? []).filter((entryId) => this.has(intent, entryId));
+		return ids.length === 1 ? ids[0] : void 0;
+	}
+	/** 检查缓存中是否有某个 Intent 的数据 */
+	has(intent, entryId) {
+		return !!entryId && this.intents.has(stableStringify([entryId, intent]));
+	}
+	/** 缓存中的条目数 */
+	get size() {
+		return this.intents.size;
+	}
+};
+//#endregion
+//#region ../web/src/bootstrap/define-routes.ts
+/**
+* 构造一条强类型路由定义。
+* `params` 的 key 受 `path` 字面量约束——写入 path 中不存在的参数名会编译期报错。
+*
+* @example
+* route("/product/:id", { intentId: "product", params: { id: int() } })
+*/
+function route(path, def) {
+	return Object.freeze({
+		path,
+		...def
+	});
+}
+//#endregion
+//#region ../web/src/navigation/types.ts
+/** 导航节点 Kind 常量 */
+const NAVIGATION_NODE_KINDS = {
+	LEAF: "leaf",
+	STACK: "stack",
+	TABS: "tabs",
+	SPLIT: "split"
+};
+/**
+* Split 列可见性，对标 SwiftUI `NavigationSplitViewVisibility`。
+*
+* 这是**可绑定 / 可序列化 / 可恢复的导航状态**（不是渲染样式）：它决定哪些列算「可见」，
+* 进而影响 `collectVisibleDestinations` 与 SSR 预取——例如深链到 `detailOnly` 时服务端只预取 detail 列。
+*
+* - `automatic`（缺省）：框架不裁剪，所有有内容的列都可见（SSR 端无视口信息时的安全默认；客户端再按视口自适应）。
+* - `all`：显式所有列可见（语义同 automatic 的全列）。
+* - `doubleColumn`：仅首列 + 末列可见（三列时隐藏中间 content 列）。
+* - `detailOnly`：仅末列（detail）可见。
+*
+* 注意：compact 视口塌缩成单栈（SwiftUI 的 `preferredCompactColumn`）是视口反应式的纯渲染决策，
+* 框架不建模，交给应用按 `getPlatform()` / 视口自行处理。
+*/
+const SPLIT_VISIBILITIES = {
+	AUTOMATIC: "automatic",
+	ALL: "all",
+	DOUBLE_COLUMN: "doubleColumn",
+	DETAIL_ONLY: "detailOnly"
+};
+/** 错误类型：序列化 / 路径 / 操作非法时抛出 */
+var NavigationError = class extends Error {
+	constructor(message) {
+		super(message);
+		this.name = "NavigationError";
+	}
+};
+//#endregion
+//#region ../web/src/navigation/nodes.ts
+/**
+* Navigation — 节点构造器 + 类型守卫
+*
+* 构造器产出冻结的不可变节点；守卫用 `is*Node` 前缀做可辨识联合的窄化。
+*/
+/** 构造叶子节点（一个具体导航目标）。 */
+function leaf(intent, params = {}, options = {}) {
+	return {
+		kind: NAVIGATION_NODE_KINDS.LEAF,
+		intent,
+		params,
+		...options.query && Object.keys(options.query).length ? { query: options.query } : {},
+		entryId: options.entryId ?? generateUuid(),
+		...options.url ? { url: options.url } : {}
+	};
+}
+/**
+* 构造栈节点。
+* 接受单个根节点（栈仅含根）或一个 entries 数组（entries[0]=根，末尾=栈顶）。
+*
+* @example
+* stack(leaf("home"))                       // 单根栈
+* stack([leaf("home"), leaf("detail")])     // 根 + 栈顶
+*/
+function stack(rootOrEntries) {
+	const entries = Array.isArray(rootOrEntries) ? [...rootOrEntries] : [rootOrEntries];
+	return {
+		kind: NAVIGATION_NODE_KINDS.STACK,
+		entries
+	};
+}
+/**
+* 构造 Tabs 节点。
+* 缺省 `order` 时按 `branches` 的插入顺序（`Object.keys`）推导稳定顺序。
+*/
+function tabs(init) {
+	const order = init.order ? [...init.order] : Object.keys(init.branches);
+	return {
+		kind: NAVIGATION_NODE_KINDS.TABS,
+		active: init.active,
+		order,
+		branches: { ...init.branches }
+	};
+}
+/**
+* 构造 Split 节点（多列并存）。
+* `visibility` 缺省（不写字段）等价 `automatic` = 全列可见；
+* 显式传入时纳入节点状态，影响 `collectVisibleDestinations` 与 SSR 预取。
+*
+* @example
+* split([{ id: "sidebar", content: leaf("folders") }, { id: "detail" }])
+* split([...], "detailOnly")   // 深链：仅 detail 列可见
+*/
+function split(columns, visibility) {
+	const normalized = columns.map((c) => ({
+		id: c.id,
+		content: c.content
+	}));
+	return visibility === void 0 ? {
+		kind: NAVIGATION_NODE_KINDS.SPLIT,
+		columns: normalized
+	} : {
+		kind: NAVIGATION_NODE_KINDS.SPLIT,
+		columns: normalized,
+		visibility
+	};
+}
+function isLeafNode(node) {
+	return node.kind === NAVIGATION_NODE_KINDS.LEAF;
+}
+function isStackNode(node) {
+	return node.kind === NAVIGATION_NODE_KINDS.STACK;
+}
+function isTabsNode(node) {
+	return node.kind === NAVIGATION_NODE_KINDS.TABS;
+}
+function isSplitNode(node) {
+	return node.kind === NAVIGATION_NODE_KINDS.SPLIT;
+}
+//#endregion
+//#region ../web/src/navigation/keys.ts
+/** Resource identity never identifies a page instance. */
+function resourceKey(intent, params, partition = {}, query) {
+	return stableStringify([
+		intent,
+		partition.identity ?? null,
+		partition.locale ?? null,
+		params,
+		...query && Object.keys(query).length ? [query] : []
+	]);
+}
+//#endregion
+//#region ../web/src/navigation/operations.ts
+/**
+* Navigation — 纯函数操作（不可变 + 结构共享）
+*
+* 所有操作都不修改输入节点，返回带结构共享的新节点：仅被改动路径上的节点重建，
+* 其余子树原样复用。操作通过「目标路径」定位要变更的子树；省略 target 时默认作用于
+* 「激活路径」（root → tabs.active → stack 顶 → split 最后一个非空列 → …）。
+*
+* 非法目标（如对非 tabs 节点 selectTab、激活路径上没有 stack 却 push）会抛 NavigationError。
+*/
+/**
+* 解析「激活路径」：从根沿可见分支一路向下，直到叶子或无法继续。
+* - leaf：路径在此结束
+* - stack：进入栈顶 entry
+* - tabs：进入 active 分支
+* - split：进入最后一个有内容的列（无任何内容则结束）
+*/
+function resolveActivePath(tree) {
+	return walkActive(tree);
+}
+/** 找到 split 中最后一个 content 非 undefined 的列。 */
+function lastNonEmptyColumn(node) {
+	for (let i = node.columns.length - 1; i >= 0; i--) if (node.columns[i].content !== void 0) return node.columns[i];
+}
+/**
+* 按路径定位节点；任一步无效（索引越界 / 键不存在 / 列为空 / kind 不匹配）返回 undefined。
+*/
+function findNode(tree, path) {
+	let node = tree;
+	for (const step of path) {
+		if (node === void 0) return void 0;
+		node = stepInto(node, step);
+	}
+	return node;
+}
+/** 沿一步路径下钻；不匹配返回 undefined。 */
+function stepInto(node, step) {
+	switch (step.kind) {
+		case "stack-entry":
+			if (node.kind !== NAVIGATION_NODE_KINDS.STACK) return void 0;
+			return node.entries[step.index];
+		case "tab":
+			if (node.kind !== NAVIGATION_NODE_KINDS.TABS) return void 0;
+			return node.branches[step.key];
+		case "column":
+			if (node.kind !== NAVIGATION_NODE_KINDS.SPLIT) return void 0;
+			return node.columns.find((c) => c.id === step.id)?.content;
+	}
+}
+/**
+* 找到 target 处（默认激活路径）「at/under」最近的 StackNode 路径。
+* 从 target 节点沿激活分支向下，返回第一个遇到的 StackNode 的完整路径；
+* 找不到则返回 undefined。
+*/
+function findNearestStack(tree, path) {
+	const start = findNode(tree, path);
+	if (start === void 0) return void 0;
+	let stackPath;
+	walkActive(start, (node, activePath) => {
+		if (node.kind === NAVIGATION_NODE_KINDS.STACK) {
+			stackPath = [...path, ...activePath];
+			return true;
+		}
+		return false;
+	});
+	return stackPath;
+}
+/** Walk the active branch once, optionally observing every visited node. */
+function walkActive(tree, visit) {
+	const path = [];
+	let node = tree;
+	for (;;) {
+		if (visit?.(node, path)) return path;
+		switch (node.kind) {
+			case NAVIGATION_NODE_KINDS.LEAF: return path;
+			case NAVIGATION_NODE_KINDS.STACK: {
+				const index = node.entries.length - 1;
+				const entry = node.entries[index];
+				if (entry === void 0) return path;
+				path.push({
+					kind: "stack-entry",
+					index
+				});
+				node = entry;
+				break;
+			}
+			case NAVIGATION_NODE_KINDS.TABS: {
+				const branch = node.branches[node.active];
+				if (branch === void 0) return path;
+				path.push({
+					kind: "tab",
+					key: node.active
+				});
+				node = branch;
+				break;
+			}
+			case NAVIGATION_NODE_KINDS.SPLIT: {
+				const column = lastNonEmptyColumn(node);
+				if (column?.content === void 0) return path;
+				path.push({
+					kind: "column",
+					id: column.id
+				});
+				node = column.content;
+				break;
+			}
+		}
+	}
+}
+/**
+* 收集所有可见的叶子目标（顺序即渲染/解析顺序）。
+* - leaf → [leaf]
+* - stack → 栈顶 entry 的可见目标
+* - tabs → active 分支的可见目标
+* - split → 每个有内容的列的可见目标，按列序拼接
+*/
+function collectVisibleDestinations(tree) {
+	const out = [];
+	collectInto(tree, out);
+	return out;
+}
+function collectInto(node, out) {
+	switch (node.kind) {
+		case NAVIGATION_NODE_KINDS.LEAF:
+			out.push(node);
+			return;
+		case NAVIGATION_NODE_KINDS.STACK:
+			if (node.entries.length === 0) return;
+			collectInto(node.entries[node.entries.length - 1], out);
+			return;
+		case NAVIGATION_NODE_KINDS.TABS: {
+			const branch = node.branches[node.active];
+			if (branch !== void 0) collectInto(branch, out);
+			return;
+		}
+		case NAVIGATION_NODE_KINDS.SPLIT:
+			for (const col of visibleSplitColumns(node)) if (col.content !== void 0) collectInto(col.content, out);
+			return;
+	}
+}
+/**
+* 收集树中**全部存在**的叶子（含不可见：栈非顶 entry、未激活 tab 分支、所有非空 split 列）。
+* 区别于 `collectVisibleDestinations`（只沿可见分支）—— 保活 / 缓存 prune / 作用域保留需要
+* 全部 present 条目。顺序：栈按序、tabs 按 `Object.values(branches)` 序、split 按列序。
+*/
+function collectAllLeaves(tree) {
+	const out = [];
+	collectAllInto(tree, out);
+	return out;
+}
+function collectAllInto(node, out) {
+	switch (node.kind) {
+		case NAVIGATION_NODE_KINDS.LEAF:
+			out.push(node);
+			return;
+		case NAVIGATION_NODE_KINDS.STACK:
+			for (const entry of node.entries) collectAllInto(entry, out);
+			return;
+		case NAVIGATION_NODE_KINDS.TABS:
+			for (const branch of Object.values(node.branches)) collectAllInto(branch, out);
+			return;
+		case NAVIGATION_NODE_KINDS.SPLIT:
+			for (const col of node.columns) if (col.content !== void 0) collectAllInto(col.content, out);
+			return;
+	}
+}
+/**
+* 按 `visibility` 求出一个 split 节点当前**可见**的列（不裁剪空内容列——空 content 由调用方处理）。
+*
+* - `automatic`（缺省）/ `all`：全部列。
+* - `doubleColumn`：首列 + 末列（三列时隐藏中间 content 列；列数 ≤ 2 时等价全部）。
+* - `detailOnly`：仅末列（detail）。
+*
+* 应用渲染时也可用它决定该画哪几列，无需自行重实现可见性映射。
+*/
+function visibleSplitColumns(node) {
+	const { columns, visibility } = node;
+	if (columns.length === 0) return columns;
+	switch (visibility) {
+		case SPLIT_VISIBILITIES.DETAIL_ONLY: return [columns[columns.length - 1]];
+		case SPLIT_VISIBILITIES.DOUBLE_COLUMN: {
+			const last = columns.length - 1;
+			return last === 0 ? [columns[0]] : [columns[0], columns[last]];
+		}
+		default: return columns;
+	}
+}
+/**
+* 在 `path` 指向的节点上应用 `mapper`，返回重建后的根（仅路径上的节点重建）。
+* 任一步无效抛 NavigationError。
+*/
+function transformAt(tree, path, mapper) {
+	if (path.length === 0) return mapper(tree);
+	return rebuild(tree, path, 0, mapper);
+}
+function rebuild(node, path, depth, mapper) {
+	if (depth === path.length) return mapper(node);
+	const step = path[depth];
+	switch (step.kind) {
+		case "stack-entry": {
+			if (node.kind !== NAVIGATION_NODE_KINDS.STACK) throw new NavigationError(`路径无效：在 ${node.kind} 节点上期望 stack（stack-entry 步）`);
+			if (step.index < 0 || step.index >= node.entries.length) throw new NavigationError(`路径无效：stack entry 索引越界 ${step.index}`);
+			const entries = node.entries.slice();
+			entries[step.index] = rebuild(entries[step.index], path, depth + 1, mapper);
+			return {
+				...node,
+				entries
+			};
+		}
+		case "tab": {
+			if (node.kind !== NAVIGATION_NODE_KINDS.TABS) throw new NavigationError(`路径无效：在 ${node.kind} 节点上期望 tabs（tab 步）`);
+			const branch = node.branches[step.key];
+			if (branch === void 0) throw new NavigationError(`路径无效：tabs 分支 "${step.key}" 不存在`);
+			return {
+				...node,
+				branches: {
+					...node.branches,
+					[step.key]: rebuild(branch, path, depth + 1, mapper)
+				}
+			};
+		}
+		case "column": {
+			if (node.kind !== NAVIGATION_NODE_KINDS.SPLIT) throw new NavigationError(`路径无效：在 ${node.kind} 节点上期望 split（column 步）`);
+			const idx = node.columns.findIndex((c) => c.id === step.id);
+			if (idx === -1) throw new NavigationError(`路径无效：split 列 "${step.id}" 不存在`);
+			const content = node.columns[idx].content;
+			if (content === void 0) throw new NavigationError(`路径无效：split 列 "${step.id}" 内容为空`);
+			const columns = node.columns.slice();
+			columns[idx] = {
+				...columns[idx],
+				content: rebuild(content, path, depth + 1, mapper)
+			};
+			return {
+				...node,
+				columns
+			};
+		}
+	}
+}
+/**
+* 沿激活路径（root → 可见叶子）下行，返回「最深」（top 当前可见）的 stack 路径。
+* 这是栈操作（push/pop/…）在未显式给 target 时的默认作用栈。
+* 激活路径上没有任何 stack 则返回 undefined。
+*/
+function findActiveStack(tree) {
+	let deepest;
+	walkActive(tree, (node, path) => {
+		if (node.kind === NAVIGATION_NODE_KINDS.STACK) deepest = [...path];
+		return false;
+	});
+	return deepest;
+}
+/**
+* 在栈操作的目标栈上执行更新：
+* - 显式 target → 取 target「at/under」最近的 stack（findNearestStack 向下钻）；
+* - 缺省 → 取激活路径上最深的 stack（findActiveStack）。
+*/
+function updateStack(tree, target, operation, update) {
+	const stackPath = target ? findNearestStack(tree, target) : findActiveStack(tree);
+	if (stackPath === void 0) throw new NavigationError(`${operation} 失败：激活路径上没有可用的 stack`);
+	return transformAt(tree, stackPath, (node) => update(node));
+}
+/** 在目标栈（默认激活栈，或 target「at/under」最近的 stack）顶部 push 一个节点。 */
+function push(tree, node, target) {
+	return updateStack(tree, target, "push", (stack) => ({
+		...stack,
+		entries: [...stack.entries, node]
+	}));
+}
+/** 从 target 处最近的 stack 弹出 count 个 entry（默认 1）；绝不弹到根 entry 之下。 */
+function pop(tree, count = 1, target) {
+	if (count <= 0) return tree;
+	return updateStack(tree, target, "pop", (stack) => {
+		const keep = Math.max(1, stack.entries.length - count);
+		return keep === stack.entries.length ? stack : {
+			...stack,
+			entries: stack.entries.slice(0, keep)
+		};
+	});
+}
+/** 把 target 处最近的 stack 弹回到根 entry。 */
+function popToRoot(tree, target) {
+	return updateStack(tree, target, "popToRoot", (stack) => {
+		return stack.entries.length <= 1 ? stack : {
+			...stack,
+			entries: stack.entries.slice(0, 1)
+		};
+	});
+}
+/** 把 target 处最近的 stack 弹回到指定 index（保留 [0..index]）。 */
+function popTo(tree, index, target) {
+	return updateStack(tree, target, "popTo", (stack) => {
+		if (index < 0 || index >= stack.entries.length) throw new NavigationError(`popTo 失败：index ${index} 越界（栈深 ${stack.entries.length}）`);
+		return index === stack.entries.length - 1 ? stack : {
+			...stack,
+			entries: stack.entries.slice(0, index + 1)
+		};
+	});
+}
+/** 替换 target 处最近 stack 的栈顶 entry（栈为空时抛错）。 */
+function replaceTop(tree, node, target) {
+	return updateStack(tree, target, "replaceTop", (stack) => {
+		if (stack.entries.length === 0) throw new NavigationError("replaceTop 失败：stack 为空");
+		const entries = stack.entries.slice();
+		entries[entries.length - 1] = node;
+		return {
+			...stack,
+			entries
+		};
+	});
+}
+/**
+* 切换 tabs 节点的激活分支。
+* target 默认为「最近的激活 tabs 节点」；target 必须指向 TabsNode，且 key 必须是已知分支。
+*/
+function selectTab(tree, key, target) {
+	const tabsPath = target ?? findActiveKind(tree, NAVIGATION_NODE_KINDS.TABS);
+	if (tabsPath === void 0) throw new NavigationError("selectTab 失败：激活路径上没有 tabs 节点");
+	return transformAt(tree, tabsPath, (n) => {
+		if (n.kind !== NAVIGATION_NODE_KINDS.TABS) throw new NavigationError(`selectTab 失败：目标是 ${n.kind} 节点，不是 tabs`);
+		const t = n;
+		if (!Object.hasOwn(t.branches, key)) throw new NavigationError(`selectTab 失败：未知分支 "${key}"`);
+		if (t.active === key) return t;
+		return {
+			...t,
+			active: key
+		};
+	});
+}
+/**
+* 设置 split 某列内容，并清空它之后的所有列（content 置 undefined）。
+* target 默认为「最近的激活 split 节点」；columnId 必须是已知列。
+*/
+function selectColumn(tree, columnId, content, target) {
+	const splitPath = target ?? findActiveKind(tree, NAVIGATION_NODE_KINDS.SPLIT);
+	if (splitPath === void 0) throw new NavigationError("selectColumn 失败：激活路径上没有 split 节点");
+	return transformAt(tree, splitPath, (n) => {
+		if (n.kind !== NAVIGATION_NODE_KINDS.SPLIT) throw new NavigationError(`selectColumn 失败：目标是 ${n.kind} 节点，不是 split`);
+		const sp = n;
+		const idx = sp.columns.findIndex((c) => c.id === columnId);
+		if (idx === -1) throw new NavigationError(`selectColumn 失败：未知列 "${columnId}"`);
+		const columns = sp.columns.map((c, i) => {
+			if (i === idx) return {
+				...c,
+				content
+			};
+			if (i > idx) return {
+				...c,
+				content: void 0
+			};
+			return c;
+		});
+		return {
+			...sp,
+			columns
+		};
+	});
+}
+/**
+* 设置 split 节点的列可见性（对标 SwiftUI `NavigationSplitViewVisibility`）。
+* target 默认为「最近的激活 split 节点」。改变 visibility 会影响 `collectVisibleDestinations`，
+* 进而触发 controller 对「新变可见」的列做 dispatch / SSR 预取（如 detailOnly → all 时补预取 sidebar/content）。
+*/
+function setVisibility(tree, visibility, target) {
+	const splitPath = target ?? findActiveKind(tree, NAVIGATION_NODE_KINDS.SPLIT);
+	if (splitPath === void 0) throw new NavigationError("setVisibility 失败：激活路径上没有 split 节点");
+	return transformAt(tree, splitPath, (n) => {
+		if (n.kind !== NAVIGATION_NODE_KINDS.SPLIT) throw new NavigationError(`setVisibility 失败：目标是 ${n.kind} 节点，不是 split`);
+		return {
+			...n,
+			visibility
+		};
+	});
+}
+/**
+* 沿激活路径（root → 可见叶子）下行，返回 kind 匹配的「最外层」（最接近根）节点路径。
+* 这是 `selectTab`/`selectColumn` 的默认目标：无 target 时操作最顶层的 tabs/split
+* （主标签栏 / 主分栏）；需要更深的容器由调用方显式传 target。
+* 整条激活路径上都没有匹配则返回 undefined。
+*/
+function findActiveKind(tree, kind) {
+	let match;
+	walkActive(tree, (node, path) => {
+		if (node.kind === kind) {
+			match = [...path];
+			return true;
+		}
+		return false;
+	});
+	return match;
+}
+/** Reveal a particular existing entry, preserving its identity and retained state. */
+function reuseEntry(tree, entryId) {
+	const reveal = (node) => {
+		switch (node.kind) {
+			case "leaf": return node.entryId === entryId ? node : void 0;
+			case "stack":
+				for (let index = 0; index < node.entries.length; index++) {
+					const found = reveal(node.entries[index]);
+					if (found) return {
+						...node,
+						entries: [...node.entries.slice(0, index), found]
+					};
+				}
+				return;
+			case "tabs":
+				for (const key of node.order) {
+					const found = reveal(node.branches[key]);
+					if (found) return {
+						...node,
+						active: key,
+						branches: {
+							...node.branches,
+							[key]: found
+						}
+					};
+				}
+				return;
+			case "split":
+				for (let index = 0; index < node.columns.length; index++) {
+					const column = node.columns[index];
+					const found = column.content && reveal(column.content);
+					if (found) return {
+						...node,
+						visibility: "all",
+						columns: node.columns.map((item, i) => i === index ? {
+							...item,
+							content: found
+						} : item)
+					};
+				}
+				return;
+		}
+	};
+	const result = reveal(tree);
+	if (!result) throw new NavigationError(`Unknown entry ID: ${entryId}`);
+	return result;
+}
+/** Apply resolved route metadata to leaves without changing their instance identities. */
+function mapNavigationLeaves(tree, transform) {
+	switch (tree.kind) {
+		case "leaf": return transform(tree);
+		case "stack": return {
+			...tree,
+			entries: tree.entries.map((node) => mapNavigationLeaves(node, transform))
+		};
+		case "tabs": return {
+			...tree,
+			branches: Object.fromEntries(Object.entries(tree.branches).map(([key, node]) => [key, mapNavigationLeaves(node, transform)]))
+		};
+		case "split": return {
+			...tree,
+			columns: tree.columns.map((column) => ({
+				...column,
+				content: column.content && mapNavigationLeaves(column.content, transform)
+			}))
+		};
+	}
+}
+//#endregion
+//#region ../web/src/navigation/serialization.ts
+/**
+* Navigation — 序列化 / 反序列化
+*
+* `serializeNavigation` 把导航树转成 JSON 安全的纯对象（SerializedNavigation），
+* `deserializeNavigation` 反向还原并校验结构，畸形数据抛 NavigationError。
+* 往返必须无损（含 split 空列 `content: undefined`、params 任意 JSON 值）。
+*
+* 复用 `stableStringify` 提供 `serializeNavigationStable` —— 给需要稳定字符串/键的
+* 场景（如 codec 的紧凑稳定编码、缓存键）一个确定性输出。
+*/
+/** 合法的 split 可见性取值集合（反序列化校验用） */
+const SPLIT_VISIBILITY_VALUES = new Set(Object.values(SPLIT_VISIBILITIES));
+/** 把导航树序列化为 JSON 安全的纯对象。 */
+function serializeNavigation(tree) {
+	switch (tree.kind) {
+		case NAVIGATION_NODE_KINDS.LEAF: return {
+			kind: NAVIGATION_NODE_KINDS.LEAF,
+			intent: tree.intent,
+			params: tree.params,
+			...tree.query ? { query: tree.query } : {},
+			entryId: tree.entryId,
+			...tree.url ? { url: tree.url } : {}
+		};
+		case NAVIGATION_NODE_KINDS.STACK: return {
+			kind: NAVIGATION_NODE_KINDS.STACK,
+			entries: tree.entries.map(serializeNavigation)
+		};
+		case NAVIGATION_NODE_KINDS.TABS: {
+			const branches = Object.create(null);
+			for (const key of Object.keys(tree.branches)) branches[key] = serializeNavigation(tree.branches[key]);
+			return {
+				kind: NAVIGATION_NODE_KINDS.TABS,
+				active: tree.active,
+				order: [...tree.order],
+				branches
+			};
+		}
+		case NAVIGATION_NODE_KINDS.SPLIT: {
+			const columns = tree.columns.map((c) => ({
+				id: c.id,
+				content: c.content === void 0 ? null : serializeNavigation(c.content)
+			}));
+			return tree.visibility === void 0 ? {
+				kind: NAVIGATION_NODE_KINDS.SPLIT,
+				columns
+			} : {
+				kind: NAVIGATION_NODE_KINDS.SPLIT,
+				columns,
+				visibility: tree.visibility
+			};
+		}
+	}
+}
+/** 导航树的确定性字符串形式（keys 排序）；用于稳定缓存键 / 紧凑编码。 */
+function serializeNavigationStable(tree) {
+	return stableStringify(serializeNavigation(tree));
+}
+const KNOWN_KINDS = /* @__PURE__ */ new Set([
+	NAVIGATION_NODE_KINDS.LEAF,
+	NAVIGATION_NODE_KINDS.STACK,
+	NAVIGATION_NODE_KINDS.TABS,
+	NAVIGATION_NODE_KINDS.SPLIT
+]);
+/** 从 JSON 安全数据还原导航树；结构畸形抛 NavigationError。 */
+function deserializeNavigation(data) {
+	const tree = parseNode(data, "$");
+	const ids = /* @__PURE__ */ new Set();
+	for (const leaf of collectAllLeaves(tree)) {
+		if (ids.has(leaf.entryId)) throw new NavigationError(`Duplicate entry ID: ${leaf.entryId}`);
+		ids.add(leaf.entryId);
+	}
+	return tree;
+}
+function isPlainObject$1(v) {
+	return typeof v === "object" && v !== null && !Array.isArray(v);
+}
+function parseNode(data, path) {
+	if (!isPlainObject$1(data)) throw new NavigationError(`反序列化失败：${path} 不是对象`);
+	const kind = data.kind;
+	if (typeof kind !== "string" || !KNOWN_KINDS.has(kind)) throw new NavigationError(`反序列化失败：${path}.kind 非法（${String(kind)}）`);
+	switch (kind) {
+		case NAVIGATION_NODE_KINDS.LEAF: return parseLeaf(data, path);
+		case NAVIGATION_NODE_KINDS.STACK: return parseStack(data, path);
+		case NAVIGATION_NODE_KINDS.TABS: return parseTabs(data, path);
+		case NAVIGATION_NODE_KINDS.SPLIT: return parseSplit(data, path);
+	}
+}
+function parseLeaf(data, path) {
+	if (typeof data.entryId !== "string" || !data.entryId.trim()) throw new NavigationError(`Invalid entry ID at ${path}`);
+	if (data.url !== void 0 && typeof data.url !== "string") throw new NavigationError(`Invalid URL at ${path}`);
+	if (typeof data.intent !== "string") throw new NavigationError(`反序列化失败：${path}.intent 必须是字符串`);
+	if (!isPlainObject$1(data.params)) throw new NavigationError(`反序列化失败：${path}.params 必须是对象`);
+	if (data.query !== void 0 && !isPlainObject$1(data.query)) throw new NavigationError(`Invalid query at ${path}`);
+	return {
+		kind: NAVIGATION_NODE_KINDS.LEAF,
+		entryId: data.entryId,
+		...typeof data.url === "string" ? { url: data.url } : {},
+		intent: data.intent,
+		params: { ...data.params },
+		...data.query ? { query: { ...data.query } } : {}
+	};
+}
+function parseStack(data, path) {
+	if (!Array.isArray(data.entries)) throw new NavigationError(`反序列化失败：${path}.entries 必须是数组`);
+	return {
+		kind: NAVIGATION_NODE_KINDS.STACK,
+		entries: data.entries.map((e, i) => parseNode(e, `${path}.entries[${i}]`))
+	};
+}
+function parseTabs(data, path) {
+	if (typeof data.active !== "string") throw new NavigationError(`反序列化失败：${path}.active 必须是字符串`);
+	if (!Array.isArray(data.order) || !data.order.every((k) => typeof k === "string")) throw new NavigationError(`反序列化失败：${path}.order 必须是字符串数组`);
+	if (!isPlainObject$1(data.branches)) throw new NavigationError(`反序列化失败：${path}.branches 必须是对象`);
+	const branches = Object.create(null);
+	for (const key of Object.keys(data.branches)) branches[key] = parseNode(data.branches[key], `${path}.branches.${key}`);
+	for (const key of data.order) if (!Object.hasOwn(branches, key)) throw new NavigationError(`反序列化失败：${path}.order 包含不在 branches 中的键 "${key}"`);
+	if (!Object.hasOwn(branches, data.active)) throw new NavigationError(`反序列化失败：${path}.active "${data.active}" 不在 branches 中`);
+	return {
+		kind: NAVIGATION_NODE_KINDS.TABS,
+		active: data.active,
+		order: [...data.order],
+		branches
+	};
+}
+function parseSplit(data, path) {
+	if (!Array.isArray(data.columns)) throw new NavigationError(`反序列化失败：${path}.columns 必须是数组`);
+	const columns = data.columns.map((col, i) => {
+		const colPath = `${path}.columns[${i}]`;
+		if (!isPlainObject$1(col)) throw new NavigationError(`反序列化失败：${colPath} 不是对象`);
+		if (typeof col.id !== "string") throw new NavigationError(`反序列化失败：${colPath}.id 必须是字符串`);
+		const content = col.content === null || col.content === void 0 ? void 0 : parseNode(col.content, `${colPath}.content`);
+		return {
+			id: col.id,
+			content
+		};
+	});
+	if (data.visibility === void 0) return {
+		kind: NAVIGATION_NODE_KINDS.SPLIT,
+		columns
+	};
+	if (typeof data.visibility !== "string" || !SPLIT_VISIBILITY_VALUES.has(data.visibility)) throw new NavigationError(`反序列化失败：${path}.visibility 非法值 ${JSON.stringify(data.visibility)}`);
+	return {
+		kind: NAVIGATION_NODE_KINDS.SPLIT,
+		columns,
+		visibility: data.visibility
+	};
+}
+//#endregion
+//#region ../web/src/navigation/codec.ts
+const DEFAULT_NAV_PARAM = "__nav";
+function encodeNavigationTreeParam(tree) {
+	const bytes = new TextEncoder().encode(stableStringify(serializeNavigation(tree)));
+	let binary = "";
+	for (const byte of bytes) binary += String.fromCharCode(byte);
+	return btoa(binary).replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "");
+}
+function decodeNavigationTreeParam(encoded) {
+	try {
+		const binary = atob(encoded.replace(/-/g, "+").replace(/_/g, "/"));
+		const bytes = Uint8Array.from(binary, (char) => char.charCodeAt(0));
+		return deserializeNavigation(JSON.parse(new TextDecoder("utf-8", { fatal: true }).decode(bytes)));
+	} catch {
+		throw new NavigationError("Invalid navigation parameter");
+	}
+}
+function activeUrl(tree, router) {
+	const target = findNode(tree, resolveActivePath(tree));
+	return target?.kind === "leaf" ? target.url ?? router.reverse(target.intent, target.params, target.query) ?? "/" : "/";
+}
+function createActiveLeafCodec() {
+	return {
+		encode: activeUrl,
+		decode(url) {
+			const value = new URL(url, "http://localhost").searchParams.get(DEFAULT_NAV_PARAM);
+			return value ? decodeNavigationTreeParam(value) : void 0;
+		}
+	};
+}
+function createFullStateCodec(options = {}) {
+	const param = options.param ?? "__nav";
+	return {
+		encode(tree, router) {
+			const url = new URL(activeUrl(tree, router), "http://localhost");
+			url.searchParams.set(param, encodeNavigationTreeParam(tree));
+			return url.pathname + url.search;
+		},
+		decode(url) {
+			const value = new URL(url, "http://localhost").searchParams.get(param);
+			return value ? decodeNavigationTreeParam(value) : void 0;
+		}
+	};
+}
+//#endregion
+//#region ../web/src/application/controller-context.ts
+const SERVER_CONTROLLER = Symbol.for("finesoft.serverController");
+const SERVER_REQUEST = "@finesoft/web/server-request";
+function controllerContext(execution, navigation) {
+	const state = execution.bindings[SERVER_REQUEST];
+	return Object.freeze({
+		...execution,
+		url: navigation.url,
+		path: navigation.path,
+		intent: navigation.intent,
+		isServer: navigation.isServer,
+		getCookie: (name) => state ? state.cookies.get(name) : navigation.getCookie(name),
+		getHeader: (name) => navigation.getHeader(name)
+	});
+}
+//#endregion
+//#region ../web/src/application/definition.ts
+const WEB_EXECUTION = "@finesoft/web/execution";
+function consumePage(context, id, input) {
+	const state = context.bindings[WEB_EXECUTION];
+	return state?.retained.get(input) ?? state?.prefetched.get(routeIntent(id, input.params, input.query), state.entryIds.get(input));
+}
+const plans = /* @__PURE__ */ new WeakMap();
+function getWebPlan(definition) {
+	const plan = plans.get(definition);
+	if (!plan) throw new ExecutionError("configuration", "Use defineWebApp to assemble the Web definition");
+	return plan;
+}
+function freezeSnapshot(value) {
+	if (value && typeof value === "object") {
+		for (const child of Object.values(value)) freezeSnapshot(child);
+		Object.freeze(value);
+	}
+	return value;
+}
+function defineWebApp(input) {
+	const routes = Object.freeze(input.pages.flatMap((page) => (page.routes ?? []).map((route) => ({
+		...typeof route === "string" ? { path: route } : route,
+		intentId: page.id
+	}))).map((route) => {
+		if ("controller" in route) throw new ExecutionError("configuration", "Web routes reference controller factories by intentId");
+		return Object.freeze({
+			...route,
+			beforeLoad: route.beforeLoad && Object.freeze([...route.beforeLoad]),
+			afterLoad: route.afterLoad && Object.freeze([...route.afterLoad])
+		});
+	}));
+	const pages = Object.freeze(input.pages.map((controller) => Object.freeze({ ...controller })));
+	const definition = Object.freeze({
+		...input,
+		pages,
+		navigation: typeof input.navigation === "function" ? input.navigation : input.navigation && freezeSnapshot(structuredClone(input.navigation)),
+		beforeNavigate: input.beforeNavigate && Object.freeze([...input.beforeNavigate]),
+		beforeCommit: input.beforeCommit && Object.freeze([...input.beforeCommit]),
+		beforeLoad: input.beforeLoad && Object.freeze([...input.beforeLoad]),
+		afterLoad: input.afterLoad && Object.freeze([...input.afterLoad]),
+		configuration: input.configuration && Object.freeze({ ...input.configuration })
+	});
+	const operations = /* @__PURE__ */ new Map();
+	for (const controller of pages) {
+		if (operations.has(controller.id) || !!controller.create === !!controller.handler) throw new ExecutionError("configuration", `Invalid page controller: ${controller.id}`);
+		operations.set(controller.id, defineOperation({
+			id: controller.id,
+			kind: "query",
+			policies: controller.policies?.map((policy) => (input, context) => policy(input.params, context)),
+			handler: (input, context) => {
+				const state = context.bindings[WEB_EXECUTION];
+				const request = context.bindings[SERVER_REQUEST];
+				const current = state?.contexts.get(input) ?? controllerContext(context, {
+					url: "",
+					path: "",
+					intent: routeIntent(controller.id, input.params, input.query),
+					isServer: !!request || typeof window === "undefined",
+					getCookie: () => void 0,
+					getHeader: (name) => request?.request.headers.get(name) ?? void 0
+				});
+				const cached = consumePage(context, controller.id, input);
+				if (cached !== void 0) return cached;
+				const instance = controller.create?.();
+				if (request?.remote && (!instance || !(SERVER_CONTROLLER in instance))) throw new ExecutionError("not_found");
+				if (controller.handler) return controller.handler(input.params, current, input.query);
+				return instance.perform(input.params, current, input.query);
+			}
+		}));
+	}
+	const router = new Router();
+	const paths = /* @__PURE__ */ new Set();
+	for (const route of routes) {
+		if (paths.has(route.path)) throw new ExecutionError("configuration", `Duplicate route: ${route.path}`);
+		if (!operations.has(route.intentId)) throw new ExecutionError("configuration", `Unknown page: ${route.intentId}`);
+		paths.add(route.path);
+		router.add(route.path, route.intentId, {
+			renderMode: route.renderMode,
+			cache: route.cache,
+			beforeGuards: route.beforeLoad,
+			afterGuards: route.afterLoad,
+			paramCodecs: route.params,
+			queryCodecs: route.query
+		});
+	}
+	const app = defineApp({
+		...input.app,
+		id: input.id,
+		operations: [...input.app?.operations ?? [], ...operations.values()]
+	});
+	plans.set(definition, {
+		app,
+		router: router.seal(),
+		operations,
+		routes
+	});
+	return definition;
+}
+//#endregion
+//#region ../web/src/middleware/pipeline.ts
+/**
+* Guard Pipeline — 顺序执行守卫链
+*
+* 按注册顺序执行守卫，遇到第一个非 `next` 结果立即短路返回。
+*/
+async function runGuards(guards, ctx) {
+	for (const guard of guards) {
+		if (ctx.signal?.aborted) throw new ExecutionError("cancelled");
+		const result = await guard(ctx);
+		if (ctx.signal?.aborted) throw new ExecutionError("cancelled");
+		if (result.kind !== "next") return result;
+	}
+	return { kind: "next" };
+}
+/** 执行 beforeLoad 守卫链 */
+const runBeforeLoadGuards = runGuards;
+/** 执行 afterLoad 守卫链 */
+const runAfterLoadGuards = runGuards;
+//#endregion
+//#region ../web/src/application/execution.ts
+/** Attach a cancellation boundary to the existing scope without taking its disposal ownership. */
+function bindExecutionCancellation(execution, signal) {
+	if (!signal) return () => {};
+	const cancel = () => execution.cancel(signal.reason);
+	if (signal.aborted) cancel();
+	else signal.addEventListener("abort", cancel, { once: true });
+	return () => signal.removeEventListener("abort", cancel);
+}
+//#endregion
+//#region ../web/src/protocol.ts
+const FRAMEWORK_PROTOCOL_VERSION = 2;
+function getFrameworkBuildId() {
+	return typeof __FINESOFT_BUILD_ID__ === "string" ? __FINESOFT_BUILD_ID__ : "unbundled";
+}
+function record(value) {
+	return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function decodeWireEnvelope(value, buildId = getFrameworkBuildId()) {
+	const invalid = {
+		status: "fresh-load",
+		code: "invalid-payload"
+	};
+	if (!record(value)) return invalid;
+	if (value.protocolVersion !== 2) return {
+		status: "fresh-load",
+		code: "protocol-mismatch"
+	};
+	if (value.buildId !== buildId) return {
+		status: "fresh-load",
+		code: "build-mismatch"
+	};
+	if (!record(value.payload) || !Array.isArray(value.payload.pages) || !value.payload.tree) return invalid;
+	let leaves;
+	try {
+		leaves = collectAllLeaves(deserializeNavigation(value.payload.tree));
+	} catch {
+		return invalid;
+	}
+	const entries = new Map(leaves.map((leaf) => [leaf.entryId, leaf]));
+	const seen = /* @__PURE__ */ new Set();
+	for (const page of value.payload.pages) {
+		if (!record(page) || typeof page.entryId !== "string" || seen.has(page.entryId) || !record(page.intent) || !record(page.data)) return invalid;
+		const leaf = entries.get(page.entryId);
+		if (!leaf || leaf.intent !== page.intent.id || page.intent.params !== void 0 && !record(page.intent.params) || page.intent.query !== void 0 && !record(page.intent.query)) return invalid;
+		if (typeof page.data.pageType !== "string" || !page.data.pageType) return invalid;
+		seen.add(page.entryId);
+	}
+	return {
+		status: "ready",
+		data: value.payload
+	};
+}
+//#endregion
+//#region ../web/src/application/server-controller-proxy.ts
+const remotePages = /* @__PURE__ */ new WeakMap();
+const SERVER_CONTROLLER_PATH = "/__finesoft/controller";
+var RemoteNavigationResult = class extends ExecutionError {
+	result;
+	constructor(result) {
+		super("denied", "Server controller navigation result");
+		this.result = result;
+	}
+};
+/** The compiler replaces a complete server controller module with these inert references. */
+var ServerControllerProxy = class {
+	async perform(params, execution, query = {}) {
+		const context = execution;
+		if (!context.intent || context.isServer) throw new ExecutionError("configuration", "Server controller proxy requires browser navigation");
+		const response = await context.fetch(SERVER_CONTROLLER_PATH, {
+			method: "POST",
+			credentials: "same-origin",
+			headers: {
+				"content-type": "application/json",
+				"x-finesoft-controller": "1"
+			},
+			body: JSON.stringify({
+				intent: context.intent.id,
+				params,
+				query,
+				url: context.url
+			})
+		});
+		if (!response.ok) throw new ExecutionError(response.status === 403 ? "denied" : "failure");
+		const result = await response.json();
+		if (result.redirect) throw new RemoteNavigationResult({
+			kind: "redirect",
+			...result.redirect
+		});
+		if (result.rejection) throw new RemoteNavigationResult({
+			kind: "deny",
+			...result.rejection
+		});
+		const decoded = decodeWireEnvelope(result);
+		if (decoded.status !== "ready" || decoded.data.pages.length !== 1) throw new ExecutionError("failure", "Invalid server controller response");
+		const loaded = decoded.data.pages[0];
+		const target = collectAllLeaves(deserializeNavigation(decoded.data.tree)).find((leaf) => leaf.entryId === loaded.entryId);
+		const page = loaded.data;
+		remotePages.set(page, {
+			target,
+			rewriteUrl: response.headers.get("content-location") ?? void 0
+		});
+		return page;
+	}
+};
+//#endregion
+//#region ../web/src/application/load-page.ts
+/** One page pipeline, shared by URL, SSR and every visible tree destination. */
+async function loadPage(options) {
+	const { web } = options;
+	const owned = !options.execution;
+	const execution = options.execution ?? web.createExecution({ signal: options.signal });
+	const unbind = bindExecutionCancellation(execution, options.signal);
+	const check = () => {
+		if (execution.context.signal.aborted || options.signal?.aborted) throw new ExecutionError("cancelled");
+	};
+	try {
+		let target = options.target;
+		let entryId = typeof target === "string" ? options.entryId : target.entryId;
+		let retained = options.retained;
+		for (let depth = 0; depth < 5; depth++) {
+			check();
+			const direct = typeof target !== "string" ? target : void 0;
+			const hasRoutes = direct && web.router.hasIntent(direct.intent);
+			const url = typeof target === "string" ? target : target.url ?? (hasRoutes ? createActiveLeafCodec().encode(target, web.router) : "");
+			let match = direct && !direct.url && !hasRoutes ? {
+				intent: routeIntent(direct.intent, direct.params, direct.query),
+				action: {
+					kind: "flow",
+					url: ""
+				}
+			} : await web.router.resolve(url);
+			check();
+			if (!match) return {
+				kind: "deny",
+				status: 404,
+				message: "Page not found"
+			};
+			if (direct && match.intent.id !== direct.intent) throw new ExecutionError("configuration", "Leaf URL does not match its intent");
+			let destination = typeof target === "string" ? leaf(match.intent.id, match.intent.params ?? {}, {
+				url,
+				query: match.intent.query,
+				entryId: entryId ?? web.prefetchedIntents.entryIdFor(match.intent)
+			}) : !hasRoutes && !target.url ? target : {
+				...target,
+				intent: match.intent.id,
+				params: match.intent.params ?? {},
+				query: match.intent.query,
+				url
+			};
+			entryId = destination.entryId;
+			let navContext = {
+				...options.createContext?.({
+					url,
+					intent: match.intent,
+					execution
+				}) ?? {
+					url,
+					path: new URL(url, "http://localhost").pathname,
+					intent: match.intent,
+					params: match.intent.params ?? {},
+					query: match.intent.query ?? {},
+					container: execution.context.container,
+					isServer: true,
+					getCookie: () => void 0,
+					getHeader: () => void 0
+				},
+				params: match.intent.params ?? {},
+				query: match.intent.query ?? {},
+				container: execution.context.container,
+				signal: options.signal ? AbortSignal.any([execution.context.signal, options.signal]) : execution.context.signal
+			};
+			const before = await runBeforeLoadGuards([
+				...web.definition.beforeLoad ?? [],
+				...match.beforeGuards ?? [],
+				...options.beforeLoad ?? []
+			], navContext);
+			check();
+			if (before.kind === "rewrite") {
+				target = before.url;
+				retained = void 0;
+				continue;
+			}
+			if (before.kind !== "next") return before;
+			let page;
+			try {
+				const operation = getWebPlan(web.definition).operations.get(match.intent.id);
+				if (!operation) throw new ExecutionError("not_found");
+				const input = {
+					params: { ...match.intent.params },
+					query: { ...match.intent.query }
+				};
+				const state = execution.context.bindings[WEB_EXECUTION];
+				state.entryIds.set(input, destination.entryId);
+				state.contexts.set(input, controllerContext(execution.context, navContext));
+				if (retained) state.retained.set(input, retained);
+				page = await execution.execute(operation, input);
+			} catch (error) {
+				if (error instanceof RemoteNavigationResult) return error.result;
+				if (error instanceof ExecutionError && error.code === "cancelled") throw error;
+				return {
+					kind: "deny",
+					status: error instanceof ExecutionError ? error.status : 500,
+					message: error instanceof ExecutionError ? error.message : "Internal error"
+				};
+			}
+			check();
+			const remote = remotePages.get(page);
+			if (remote) {
+				remotePages.delete(page);
+				destination = {
+					...remote.target,
+					entryId: destination.entryId
+				};
+				if (destination.url) match = await web.router.resolve(destination.url);
+				navContext = {
+					...navContext,
+					intent: routeIntent(destination.intent, destination.params, destination.query),
+					params: destination.params,
+					query: destination.query ?? {},
+					url: destination.url ?? "",
+					path: new URL(destination.url || "/", "http://localhost").pathname
+				};
+				check();
+			}
+			const after = await runAfterLoadGuards([
+				...web.definition.afterLoad ?? [],
+				...match?.afterGuards ?? [],
+				...options.afterLoad ?? []
+			], {
+				...navContext,
+				page
+			});
+			check();
+			if (after.kind === "deny" || after.kind === "redirect") return after;
+			return {
+				kind: "page",
+				page,
+				target: destination,
+				match: match ?? void 0,
+				...after.kind === "rewrite" ? { rewriteUrl: after.url } : remote?.rewriteUrl ? { rewriteUrl: remote.rewriteUrl } : {}
+			};
+		}
+		throw new ExecutionError("configuration", "Page rewrite recursion depth exceeded");
+	} finally {
+		unbind();
+		if (owned) await execution.dispose();
+	}
+}
+//#endregion
+//#region ../web/src/utils/notify-observers.ts
+/** Notify without awaiting observers or allowing their failures to break a committed state. */
+function notifyObservers(listeners, onError, ...args) {
+	for (const listener of listeners) try {
+		const result = listener(...args);
+		if (result && typeof result.then === "function") Promise.resolve(result).catch(onError);
+	} catch {
+		onError();
+	}
+}
+//#endregion
+//#region ../web/src/session/types.ts
+var StorageUnavailableError = class extends Error {
+	constructor() {
+		super("storage-unavailable");
+		this.name = "StorageUnavailableError";
+	}
+};
+/** 会话快照在 Storage 中的默认键。 */
+const SESSION_DEFAULT_KEY = "__finesoft_session__";
+/** 会话快照的默认版本号；解码时不匹配即整份丢弃。 */
+const SESSION_DEFAULT_VERSION = 2;
+/** 会话错误：序列化 / 编排过程中需要显式标识的错误类型。 */
+var SessionError = class extends Error {
+	constructor(message) {
+		super(message);
+		this.name = "SessionError";
+	}
+};
+//#endregion
+//#region ../web/src/application/session.ts
+/**
+* One WebSession owns navigation transactions and native view snapshots.
+* EntryId indexes both visible and retained pages in stable mount order.
+* Browser history, DOM acknowledgement and storage remain host responsibilities.
+*/
+const TREE_ACTION_KINDS = Object.values(ACTION_KINDS).filter((kind) => kind !== "flow" && kind !== "externalUrl" && kind !== "compound");
+function createWebSession(options) {
+	const web = options.web;
+	let locale, translator;
+	const beforeNavigate = [...web.definition.beforeNavigate ?? [], ...options.beforeNavigate ?? []];
+	const beforeCommit = [...web.definition.beforeCommit ?? [], ...options.beforeCommit ?? []];
+	const getErrorPage = options.getErrorPage ?? web.definition.getErrorPage;
+	let snapshot = Object.freeze({
+		tree: options.initial,
+		destinations: [],
+		entries: [],
+		revision: 0,
+		navigation: summarize(options.initial)
+	});
+	const actions = new ActionDispatcher(() => snapshot);
+	const cancelActions = actions.cancel;
+	let retryInitial = false;
+	const navigationTree = () => retryInitial ? options.initial : snapshot.tree;
+	const listeners = /* @__PURE__ */ new Set();
+	const entries = /* @__PURE__ */ new Map();
+	let presentIds = new Set(collectAllLeaves(options.initial).map((entry) => entry.entryId));
+	const stale = /* @__PURE__ */ new Set();
+	const commitSteps = /* @__PURE__ */ new Set();
+	let invalidationVersion = 0;
+	const unsubscribeInvalidation = web.runtime.onInvalidate(() => {
+		invalidationVersion++;
+		for (const id of entries.keys()) stale.add(id);
+	});
+	let inflight = Promise.resolve();
+	const settling = /* @__PURE__ */ new Set();
+	let current;
+	let closed = false;
+	function enqueue(produce) {
+		if (closed) return Promise.reject(new ExecutionError("configuration", "Navigation is closed"));
+		const submittedGeneration = actions.generation;
+		const runCurrent = () => {
+			if (closed || submittedGeneration !== actions.generation) throw new ExecutionError("cancelled");
+			return produce();
+		};
+		const run = inflight.then(runCurrent, runCurrent);
+		settling.add(run);
+		run.then(() => settling.delete(run), () => settling.delete(run));
+		inflight = run.catch(() => {});
+		return run;
+	}
+	async function resolveTree(nextTree, signal, historyMode, refreshEntryId) {
+		const ownGeneration = actions.generation;
+		const check = () => {
+			if (signal?.aborted) {
+				options.execution?.cancel(signal.reason);
+				throw new ExecutionError("cancelled");
+			}
+			if (closed || ownGeneration !== actions.generation) throw new ExecutionError("cancelled");
+		};
+		const transaction = {
+			from: retryInitial ? {
+				tree: options.initial,
+				destinations: []
+			} : snapshot,
+			transitionId: generateUuid()
+		};
+		for (let redirects = 0;; redirects++) {
+			check();
+			const result = await resolveCandidate(nextTree, transaction, redirects === 0, signal, historyMode, refreshEntryId);
+			check();
+			if (!result.redirect) return result.snapshot;
+			if (redirects === 5) throw new ExecutionError("configuration", "Too many navigation redirects (maximum 5)");
+			const redirectedTree = await options.onRedirect?.(result.redirect, result.snapshot);
+			check();
+			if (!redirectedTree) return result.snapshot;
+			nextTree = redirectedTree;
+		}
+	}
+	async function resolveCandidate(nextTree, transaction, admission, signal, historyMode, refreshEntryId) {
+		const ownGeneration = actions.generation;
+		const ownInvalidation = invalidationVersion;
+		const ids = /* @__PURE__ */ new Set();
+		for (const dest of collectAllLeaves(nextTree)) {
+			if (ids.has(dest.entryId)) throw new Error(`Duplicate entry ID: ${dest.entryId}`);
+			ids.add(dest.entryId);
+		}
+		current = new AbortController();
+		const combined = signal ? AbortSignal.any([signal, current.signal]) : current.signal;
+		const execution = options.execution ?? web.createExecution({ signal: combined });
+		const unbind = bindExecutionCancellation(execution, combined);
+		const check = () => {
+			if (combined.aborted || execution.context.signal.aborted || ownGeneration !== actions.generation || ownInvalidation !== invalidationVersion) throw new ExecutionError("cancelled");
+		};
+		const executionState = execution.context.bindings[WEB_EXECUTION];
+		const prefetched = executionState.prefetched;
+		const stage = prefetched.stage();
+		executionState.prefetched = stage.cache;
+		const context = {
+			...transaction,
+			tree: nextTree,
+			execution: execution.context,
+			signal: execution.context.signal,
+			isServer: options.isServer ?? true
+		};
+		const reject = (result, candidate) => ({
+			snapshot: {
+				...candidate,
+				...result.kind === "deny" ? { rejection: result } : {},
+				...result.kind === "redirect" ? { redirect: {
+					url: result.url,
+					status: result.status
+				} } : {}
+			},
+			...result.kind === "redirect" ? { redirect: {
+				url: result.url,
+				status: result.status
+			} } : {}
+		});
+		const destinations = [];
+		const resolvedLeaves = /* @__PURE__ */ new Map();
+		let redirect;
+		try {
+			if (admission) for (const policy of beforeNavigate) {
+				check();
+				const result = await policy(context);
+				check();
+				if (!result || ![
+					"next",
+					"deny",
+					"redirect"
+				].includes(result.kind)) throw new ExecutionError("configuration", "Invalid beforeNavigate result");
+				if (result.kind !== "next") return reject(result, {
+					tree: nextTree,
+					destinations: [],
+					transitionId: transaction.transitionId,
+					historyMode
+				});
+			}
+			for (const dest of collectVisibleDestinations(nextTree)) {
+				check();
+				const key = resourceKey(dest.intent, dest.params, execution.context, dest.query);
+				const retained = retryInitial || dest.entryId === refreshEntryId || stale.has(dest.entryId) ? void 0 : entries.get(dest.entryId);
+				const result = await loadPage({
+					web,
+					target: dest,
+					execution,
+					signal: combined,
+					retained: retained?.resourceKey === key ? retained.page : void 0,
+					beforeLoad: options.beforeLoad,
+					afterLoad: options.afterLoad,
+					createContext: ({ url, intent, execution: active }) => {
+						return options.createContext?.({
+							execution: active.context,
+							intent: intent.id,
+							params: intent.params ?? {},
+							query: intent.query ?? {},
+							signal: combined,
+							url
+						}) ?? {
+							url,
+							path: new URL(url, "http://localhost").pathname,
+							params: intent.params ?? {},
+							query: intent.query ?? {},
+							intent,
+							isServer: options.isServer ?? true,
+							container: active.context.container,
+							getCookie: () => void 0,
+							getHeader: () => void 0
+						};
+					}
+				});
+				check();
+				if (result.kind === "page") resolvedLeaves.set(dest.entryId, result.rewriteUrl ? {
+					...result.target,
+					entryId: dest.entryId,
+					url: result.rewriteUrl
+				} : result.target);
+				if (result.kind === "redirect") redirect ??= result;
+				destinations.push({
+					...result.kind === "page" && result.match?.cache ? { cache: result.match.cache } : {},
+					...result.kind === "page" ? {
+						renderMode: result.match?.renderMode,
+						rewriteUrl: result.rewriteUrl
+					} : {},
+					entryId: dest.entryId,
+					resourceKey: result.kind === "page" ? resourceKey(result.target.intent, result.target.params, execution.context, result.target.query) : key,
+					intent: result.kind === "page" ? result.target.intent : dest.intent,
+					params: result.kind === "page" ? result.target.params : dest.params,
+					query: result.kind === "page" ? result.target.query : dest.query,
+					page: result.kind === "page" ? result.page : getErrorPage(result.status, result.kind === "deny" ? result.message : "Redirecting"),
+					...result.kind !== "page" ? { status: result.status } : {}
+				});
+			}
+			check();
+			const candidate = {
+				tree: mapNavigationLeaves(nextTree, (node) => resolvedLeaves.get(node.entryId) ?? node),
+				destinations,
+				transitionId: transaction.transitionId,
+				historyMode
+			};
+			if (redirect) return {
+				snapshot: candidate,
+				redirect: {
+					url: redirect.url,
+					status: redirect.status
+				}
+			};
+			if (destinations.some((dest) => dest.status !== void 0)) return { snapshot: candidate };
+			for (const policy of beforeCommit) {
+				check();
+				const result = await policy({
+					...context,
+					tree: candidate.tree,
+					candidate
+				});
+				check();
+				if (!result || !["next", "deny"].includes(result.kind)) throw new ExecutionError("configuration", "Invalid beforeCommit result: only next or deny is supported");
+				if (result.kind === "deny") return reject(result, candidate);
+			}
+			check();
+			stage.commit();
+			const previous = snapshot;
+			publish(candidate, ids);
+			for (const dest of destinations) stale.delete(dest.entryId);
+			const commitErrors = [];
+			for (const step of commitSteps) try {
+				step(snapshot, previous);
+			} catch (error) {
+				commitErrors.push(error);
+			}
+			notifyObservers(listeners, () => web.runtime.record("session.observer-error", { transitionId: snapshot.transitionId }), snapshot);
+			try {
+				await options.viewReady?.(snapshot, combined);
+				check();
+			} catch (error) {
+				commitErrors.push(error);
+			}
+			if (commitErrors.length) throw new NavigationCommitError(snapshot, commitErrors);
+			return { snapshot };
+		} finally {
+			executionState.prefetched = prefetched;
+			unbind();
+			if (!options.execution) await execution.dispose();
+		}
+	}
+	function publish(candidate, ids) {
+		if (retryInitial) {
+			entries.clear();
+			stale.clear();
+		}
+		retryInitial = false;
+		const visible = new Set(candidate.destinations.map((entry) => entry.entryId));
+		for (const [id, entry] of entries) if (!ids.has(id)) {
+			entries.delete(id);
+			stale.delete(id);
+		} else if (entry.visible && !visible.has(id)) entries.set(id, Object.freeze({
+			...entry,
+			visible: false
+		}));
+		for (const entry of candidate.destinations) {
+			const old = entries.get(entry.entryId);
+			if (!old || !old.visible || old.page !== entry.page || old.resourceKey !== entry.resourceKey || old.status !== entry.status || old.cache !== entry.cache || old.renderMode !== entry.renderMode || old.rewriteUrl !== entry.rewriteUrl) entries.set(entry.entryId, Object.freeze({
+				...entry,
+				visible: true
+			}));
+		}
+		presentIds = ids;
+		snapshot = Object.freeze({
+			...candidate,
+			revision: snapshot.revision + 1,
+			destinations: Object.freeze(candidate.destinations.map((entry) => entries.get(entry.entryId))),
+			entries: Object.freeze([...entries.values()]),
+			navigation: summarize(candidate.tree)
+		});
+	}
+	function computeNextTree(op) {
+		const tree = navigationTree();
+		switch (op.kind) {
+			case ACTION_KINDS.REUSE_ENTRY: return reuseEntry(tree, op.entryId);
+			case ACTION_KINDS.PUSH: return push(tree, leaf(op.intent, op.params, {
+				url: op.url,
+				query: op.query
+			}), op.target);
+			case ACTION_KINDS.POP: return pop(tree, op.count, op.target);
+			case ACTION_KINDS.POP_TO_ROOT: return popToRoot(tree, op.target);
+			case ACTION_KINDS.POP_TO: return popTo(tree, op.index, op.target);
+			case ACTION_KINDS.REPLACE_TOP: return replaceTop(tree, leaf(op.intent, op.params, {
+				url: op.url,
+				query: op.query
+			}), op.target);
+			case ACTION_KINDS.SELECT_TAB: return selectTab(tree, op.key, op.target);
+			case ACTION_KINDS.SELECT_COLUMN: return selectColumn(tree, op.columnId, op.intent === void 0 ? void 0 : leaf(op.intent, op.params, { query: op.query }), op.target);
+			case ACTION_KINDS.SET_VISIBILITY: return setVisibility(tree, op.visibility, op.target);
+			case ACTION_KINDS.HYDRATE: return op.tree;
+			case ACTION_KINDS.REFRESH: return tree;
+		}
+	}
+	function performTree(op, invocation) {
+		return enqueue(() => {
+			return resolveTree(computeNextTree(op), invocation?.signal, op.kind === "refresh" ? void 0 : op.kind === "replaceTop" ? "replace" : "push", op.kind === "refresh" ? findActiveLeaf(navigationTree())?.entryId : void 0);
+		});
+	}
+	for (const kind of TREE_ACTION_KINDS) actions.onAction(kind, performTree);
+	const session = Object.assign(actions, {
+		runtime: web.runtime,
+		commit(revision) {
+			if (revision === snapshot.revision) options.commit?.(revision);
+		},
+		captureNavigation: () => serializeNavigation(navigationTree()),
+		captureUrl: options.captureUrl,
+		presentKeys: () => presentIds.values(),
+		async restoreNavigation(navigation) {
+			if (navigation === void 0) return;
+			if (await session.perform({
+				kind: "hydrate",
+				tree: deserializeNavigation(navigation)
+			}) !== snapshot) throw new SessionError("navigation-uncommitted");
+		},
+		async start(invocation) {
+			if (snapshot.revision) throw new ExecutionError("configuration", "Web session already started");
+			const ownGeneration = actions.generation;
+			[locale, translator] = await Promise.all([web.getLocale(options.execution), web.getTranslator(options.execution)]);
+			if (closed || ownGeneration !== actions.generation || invocation?.signal?.aborted) throw new ExecutionError("cancelled");
+			const candidate = await enqueue(() => resolveTree(navigationTree(), invocation?.signal));
+			if (closed || ownGeneration !== actions.generation) throw new ExecutionError("cancelled");
+			if (candidate !== snapshot) {
+				let result = candidate;
+				if (candidate.rejection) {
+					const { status, message } = candidate.rejection;
+					const error = leaf("@finesoft/error");
+					result = {
+						tree: stack(error),
+						destinations: [{
+							...error,
+							resourceKey: resourceKey(error.intent, error.params),
+							page: getErrorPage(status, message),
+							status
+						}]
+					};
+				}
+				publish(result, new Set(collectAllLeaves(options.initial).map((entry) => entry.entryId)));
+				retryInitial = true;
+			}
+			return snapshot;
+		},
+		onCommit(listener) {
+			commitSteps.add(listener);
+			return () => {
+				commitSteps.delete(listener);
+			};
+		},
+		getTree() {
+			return navigationTree();
+		},
+		getSnapshot() {
+			return snapshot;
+		},
+		async dispose() {
+			closed = true;
+			actions.close();
+			current?.abort();
+			await Promise.allSettled(settling);
+			unsubscribeInvalidation();
+			listeners.clear();
+			commitSteps.clear();
+			entries.clear();
+			stale.clear();
+		},
+		cancel(invocation) {
+			cancelActions(invocation);
+			current?.abort();
+			inflight = Promise.resolve();
+		},
+		invalidate(entryKey) {
+			if (entryKey === void 0) for (const id of entries.keys()) stale.add(id);
+			else stale.add(entryKey);
+		},
+		subscribe(listener) {
+			listeners.add(listener);
+			return () => {
+				listeners.delete(listener);
+			};
+		}
+	});
+	Object.defineProperties(session, {
+		session: {
+			get: () => options.session?.(),
+			enumerable: true
+		},
+		locale: {
+			get: () => locale,
+			enumerable: true
+		},
+		translator: {
+			get: () => translator,
+			enumerable: true
+		}
+	});
+	return session;
+}
+/** 找到树中「激活路径」末端的 leaf；无（如空 stack/空 split）则返回 undefined。 */
+function findActiveLeaf(tree) {
+	const node = findNode(tree, resolveActivePath(tree));
+	if (node === void 0) return void 0;
+	return node.kind === "leaf" ? node : void 0;
+}
+/** State is already committed; observers and hosts must not report a pre-commit rejection. */
+var NavigationCommitError = class extends Error {
+	snapshot;
+	committed = true;
+	constructor(snapshot, causes) {
+		super("Navigation committed but host presentation failed", { cause: new AggregateError(causes) });
+		this.snapshot = snapshot;
+		this.name = "NavigationCommitError";
+	}
+};
+function summarize(tree) {
+	let node = tree;
+	let canGoBack = false;
+	let tabs;
+	while (node) {
+		if (node.kind === "leaf") return {
+			canGoBack,
+			tabs,
+			activeEntryId: node.entryId
+		};
+		if (node.kind === "stack") {
+			canGoBack ||= node.entries.length > 1;
+			node = node.entries.at(-1);
+		} else if (node.kind === "tabs") {
+			tabs = {
+				active: node.active,
+				order: node.order
+			};
+			node = node.branches[node.active];
+		} else node = visibleSplitColumns(node).at(-1)?.content;
+	}
+	return {
+		canGoBack,
+		tabs
+	};
+}
+//#endregion
+//#region ../web/src/session/snapshot.ts
+/**
+* Session — 快照编码 / 解码
+*
+* `encodeSnapshot` 用 `stableStringify` 产出确定性字符串（相同内容 → 相同输出，利于去重 / 对比）。
+* `decodeSnapshot` 做 `JSON.parse` + 结构校验 + 版本检查：任何异常（缺字段 / 类型错 / 版本不符 /
+* 畸形 JSON / `undefined`）一律返回 `undefined`，**绝不把异常抛进调用方** —— 旧态恢复失败不应崩应用。
+*/
+/** @internal Synchronously detach JSON state without freezing or invoking object codecs. */
+function cloneSnapshotValue(value) {
+	try {
+		return cloneValue(value, /* @__PURE__ */ new Set());
+	} catch {
+		throw new SessionError("invalid-snapshot-value");
+	}
+}
+function cloneValue(value, ancestors) {
+	if (value === void 0 || value === null || typeof value === "string" || typeof value === "boolean") return value;
+	if (typeof value === "number" && Number.isFinite(value)) return value;
+	if (typeof value !== "object" || value === null || ancestors.has(value)) throw new SessionError("invalid-snapshot-value");
+	if (!Array.isArray(value) && Object.getPrototypeOf(value) !== Object.prototype && Object.getPrototypeOf(value) !== null) throw new SessionError("invalid-snapshot-value");
+	ancestors.add(value);
+	try {
+		if (Array.isArray(value)) return Array.from(value, (item) => cloneValue(item, ancestors) ?? null);
+		const result = Object.create(null);
+		for (const key of Object.keys(value)) {
+			const item = cloneValue(value[key], ancestors);
+			if (item !== void 0) result[key] = item;
+		}
+		return result;
+	} finally {
+		ancestors.delete(value);
+	}
+}
+/** 把快照编码为确定性字符串（keys 排序），用作 `storage.set` 的值。 */
+function encodeSnapshot(snapshot) {
+	return stableStringify(snapshot);
+}
+/**
+* 解码并校验快照。
+*
+* 校验：`version === expectedVersion`、`slices`/`scoped` 为对象、`capturedAt` 为数值；
+* `navigation` 可缺省。任一不符或解析失败 → `undefined`（永不抛）。
+*/
+function decodeSnapshot(raw, expectedVersion) {
+	if (raw === void 0) return void 0;
+	let parsed;
+	try {
+		parsed = JSON.parse(raw);
+	} catch {
+		return;
+	}
+	if (!isPlainObject(parsed)) return void 0;
+	if (parsed.version !== expectedVersion) return void 0;
+	if (typeof parsed.capturedAt !== "number" || !Number.isFinite(parsed.capturedAt)) return void 0;
+	if (!isPlainObject(parsed.slices)) return void 0;
+	if (!isPlainObject(parsed.scoped)) return void 0;
+	if (Object.keys(parsed.scoped).some((key) => !key.trim())) return void 0;
+	if (parsed.url !== void 0 && typeof parsed.url !== "string") return void 0;
+	if (parsed.navigation !== void 0) {
+		const nav = parsed.navigation;
+		if (!isPlainObject(nav)) return void 0;
+		try {
+			deserializeNavigation(nav);
+		} catch {
+			return;
+		}
+	}
+	return parsed;
+}
+/** 普通对象判别（排除 null 与数组）。 */
+function isPlainObject(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+//#endregion
+//#region ../web/src/session/scoped-state.ts
+/**
+* Session — 导航作用域状态（SwiftUI push/pop 生命周期的核心）
+*
+* 状态按实际 EntryId 存入 Map；序列化/恢复保留该 ID，不由业务参数推导。每次导航提交后，框架按**树中实际存在的全部条目**
+* （注意「存在」而非「可见」）prune —— 身份不在树里的条目状态被丢弃，得到 SwiftUI `@State` 语义：
+*
+*   A → push B：present `{A, B}` → A 状态保留（仍在栈、只是不可见），B 拿到自己的作用域。
+*   pop B：present `{A}` → B 的作用域被 prune 丢弃，A 原样保留；返回 A 按保留态渲染。
+*   TabView 切 tab：其它分支仍在树中 → 其状态保留（与 SwiftUI tab 保活一致）。
+*
+* `collectLeafKeys` 收集树中**全部 leaf**（含不可见的栈底、未激活分支、各 split 列），
+* 区别于 `collectVisibleDestinations`（仅沿可见路径）—— 作用域保留需要全部 present 条目。
+*/
+/**
+* 收集导航树中**全部 leaf** 的身份键（含不可见 / 未激活分支 / 各 split 列）。
+* 委派给 `collectAllLeaves`（同一「全部存在」遍历），映射成 entryKey。
+* 「全部存在」而非「可见」，用于 scoped 状态保留。
+*/
+function collectLeafKeys(tree) {
+	return collectAllLeaves(tree).map((l) => l.entryId);
+}
+/**
+* 创建导航作用域状态容器。
+*
+* 内部持一个 `Map`；`prune` 由 `presentKeys` 构造 `Set`，删除不在其中的全部键。
+* `initial` 在构造时浅拷贝进 `Map`，构造后改动源对象不会泄漏进容器。
+*/
+function createNavigationScopedState(initial) {
+	const store = new Map(initial ? Object.entries(initial) : void 0);
+	return {
+		get(entryKey) {
+			return store.get(entryKey);
+		},
+		set(entryKey, data) {
+			if (!entryKey.trim()) throw new SessionError("invalid-entry-id");
+			store.set(entryKey, data);
+		},
+		delete(entryKey) {
+			store.delete(entryKey);
+		},
+		prune(presentKeys) {
+			const present = new Set(presentKeys);
+			for (const key of store.keys()) if (!present.has(key)) store.delete(key);
+		},
+		keys() {
+			return [...store.keys()];
+		}
+	};
+}
+//#endregion
+//#region ../web/src/session/session-store.ts
+/** One ordered persistence owner; implicit saves capture when their queue slot starts. */
+function createSessionStore(options) {
+	const { storage, key = SESSION_DEFAULT_KEY, version = 2, maxAgeMs, navigation, now = () => Date.now(), onError } = options;
+	const providers = /* @__PURE__ */ new Map();
+	let scope = createNavigationScopedState();
+	let queue = Promise.resolve();
+	let closed = false;
+	let queuedImplicit;
+	function report(ctx) {
+		try {
+			onError?.(new SessionError(ctx.code ?? "session-failed"), ctx);
+		} catch {}
+	}
+	function failure(cause, phase) {
+		const unavailable = cause instanceof StorageUnavailableError;
+		report({
+			phase,
+			code: unavailable ? "storage-unavailable" : "storage-failed"
+		});
+		return unavailable ? { status: "unavailable" } : {
+			status: "failed",
+			cause
+		};
+	}
+	function enqueue(work, implicit = false) {
+		if (closed) return Promise.resolve({ status: "closed" });
+		if (!implicit) queuedImplicit = void 0;
+		let slot;
+		const result = queue.then(async () => {
+			if (slot) {
+				slot.started = true;
+				if (queuedImplicit === slot) queuedImplicit = void 0;
+			}
+			return work();
+		});
+		queue = result.then(() => {}, () => {});
+		if (implicit) {
+			slot = {
+				result,
+				started: false
+			};
+			queuedImplicit = slot;
+		}
+		return result;
+	}
+	function capture() {
+		const slices = Object.create(null);
+		for (const provider of providers.values()) try {
+			slices[provider.key] = {
+				version: provider.version,
+				data: cloneSnapshotValue(provider.capture())
+			};
+		} catch {
+			report({
+				phase: "capture",
+				key: provider.key,
+				code: "slice-failed"
+			});
+		}
+		const scoped = cloneSnapshotValue(Object.fromEntries(scope.keys().map((id) => [id, scope.get(id)])));
+		return {
+			version,
+			navigation: cloneSnapshotValue(navigation?.captureNavigation()),
+			url: navigation?.captureUrl?.(),
+			slices,
+			scoped,
+			capturedAt: now()
+		};
+	}
+	async function read() {
+		try {
+			const raw = await storage.get(key);
+			if (raw === void 0) return { status: "missing" };
+			const snapshot = decodeSnapshot(raw, version);
+			if (!snapshot) return { status: "invalid" };
+			if (maxAgeMs !== void 0 && now() - snapshot.capturedAt > maxAgeMs) return { status: "expired" };
+			return {
+				status: "loaded",
+				snapshot
+			};
+		} catch (cause) {
+			return failure(cause, "load");
+		}
+	}
+	function persist(snapshot) {
+		if (closed) return Promise.resolve({ status: "closed" });
+		if (snapshot === void 0) {
+			if (queuedImplicit && !queuedImplicit.started) return queuedImplicit.result;
+			return enqueue(async () => {
+				try {
+					await storage.set(key, encodeSnapshot(capture()));
+					return { status: "saved" };
+				} catch (cause) {
+					return failure(cause, "persist");
+				}
+			}, true);
+		}
+		let admitted;
+		let rejected;
+		try {
+			admitted = encodeSnapshot(cloneSnapshotValue(snapshot));
+		} catch (cause) {
+			rejected = failure(cause, "persist");
+		}
+		return enqueue(async () => {
+			if (rejected) return rejected;
+			try {
+				await storage.set(key, admitted);
+				return { status: "saved" };
+			} catch (cause) {
+				return failure(cause, "persist");
+			}
+		});
+	}
+	return {
+		register(provider) {
+			if (closed) throw new SessionError("session-closed");
+			if (providers.has(provider.key)) throw new SessionError("duplicate-provider-key");
+			if (!provider.key || !Number.isInteger(provider.version) || provider.version < 1 || typeof provider.decode !== "function") throw new SessionError("invalid-provider-schema");
+			providers.set(provider.key, provider);
+			return () => {
+				if (providers.get(provider.key) === provider) providers.delete(provider.key);
+			};
+		},
+		get scope() {
+			return scope;
+		},
+		capture,
+		persist,
+		save: () => persist(),
+		load: () => enqueue(read),
+		restore(snapshot) {
+			return enqueue(async () => {
+				if (snapshot === void 0) {
+					const loaded = await read();
+					if (loaded.status !== "loaded") return loaded;
+					snapshot = loaded.snapshot;
+				}
+				let valid;
+				try {
+					valid = decodeSnapshot(encodeSnapshot(snapshot), version);
+				} catch {}
+				if (!valid) {
+					report({
+						phase: "restore",
+						code: "navigation-invalid"
+					});
+					return { status: "invalid" };
+				}
+				try {
+					await navigation?.restoreNavigation(valid.navigation);
+				} catch (cause) {
+					report({
+						phase: "restore",
+						code: "navigation-invalid"
+					});
+					return {
+						status: "failed",
+						cause
+					};
+				}
+				scope = createNavigationScopedState({ ...valid.scoped });
+				const discarded = [];
+				for (const provider of providers.values()) {
+					if (!Object.hasOwn(valid.slices, provider.key)) continue;
+					const slice = valid.slices[provider.key];
+					try {
+						if (!slice || !Number.isInteger(slice.version) || slice.version !== provider.version && !provider.migrate) {
+							discarded.push(provider.key);
+							report({
+								phase: "restore",
+								key: provider.key,
+								code: "slice-incompatible"
+							});
+							continue;
+						}
+						const data = slice.version === provider.version ? slice.data : provider.migrate(slice.data, slice.version);
+						await provider.restore(provider.decode(data));
+					} catch {
+						discarded.push(provider.key);
+						report({
+							phase: "restore",
+							key: provider.key,
+							code: "slice-failed"
+						});
+					}
+				}
+				return discarded.length ? {
+					status: "partial",
+					discarded
+				} : { status: "restored" };
+			});
+		},
+		clear: () => enqueue(async () => {
+			try {
+				await storage.delete(key);
+				return { status: "cleared" };
+			} catch (cause) {
+				return failure(cause, "clear");
+			}
+		}),
+		dispose() {
+			closed = true;
+			return queue;
+		}
+	};
+}
+//#endregion
+//#region ../web/src/application/runtime.ts
+const SERVICES = "@finesoft/web/services";
+var MissingWebServiceError = class extends ExecutionError {};
+function createWebRuntime(input) {
+	const config = {
+		...input.definition.configuration,
+		...input
+	};
+	const plan = getWebPlan(config.definition);
+	const prefetchedIntents = config.prefetchedIntents ?? PrefetchedIntents.empty();
+	let defaultTranslator;
+	const getTranslatorForLocale = (locale) => {
+		if (!locale) return void 0;
+		if (locale === config.locale) {
+			if (!defaultTranslator) {
+				const messages = config.messages && resolveMessages(config.messages, locale);
+				if (messages) defaultTranslator = new SimpleTranslator({
+					locale,
+					messages
+				});
+			}
+			return defaultTranslator;
+		}
+		const messages = config.messages && resolveMessages(config.messages, locale);
+		return messages ? new SimpleTranslator({
+			locale,
+			messages
+		}) : void 0;
+	};
+	let loggerFactory;
+	const getLoggerFactory = () => loggerFactory ??= config.reportCallback ? new CompositeLoggerFactory([new ConsoleLoggerFactory(config.logFilter), new ReportingLoggerFactory({ report: config.reportCallback })]) : new ConsoleLoggerFactory(config.logFilter);
+	let externalStorage;
+	const createMemoryStorage = () => {
+		const values = /* @__PURE__ */ new Map();
+		return {
+			get: (key) => values.get(key),
+			set: (key, value) => {
+				values.set(key, value);
+			},
+			delete: (key) => {
+				values.delete(key);
+			}
+		};
+	};
+	const getExternalStorage = () => externalStorage ??= createMemoryStorage();
+	function createDefaultProviders(scopeFallback = false) {
+		const defaultLifetime = scopeFallback ? "scope" : "runtime";
+		const storageLifetime = scopeFallback || config.storageScope === "execution" ? "scope" : "runtime";
+		return [
+			provide({
+				token: DEP_KEYS.LOGGER_FACTORY,
+				lifetime: defaultLifetime,
+				create: getLoggerFactory
+			}),
+			provide({
+				token: DEP_KEYS.LOGGER,
+				lifetime: defaultLifetime,
+				dependencies: [DEP_KEYS.LOGGER_FACTORY],
+				create: async (c) => (await c.get(DEP_KEYS.LOGGER_FACTORY)).loggerFor("web")
+			}),
+			provide({
+				token: DEP_KEYS.FETCH,
+				lifetime: "scope",
+				create: (c) => c.bindings[SERVICES].fetch
+			}),
+			provide({
+				token: DEP_KEYS.SAFE_FETCH,
+				lifetime: "scope",
+				dependencies: [DEP_KEYS.FETCH],
+				create: async (c) => secureFetch(await c.get(DEP_KEYS.FETCH), c.bindings[SERVICES].safeFetch)
+			}),
+			provide({
+				token: DEP_KEYS.LOCALE,
+				lifetime: "scope",
+				create: (c) => {
+					const value = c.bindings[SERVICES].locale;
+					if (!value) throw new MissingWebServiceError("configuration", "Locale is not configured");
+					return value;
+				}
+			}),
+			provide({
+				token: DEP_KEYS.TRANSLATOR,
+				lifetime: "scope",
+				create: (c) => {
+					const value = c.bindings[SERVICES].translator;
+					if (!value) throw new MissingWebServiceError("configuration", "Messages are not configured");
+					return value;
+				}
+			}),
+			provide({
+				token: DEP_KEYS.PLATFORM,
+				lifetime: defaultLifetime,
+				create: () => {
+					return config.platform ?? detectPlatform();
+				}
+			}),
+			provide({
+				token: DEP_KEYS.EVENT_RECORDER,
+				lifetime: defaultLifetime,
+				create: () => scopeFallback && config.eventRecorder ? config.eventRecorder : { record: (type, fields) => runtime.record(type, fields) }
+			}),
+			provide({
+				token: DEP_KEYS.STORAGE,
+				lifetime: storageLifetime,
+				create: () => {
+					if (scopeFallback && config.storageScope !== "execution") return getExternalStorage();
+					return createMemoryStorage();
+				}
+			}),
+			provide({
+				token: DEP_KEYS.FEATURE_FLAGS,
+				lifetime: defaultLifetime,
+				create: () => {
+					const providers = [...config.featureFlagsProviders ?? []].reverse();
+					return {
+						isEnabled: (key) => providers.some((p) => p.isEnabled(key)) || config.featureFlags?.[key] === true,
+						getString: (key) => {
+							for (const provider of providers) {
+								const value = provider.getString?.(key);
+								if (value !== void 0) return value;
+							}
+							const value = config.featureFlags?.[key];
+							return typeof value === "string" ? value : void 0;
+						},
+						getNumber: (key) => {
+							for (const provider of providers) {
+								const value = provider.getNumber?.(key);
+								if (value !== void 0) return value;
+							}
+							const value = config.featureFlags?.[key];
+							return typeof value === "number" ? value : void 0;
+						}
+					};
+				}
+			})
+		];
+	}
+	function createOwnedRuntime() {
+		const defaults = createDefaultProviders();
+		const supplied = new Set([...plan.app.providers ?? [], ...(plan.app.modules ?? []).flatMap((m) => m.providers ?? [])].map((p) => p.token));
+		return createRuntime({
+			app: defineApp({
+				...plan.app,
+				providers: [...defaults.filter((p) => !supplied.has(p.token)), ...plan.app.providers ?? []]
+			}),
+			capabilities: { fetch: config.fetch ?? globalThis.fetch?.bind(globalThis) },
+			invocationCapabilities: ["fetch"],
+			recorder: config.eventRecorder
+		});
+	}
+	const runtime = config.runtime ?? createOwnedRuntime();
+	const externalDefaultProviders = config.runtime ? createDefaultProviders(true) : [];
+	const active = /* @__PURE__ */ new Set();
+	let closed = false, disposing;
+	let viewExecution;
+	const serviceContext = (execution) => (execution ?? (viewExecution ??= web.createExecution())).context;
+	async function optionalService(token, execution) {
+		try {
+			return await serviceContext(execution).get(token);
+		} catch (error) {
+			if (!(error instanceof MissingWebServiceError)) throw error;
+			return;
+		}
+	}
+	const web = {
+		definition: config.definition,
+		router: plan.router,
+		runtime,
+		prefetchedIntents,
+		getLocale: (execution) => optionalService(DEP_KEYS.LOCALE, execution),
+		getTranslator: (execution) => optionalService(DEP_KEYS.TRANSLATOR, execution),
+		getLogger: (execution) => serviceContext(execution).get(DEP_KEYS.LOGGER),
+		createExecution(invocation = {}) {
+			if (closed) throw new ExecutionError("configuration", "Web runtime is closed");
+			const base = config.invocation;
+			const signals = [base?.signal, invocation.signal].filter((s) => !!s);
+			const services = {};
+			const execution = runtime.createExecution({
+				...base,
+				...invocation,
+				signal: signals.length ? AbortSignal.any(signals) : void 0,
+				locale: invocation.locale ?? base?.locale ?? config.locale,
+				fetch: invocation.fetch ?? base?.fetch ?? config.fetch,
+				bindings: {
+					...base?.bindings,
+					...invocation.bindings,
+					[SERVICES]: services,
+					[WEB_EXECUTION]: {
+						prefetched: prefetchedIntents,
+						retained: /* @__PURE__ */ new WeakMap(),
+						entryIds: /* @__PURE__ */ new WeakMap(),
+						contexts: /* @__PURE__ */ new WeakMap()
+					}
+				}
+			});
+			for (const provider of externalDefaultProviders) if (!execution.context.container.hasProvider(provider.token)) execution.context.container.registerProvider(provider);
+			services.fetch = execution.context.fetch;
+			services.locale = execution.context.locale ? (execution.context.locale === config.locale ? config.localeAttributes : void 0) ?? getLocaleAttributes(execution.context.locale) : void 0;
+			Object.defineProperty(services, "translator", { get: () => getTranslatorForLocale(execution.context.locale) });
+			services.safeFetch = config.safeFetch;
+			const dispose = execution.dispose.bind(execution);
+			execution.dispose = async () => {
+				try {
+					await dispose();
+				} finally {
+					active.delete(execution);
+				}
+			};
+			active.add(execution);
+			return execution;
+		},
+		dispose() {
+			closed = true;
+			return disposing ??= (async () => {
+				const results = await Promise.allSettled([...active].map((e) => e.dispose()));
+				if (!config.runtime) results.push(...await Promise.allSettled([runtime.dispose()]));
+				const errors = results.filter((r) => r.status === "rejected").map((r) => r.reason);
+				if (errors.length) throw new AggregateError(errors, "Web cleanup failed");
+			})();
+		}
+	};
+	return web;
+}
+//#endregion
+//#region ../web/src/application/initial-navigation.ts
+/** Resolve and validate once, then let an application arrange typed targets. */
+async function resolveInitialNavigation(web, url, options = {}) {
+	const overlay = (options.codec ?? web.definition.navigationCodec ?? createActiveLeafCodec()).decode(url, web.router);
+	const match = await web.router.resolve(url);
+	const target = match ? leaf(match.intent.id, match.intent.params, {
+		url,
+		query: match.intent.query
+	}) : void 0;
+	const initial = options.initial ?? web.definition.navigation;
+	const arranged = typeof initial === "function" ? initial({
+		url,
+		match: match ?? void 0,
+		target
+	}) : initial;
+	const tree = overlay ?? arranged ?? (target && stack(target));
+	if (!tree) return void 0;
+	return {
+		tree: deserializeNavigation(serializeNavigation(tree)),
+		renderMode: match?.renderMode
+	};
+}
+//#endregion
+//#region ../web/src/application/page.ts
+function definePage(input) {
+	return Object.freeze({
+		...input,
+		route: ((path, options) => route(path, {
+			...options,
+			intentId: input.id
+		})),
+		leaf: (params = {}, options = {}) => leaf(input.id, params, options),
+		bindView: (pageType, view) => Object.freeze({ [pageType]: view })
+	});
+}
+//#endregion
+//#region ../web/src/middleware/cookies.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;
+}
+//#endregion
+export { isLeafNode as $, createActiveLeafCodec as A, getTextDirection as At, findNode as B, fetchWithRedirects as Bt, runBeforeLoadGuards as C, defineModule as Ct, SERVER_REQUEST as D, SimpleTranslator as Dt, SERVER_CONTROLLER as E, implementOperation as Et, serializeNavigation as F, interpolate as Ft, push as G, ConsoleLogger as Gt, pop as H, stableStringify as Ht, serializeNavigationStable as I, resolvePluralKey as It, selectColumn as J, CompositeLoggerFactory as Jt, replaceTop as K, ConsoleLoggerFactory as Kt, collectAllLeaves as L, generateUuid as Lt, decodeNavigationTreeParam as M, makeLocaleInfo as Mt, encodeNavigationTreeParam as N, resolveLocaleFromUrl as Nt, controllerContext as O, resolveMessages as Ot, deserializeNavigation as P, englishPlural as Pt, resourceKey as Q, collectVisibleDestinations as R, detectPlatform as Rt, runAfterLoadGuards as S, defineApp as St, getWebPlan as T, implementController as Tt, popTo as U, ReportingLogger as Ut, mapNavigationLeaves as V, enforceHostGuard as Vt, popToRoot as W, ReportingLoggerFactory as Wt, setVisibility as X, list as Xt, selectTab as Y, isMultiValueSchema as Yt, visibleSplitColumns as Z, Container as Zt, SERVER_CONTROLLER_PATH as _, isFlowAction as _t, createSessionStore as a, stack as at, decodeWireEnvelope as b, provide as bt, decodeSnapshot as c, NavigationError as ct, createWebSession as d, PrefetchedIntents as dt, isSplitNode as et, SESSION_DEFAULT_KEY as f, Router as ft, loadPage as g, isExternalUrlAction as gt, StorageUnavailableError as h, isCompoundAction as ht, createWebRuntime as i, split as it, createFullStateCodec as j, isRtl as jt, DEFAULT_NAV_PARAM as k, getLocaleAttributes as kt, encodeSnapshot as l, SPLIT_VISIBILITIES as lt, SessionError as m, ACTION_KINDS as mt, definePage as n, isTabsNode as nt, collectLeafKeys as o, tabs as ot, SESSION_DEFAULT_VERSION as p, ActionDispatcher as pt, resolveActivePath as q, CompositeLogger as qt, resolveInitialNavigation as r, leaf as rt, createNavigationScopedState as s, NAVIGATION_NODE_KINDS as st, parseCookieString as t, isStackNode as tt, NavigationCommitError as u, route as ut, ServerControllerProxy as v, makeExternalUrlAction as vt, defineWebApp as w, defineOperation as wt, getFrameworkBuildId as x, createRuntime as xt, FRAMEWORK_PROTOCOL_VERSION as y, makeFlowAction as yt, findNearestStack as z, secureFetch as zt };
+
+//# sourceMappingURL=src-qwx7Vw8g.mjs.map