@finesoft/front 0.5.1 → 0.5.3

package/dist/browser-CR5vhgXg.mjs

@@ -0,0 +1,1317 @@
+import { A as createActiveLeafCodec, F as serializeNavigation, P as deserializeNavigation, R as collectVisibleDestinations, Rt as generateUuid, V as mapNavigationLeaves, a as createSessionStore, at as stack, b as decodeWireEnvelope, d as createWebSession, dt as createHydrationDigest, ft as PrefetchedIntents, h as StorageUnavailableError, ht as ACTION_KINDS, i as createWebRuntime, r as resolveInitialNavigation, rt as leaf, t as parseCookieString, zt as detectPlatform } from "./src-BQBfaaPO.mjs";
+import { n as ExecutionError } from "./path-CGFl2w7D.mjs";
+import { t as resolveConfiguredMessages } from "./messages-CAt2QdGr.mjs";
+import { t as LruMap } from "./lru-map-BKoUAySU.mjs";
+import "./src-Ftl_0rhu.mjs";
+//#region ../browser/src/utils/try-scroll.ts
+const MAX_WAIT_MS = 5e3;
+const POLL_INTERVAL_MS = 100;
+const SCROLL_TOLERANCE = 2;
+let pendingCleanup = null;
+function cancelTryScroll() {
+	pendingCleanup?.();
+}
+function tryScroll(log, getScrollableElement, scrollY) {
+	cancelTryScroll();
+	const target = Math.max(0, scrollY);
+	const startedAt = Date.now();
+	let disposed = false;
+	let pendingFrame = null;
+	let intervalId = null;
+	let timeoutId = null;
+	let mutationObserver = null;
+	pendingCleanup = cleanup;
+	observeDocumentActivity();
+	document.addEventListener("load", scheduleAttempt, true);
+	intervalId = setInterval(scheduleAttempt, POLL_INTERVAL_MS);
+	timeoutId = setTimeout(scheduleAttempt, MAX_WAIT_MS);
+	scheduleAttempt();
+	function scheduleAttempt() {
+		if (disposed || pendingFrame !== null) return;
+		pendingFrame = requestAnimationFrame(() => {
+			pendingFrame = null;
+			attemptRestore();
+		});
+	}
+	function attemptRestore() {
+		if (disposed) return;
+		const elapsedMs = Date.now() - startedAt;
+		const element = getScrollableElement();
+		if (!element) {
+			if (elapsedMs >= MAX_WAIT_MS) {
+				log.warn("tryScroll: timed out waiting for the scrollable element", {
+					target,
+					elapsedMs
+				});
+				cleanup();
+			}
+			return;
+		}
+		element.scrollTop = target;
+		const actual = element.scrollTop;
+		if (actual >= target - SCROLL_TOLERANCE) {
+			log.info("scroll restored", {
+				target,
+				actual,
+				elapsedMs
+			});
+			cleanup();
+			return;
+		}
+		if (elapsedMs >= MAX_WAIT_MS) {
+			log.warn("tryScroll: timed out before reaching the target", {
+				target,
+				actual,
+				elapsedMs,
+				scrollHeight: element.scrollHeight,
+				clientHeight: element.clientHeight
+			});
+			cleanup();
+		}
+	}
+	function observeDocumentActivity() {
+		if (typeof MutationObserver === "undefined") return;
+		const root = document.body ?? document.documentElement;
+		if (!root) return;
+		mutationObserver = new MutationObserver(() => {
+			scheduleAttempt();
+		});
+		mutationObserver.observe(root, {
+			childList: true,
+			subtree: true
+		});
+	}
+	function cleanup() {
+		if (disposed) return;
+		disposed = true;
+		if (pendingCleanup === cleanup) pendingCleanup = null;
+		if (pendingFrame !== null) {
+			cancelAnimationFrame(pendingFrame);
+			pendingFrame = null;
+		}
+		if (intervalId !== null) {
+			clearInterval(intervalId);
+			intervalId = null;
+		}
+		if (timeoutId !== null) {
+			clearTimeout(timeoutId);
+			timeoutId = null;
+		}
+		mutationObserver?.disconnect();
+		mutationObserver = null;
+		document.removeEventListener("load", scheduleAttempt, true);
+	}
+}
+//#endregion
+//#region ../browser/src/utils/history.ts
+const HISTORY_SIZE_LIMIT = 10;
+function ownedPosition(state) {
+	const value = state?.__finesoftHistory;
+	return value && typeof value.owner === "string" && value.owner.length > 0 && Number.isSafeInteger(value.position) ? value : void 0;
+}
+var History = class {
+	entries;
+	log;
+	getScrollablePageElement;
+	persistInHistoryState;
+	currentStateId;
+	popstateSequence = 0;
+	positions = /* @__PURE__ */ new Map();
+	position = 0;
+	owner;
+	positionKnown = true;
+	committedStateId;
+	compensation;
+	cleanups = [];
+	dispose() {
+		this.popstateSequence++;
+		cancelTryScroll();
+		this.compensation = void 0;
+		this.positions.clear();
+		for (const cleanup of this.cleanups.splice(0)) cleanup();
+	}
+	constructor(log, options, sizeLimit = HISTORY_SIZE_LIMIT) {
+		this.entries = new LruMap(sizeLimit);
+		const native = window.history.state;
+		const position = ownedPosition(native);
+		this.owner = position?.owner;
+		if (position && typeof native?.id === "string") {
+			this.position = position.position;
+			this.currentStateId = this.committedStateId = native.id;
+			this.positions.set(native.id, position.position);
+		}
+		this.log = log;
+		this.getScrollablePageElement = options.getScrollablePageElement;
+		this.persistInHistoryState = options.persistInHistoryState ?? false;
+	}
+	/** 写入 window.history.state 的载荷：persist 时连 state 一起带（跨刷新保留）。 */
+	historyState(id, state) {
+		return {
+			id,
+			...this.persistInHistoryState && state !== void 0 ? { state } : {},
+			__finesoftHistory: {
+				owner: this.owner ??= id,
+				position: this.positions.get(id) ?? this.position
+			}
+		};
+	}
+	replaceState(state, url) {
+		const id = this.write("replaceState", url, {
+			state,
+			scrollY: 0
+		});
+		this.log.info("replaceState", state, url, id);
+	}
+	pushState(state, url) {
+		const id = this.write("pushState", url, {
+			state,
+			scrollY: 0
+		});
+		this.log.info("pushState", state, url, id);
+	}
+	write(method, url, entry) {
+		cancelTryScroll();
+		const id = generateUuid();
+		this.recordWrite(id, method === "pushState");
+		window.history[method](this.historyState(id, entry?.state), "", url);
+		this.currentStateId = id;
+		if (entry) this.entries.set(id, entry);
+		this.scrollTop = 0;
+		return id;
+	}
+	recordWrite(id, push) {
+		this.popstateSequence++;
+		if (!this.positionKnown) {
+			this.positions.clear();
+			this.owner = void 0;
+			this.position = 0;
+			this.positionKnown = true;
+		}
+		if (push) {
+			for (const [key, position] of this.positions) if (position > this.position) this.positions.delete(key);
+			this.position++;
+		}
+		this.positions.set(id, this.position);
+		this.committedStateId = id;
+	}
+	compensate(targetId, sequence) {
+		if (sequence !== this.popstateSequence || this.currentStateId !== targetId) return;
+		const committed = this.committedStateId;
+		const targetPosition = targetId && this.positions.get(targetId);
+		const committedPosition = committed && this.positions.get(committed);
+		if (!committed || typeof targetPosition !== "number" || typeof committedPosition !== "number") {
+			this.log.warn("Cannot compensate rejected navigation to an entry outside this History owner");
+			return;
+		}
+		const distance = committedPosition - targetPosition;
+		if (!distance) return;
+		this.compensation = { targetId: committed };
+		window.history.go(distance);
+	}
+	beforeTransition() {
+		cancelTryScroll();
+		const { state } = window.history;
+		if (!state) return;
+		this.saveScrollPosition(this.currentStateId === this.committedStateId ? state.id : this.committedStateId);
+	}
+	saveScrollPosition(stateId) {
+		if (!stateId) return;
+		const oldEntry = this.entries.get(stateId);
+		if (!oldEntry) {
+			this.log.info("current history state evicted from LRU, not saving scroll position");
+			return;
+		}
+		const { scrollTop } = this;
+		this.entries.set(stateId, {
+			...oldEntry,
+			scrollY: scrollTop
+		});
+		this.log.info("saving scroll position", scrollTop);
+	}
+	onPopState(listener) {
+		const handler = (event) => {
+			cancelTryScroll();
+			const targetStateId = event.state?.id;
+			const sequence = ++this.popstateSequence;
+			if (this.currentStateId === this.committedStateId) this.saveScrollPosition(this.currentStateId);
+			this.currentStateId = targetStateId;
+			const nativePosition = ownedPosition(event.state);
+			if (nativePosition && nativePosition.owner === this.owner && typeof targetStateId === "string") this.positions.set(targetStateId, nativePosition.position);
+			const targetPosition = this.positions.get(targetStateId);
+			this.positionKnown = targetPosition !== void 0;
+			if (targetPosition !== void 0) this.position = targetPosition;
+			if (this.compensation && this.compensation.targetId === targetStateId) {
+				this.compensation = void 0;
+				if (targetStateId !== this.committedStateId) {
+					this.compensate(targetStateId, sequence);
+					return;
+				}
+				const retained = this.entries.get(targetStateId);
+				if (retained) tryScroll(this.log, () => this.getScrollablePageElement(), retained.scrollY);
+				return;
+			}
+			if (!this.currentStateId) this.log.warn("encountered a null event.state.id in onPopState event:", window.location.href);
+			this.log.info("popstate", this.entries, this.currentStateId);
+			const entry = this.currentStateId ? this.entries.get(this.currentStateId) : void 0;
+			const embedded = this.persistInHistoryState ? event.state?.state : void 0;
+			const cachedState = entry?.state ?? embedded;
+			let navigation;
+			try {
+				navigation = listener(window.location.href, cachedState);
+			} catch (error) {
+				this.log.error("onPopState listener error:", error);
+				this.compensate(targetStateId, sequence);
+				return;
+			}
+			Promise.resolve(navigation).then(() => {
+				if (sequence !== this.popstateSequence || this.currentStateId !== targetStateId) return;
+				this.committedStateId = targetStateId;
+				if (!entry) return;
+				const { scrollY } = entry;
+				this.log.info("restoring scroll to", scrollY);
+				tryScroll(this.log, () => this.getScrollablePageElement(), scrollY);
+			}, (error) => {
+				this.log.error("onPopState listener error:", error);
+				this.compensate(targetStateId, sequence);
+			});
+		};
+		window.addEventListener("popstate", handler);
+		this.cleanups.push(() => window.removeEventListener("popstate", handler));
+	}
+	/** 仅推入 URL，不缓存页面状态（用于页面加载失败场景） */
+	pushUrl(url) {
+		const id = this.write("pushState", url);
+		this.log.info("pushUrl (no state)", url, id);
+	}
+	/** 仅替换 URL，不缓存页面状态（用于页面加载失败场景） */
+	replaceUrl(url) {
+		const id = this.write("replaceState", url);
+		this.log.info("replaceUrl (no state)", url, id);
+	}
+	updateState(update, url) {
+		if (!this.currentStateId) {
+			this.log.warn("failed: encountered a null currentStateId inside updateState");
+			return;
+		}
+		const currentState = this.entries.get(this.currentStateId);
+		const newState = update(currentState?.state);
+		this.log.info("updateState", newState, this.currentStateId);
+		this.entries.set(this.currentStateId, {
+			scrollY: currentState?.scrollY ?? 0,
+			state: newState
+		});
+		if (url !== void 0 || this.persistInHistoryState) window.history.replaceState(this.historyState(this.currentStateId, newState), "", url);
+	}
+	get scrollTop() {
+		return this.getScrollablePageElement()?.scrollTop || 0;
+	}
+	set scrollTop(scrollTop) {
+		const element = this.getScrollablePageElement();
+		if (element) element.scrollTop = scrollTop;
+	}
+};
+//#endregion
+//#region ../browser/src/navigation-bridge.ts
+/** 默认可滚动元素查找（与 FlowAction handler 一致）。 */
+function defaultGetScrollable() {
+	return document.getElementById("scrollable-page-override") || document.getElementById("scrollable-page") || document.documentElement;
+}
+/**
+* 创建 NavigationBridge：订阅 controller、装配 popstate、返回历史绑定。
+*
+* 调用后 bridge 已激活（已订阅 controller + 已注册 popstate listener）。应用应在调用前/后
+* 调一次 `controller.start()` 完成首屏解析；首屏的快照提交会被 bridge 用 `replaceState`
+* 写入 history（first-page 语义），不会污染历史栈。
+*/
+function createNavigationBridge(deps) {
+	const { controller, codec, router, log } = deps;
+	const history = new History(log, {
+		getScrollablePageElement: deps.getScrollablePageElement ?? defaultGetScrollable,
+		persistInHistoryState: true
+	});
+	let isApplyingHistory = false;
+	let isFirstSnapshot = true;
+	let lastEntryId;
+	let popSequence = 0;
+	const unsubscribe = controller.onCommit((snapshot) => {
+		if (isApplyingHistory) return;
+		++popSequence;
+		const url = codec.encode(snapshot.tree, router);
+		const state = { tree: serializeNavigation(snapshot.tree) };
+		const entryId = snapshot.destinations.at(-1)?.entryId;
+		const shouldReplace = isFirstSnapshot || snapshot.historyMode === "replace" || snapshot.historyMode !== "push" && entryId !== void 0 && entryId === lastEntryId;
+		lastEntryId = entryId;
+		history.beforeTransition();
+		if (shouldReplace) history.replaceState(state, url);
+		else history.pushState(state, url);
+		isFirstSnapshot = false;
+		log.debug(`[navigation] snapshot → ${shouldReplace ? "replace" : "push"} ${url}`);
+	});
+	history.onPopState(async (url, cachedState) => {
+		log.debug(`[navigation] popstate → ${url}, cached=${!!cachedState}`);
+		const pop = ++popSequence;
+		deps.onPopStart?.();
+		controller.cancel?.();
+		isApplyingHistory = false;
+		const tree = restoreTree(url, cachedState) ?? await deps.resolveUrl?.(url);
+		if (pop !== popSequence) return;
+		if (tree === void 0) {
+			log.warn(`[navigation] popstate: cannot restore tree for ${url}, keeping current`);
+			throw Error(`Cannot restore navigation for ${url}`);
+		}
+		isApplyingHistory = true;
+		try {
+			const result = await controller.perform({
+				kind: "hydrate",
+				tree
+			});
+			if (result !== controller.getSnapshot()) throw Error(`Navigation rejected for ${url}`);
+			await deps.viewReady?.();
+			if (pop !== popSequence) return;
+			const canonical = codec.encode(result.tree, router);
+			if (new URL(canonical, window.location.origin).href !== new URL(url, window.location.origin).href) history.updateState(() => ({ tree: serializeNavigation(result.tree) }), canonical);
+			lastEntryId = result.destinations.at(-1)?.entryId;
+		} finally {
+			if (pop === popSequence) isApplyingHistory = false;
+		}
+	});
+	/** 还原整棵树：优先 history 缓存（反序列化），未命中回退 codec.decode。 */
+	function restoreTree(url, cachedState) {
+		if (cachedState !== void 0) try {
+			return deserializeNavigation(cachedState.tree);
+		} catch (error) {
+			log.warn("[navigation] cached tree deserialize failed, falling back to codec", error);
+		}
+		try {
+			return codec.decode(url, router);
+		} catch (error) {
+			log.error("[navigation] codec.decode failed:", error);
+			return;
+		}
+	}
+	return { dispose() {
+		unsubscribe();
+		history.dispose();
+	} };
+}
+//#endregion
+//#region ../browser/src/server-data.ts
+function deserializeServerData(source) {
+	const script = source.script;
+	if (!script?.textContent) return {
+		status: "fresh-load",
+		code: "missing"
+	};
+	script.parentNode?.removeChild(script);
+	let value;
+	try {
+		value = JSON.parse(script.textContent);
+	} catch {
+		return {
+			status: "fresh-load",
+			code: "invalid-json"
+		};
+	}
+	return decodeWireEnvelope(value, source.buildId);
+}
+function createPrefetchedIntentsFromDom(source) {
+	const result = deserializeServerData(source);
+	if (result.status === "ready") return PrefetchedIntents.fromArray(result.data.pages);
+	source.onFallback?.(result.code);
+	return PrefetchedIntents.empty();
+}
+//#endregion
+//#region ../browser/src/session-bridge.ts
+/** 导航变更后自动落盘的默认防抖窗口（ms）：合并连续导航，避免每跳一屏写一次。 */
+const SESSION_DEFAULT_DEBOUNCE_MS = 500;
+/** 剥离 query / hash，仅取路径部分（用于「根入口」判定）。 */
+function pathOf(url) {
+	const cut = [url.indexOf("?"), url.indexOf("#")].filter((i) => i >= 0);
+	return cut.length > 0 ? url.slice(0, Math.min(...cut)) : url;
+}
+/**
+* 默认恢复门控策略（精确、无歧义，遵循「显式深链优先」）。
+*
+* - **带可比 URL**（快照含 `url` —— 扁平天然有，结构化由适配器在 capture 时记录浏览器
+*   `location`）：当且仅当 `currentUrl` 全等 `snapshot.url`，**或** `currentUrl` 路径为根 `/`
+*   （重载同深链 / 全新进入 → 恢复；改去别的深链 → 跳过，显式深链不被旧会话覆盖）。
+*   这让结构化导航与扁平**对称**：重载 `/item/1` 即恢复其作用域状态。
+* - **回退（无 `url`）**：适配器不提供 URL 时只在根 `/` 放行。
+* - **无 `navigation`**（仅切片）：总恢复（与 URL 无关）。
+*
+* 「根」判定为路径 `=== "/"`（剥离 query/hash）；带 base path 的应用应覆盖 `shouldRestore`。
+*/
+function defaultShouldRestore(snapshot, currentUrl) {
+	if (snapshot.navigation === void 0) return true;
+	const atRoot = pathOf(currentUrl) === "/";
+	if (snapshot.url !== void 0) return currentUrl === snapshot.url || atRoot;
+	return atRoot;
+}
+/**
+* 创建 SessionBridge：订阅导航、装配生命周期监听、返回会话句柄。
+*
+* 调用后 bridge 已激活（已订阅导航 + 已注册 `pagehide` / `visibilitychange`）。应用应在
+* 首次导航完成后调一次 `restoreFromUrl(initialUrl)` 完成 boot 恢复。
+*/
+function createSessionBridge(options) {
+	const { store, navigation, subscribeNavigation } = options;
+	const clear = store.clear.bind(store), dispose = store.dispose.bind(store);
+	const debounceMs = options.debounceMs ?? 500;
+	const shouldRestore = options.shouldRestore ?? defaultShouldRestore;
+	let disposed;
+	let restoring = options.deferPersistenceUntilRestore ?? false;
+	let timer;
+	function cancelTimer() {
+		if (timer !== void 0) {
+			clearTimeout(timer);
+			timer = void 0;
+		}
+	}
+	/** 立即落盘并取消挂起的防抖（生命周期事件用）。 */
+	function flush() {
+		if (disposed || restoring) return;
+		cancelTimer();
+		store.save();
+	}
+	/** 导航变更：先 prune 离树作用域，再防抖落盘。 */
+	function onNavigationChange() {
+		if (disposed || restoring) return;
+		store.scope.prune(navigation.presentKeys());
+		cancelTimer();
+		timer = setTimeout(() => {
+			timer = void 0;
+			store.save();
+		}, debounceMs);
+	}
+	/** `visibilitychange`：仅在隐藏时落盘（切后台 / 回收前抓末态）。 */
+	function onVisibilityChange() {
+		if (document.visibilityState === "hidden") flush();
+	}
+	const unsubscribeNavigation = subscribeNavigation?.(onNavigationChange);
+	window.addEventListener("pagehide", flush);
+	document.addEventListener("visibilitychange", onVisibilityChange);
+	return Object.assign(store, {
+		async restoreFromUrl(currentUrl) {
+			if (disposed) return { status: "closed" };
+			restoring = true;
+			cancelTimer();
+			try {
+				const loaded = await store.load();
+				if (disposed) return { status: "closed" };
+				if (loaded.status !== "loaded") return loaded;
+				if (!shouldRestore(loaded.snapshot, currentUrl)) return { status: "skipped" };
+				return await store.restore(loaded.snapshot);
+			} finally {
+				restoring = false;
+			}
+		},
+		clear() {
+			cancelTimer();
+			return clear();
+		},
+		dispose() {
+			if (disposed) return disposed;
+			if (!restoring) flush();
+			cancelTimer();
+			unsubscribeNavigation?.();
+			window.removeEventListener("pagehide", flush);
+			document.removeEventListener("visibilitychange", onVisibilityChange);
+			disposed = dispose();
+			return disposed;
+		}
+	});
+}
+//#endregion
+//#region ../browser/src/web-storage.ts
+/** Rejections remain observable by the session owner; unavailable is never a successful no-op. */
+function createWebStorage(kind) {
+	function area() {
+		try {
+			const storage = kind === "session" ? window.sessionStorage : window.localStorage;
+			if (storage) return storage;
+		} catch {}
+		throw new StorageUnavailableError();
+	}
+	return {
+		async get(key) {
+			return area().getItem(key) ?? void 0;
+		},
+		async set(key, value) {
+			area().setItem(key, value);
+		},
+		async delete(key) {
+			area().removeItem(key);
+		}
+	};
+}
+//#endregion
+//#region ../browser/src/dom-restore.ts
+function entryOwns(entry, element, appRoot) {
+	if (element.closest("[data-fs-entry]") !== entry) return false;
+	return !appRoot?.hasAttribute("data-fs-app") || element.closest("[data-fs-app]") === appRoot;
+}
+function restoreRoots(entry, appRoot) {
+	const candidates = [];
+	if (entry.hasAttribute("data-restore-root") && entryOwns(entry, entry, appRoot)) candidates.push(entry);
+	for (const root of entry.querySelectorAll("[data-restore-root]")) if (entryOwns(entry, root, appRoot)) candidates.push(root);
+	return candidates;
+}
+function fieldKey(element) {
+	const restoreKey = element.getAttribute("data-restore-key");
+	if (restoreKey) return restoreKey;
+	return element.name || void 0;
+}
+function entryKey(entry) {
+	return entry.getAttribute("data-fs-key") ?? void 0;
+}
+function keyedElements(root, entry, appRoot, selector, key) {
+	const result = /* @__PURE__ */ new Map();
+	for (const element of root.querySelectorAll(selector)) {
+		if (!entryOwns(entry, element, appRoot)) continue;
+		const value = key(element);
+		if (value && !result.has(value)) result.set(value, element);
+	}
+	return result;
+}
+function createDomRestore(options) {
+	const schedule = options.schedule ?? ((callback) => callback());
+	let disposed = false;
+	let boundOutlet;
+	function collect(entry) {
+		const fields = Object.create(null);
+		const details = Object.create(null);
+		const scroll = Object.create(null);
+		for (const root of restoreRoots(entry, boundOutlet)) {
+			for (const element of root.querySelectorAll("input, textarea, select")) {
+				if (!entryOwns(entry, element, boundOutlet)) continue;
+				if (element.type === "password" || element.hasAttribute("data-restore-ignore")) continue;
+				const key = fieldKey(element);
+				if (!key) continue;
+				fields[key] = element.type === "checkbox" || element.type === "radio" ? element.checked : element.value;
+			}
+			for (const element of root.querySelectorAll("details")) {
+				if (!entryOwns(entry, element, boundOutlet)) continue;
+				const key = element.getAttribute("data-restore-key");
+				if (key) details[key] = element.open;
+			}
+			for (const element of root.querySelectorAll("[data-restore-scroll]")) {
+				if (!entryOwns(entry, element, boundOutlet)) continue;
+				const key = element.getAttribute("data-restore-key") ?? element.getAttribute("data-restore-scroll");
+				if (key) scroll[key] = {
+					top: element.scrollTop,
+					left: element.scrollLeft
+				};
+			}
+		}
+		return {
+			fields,
+			details,
+			scroll
+		};
+	}
+	function captureEntry(entry) {
+		if (!belongsToBoundApp(entry)) return;
+		const key = entryKey(entry);
+		if (!key) return;
+		const bag = options.scope.get(key) ?? {};
+		options.scope.set(key, {
+			...bag,
+			__dom: collect(entry)
+		});
+	}
+	function apply(entry, dom) {
+		for (const root of restoreRoots(entry, boundOutlet)) {
+			const fields = keyedElements(root, entry, boundOutlet, "input, textarea, select", fieldKey);
+			for (const [key, value] of Object.entries(dom.fields ?? {})) {
+				const element = fields.get(key);
+				if (!element || element.type === "password" || element.hasAttribute("data-restore-ignore")) continue;
+				if (typeof value === "boolean") element.checked = value;
+				else {
+					const descriptor = Object.getOwnPropertyDescriptor(Object.getPrototypeOf(element), "value");
+					if (descriptor?.set) descriptor.set.call(element, value);
+					else element.value = value;
+				}
+				element.dispatchEvent(new Event("input", { bubbles: true }));
+				element.dispatchEvent(new Event("change", { bubbles: true }));
+			}
+			const details = keyedElements(root, entry, boundOutlet, "details", (element) => element.getAttribute("data-restore-key") ?? void 0);
+			for (const [key, open] of Object.entries(dom.details ?? {})) {
+				const element = details.get(key);
+				if (element) element.open = open;
+			}
+			const scroll = keyedElements(root, entry, boundOutlet, "[data-restore-scroll]", (element) => element.getAttribute("data-restore-key") ?? element.getAttribute("data-restore-scroll") ?? void 0);
+			for (const [key, position] of Object.entries(dom.scroll ?? {})) {
+				const element = scroll.get(key);
+				if (!element) continue;
+				element.scrollTop = position.top;
+				element.scrollLeft = position.left;
+			}
+		}
+	}
+	function restoreEntry(entry) {
+		if (!belongsToBoundApp(entry)) return;
+		const key = entryKey(entry);
+		const dom = key ? options.scope.get(key)?.__dom : void 0;
+		if (!dom) return;
+		schedule(() => {
+			if (!disposed) apply(entry, dom);
+		});
+	}
+	function belongsToBoundApp(entry) {
+		return !boundOutlet?.hasAttribute("data-fs-app") || entry.closest("[data-fs-app]") === boundOutlet;
+	}
+	function ownsEntry(entry) {
+		if (!boundOutlet || !belongsToBoundApp(entry)) return false;
+		for (let current = entry; current; current = current.parentElement) if (current === boundOutlet) return true;
+		return false;
+	}
+	function entryFrom(target) {
+		const entry = target?.closest("[data-fs-entry]");
+		return entry && ownsEntry(entry) ? entry : void 0;
+	}
+	const onEdit = (event) => {
+		const entry = entryFrom(event.target);
+		if (entry) captureEntry(entry);
+	};
+	const flushEntries = () => {
+		if (!boundOutlet) return;
+		if (boundOutlet.hasAttribute("data-fs-entry")) captureEntry(boundOutlet);
+		for (const entry of boundOutlet.querySelectorAll("[data-fs-entry]")) if (ownsEntry(entry)) captureEntry(entry);
+	};
+	const onVisibility = () => {
+		if (document.visibilityState === "hidden") flushEntries();
+	};
+	function attach(outlet) {
+		disposed = false;
+		boundOutlet = outlet;
+		outlet.addEventListener("input", onEdit, true);
+		outlet.addEventListener("change", onEdit, true);
+		window.addEventListener("pagehide", flushEntries);
+		document.addEventListener("visibilitychange", onVisibility);
+	}
+	function dispose() {
+		disposed = true;
+		if (!boundOutlet) return;
+		boundOutlet.removeEventListener("input", onEdit, true);
+		boundOutlet.removeEventListener("change", onEdit, true);
+		window.removeEventListener("pagehide", flushEntries);
+		document.removeEventListener("visibilitychange", onVisibility);
+		boundOutlet = void 0;
+	}
+	return {
+		captureEntry,
+		restoreEntry,
+		attach,
+		dispose
+	};
+}
+//#endregion
+//#region ../browser/src/middleware/context.ts
+/** 从 document.cookie 构建浏览器端上下文 */
+function createBrowserContext(options) {
+	const { url, intent, container } = options;
+	return {
+		url,
+		path: new URL(url, window.location.origin).pathname,
+		params: intent.params ?? {},
+		query: intent.query ?? {},
+		intent,
+		isServer: false,
+		container,
+		getCookie: (name) => parseCookieString(document.cookie).get(name),
+		getHeader: () => void 0
+	};
+}
+//#endregion
+//#region ../browser/src/hydration.ts
+/** Inspect renderer children only; host attributes and the rest of the document are independent. */
+function digestHydrationDOM(target) {
+	const digest = createHydrationDigest();
+	function write(node) {
+		if (node.nodeType === 3 || node.nodeType === 8) {
+			digest.write(node.nodeType === 3 ? "text" : "comment");
+			digest.write(node.nodeValue ?? "");
+		} else if (node.nodeType === 1) {
+			const element = node;
+			if (element.matches("script[data-fs-server-data]")) return;
+			digest.write("element");
+			digest.write(element.namespaceURI ?? "");
+			digest.write(element.localName);
+			if (element.localName.includes("-")) {
+				digest.write("opaque");
+				return;
+			}
+			for (const attribute of [...element.attributes].sort((a, b) => a.name < b.name ? -1 : a.name > b.name ? 1 : 0)) {
+				digest.write(attribute.name);
+				digest.write(attribute.name === "nonce" ? element.nonce : attribute.value);
+			}
+			digest.write("children");
+			const parent = element.localName === "template" ? element.content : element;
+			for (const child of parent.childNodes) write(child);
+			digest.write("end");
+		}
+	}
+	for (const child of target.childNodes) write(child);
+	return digest.value();
+}
+/** Decide how to attach a native root without guessing which script modified it. */
+function inspectHydration(target, serverReady, expected) {
+	if (!serverReady || !target.hasChildNodes()) return { shouldHydrate: false };
+	if (!expected?.startsWith("v1:") || digestHydrationDOM(target) === expected) return { shouldHydrate: true };
+	const document = target.ownerDocument;
+	const selection = document.getSelection();
+	return {
+		shouldHydrate: !!(!!document.defaultView?.scrollX || !!document.defaultView?.scrollY || document.activeElement !== target && target.contains(document.activeElement) || selection && !selection.isCollapsed && target.contains(selection.anchorNode) || target.scrollTop !== 0 || target.scrollLeft !== 0 || [...target.querySelectorAll("*")].some((element) => {
+			if (element.localName.includes("-") || element.hasAttribute("data-fs-app") || element.shadowRoot) return true;
+			if (element.isContentEditable || element.scrollTop || element.scrollLeft) return true;
+			switch (element.tagName) {
+				case "INPUT": {
+					const input = element;
+					return input.type === "checkbox" || input.type === "radio" ? input.checked !== input.defaultChecked : input.value !== input.defaultValue || !!input.files?.length;
+				}
+				case "TEXTAREA": {
+					const input = element;
+					return input.value !== input.defaultValue;
+				}
+				case "SELECT": {
+					const input = element;
+					const options = [...input.options];
+					return options.some((option) => option.defaultSelected) ? options.some((option) => option.selected !== option.defaultSelected) : input.multiple ? input.selectedIndex !== -1 : input.selectedIndex > 0;
+				}
+				case "DETAILS":
+				case "IFRAME":
+				case "OBJECT":
+				case "EMBED":
+				case "CANVAS": return true;
+				case "AUDIO":
+				case "VIDEO": {
+					const media = element;
+					return !media.paused || media.currentTime !== 0;
+				}
+				default: return false;
+			}
+		})),
+		changedDOM: true
+	};
+}
+//#endregion
+//#region ../browser/src/start-app.ts
+const targets = /* @__PURE__ */ new WeakSet();
+const windows = /* @__PURE__ */ new WeakSet();
+async function createBrowserApp(config) {
+	const { target, definition } = config;
+	if (!target) throw Error("A browser target is required");
+	const ownerWindow = target.ownerDocument.defaultView;
+	if (!ownerWindow) throw Error("A browser window is required");
+	const win = ownerWindow;
+	const browserHistory = (config.history ?? "browser") === "browser";
+	if (targets.has(target)) throw Error("Browser target already owned");
+	if (browserHistory && windows.has(win)) throw Error("Browser history already owned; use memory history for embedded apps");
+	if (config.session && !config.persistenceKey) throw Error("Session requires a stable persistenceKey");
+	if (config.domRestore && !config.session) throw Error("DOM restore requires session storage");
+	targets.add(target);
+	if (browserHistory) windows.add(win);
+	let web, controller;
+	let disposeSession;
+	let bridge, session, dom;
+	let closed = false, mounted = false, restoring = !!config.session;
+	let acknowledged = 0, navigationSequence = 0, disposal;
+	let settleReady, failReady;
+	const ready = new Promise((resolve, reject) => {
+		settleReady = resolve;
+		failReady = reject;
+	});
+	ready.catch(() => {});
+	const pending = /* @__PURE__ */ new Map();
+	const domResets = /* @__PURE__ */ new Set();
+	const modalControllers = /* @__PURE__ */ new Set();
+	const modalWork = /* @__PURE__ */ new Set();
+	const cleanups = [];
+	const originalLocale = {
+		lang: target.getAttribute("lang"),
+		dir: target.getAttribute("dir"),
+		"data-fs-app": target.getAttribute("data-fs-app")
+	};
+	target.setAttribute("data-fs-app", definition.id);
+	const containers = () => [...target.querySelectorAll("[data-fs-entry]")].filter((element) => element.closest("[data-fs-app]") === target);
+	const capture = () => {
+		if (!restoring) for (const element of containers()) dom?.captureEntry(element);
+	};
+	const restore = () => {
+		for (const element of containers()) if (!element.hidden) dom?.restoreEntry(element);
+	};
+	const dispose = () => disposal ??= (async () => {
+		capture();
+		closed = true;
+		controller?.cancel();
+		for (const modal of modalControllers) modal.cancel();
+		for (const waiter of pending.values()) waiter.reject(new ExecutionError("cancelled"));
+		pending.clear();
+		failReady(new ExecutionError("cancelled"));
+		for (const cleanup of cleanups) cleanup();
+		bridge?.dispose();
+		const errors = [];
+		for (const cleanup of [
+			() => disposeSession?.(),
+			() => Promise.allSettled(modalWork),
+			() => session?.dispose(),
+			() => dom?.dispose(),
+			() => web?.dispose()
+		]) try {
+			await cleanup();
+		} catch (error) {
+			errors.push(error);
+		}
+		for (const [key, value] of Object.entries(originalLocale)) if (value === null) target.removeAttribute(key);
+		else target.setAttribute(key, value);
+		targets.delete(target);
+		if (browserHistory) windows.delete(win);
+		if (errors.length) throw new AggregateError(errors, "Browser cleanup failed");
+	})();
+	try {
+		const initialUrl = config.url ?? (browserHistory ? win.location.pathname + win.location.search : "/");
+		const serverDataScript = config.serverDataSource === void 0 ? target.querySelector("script[data-fs-server-data]") : config.serverDataSource;
+		const expectedDOM = serverDataScript?.parentNode === target ? serverDataScript.getAttribute("data-fs-dom") : void 0;
+		const wire = deserializeServerData({
+			script: serverDataScript,
+			buildId: config.buildId
+		});
+		const configuration = definition.configuration ?? {};
+		const locale = configuration.locale ?? target.getAttribute("lang") ?? target.ownerDocument.documentElement.lang ?? void 0;
+		const fetch = configuration.fetch ?? globalThis.fetch?.bind(globalThis);
+		const messages = await resolveConfiguredMessages({
+			locale,
+			loadMessages: definition.loadMessages,
+			context: locale ? {
+				runtime: "browser",
+				url: initialUrl,
+				fetch
+			} : void 0
+		});
+		web = createWebRuntime({
+			...configuration,
+			definition,
+			locale,
+			fetch,
+			messages,
+			safeFetch: {
+				validateDns: false,
+				...configuration.safeFetch
+			},
+			platform: configuration.platform ?? detectPlatform(win.navigator.userAgent, win.navigator.maxTouchPoints),
+			prefetchedIntents: wire.status === "ready" ? PrefetchedIntents.fromArray(wire.data.pages) : PrefetchedIntents.empty()
+		});
+		const activeWeb = web;
+		const [log, attributes] = await Promise.all([web.getLogger(), web.getLocale()]);
+		if (attributes) {
+			target.setAttribute("lang", attributes.lang);
+			target.setAttribute("dir", attributes.dir);
+		}
+		const codec = definition.navigationCodec ?? createActiveLeafCodec();
+		const resolveUrl = async (url) => (await resolveInitialNavigation(activeWeb, url, { codec }))?.tree;
+		function browserUrl(value, external = false) {
+			let url;
+			try {
+				url = new URL(value, win.location.href);
+			} catch {
+				throw new ExecutionError("validation", "Invalid browser destination");
+			}
+			if (url.protocol !== "http:" && url.protocol !== "https:" && !(external && (url.protocol === "mailto:" || url.protocol === "tel:"))) throw new ExecutionError("validation", "Unsupported browser destination protocol");
+			return url;
+		}
+		const initial = wire.status === "ready" && wire.data.tree ? deserializeNavigation(wire.data.tree) : await resolveUrl(initialUrl) ?? stack(leaf("@finesoft/not-found", {}, { url: initialUrl }));
+		async function navigate(url, invocation) {
+			if (closed) throw new ExecutionError("configuration", "Browser application is closed");
+			const parsed = browserUrl(url);
+			if (parsed.origin !== win.location.origin) {
+				win.location.assign(parsed.href);
+				return;
+			}
+			const sequence = ++navigationSequence;
+			controller.cancel(invocation);
+			const path = parsed.pathname + parsed.search + parsed.hash;
+			const tree = controller.getTree();
+			const recovering = tree.kind === "stack" && tree.entries.length === 1 && tree.entries[0]?.kind === "leaf" && ["@finesoft/not-found", "@finesoft/error"].includes(tree.entries[0].intent);
+			const overlay = (recovering ? await resolveUrl(path) : void 0) ?? codec.decode(path, activeWeb.router);
+			const match = overlay ? void 0 : await activeWeb.router.resolve(path);
+			if (closed || sequence !== navigationSequence || invocation?.signal?.aborted) throw new ExecutionError("cancelled");
+			const action = !recovering && parsed.href === new URL(codec.encode(tree, activeWeb.router), win.location.href).href ? { kind: "refresh" } : overlay ? {
+				kind: "hydrate",
+				tree: overlay
+			} : definition.navigation || definition.navigationCodec ? {
+				kind: "push",
+				intent: match?.intent.id ?? "@finesoft/not-found",
+				params: match?.intent.params,
+				query: match?.intent.query,
+				url: path
+			} : {
+				kind: "hydrate",
+				tree: stack(leaf(match?.intent.id ?? "@finesoft/not-found", match?.intent.params, {
+					url: path,
+					query: match?.intent.query
+				}))
+			};
+			if (await controller.perform(action, invocation) !== controller.getSnapshot()) throw new ExecutionError("denied", "Navigation was not committed");
+		}
+		const createContext = ({ intent, params, query, url, execution }) => createBrowserContext({
+			url: url ?? initialUrl,
+			intent: {
+				id: intent,
+				params,
+				query
+			},
+			container: execution.container
+		});
+		const followRedirect = async (value, candidate) => {
+			const url = browserUrl(value.url);
+			if (url.origin !== win.location.origin) {
+				win.location.assign(url.href);
+				return;
+			}
+			const path = url.pathname + url.search + url.hash;
+			const overlay = codec.decode(path, activeWeb.router);
+			if (overlay) return overlay;
+			const match = await activeWeb.router.resolve(path);
+			const target = leaf(match?.intent.id ?? "@finesoft/not-found", match?.intent.params, {
+				url: path,
+				query: match?.intent.query
+			});
+			const redirected = candidate.destinations.find((entry) => entry.status && entry.status >= 300 && entry.status < 400)?.entryId ?? collectVisibleDestinations(candidate.tree).at(-1)?.entryId;
+			return redirected ? mapNavigationLeaves(candidate.tree, (entry) => entry.entryId === redirected ? target : entry) : stack(target);
+		};
+		const waitForCommit = (revision, signal) => {
+			if (!mounted || revision === acknowledged) return Promise.resolve();
+			if (signal?.aborted || closed) return Promise.reject(new ExecutionError("cancelled"));
+			return new Promise((resolve, reject) => {
+				const finish = (error) => {
+					pending.delete(revision);
+					signal?.removeEventListener("abort", abort);
+					if (error) reject(error);
+					else resolve();
+				};
+				const abort = () => finish(new ExecutionError("cancelled"));
+				pending.set(revision, {
+					resolve: () => finish(),
+					reject: finish
+				});
+				signal?.addEventListener("abort", abort, { once: true });
+			});
+		};
+		const recordPageView = (snapshot) => {
+			const page = snapshot.destinations.at(-1)?.page;
+			if (page) activeWeb.runtime.record("PageView", {
+				page: page.pageType,
+				pageId: page.id,
+				title: page.title,
+				transitionId: snapshot.transitionId
+			});
+		};
+		controller = createWebSession({
+			session: () => session,
+			commit(revision) {
+				if (closed) return;
+				acknowledged = revision;
+				for (const entryId of domResets) {
+					const bag = session?.scope.get(entryId);
+					if (bag) {
+						const { __dom: _oldDom, ...state } = bag;
+						session.scope.set(entryId, state);
+					}
+				}
+				domResets.clear();
+				pending.get(revision)?.resolve();
+				if (mounted) return;
+				mounted = true;
+				recordPageView(controller.getSnapshot());
+				queueMicrotask(() => {
+					if (closed) return;
+					(async () => {
+						await session?.restoreFromUrl(initialUrl);
+						if (closed) return;
+						restoring = false;
+						restore();
+						settleReady();
+					})().catch((error) => {
+						restoring = false;
+						failReady(error);
+						log.error("Session restore failed", error);
+					});
+				});
+			},
+			captureUrl: () => browserHistory ? win.location.pathname + win.location.search : codec.encode(controller.getTree(), activeWeb.router),
+			web,
+			initial,
+			isServer: false,
+			createContext,
+			onRedirect: followRedirect,
+			viewReady: async (snapshot, signal) => {
+				await waitForCommit(controller.getSnapshot().revision, signal);
+				if (!mounted) return;
+				if (!restoring) restore();
+				recordPageView(snapshot);
+			}
+		});
+		disposeSession = controller.dispose;
+		if (browserHistory) bridge = createNavigationBridge({
+			controller,
+			codec,
+			router: web.router,
+			log,
+			onPopStart: () => {
+				navigationSequence++;
+			},
+			resolveUrl,
+			getScrollablePageElement: () => target.querySelector("[data-fs-scroll]") ?? target
+		});
+		controller.onAction(ACTION_KINDS.FLOW, async (action, invocation) => {
+			if (closed) throw new ExecutionError("configuration", "Browser application is closed");
+			if (invocation?.signal?.aborted) throw new ExecutionError("cancelled");
+			if (action.presentationContext !== "modal") return navigate(action.url, invocation);
+			if (!config.onModal) throw new ExecutionError("configuration", "Modal actions require onModal");
+			const work = (async () => {
+				const match = await activeWeb.router.resolve(action.url);
+				if (closed || invocation?.signal?.aborted) throw new ExecutionError("cancelled");
+				let handedOff = false;
+				const modal = createWebSession({
+					web: activeWeb,
+					initial: stack(leaf(match?.intent.id ?? "@finesoft/not-found", match?.intent.params, {
+						url: action.url,
+						query: match?.intent.query
+					})),
+					isServer: false,
+					createContext,
+					onRedirect: async (value, candidate) => {
+						const tree = await followRedirect(value, candidate);
+						handedOff = !tree;
+						return tree;
+					}
+				});
+				modalControllers.add(modal);
+				try {
+					const snapshot = await modal.start(invocation);
+					if (closed || handedOff) return;
+					const page = snapshot.destinations.at(-1)?.page;
+					if (page) await config.onModal(page, {
+						app: controller,
+						snapshot
+					});
+				} finally {
+					await modal.dispose();
+					modalControllers.delete(modal);
+				}
+			})();
+			modalWork.add(work);
+			try {
+				await work;
+			} finally {
+				modalWork.delete(work);
+			}
+		});
+		controller.onAction(ACTION_KINDS.EXTERNAL_URL, (action, invocation) => {
+			if (closed) throw new ExecutionError("configuration", "Browser application is closed");
+			if (invocation?.signal?.aborted) throw new ExecutionError("cancelled");
+			win.open(browserUrl(action.url, true).href, "_blank", "noopener,noreferrer");
+		});
+		cleanups.push(controller.onCommit((next, previousSnapshot) => {
+			capture();
+			for (const destination of next.destinations) {
+				const previous = previousSnapshot.entries.find((entry) => entry.entryId === destination.entryId);
+				if (previous && previous.page.pageType !== destination.page.pageType && session) domResets.add(destination.entryId);
+			}
+		}));
+		if (config.session) {
+			const store = createSessionStore({
+				...config.session,
+				storage: config.session.storage ?? createWebStorage("local"),
+				key: `finesoft:${definition.id}:${config.persistenceKey}`,
+				navigation: controller
+			});
+			for (const provider of config.session.providers ?? []) store.register(provider);
+			session = createSessionBridge({
+				store,
+				navigation: controller,
+				subscribeNavigation: controller.subscribe,
+				debounceMs: config.session.debounceMs,
+				shouldRestore: config.session.shouldRestore,
+				deferPersistenceUntilRestore: true
+			});
+			if (config.domRestore) {
+				dom = createDomRestore({
+					schedule: (callback) => callback(),
+					get scope() {
+						return session.scope;
+					}
+				});
+				dom.attach(target);
+			}
+		}
+		await controller.start();
+		const onClick = (event) => {
+			if (event.defaultPrevented || event.button !== 0 || event.metaKey || event.ctrlKey || event.altKey || event.shiftKey) return;
+			const anchor = event.target?.closest?.("a[href]");
+			if (!anchor || !target.contains(anchor) || anchor.closest("[data-fs-app]") !== target || anchor.hasAttribute("download") || anchor.target && anchor.target !== "_self" || anchor.rel.split(/\s+/).includes("external")) return;
+			const url = new URL(anchor.href, win.location.href);
+			if (url.origin !== win.location.origin || !["http:", "https:"].includes(url.protocol)) return;
+			if (url.pathname === win.location.pathname && url.search === win.location.search && url.hash) return;
+			event.preventDefault();
+			controller.perform({
+				kind: "flow",
+				url: url.href
+			}).catch((error) => {
+				if (!(error instanceof ExecutionError && error.code === "cancelled")) log.error("Navigation failed", error);
+			});
+		};
+		target.addEventListener("click", onClick);
+		cleanups.push(() => target.removeEventListener("click", onClick));
+		const hydration = inspectHydration(target, wire.status === "ready", expectedDOM);
+		if (hydration.changedDOM) log.info(hydration.shouldHydrate ? "SSR DOM changed before mount; retaining native hydration to avoid discarding browser state" : "SSR DOM changed before mount; rendering a fresh native root with the existing server data", {
+			source: "hydration",
+			code: "dom-changed",
+			recovery: hydration.shouldHydrate ? "deferred" : "native-mount"
+		});
+		return Object.assign(controller, {
+			shouldHydrate: hydration.shouldHydrate,
+			ready,
+			dispose
+		});
+	} catch (error) {
+		await dispose().catch(() => {});
+		throw error;
+	}
+}
+//#endregion
+//#region ../browser/src/logger/local-storage-filter.ts
+const LEVEL_TO_NUM = {
+	"*": 4,
+	debug: 4,
+	info: 3,
+	warn: 2,
+	error: 1,
+	off: 0,
+	"": 0
+};
+let cachedRules;
+let cachedRaw;
+function parseRules() {
+	if (typeof globalThis.localStorage === "undefined") return {};
+	let raw;
+	try {
+		raw = globalThis.localStorage.getItem("onyxLog");
+	} catch {
+		return {};
+	}
+	if (!raw) return {};
+	if (raw === cachedRaw && cachedRules) return cachedRules;
+	cachedRaw = raw;
+	const rules = {};
+	const parts = raw.split(",");
+	for (const part of parts) {
+		const [name, level] = part.trim().split("=");
+		if (!name || level === void 0) continue;
+		const num = LEVEL_TO_NUM[level.toLowerCase()] ?? void 0;
+		if (num === void 0) continue;
+		if (name === "*") rules.defaultLevel = num;
+		else {
+			rules.named ??= {};
+			rules.named[name] = num;
+		}
+	}
+	cachedRules = rules;
+	return rules;
+}
+function shouldLog(name, level) {
+	const rules = parseRules();
+	if (rules.defaultLevel === void 0 && !rules.named) return true;
+	const currentNum = LEVEL_TO_NUM[level] ?? 4;
+	if (rules.named?.[name] !== void 0) return currentNum <= rules.named[name];
+	if (rules.defaultLevel !== void 0) return currentNum <= rules.defaultLevel;
+	return true;
+}
+function resetFilterCache() {
+	cachedRules = void 0;
+	cachedRaw = void 0;
+}
+//#endregion
+//#region ../browser/src/utils/pwa.ts
+/**
+* 检测 PWA display mode
+*
+* - `standalone`: 已安装的 PWA（通过 Add to Home Screen）
+* - `twa`: Trusted Web Activity（Android 原生壳）
+* - `browser`: 普通浏览器标签页
+*/
+function getPWADisplayMode() {
+	if (typeof window === "undefined") return "browser";
+	if (document.referrer.startsWith("android-app://")) return "twa";
+	if (window.matchMedia("(display-mode: standalone)").matches || "standalone" in window.navigator && window.navigator.standalone === true) return "standalone";
+	return "browser";
+}
+//#endregion
+//#region ../browser/src/metrics/impression-observer.ts
+var IntersectionImpressionObserver = class {
+	observer;
+	tracked = /* @__PURE__ */ new Map();
+	captured = [];
+	minDuration;
+	constructor(options = {}) {
+		this.minDuration = options.minVisibleDuration ?? 1e3;
+		this.observer = new IntersectionObserver((entries) => {
+			const now = Date.now();
+			for (const entry of entries) {
+				const tracked = this.tracked.get(entry.target);
+				if (!tracked) continue;
+				if (entry.isIntersecting) {
+					if (tracked.visibleSince === null) tracked.visibleSince = now;
+				} else if (tracked.visibleSince !== null) {
+					if (now - tracked.visibleSince >= this.minDuration) this.captured.push({
+						id: tracked.id,
+						timestamp: tracked.visibleSince,
+						metadata: tracked.metadata
+					});
+					tracked.visibleSince = null;
+				}
+			}
+		}, { threshold: options.threshold ?? .5 });
+	}
+	observe(element, id, metadata) {
+		this.tracked.set(element, {
+			id,
+			metadata,
+			visibleSince: null
+		});
+		this.observer.observe(element);
+	}
+	unobserve(element) {
+		this.observer.unobserve(element);
+		this.tracked.delete(element);
+	}
+	consume() {
+		const now = Date.now();
+		for (const [, tracked] of this.tracked) if (tracked.visibleSince !== null) {
+			if (now - tracked.visibleSince >= this.minDuration) {
+				this.captured.push({
+					id: tracked.id,
+					timestamp: tracked.visibleSince,
+					metadata: tracked.metadata
+				});
+				tracked.visibleSince = now;
+			}
+		}
+		return this.captured.splice(0);
+	}
+	destroy() {
+		this.observer.disconnect();
+		this.tracked.clear();
+		this.captured.length = 0;
+	}
+};
+//#endregion
+//#region ../browser/src/i18n/locale.ts
+function setHtmlLocaleAttributes(attrs) {
+	document.documentElement.lang = attrs.lang;
+	document.documentElement.dir = attrs.dir;
+}
+//#endregion
+export { tryScroll as _, shouldLog as a, createDomRestore as c, createSessionBridge as d, defaultShouldRestore as f, History as g, createNavigationBridge as h, resetFilterCache as i, createWebStorage as l, deserializeServerData as m, IntersectionImpressionObserver as n, createBrowserApp as o, createPrefetchedIntentsFromDom as p, getPWADisplayMode as r, createBrowserContext as s, setHtmlLocaleAttributes as t, SESSION_DEFAULT_DEBOUNCE_MS as u };
+
+//# sourceMappingURL=browser-CR5vhgXg.mjs.map