@ubean/client 0.2.0

package/dist/index.js

@@ -0,0 +1,1024 @@
+import { A as getI18nConfig, B as setLocale, C as addLocale, D as detectLocale, E as detectBrowserLocale, F as initClientI18n, G as useSwitchLocalePath, H as t, I as localizePath, K as createUbeanRouter, L as mergeLocale, M as getLocaleDir, N as getLocaleName, O as extractLocaleFromPath, P as getRegisteredLocales, R as onLocaleChange, S as definePage, T as defineLocale, U as useI18n, V as switchLocalePath, W as useLocalePath, _ as useSeoMeta, b as defineMeta, j as getLocale, k as getDefaultLocale, m as createUbeanSSRApp, n as Head, p as createUbeanClientApp, q as usePage, v as useUnheadHead, w as clearLocales, x as defineMiddleware, z as setI18nConfig } from "./app-Bc1d5Svw.js";
+import { applyAppConfig, createDefaultAppConfig, defineApp, mergeAppConfig } from "./define-app.js";
+import { computed, getCurrentInstance, markRaw, onMounted, onScopeDispose, onUnmounted, ref, shallowRef, watch } from "vue";
+import { useRouter } from "vue-router";
+import { ERROR_KEY, ErrorBoundary, LAYOUT_CHAIN_KEY, LOADING_KEY, LOCALIZE_PATH_KEY, LayoutChainRenderer, Link, PAGE_KEY, PageView, SSR_KEY, SlotView, TRANSITION_KEY, clearPageTransition, disablePageCache, enablePageCache, excludePageCache, getCacheEnabled, getCachedViewNames, getExcludedViewNames, getNamedPageWrapper, getNavigationType, getPageTransitionName, getReloadCounter, includePageCache, initCachedViewsFromRoutes, invalidatePageCache, isActiveRoute, isCacheEnabled, isPageCached, isPageExcluded, isReloading, reloadPage, resetNamedPageWrappers, resetRouteCache, resolveRoute, setPageTransition, supportsViewTransitions, ubeanVue, useCacheViews, usePageTransition, useReloadSignal, useViewTransition, useViewTransitionState, withViewTransition } from "@ubean/vue";
+import { injectHead, injectHead as injectHead$1 } from "@unhead/vue";
+import { createHead as createClientHead } from "@unhead/vue/client";
+import { defineDataKey as defineDataKey$1 } from "@ubean/pages";
+import { collectIslands, hydrateIsland, hydrateIslands } from "@ubean/islands/runtime";
+//#region src/client.ts
+const _global$1 = globalThis;
+function getInitialPageData() {
+	if (typeof _global$1.document === "undefined") return null;
+	const el = _global$1.document.getElementById("__UBEAN_PAGE_DATA__");
+	if (!el) return _global$1.__UBEAN_PAGE_DATA__ ?? null;
+	try {
+		return JSON.parse(el.textContent || "null");
+	} catch {
+		return null;
+	}
+}
+/**
+* 从 DOM 中的 `<script id="__UBEAN_STATE__">` 读取 SSR 序列化的状态。
+*
+* 该状态由服务端 `defineApp({ serializeState })` 产生,用于在客户端 mount 前
+* 水合到对应的库实例(如 Pinia 的 `pinia.state.value`)。
+*
+* 必须在 `app.mount()` 之前调用(在 `defineApp({ hydrateState })` 内部使用)。
+*
+* @returns 解析后的状态对象,或 `null`(无状态 / 解析失败 / 非 DOM 环境)
+*/
+function getInitialState() {
+	if (typeof _global$1.document === "undefined") return null;
+	const el = _global$1.document.getElementById("__UBEAN_STATE__");
+	if (!el) return _global$1.__UBEAN_STATE__ ?? null;
+	try {
+		const text = el.textContent || "";
+		if (!text.trim()) return null;
+		return JSON.parse(text);
+	} catch {
+		return null;
+	}
+}
+//#endregion
+//#region src/head.ts
+function useHeadInstance() {
+	return injectHead$1();
+}
+//#endregion
+//#region src/composables.ts
+const _global = globalThis;
+function createDataCacheStore() {
+	const cache = /* @__PURE__ */ new Map();
+	const tagIndex = /* @__PURE__ */ new Map();
+	const listeners = /* @__PURE__ */ new Set();
+	function notify() {
+		for (const fn of listeners) fn();
+	}
+	return {
+		get(key) {
+			return cache.get(key)?.data;
+		},
+		set(key, value, tags) {
+			cache.set(key, {
+				data: value,
+				timestamp: Date.now(),
+				tags
+			});
+			if (tags) for (const tag of tags) {
+				let set = tagIndex.get(tag);
+				if (!set) {
+					set = /* @__PURE__ */ new Set();
+					tagIndex.set(tag, set);
+				}
+				set.add(key);
+			}
+			notify();
+		},
+		has(key) {
+			return cache.has(key);
+		},
+		invalidate(keyOrTag) {
+			let count = 0;
+			if (typeof keyOrTag === "string") {
+				if (cache.has(keyOrTag)) {
+					const entry = cache.get(keyOrTag);
+					if (entry.tags) for (const t of entry.tags) {
+						const ts = tagIndex.get(t);
+						if (ts) ts.delete(keyOrTag);
+					}
+					cache.delete(keyOrTag);
+					count = 1;
+				}
+				const keys = tagIndex.get(keyOrTag);
+				if (keys) {
+					for (const k of keys) {
+						const entry = cache.get(k);
+						if (entry) {
+							if (entry.tags) for (const t of entry.tags) {
+								const ts = tagIndex.get(t);
+								if (ts) ts.delete(k);
+							}
+							cache.delete(k);
+							count++;
+						}
+					}
+					tagIndex.delete(keyOrTag);
+				}
+			} else {
+				const entry = cache.get(keyOrTag);
+				if (entry) {
+					if (entry.tags) for (const t of entry.tags) {
+						const ts = tagIndex.get(t);
+						if (ts) ts.delete(keyOrTag);
+					}
+					cache.delete(keyOrTag);
+					count = 1;
+				}
+			}
+			if (count > 0) notify();
+			return count;
+		},
+		clear() {
+			cache.clear();
+			tagIndex.clear();
+			notify();
+		},
+		subscribe(fn) {
+			listeners.add(fn);
+			return () => listeners.delete(fn);
+		},
+		getTimestamp(key) {
+			return cache.get(key)?.timestamp;
+		}
+	};
+}
+function createUseAsyncData(store) {
+	return function useAsyncData(keyOrFetcher, fetcherOrOptions, options) {
+		let key;
+		let fetcher;
+		let opts = {};
+		if (typeof keyOrFetcher === "string") {
+			key = keyOrFetcher;
+			fetcher = fetcherOrOptions;
+			opts = options || {};
+		} else {
+			fetcher = keyOrFetcher;
+			key = fetcherOrOptions?.key || Math.random().toString(36).slice(2);
+			opts = fetcherOrOptions || {};
+		}
+		const state = {
+			data: { value: store.get(key) ?? (opts.default ? opts.default() : void 0) },
+			error: { value: null },
+			loading: { value: false }
+		};
+		async function execute() {
+			state.loading.value = true;
+			state.error.value = null;
+			try {
+				const raw = await fetcher();
+				const value = opts.transform ? opts.transform(raw) : raw;
+				store.set(key, value, opts.tags);
+				state.data.value = value;
+			} catch (err) {
+				state.error.value = err instanceof Error ? err : new Error(String(err));
+			} finally {
+				state.loading.value = false;
+			}
+		}
+		function invalidate() {
+			store.invalidate(key);
+		}
+		if (!opts.lazy) {
+			if (!store.has(key)) execute();
+		}
+		store.subscribe(() => {
+			state.data.value = store.get(key) ?? (opts.default ? opts.default() : void 0);
+		});
+		return {
+			data: state.data,
+			error: state.error,
+			loading: state.loading,
+			refresh: execute,
+			invalidate
+		};
+	};
+}
+function invalidateCache(store, keyOrTag) {
+	return store.invalidate(keyOrTag);
+}
+function clearCache(store) {
+	store.clear();
+}
+function defineDataKey(key) {
+	return defineDataKey$1(key);
+}
+function createLinkHandler(ctx) {
+	return {
+		getProps: () => ({}),
+		async navigate(href, opts = {}) {
+			if (!ctx.__ubean_router) {
+				const loc = _global.location;
+				if (opts.replace) loc.replace(href);
+				else loc.href = href;
+				return;
+			}
+			if (opts.replace) await ctx.__ubean_router.replace(href);
+			else await ctx.__ubean_router.push(href);
+		},
+		async prefetch(_href) {}
+	};
+}
+function extractPageData() {
+	if (typeof _global.document === "undefined") return null;
+	const el = _global.document.getElementById("__UBEAN_PAGE_DATA__");
+	if (!el) return null;
+	try {
+		return JSON.parse(el.textContent || "null");
+	} catch {
+		return null;
+	}
+}
+async function useServerData(fetcher) {
+	return fetcher();
+}
+function getInvalidatedKeysForAction(actionName, invalidationMap, store) {
+	const toInvalidate = invalidationMap[actionName];
+	if (!toInvalidate) return 0;
+	let count = 0;
+	for (const key of toInvalidate) count += store.invalidate(key);
+	return count;
+}
+//#endregion
+//#region src/color-mode.ts
+/**
+* P9-21: Color mode (dark/light) support.
+*
+* Aligns with Nuxt `@nuxtjs/color-mode`. Provides:
+* - A no-FOUC inline script injected into `<head>` that resolves the color
+*   mode (from cookie / localStorage / system preference) and sets the
+*   `<html>` class or `data-*` attribute **before** the page renders.
+* - A `useColorMode()` composable for reactive access and toggling.
+*
+* The script runs synchronously in `<head>` so the correct class is set
+* before the browser paints, preventing a flash of unstyled content.
+*
+* Usage (composable):
+* ```typescript
+* import { useColorMode } from 'ubean/runtime/color-mode';
+*
+* const colorMode = useColorMode();
+* colorMode.value;     // 'light' | 'dark' | ...
+* colorMode.preference; // 'system' | 'light' | 'dark' | ...
+* colorMode.toggle();   // cycle through modes
+* ```
+*/
+const DEFAULT_CONFIG$1 = {
+	preference: "system",
+	fallback: "light",
+	classPrefix: "",
+	classSuffix: "-mode",
+	storageKey: "ubean-color-mode",
+	cookieName: "ubean-color-mode",
+	dataValue: false,
+	modes: ["light", "dark"]
+};
+/** Merge user config with defaults. */
+function resolveColorModeConfig(config) {
+	return {
+		...DEFAULT_CONFIG$1,
+		...config
+	};
+}
+/**
+* Generate the no-FOUC inline script that resolves the color mode and sets
+* the `<html>` class/attribute **before** the page renders.
+*
+* The script:
+* 1. Reads the user's preference from a cookie (SSR-friendly) or localStorage.
+* 2. If preference is 'system', checks `prefers-color-scheme`.
+* 3. Falls back to `config.fallback` if system preference is unknown.
+* 4. Sets the class or `data-*` attribute on `<html>`.
+*
+* This script is injected into `<head>` and runs synchronously.
+*/
+function getColorModeScript(config) {
+	const modes = JSON.stringify(config.modes);
+	const fallback = JSON.stringify(config.fallback);
+	const storageKey = JSON.stringify(config.storageKey);
+	const cookieName = JSON.stringify(config.cookieName);
+	const classPrefix = JSON.stringify(config.classPrefix);
+	const classSuffix = JSON.stringify(config.classSuffix);
+	const setAttr = config.dataValue ? `el.setAttribute('data-color-mode', value);` : `var className = ${classPrefix} + value + ${classSuffix};
+       el.classList.add(className);`;
+	return `<script>(() => {
+  const modes = ${modes};
+  const fallback = ${fallback};
+  const storageKey = ${storageKey};
+  const cookieName = ${cookieName};
+  const classPrefix = ${classPrefix};
+  const classSuffix = ${classSuffix};
+  const el = document.documentElement;
+
+  function getCookie(name) {
+    const match = document.cookie.match(new RegExp('(^|;\\\\s*)' + name + '=([^;]+)'));
+    return match ? decodeURIComponent(match[2]) : null;
+  }
+
+  // 1. Read preference: cookie first (SSR), then localStorage
+  let preference = getCookie(cookieName) || localStorage.getItem(storageKey) || ${JSON.stringify(config.preference)};
+
+  // 2. Resolve the actual mode
+  let value;
+  if (preference === 'system') {
+    const media = window.matchMedia('(prefers-color-scheme: dark)');
+    value = media.matches ? 'dark' : (media.media !== '(prefers-color-scheme: dark)' ? 'light' : fallback);
+  } else {
+    value = modes.includes(preference) ? preference : fallback;
+  }
+
+  // 3. Set the class or data attribute on <html>
+  ${setAttr}
+})();<\/script>`;
+}
+let _config$1 = DEFAULT_CONFIG$1;
+let _preference = null;
+let _value = null;
+let _unknown = null;
+let _forced = null;
+let _initialized = false;
+/** Configure the color mode module (called once during app initialization). */
+function configureColorMode(config) {
+	_config$1 = resolveColorModeConfig(config);
+	return _config$1;
+}
+/** Get the current color mode config. */
+function getColorModeConfig() {
+	return _config$1;
+}
+/**
+* Read the current color mode from the DOM (set by the no-FOUC script).
+* Returns `null` if not running in a browser or the mode can't be determined.
+*/
+function readModeFromDom() {
+	if (typeof document === "undefined") return null;
+	if (_config$1.dataValue) return document.documentElement.getAttribute("data-color-mode");
+	for (const mode of _config$1.modes) {
+		const className = `${_config$1.classPrefix}${mode}${_config$1.classSuffix}`;
+		if (document.documentElement.classList.contains(className)) return mode;
+	}
+	return null;
+}
+/**
+* Apply a color mode to the DOM (set class or data attribute on `<html>`).
+*/
+function applyModeToDom(mode) {
+	if (typeof document === "undefined") return;
+	const el = document.documentElement;
+	if (_config$1.dataValue) {
+		el.setAttribute("data-color-mode", mode);
+		return;
+	}
+	for (const m of _config$1.modes) {
+		const className = `${_config$1.classPrefix}${m}${_config$1.classSuffix}`;
+		el.classList.remove(className);
+	}
+	const className = `${_config$1.classPrefix}${mode}${_config$1.classSuffix}`;
+	el.classList.add(className);
+}
+/**
+* Detect system color preference via `prefers-color-scheme`.
+* Returns the mode string or `null` if unknown.
+*/
+function detectSystemMode() {
+	if (typeof window === "undefined" || !window.matchMedia) return null;
+	const media = window.matchMedia("(prefers-color-scheme: dark)");
+	if (media.matches) return "dark";
+	if (media.media === "(prefers-color-scheme: dark)") return "light";
+	return null;
+}
+/**
+* Persist the user's preference to localStorage and cookie.
+*/
+function persistPreference(preference) {
+	if (typeof window === "undefined") return;
+	try {
+		localStorage.setItem(_config$1.storageKey, preference);
+	} catch {}
+	const expires = /* @__PURE__ */ new Date();
+	expires.setFullYear(expires.getFullYear() + 1);
+	document.cookie = `${_config$1.cookieName}=${encodeURIComponent(preference)}; expires=${expires.toUTCString()}; path=/; SameSite=Lax`;
+}
+/**
+* Initialize the color mode state. Called on first `useColorMode()` invocation.
+* Reads the initial mode from the DOM (set by the no-FOUC script).
+*/
+function initColorMode() {
+	if (_initialized) return;
+	_initialized = true;
+	let preference = _config$1.preference;
+	if (typeof window !== "undefined") try {
+		const stored = localStorage.getItem(_config$1.storageKey);
+		if (stored) preference = stored;
+	} catch {}
+	_preference = ref(preference);
+	_forced = ref(false);
+	const domMode = readModeFromDom();
+	_value = ref(domMode || _config$1.fallback);
+	_unknown = ref(false);
+	if (preference === "system") _unknown.value = detectSystemMode() === null;
+	if (!domMode) {
+		if (preference === "system") {
+			const system = detectSystemMode();
+			if (system) {
+				_value.value = system;
+				applyModeToDom(system);
+			} else applyModeToDom(_config$1.fallback);
+		} else applyModeToDom(preference);
+	}
+}
+/**
+* Reactively access and control the color mode.
+*
+* Returns a `ColorMode` object with reactive refs and methods:
+* - `preference` — the user's preference ('system', 'light', 'dark', ...)
+* - `value` — the resolved mode (never 'system')
+* - `unknown` — whether the system preference is unknown
+* - `forced` — whether the mode is forced (e.g. by route meta)
+* - `set(mode)` — set the preference and persist it
+* - `toggle()` — cycle to the next mode
+*
+* @example
+* ```typescript
+* const colorMode = useColorMode();
+* console.log(colorMode.value); // 'dark'
+* colorMode.set('light');
+* colorMode.toggle(); // cycles: light → dark → light
+* ```
+*/
+function useColorMode() {
+	initColorMode();
+	const preference = _preference;
+	const forced = _forced;
+	const unknown = _unknown;
+	const valueRef = _value;
+	const value = computed(() => {
+		if (forced.value) return valueRef.value;
+		if (preference.value === "system") return detectSystemMode() || _config$1.fallback;
+		return preference.value;
+	});
+	const stopWatch = watch(preference, (newPref) => {
+		if (forced.value) return;
+		persistPreference(newPref);
+		if (newPref === "system") {
+			const system = detectSystemMode();
+			unknown.value = system === null;
+			if (system) applyModeToDom(system);
+		} else {
+			unknown.value = false;
+			applyModeToDom(newPref);
+		}
+	}, { flush: "sync" });
+	let mediaQuery = null;
+	const handleMediaChange = (e) => {
+		if (preference.value !== "system" || forced.value) return;
+		const mode = e.matches ? "dark" : "light";
+		applyModeToDom(mode);
+		valueRef.value = mode;
+	};
+	if (typeof window !== "undefined" && window.matchMedia) {
+		mediaQuery = window.matchMedia("(prefers-color-scheme: dark)");
+		mediaQuery.addEventListener("change", handleMediaChange);
+	}
+	onScopeDispose(() => {
+		stopWatch();
+		if (mediaQuery) mediaQuery.removeEventListener("change", handleMediaChange);
+	});
+	function set(mode) {
+		preference.value = mode;
+	}
+	function toggle() {
+		const current = value.value;
+		const modes = _config$1.modes;
+		set(modes[(modes.indexOf(current) + 1) % modes.length]);
+	}
+	return {
+		preference,
+		value,
+		unknown,
+		forced,
+		set,
+		toggle
+	};
+}
+/**
+* Force a color mode (e.g. from route meta `colorMode: 'dark'`).
+* When forced, user changes are ignored until `unforceColorMode()` is called.
+*/
+function forceColorMode(mode) {
+	if (!_initialized) initColorMode();
+	if (_value) _value.value = mode;
+	if (_forced) _forced.value = true;
+	applyModeToDom(mode);
+}
+/**
+* Remove the forced color mode, returning to user preference.
+*/
+function unforceColorMode() {
+	if (!_initialized) return;
+	if (_forced) _forced.value = false;
+	if (_preference) {
+		const pref = _preference.value;
+		if (pref === "system") {
+			const system = detectSystemMode();
+			if (system) applyModeToDom(system);
+		} else applyModeToDom(pref);
+	}
+}
+/**
+* Reset the color mode module state (for testing).
+* @internal
+*/
+function _resetColorMode() {
+	_config$1 = DEFAULT_CONFIG$1;
+	_preference = null;
+	_value = null;
+	_unknown = null;
+	_forced = null;
+	_initialized = false;
+}
+//#endregion
+//#region src/party-town.ts
+/**
+* P9-22: Third-party script optimization (Partytown integration).
+*
+* Aligns with Nuxt `@nuxtjs/scripts` and Astro Partytown integration.
+*
+* Provides:
+* - `useScript(src, options)` composable for loading third-party scripts with
+*   strategies: `'load'` (immediate), `'idle'` (requestIdleCallback),
+*   `'visible'` (IntersectionObserver on a ref), `'manual'` (explicit call).
+* - `getPartyTownScript(config)` generates the inline Partytown config script
+*   injected into `<head>` to initialize the Web Worker.
+* - Partytown runs third-party scripts off the main thread, improving
+*   performance by preventing analytics/tag-manager scripts from blocking
+*   the main thread.
+*
+* Usage (composable):
+* ```typescript
+* import { useScript } from 'ubean/runtime/party-town';
+*
+* // Load Google Analytics via Partytown when browser is idle
+* const { load, remove } = useScript('https://www.googletagmanager.com/gtag/js?id=GA_ID', {
+*   trigger: 'idle',
+*   partytown: true,
+*   attrs: { 'data-ga-id': 'GA_ID' }
+* });
+* ```
+*/
+const DEFAULT_CONFIG = {
+	enabled: false,
+	libPath: "~partytown",
+	forward: [],
+	debug: false,
+	logScriptExecution: false,
+	nonBlocking: true
+};
+/** Merge user config with defaults. */
+function resolvePartyTownConfig(config) {
+	return {
+		...DEFAULT_CONFIG,
+		...config
+	};
+}
+/**
+* Generate the inline Partytown config script for `<head>`.
+*
+* This script configures `window.partytown` **before** the Partytown lib
+* snippet loads. The Partytown lib is loaded via a separate `<script>`
+* tag that reads `window.partytown` for configuration.
+*
+* Returns an empty string if Partytown is not enabled.
+*/
+function getPartyTownScript(config) {
+	if (!config.enabled) return "";
+	const settings = [];
+	if (config.libPath !== DEFAULT_CONFIG.libPath) settings.push(`lib: ${JSON.stringify(`${config.libPath}/`)}`);
+	if (config.forward.length > 0) settings.push(`forward: ${JSON.stringify(config.forward)}`);
+	if (config.mainAccess && config.mainAccess.length > 0) settings.push(`mainAccess: ${JSON.stringify(config.mainAccess)}`);
+	if (config.debug) settings.push(`debug: true`);
+	if (config.logScriptExecution) settings.push(`logScriptExecution: true`);
+	if (!config.nonBlocking) settings.push(`nonBlocking: false`);
+	return `<script>partytown = ${settings.length > 0 ? `{ ${settings.join(", ")} }` : "{}"};<\/script>
+    <script src="${`${config.libPath}/partytown.js`}" defer><\/script>`;
+}
+/**
+* Generate the full HTML for Partytown initialization.
+* Used by the Vite plugin to inject into `<head>`.
+*/
+function getPartyTownHeadContent(config) {
+	return getPartyTownScript(config);
+}
+/** Create a script element with the given src and options. */
+function createScriptElement(src, options) {
+	const script = document.createElement("script");
+	script.src = src;
+	if (options.partytown) script.type = "text/partytown";
+	else if (options.type) script.type = options.type;
+	if (options.async !== void 0) script.async = options.async;
+	else if (!options.partytown && options.type !== "module") script.async = true;
+	if (options.defer) script.defer = true;
+	if (options.crossorigin) script.crossOrigin = options.crossorigin;
+	if (options.referrerPolicy) script.referrerPolicy = options.referrerPolicy;
+	if (options.attrs) for (const [key, value] of Object.entries(options.attrs)) script.setAttribute(key, value);
+	return script;
+}
+/** Load a script element and return a promise that resolves on load. */
+function loadScriptElement(script, container) {
+	return new Promise((resolve, reject) => {
+		script.addEventListener("load", () => resolve(), { once: true });
+		script.addEventListener("error", (e) => reject(e), { once: true });
+		container.appendChild(script);
+	});
+}
+/**
+* Load a third-party script with a loading strategy.
+*
+* @param src - The script URL
+* @param options - Loading options
+* @returns Script control object with `load()`, `remove()`, and reactive state
+*
+* @example
+* ```typescript
+* // Load immediately with Partytown
+* useScript('https://www.googletagmanager.com/gtag/js?id=GA_ID', {
+*   partytown: true,
+*   trigger: 'load'
+* });
+*
+* // Load when browser is idle
+* const { load } = useScript('/heavy-script.js', { trigger: 'idle' });
+*
+* // Load when element is visible
+* const targetRef = ref<HTMLElement | null>(null);
+* useScript('/analytics.js', { trigger: 'visible', target: targetRef });
+* ```
+*/
+function useScript(src, options = {}) {
+	const script = ref(null);
+	const loaded = ref(false);
+	const error = ref(false);
+	const trigger = options.trigger || "load";
+	let observer = null;
+	let idleCallbackId = null;
+	let loadPromise = null;
+	let isRemoved = false;
+	function doLoad() {
+		if (script.value || loaded.value || error.value || isRemoved) return;
+		if (typeof document === "undefined") return;
+		const el = createScriptElement(src, options);
+		script.value = markRaw(el);
+		loadPromise = loadScriptElement(el, document.head).then(() => {
+			if (isRemoved) return;
+			loaded.value = true;
+		}).catch(() => {
+			if (isRemoved) return;
+			error.value = true;
+		});
+	}
+	function load() {
+		doLoad();
+	}
+	function remove() {
+		isRemoved = true;
+		if (observer) {
+			observer.disconnect();
+			observer = null;
+		}
+		if (idleCallbackId !== null && typeof cancelIdleCallback === "function") {
+			cancelIdleCallback(idleCallbackId);
+			idleCallbackId = null;
+		}
+		if (script.value && script.value.parentNode) script.value.parentNode.removeChild(script.value);
+		script.value = null;
+		loaded.value = false;
+		error.value = false;
+		loadPromise = null;
+	}
+	function waitForLoad() {
+		if (!loadPromise) doLoad();
+		return loadPromise || Promise.resolve();
+	}
+	if (typeof window !== "undefined") {
+		if (trigger === "load") {
+			if (getCurrentInstance()) onMounted(() => doLoad());
+			else doLoad();
+		} else if (trigger === "idle") {
+			const scheduleLoad = () => {
+				if (typeof requestIdleCallback === "function") idleCallbackId = requestIdleCallback(() => {
+					idleCallbackId = null;
+					doLoad();
+				});
+				else setTimeout(() => doLoad(), 1);
+			};
+			if (getCurrentInstance()) onMounted(() => scheduleLoad());
+			else scheduleLoad();
+		} else if (trigger === "visible") {
+			const targetRef = options.target;
+			if (!targetRef) {
+				if (getCurrentInstance()) onMounted(() => doLoad());
+				else doLoad();
+			} else {
+				const setupObserver = () => {
+					const el = targetRef.value;
+					if (!el) return;
+					observer = new IntersectionObserver((entries) => {
+						for (const entry of entries) if (entry.isIntersecting) {
+							doLoad();
+							observer?.disconnect();
+							observer = null;
+							break;
+						}
+					}, {
+						rootMargin: options.rootMargin || "0px",
+						threshold: options.threshold ?? 0
+					});
+					observer.observe(el);
+				};
+				if (getCurrentInstance()) onMounted(() => {
+					if (targetRef.value) setupObserver();
+					else setTimeout(setupObserver, 0);
+				});
+				else setupObserver();
+			}
+		}
+	}
+	if (getCurrentInstance()) onUnmounted(() => {
+		if (options.removeOnUnmount) remove();
+		else {
+			if (observer) {
+				observer.disconnect();
+				observer = null;
+			}
+			if (idleCallbackId !== null && typeof cancelIdleCallback === "function") {
+				cancelIdleCallback(idleCallbackId);
+				idleCallbackId = null;
+			}
+		}
+	});
+	return {
+		script,
+		loaded,
+		error,
+		load,
+		remove,
+		waitForLoad
+	};
+}
+/**
+* Global Partytown configuration state.
+* Set by `configurePartyTown()` during app initialization.
+*/
+let _config = DEFAULT_CONFIG;
+/** Configure the Partytown module globally. */
+function configurePartyTown(config) {
+	_config = resolvePartyTownConfig(config);
+	return _config;
+}
+/** Get the current Partytown config. */
+function getPartyTownConfig() {
+	return _config;
+}
+/** Check if Partytown is enabled. */
+function isPartyTownEnabled() {
+	return _config.enabled;
+}
+/** Reset Partytown module state (for testing). @internal */
+function _resetPartyTown() {
+	_config = DEFAULT_CONFIG;
+}
+//#endregion
+//#region src/search.ts
+/**
+* P9-26: Full-text search via Pagefind integration.
+*
+* Aligns with Astro Pagefind integration. Pagefind is a static-site search
+* tool that indexes built HTML files at build time and provides a client-side
+* search API at runtime.
+*
+* Provides:
+* - `useSearch(options?)` composable wrapping the Pagefind browser API with
+*   reactive `results` / `loading` / `error` state and built-in debounce.
+* - `initPagefind(options)` loads and initializes the Pagefind browser library
+*   from the generated `/pagefind/` assets.
+* - `resolveSearchConfig(config)` merges user config with defaults.
+*
+* The Pagefind index is generated at build time by the Vite plugin's
+* `closeBundle` hook (runs `npx pagefind --site <outputDir>`). At runtime,
+* the browser dynamically imports `/pagefind/pagefind-modern.js`.
+*
+* Usage (composable):
+* ```typescript
+* const { results, search, loading, clear } = useSearch({ debounce: 200 });
+*
+* // In a template: <input @input="search($event.target.value)" />
+* // results.value is an array of SearchResult
+* ```
+*/
+const DEFAULT_RUNTIME_CONFIG = {
+	pagefindPath: "/pagefind/pagefind-modern.js",
+	debounce: 150,
+	limit: 10
+};
+let runtimeConfig = { ...DEFAULT_RUNTIME_CONFIG };
+/**
+* Configure the search runtime globally. Call this in `app.ts` (client-side)
+* to override defaults before any `useSearch()` call.
+*/
+function configureSearch(config) {
+	runtimeConfig = {
+		...runtimeConfig,
+		...config
+	};
+}
+/** Get the current runtime search config. */
+function getSearchConfig() {
+	return runtimeConfig;
+}
+/** Resolve a user-provided config object into a full SearchRuntimeConfig. */
+function resolveSearchConfig(config) {
+	if (config === true || config === void 0) return { ...DEFAULT_RUNTIME_CONFIG };
+	return {
+		...DEFAULT_RUNTIME_CONFIG,
+		...config
+	};
+}
+let pagefindPromise = null;
+let pagefindLoaded = false;
+/**
+* Dynamically import the Pagefind browser library.
+*
+* The library is generated at build time into `<outputDir>/pagefind/` and
+* served at `/pagefind/pagefind-modern.js`. In dev mode or when Pagefind is
+* not enabled, the import will fail — callers should catch and show a message.
+*/
+async function initPagefind(options = {}) {
+	if (pagefindPromise) return pagefindPromise;
+	const path = options.pagefindPath || runtimeConfig.pagefindPath;
+	pagefindPromise = import(
+		/* @vite-ignore */
+		path
+).then((mod) => {
+		pagefindLoaded = true;
+		if (typeof mod?.init === "function") mod.init();
+		return mod;
+	}).catch((err) => {
+		pagefindPromise = null;
+		throw new Error(`[ubean/search] Failed to load Pagefind from "${path}". Ensure \`search: true\` is set in ubean.config.ts and the site has been built. Original error: ${err instanceof Error ? err.message : String(err)}`);
+	});
+	return pagefindPromise;
+}
+/** Check whether the Pagefind browser library has been loaded. */
+function isPagefindLoaded() {
+	return pagefindLoaded;
+}
+/**
+* Execute a raw Pagefind search. Returns normalized `SearchResult[]`.
+*
+* Exposed for advanced use cases where the reactive composable is not needed
+* (e.g. server-side API routes that proxy search requests).
+*/
+async function executeSearch(query, options = {}) {
+	if (!query.trim()) return [];
+	const pagefind = await initPagefind({ pagefindPath: options.pagefindPath });
+	const searchOptions = {};
+	if (options.filters?.filters) searchOptions.filters = options.filters.filters;
+	if (options.filters?.sort) searchOptions.sort = options.filters.sort;
+	const searchResult = await pagefind.search(query, searchOptions);
+	const limit = options.limit ?? runtimeConfig.limit;
+	return await Promise.all((searchResult.results || []).slice(0, limit).map(async (r, index) => {
+		const data = typeof r.data === "function" ? await r.data() : r.data || {};
+		return {
+			id: r.id ?? index,
+			url: data.url || r.url || "",
+			excerpt: data.excerpt || r.excerpt || "",
+			meta: data.meta || r.meta || {},
+			score: r.score ?? 0,
+			wordCount: data.word_count || r.word_count,
+			data: r.data
+		};
+	}));
+}
+/**
+* `useSearch` — reactive Pagefind search composable.
+*
+* Lazily loads the Pagefind browser library on first search and provides
+* reactive `results`, `loading`, and `error` state. Built-in debounce
+* prevents excessive searches while the user is typing.
+*
+* @example
+* ```vue
+* <script setup>
+* const { search, results, loading } = useSearch({ debounce: 200 });
+* <\/script>
+*
+* <template>
+*   <input
+*     type="search"
+*     placeholder="Search..."
+*     @input="search($event.target.value)"
+*   />
+*   <div v-if="loading">Searching...</div>
+*   <ul v-else>
+*     <li v-for="r in results" :key="r.id">
+*       <a :href="r.url" v-html="r.meta.title || r.url" />
+*       <p v-html="r.excerpt" />
+*     </li>
+*   </ul>
+* </template>
+* ```
+*/
+function useSearch(options = {}) {
+	const debounce = options.debounce ?? runtimeConfig.debounce;
+	const limit = options.limit ?? runtimeConfig.limit;
+	const defaultFilters = options.filters;
+	const query = ref("");
+	const results = shallowRef([]);
+	const loading = ref(false);
+	const error = ref(null);
+	const ready = ref(false);
+	let debounceTimer = null;
+	let lastQuery = "";
+	async function doSearch(q, filters) {
+		const trimmed = q.trim();
+		if (!trimmed) {
+			results.value = [];
+			query.value = "";
+			error.value = null;
+			loading.value = false;
+			return;
+		}
+		if (trimmed === lastQuery) return;
+		lastQuery = trimmed;
+		loading.value = true;
+		error.value = null;
+		try {
+			const found = await executeSearch(trimmed, {
+				filters: filters ?? defaultFilters,
+				limit,
+				pagefindPath: options.pagefindPath
+			});
+			results.value = found;
+			ready.value = true;
+		} catch (err) {
+			error.value = err instanceof Error ? err.message : String(err);
+			results.value = [];
+		} finally {
+			loading.value = false;
+		}
+	}
+	function search(q, filters) {
+		query.value = q;
+		if (debounce > 0) {
+			if (debounceTimer) clearTimeout(debounceTimer);
+			return new Promise((resolve) => {
+				debounceTimer = setTimeout(() => {
+					debounceTimer = null;
+					doSearch(q, filters).finally(resolve);
+				}, debounce);
+			});
+		}
+		return doSearch(q, filters);
+	}
+	function clear() {
+		if (debounceTimer) {
+			clearTimeout(debounceTimer);
+			debounceTimer = null;
+		}
+		query.value = "";
+		lastQuery = "";
+		results.value = [];
+		loading.value = false;
+		error.value = null;
+	}
+	async function preload() {
+		try {
+			await initPagefind({ pagefindPath: options.pagefindPath });
+			ready.value = true;
+		} catch (err) {
+			error.value = err instanceof Error ? err.message : String(err);
+		}
+	}
+	if (options.immediate) search(options.immediate);
+	return {
+		query,
+		results,
+		loading,
+		error,
+		ready,
+		search,
+		clear,
+		preload
+	};
+}
+/** Reset all internal state (for unit tests only). */
+function _resetSearch() {
+	pagefindPromise = null;
+	pagefindLoaded = false;
+	runtimeConfig = { ...DEFAULT_RUNTIME_CONFIG };
+}
+/**
+* Inject a mock Pagefind module for testing.
+*
+* The mock replaces the dynamic `import()` so tests can simulate search
+* results without a real Pagefind build. Also calls `mock.init()` to mimic
+* the real library's initialization.
+*/
+function _setPagefindMock(mock) {
+	pagefindLoaded = true;
+	if (typeof mock?.init === "function") mock.init();
+	pagefindPromise = Promise.resolve(mock);
+}
+//#endregion
+export { ERROR_KEY, ErrorBoundary, Head, LAYOUT_CHAIN_KEY, LOADING_KEY, LOCALIZE_PATH_KEY, LayoutChainRenderer, Link, PAGE_KEY, PageView, SSR_KEY, SlotView, TRANSITION_KEY, _resetColorMode, _resetPartyTown, _resetSearch, _setPagefindMock, addLocale, applyAppConfig, clearCache, clearLocales, clearPageTransition, collectIslands, configureColorMode, configurePartyTown, configureSearch, createClientHead, createDataCacheStore, createDefaultAppConfig, createLinkHandler, createUbeanClientApp, createUbeanRouter, createUbeanSSRApp, createUseAsyncData, defineApp, defineDataKey, defineLocale, defineMeta, defineMiddleware, definePage, detectBrowserLocale, detectLocale, disablePageCache, enablePageCache, excludePageCache, executeSearch, extractLocaleFromPath, extractPageData, forceColorMode, getCacheEnabled, getCachedViewNames, getColorModeConfig, getColorModeScript, getDefaultLocale, getExcludedViewNames, getI18nConfig, getInitialPageData, getInitialState, getInvalidatedKeysForAction, getLocale, getLocaleDir, getLocaleName, getNamedPageWrapper, getNavigationType, getPageTransitionName, getPartyTownConfig, getPartyTownHeadContent, getPartyTownScript, getRegisteredLocales, getReloadCounter, getSearchConfig, hydrateIsland, hydrateIslands, includePageCache, initCachedViewsFromRoutes, initClientI18n, initPagefind, injectHead, invalidateCache, invalidatePageCache, isActiveRoute, isCacheEnabled, isPageCached, isPageExcluded, isPagefindLoaded, isPartyTownEnabled, isReloading, localizePath, mergeAppConfig, mergeLocale, onLocaleChange, reloadPage, resetNamedPageWrappers, resetRouteCache, resolveColorModeConfig, resolvePartyTownConfig, resolveRoute, resolveSearchConfig, setI18nConfig, setLocale, setPageTransition, supportsViewTransitions, switchLocalePath, t, ubeanVue, unforceColorMode, useCacheViews, useColorMode, useUnheadHead as useHead, useHeadInstance, useI18n, useLocalePath, usePage, usePageTransition, useReloadSignal, useRouter, useScript, useSearch, useSeoMeta, useServerData, useSwitchLocalePath, useViewTransition, useViewTransitionState, withViewTransition };