@ilha/router 0.9.1 → 0.9.2

package/dist/src-BBsbD5vU.js

@@ -0,0 +1,2365 @@
+import { ISLAND_MOUNT_HANDLES, ISLAND_MOUNT_INTERNAL, context, html, ilha, mount } from "ilha";
+
+//#region src/hash.ts
+const isBrowser$1 = typeof window !== "undefined" && typeof document !== "undefined";
+const historyAdapter = {
+	readLocation() {
+		if (!isBrowser$1) return {
+			pathname: "/",
+			search: "",
+			hash: ""
+		};
+		return {
+			pathname: location.pathname,
+			search: location.search,
+			hash: location.hash
+		};
+	},
+	push(to, state) {
+		if (!isBrowser$1) return;
+		history.pushState(state ?? null, "", to);
+	},
+	replace(to, state) {
+		if (!isBrowser$1) return;
+		history.replaceState(state ?? null, "", to);
+	},
+	onChange(handler) {
+		if (!isBrowser$1) return () => {};
+		window.addEventListener("popstate", handler);
+		return () => window.removeEventListener("popstate", handler);
+	},
+	toLinkHref(p) {
+		return p;
+	},
+	extractLogicalPath(anchor) {
+		const href = anchor.getAttribute("href");
+		if (!href) return null;
+		if (anchor.protocol && !/^(http:|https:)$/.test(anchor.protocol)) return null;
+		if (href.startsWith("#")) return null;
+		if (!!anchor.hostname && (anchor.hostname !== location.hostname || anchor.protocol !== location.protocol)) return null;
+		return anchor.pathname + anchor.search + anchor.hash;
+	}
+};
+function parseHash(rawHash) {
+	const stripped = rawHash.startsWith("#") ? rawHash.slice(1) : rawHash;
+	const path = stripped === "" ? "/" : stripped.startsWith("/") ? stripped : "/" + stripped;
+	const u = new URL(path, "http://_");
+	return {
+		pathname: u.pathname,
+		search: u.search,
+		hash: u.hash
+	};
+}
+const hashAdapter = {
+	readLocation() {
+		if (!isBrowser$1) return {
+			pathname: "/",
+			search: "",
+			hash: ""
+		};
+		return parseHash(location.hash);
+	},
+	push(to, state) {
+		if (!isBrowser$1) return;
+		history.pushState(state ?? null, "", to.startsWith("#") ? to : "#" + to);
+	},
+	replace(to, state) {
+		if (!isBrowser$1) return;
+		history.replaceState(state ?? null, "", to.startsWith("#") ? to : "#" + to);
+	},
+	onChange(handler) {
+		if (!isBrowser$1) return () => {};
+		window.addEventListener("popstate", handler);
+		window.addEventListener("hashchange", handler);
+		return () => {
+			window.removeEventListener("popstate", handler);
+			window.removeEventListener("hashchange", handler);
+		};
+	},
+	toLinkHref(p) {
+		if (p.startsWith("#")) return p;
+		return "#" + p;
+	},
+	extractLogicalPath(anchor) {
+		const href = anchor.getAttribute("href");
+		if (!href) return null;
+		if (anchor.protocol && !/^(http:|https:)$/.test(anchor.protocol)) return null;
+		if (href.startsWith("#")) {
+			const inner = href.slice(1);
+			if (inner === "" || !inner.startsWith("/")) return null;
+			return inner;
+		}
+		if (/^https?:\/\//i.test(href)) try {
+			const u = new URL(href);
+			if (u.origin !== location.origin) return null;
+			if (!u.hash || u.hash === "#") return null;
+			const inner = u.hash.slice(1);
+			if (!inner.startsWith("/")) return null;
+			return inner;
+		} catch {
+			return null;
+		}
+		return href;
+	}
+};
+let _mode = "history";
+let _adapter = historyAdapter;
+/**
+* Set the router's history mode. Call this once at app entry, before
+* mounting any router. Defaults to "history" (HTML5 History API).
+*
+* Use "hash" when the document is loaded over file:// (Electron, Tauri, etc.)
+* or any time there's no server able to serve a SPA fallback at arbitrary
+* pathnames.
+*
+* Switching modes mid-session is supported but not common — listeners
+* registered before the switch will keep using their original adapter
+* until they're re-attached (typically by unmounting and remounting
+* the router).
+*/
+function setHistoryMode(mode) {
+	_mode = mode;
+	_adapter = mode === "hash" ? hashAdapter : historyAdapter;
+}
+function getHistoryMode() {
+	return _mode;
+}
+/** Internal — used by index.ts. Not part of the public API. */
+function getAdapter() {
+	return _adapter;
+}
+
+//#endregion
+//#region src/route-match.ts
+function parsePattern(pattern) {
+	const segments = pattern.split("/").filter(Boolean);
+	return {
+		segments,
+		kinds: segments.map((segment) => segment.startsWith("*") ? 0 : segment.startsWith(":") ? 1 : 2)
+	};
+}
+/**
+* Match `segments` against a pathname. Returns raw (still-encoded) captured
+* params, or `null` when the path doesn't match — the caller decides whether to
+* decode via {@link safeDecode}.
+*/
+function matchSegments(segments, pathname) {
+	const pathSegments = pathname.split("/").filter(Boolean);
+	const params = {};
+	let cursor = 0;
+	for (let i = 0; i < segments.length; i++) {
+		const segment = segments[i];
+		const isLast = i === segments.length - 1;
+		if (segment.startsWith("**") && isLast) {
+			const name = segment.slice(2).replace(/^:/, "");
+			if (name) params[name] = pathSegments.slice(cursor).join("/");
+			cursor = pathSegments.length;
+			break;
+		}
+		if (segment.startsWith("*")) {
+			if (pathSegments[cursor] === void 0) return null;
+			cursor++;
+			continue;
+		}
+		if (segment.startsWith(":")) {
+			const value = pathSegments[cursor];
+			if (value === void 0) return null;
+			params[segment.slice(1)] = value;
+			cursor++;
+		} else if (pathSegments[cursor] === segment) cursor++;
+		else return null;
+	}
+	return cursor === pathSegments.length ? params : null;
+}
+/** Decode a route-param value, tolerating malformed percent-encoding. */
+function safeDecode(value) {
+	try {
+		return decodeURIComponent(value);
+	} catch {
+		return value;
+	}
+}
+
+//#endregion
+//#region src/index.ts
+const isBrowser = typeof window !== "undefined" && typeof document !== "undefined";
+/**
+* Identity function for declaring a loader. Exists purely as a type anchor and
+* a marker for the Vite plugin to detect by export name.
+*
+* Loaders must read `ctx.params`/`ctx.url` rather than `useRoute()` — the
+* route store still holds the previous route while a navigation's loader is
+* in flight, so `useRoute().params()` inside a loader reads stale params.
+*/
+function loader(fn) {
+	return fn;
+}
+/**
+* Declare a loader that runs in the browser when the view hydrates or on
+* client navigations:(() => head({ title: "About" }));
+*
+* Inside `.server.tsx` pages the function executes over RPC when the view
+* hydrates (its code never ships); it is a side-effect loader there — the
+* return value cannot flow back into server-rendered island markup.
+*/
+loader.client = (fn) => fn;
+function isValidRedirectStatus(status) {
+	return status >= 300 && status <= 399;
+}
+function isValidErrorStatus(status) {
+	return status >= 400 && status <= 599;
+}
+var Redirect = class {
+	__ilhaRedirect = true;
+	to;
+	status;
+	constructor(to, status = 302) {
+		this.to = to;
+		this.status = isValidRedirectStatus(status) ? status : 302;
+	}
+};
+var LoaderError = class {
+	__ilhaLoaderError = true;
+	status;
+	message;
+	constructor(status, message) {
+		this.message = message;
+		this.status = isValidErrorStatus(status) ? status : 500;
+	}
+};
+function redirect(to, status = 302) {
+	throw new Redirect(to, status);
+}
+function error(status, message) {
+	throw new LoaderError(status, message);
+}
+/**
+* Compose a list of loaders into a single loader. Later loaders win on key
+* collision (page loader overrides layout loader for the same key). All loaders
+* run concurrently within a chain since they share the same abort signal and
+* request — re-fetching is cheap with a request-scoped cache (future work).
+*
+* For v1 we run them in parallel via `Promise.all`. If a loader throws a
+* `Redirect` or `LoaderError`, the composed loader re-throws it unchanged.
+*/
+function composeLoaders(loaders) {
+	if (loaders.length === 0) return async () => ({});
+	if (loaders.length === 1) return loaders[0];
+	return async (ctx) => {
+		const results = await Promise.all(loaders.map((l) => l(ctx)));
+		return Object.assign({}, ...results);
+	};
+}
+const WRAP_LAYOUT_LEAF = Symbol.for("ilha.router.wrapLayout.leaf");
+const WRAP_LAYOUT_HANDLER = Symbol.for("ilha.router.wrapLayout.handler");
+const ISLAND_CALL = Symbol.for("ilha.islandCall");
+function extractHydratableInnerHtml(block) {
+	const m = block.match(/^<([a-zA-Z][\w-]*)\s[^>]*>([\s\S]*)<\/\1>\s*$/);
+	return m ? m[2] : block;
+}
+function parseHydratableOpenTag(block) {
+	const m = block.match(/^<([a-zA-Z][\w-]*)\s([^>]*)>/);
+	if (!m) return null;
+	return {
+		tag: m[1],
+		attrs: m[2]
+	};
+}
+const K_PAGE_RAW_OPEN_RE = /<(pre|script|style|textarea)\b/i;
+/** Skip through matching close tag, allowing nested `<pre>` (twoslash popups inside code blocks). */
+function skipRawElement(html, i, tag) {
+	const openRe = new RegExp(`<${tag}\\b`, "gi");
+	const closeRe = new RegExp(`</${tag}>`, "gi");
+	let depth = 1;
+	let pos = i;
+	while (depth > 0 && pos < html.length) {
+		openRe.lastIndex = pos;
+		closeRe.lastIndex = pos;
+		const openM = openRe.exec(html);
+		const closeM = closeRe.exec(html);
+		if (!closeM) return null;
+		if (openM && openM.index < closeM.index) {
+			depth += 1;
+			pos = openM.index + openM[0].length;
+		} else {
+			depth -= 1;
+			if (depth === 0) return closeM.index + closeM[0].length;
+			pos = closeM.index + closeM[0].length;
+		}
+	}
+	return pos;
+}
+/** Next `<div` or `</div>` outside raw/pre/script regions (MDX + twoslash often contain `</div>` / nested `<pre>`). */
+function nextDivToken(html, from) {
+	let i = from;
+	while (i < html.length) {
+		if (html.startsWith("<!--", i)) {
+			const end = html.indexOf("-->", i);
+			if (end === -1) return null;
+			i = end + 3;
+			continue;
+		}
+		const skip = html.slice(i).match(K_PAGE_RAW_OPEN_RE);
+		if (skip && skip.index != null && skip.index >= 0) {
+			const rawStart = i + skip.index;
+			let skipComment = false;
+			let search = i;
+			while (search < rawStart) {
+				const commentStart = html.indexOf("<!--", search);
+				if (commentStart === -1 || commentStart >= rawStart) break;
+				const commentEnd = html.indexOf("-->", commentStart);
+				if (commentEnd === -1) return null;
+				if (rawStart < commentEnd + 3) {
+					i = commentEnd + 3;
+					skipComment = true;
+					break;
+				}
+				search = commentEnd + 3;
+			}
+			if (skipComment) continue;
+			const nextOpen = html.indexOf("<div", i);
+			const nextClose = html.indexOf("</div>", i);
+			if (!(nextOpen !== -1 && nextOpen < rawStart || nextClose !== -1 && nextClose < rawStart)) {
+				const tag = skip[1].toLowerCase();
+				const end = skipRawElement(html, rawStart + skip[0].length, tag);
+				if (end === null) return null;
+				i = end;
+				continue;
+			}
+		}
+		const nextOpen = html.indexOf("<div", i);
+		const nextClose = html.indexOf("</div>", i);
+		if (nextClose === -1 && nextOpen === -1) return null;
+		if (nextOpen === -1 || nextClose !== -1 && nextClose < nextOpen) return {
+			kind: "close",
+			index: nextClose
+		};
+		return {
+			kind: "open",
+			index: nextOpen
+		};
+	}
+	return null;
+}
+function findKPageSlotSpans(layoutHtml) {
+	const spans = [];
+	for (const m of layoutHtml.matchAll(/<div\s[^>]*data-ilha-slot="k:page"[^>]*>/g)) {
+		const openEnd = m.index + m[0].length;
+		let depth = 1;
+		let i = openEnd;
+		while (depth > 0) {
+			const token = nextDivToken(layoutHtml, i);
+			if (!token) break;
+			if (token.kind === "open") {
+				depth += 1;
+				i = token.index + 4;
+			} else {
+				depth -= 1;
+				if (depth === 0) {
+					spans.push({
+						openEnd,
+						closeStart: token.index
+					});
+					break;
+				}
+				i = token.index + 6;
+			}
+		}
+	}
+	return spans;
+}
+/** Replace inner HTML of the first or innermost `k:page` slot (empty or pre-filled). */
+function injectKPageSlot(layoutHtml, slotInnerHtml, which) {
+	const spans = findKPageSlotSpans(layoutHtml);
+	if (spans.length === 0) return layoutHtml;
+	const target = which === "innermost" ? spans[spans.length - 1] : spans[0];
+	return layoutHtml.slice(0, target.openEnd) + slotInnerHtml + layoutHtml.slice(target.closeStart);
+}
+function layoutHtmlWithEmptyKPage(wrappedLayout, props) {
+	const handler = wrappedLayout[WRAP_LAYOUT_HANDLER];
+	if (!handler) return wrappedLayout.toString(props);
+	const rawKeyed = (wrappedLayout[WRAP_LAYOUT_LEAF] ?? wrappedLayout).key("page");
+	const shellChild = ((partial) => rawKeyed({
+		...props,
+		...partial ?? {}
+	}));
+	Object.assign(shellChild, { toString: () => "" });
+	shellChild[ISLAND_CALL] = true;
+	return handler(shellChild).toString(props);
+}
+async function wrapLayoutSlotMarkup(innerWrapped, leafPage, props, opts) {
+	const pageInner = extractHydratableInnerHtml(await leafPage.hydratable(props, opts));
+	return injectKPageSlot(injectKPageSlot(layoutHtmlWithEmptyKPage(innerWrapped, props), "", "innermost"), pageInner, "innermost");
+}
+function wrapLayout(layout, page) {
+	const leafPage = page[WRAP_LAYOUT_LEAF] ?? page;
+	const childWrapped = leafPage === page ? null : page;
+	const rawKeyedPage = page.key("page");
+	const layoutInputRef = {};
+	const KeyedPage = ((props) => {
+		const merged = layoutInputRef.merged;
+		const slotProps = merged && typeof merged === "object" ? {
+			...merged,
+			...props ?? {}
+		} : props;
+		return rawKeyedPage(slotProps);
+	});
+	Object.assign(KeyedPage, { toString: page.toString.bind(page) });
+	KeyedPage[ISLAND_CALL] = true;
+	const Wrapped = layout(KeyedPage);
+	Wrapped[WRAP_LAYOUT_LEAF] = leafPage;
+	Wrapped[WRAP_LAYOUT_HANDLER] = layout;
+	function setLayoutMergedInput(props) {
+		layoutInputRef.merged = props;
+	}
+	function pageMountHost(host) {
+		const slots = [...host.querySelectorAll("[data-ilha-slot=\"k:page\"]")].filter((slot) => {
+			const boundary = slot.closest("[data-ilha]");
+			return boundary === null || boundary === host;
+		});
+		if (slots.length === 0) return host;
+		return slots[slots.length - 1];
+	}
+	function preparePageMountHost(outer, mountHost) {
+		const applyOuterSnapshot = (snapshot) => {
+			delete snapshot._skipOnMount;
+			mountHost.setAttribute("data-ilha-state", JSON.stringify(snapshot));
+		};
+		if (mountHost.hasAttribute("data-ilha-state")) {
+			const outerState = outer.getAttribute("data-ilha-state");
+			if (outerState) try {
+				applyOuterSnapshot(JSON.parse(outerState));
+				return;
+			} catch {}
+			const slotState = mountHost.getAttribute("data-ilha-state");
+			if (slotState) try {
+				const snapshot = JSON.parse(slotState);
+				delete snapshot._skipOnMount;
+				mountHost.setAttribute("data-ilha-state", JSON.stringify(snapshot));
+			} catch {}
+			return;
+		}
+		const outerState = outer.getAttribute("data-ilha-state");
+		if (outerState) try {
+			applyOuterSnapshot(JSON.parse(outerState));
+			return;
+		} catch {}
+		if (mountHost.childNodes.length > 0) mountHost.setAttribute("data-ilha-state", "{}");
+	}
+	function wrapLeafPageMountHooks(leaf) {
+		const leafInternal = leaf[ISLAND_MOUNT_INTERNAL];
+		if (typeof leafInternal !== "function") return;
+		leaf[ISLAND_MOUNT_INTERNAL] = (host, props) => {
+			const outer = host.closest("[data-ilha]");
+			if (outer && outer !== host) preparePageMountHost(outer, host);
+			return leafInternal(host, props);
+		};
+		const leafMount = leaf.mount.bind(leaf);
+		leaf.mount = (host, props) => {
+			const outer = host.closest("[data-ilha]");
+			if (outer && outer !== host) preparePageMountHost(outer, host);
+			return leafMount(host, props);
+		};
+	}
+	wrapLeafPageMountHooks(leafPage);
+	const pageHandles = /* @__PURE__ */ new Map();
+	const pageInternalBase = page[ISLAND_MOUNT_INTERNAL];
+	if (typeof pageInternalBase === "function") page[ISLAND_MOUNT_INTERNAL] = (host, props) => {
+		const handle = pageInternalBase(host, props);
+		const entry = {
+			handle,
+			mountProps: props
+		};
+		pageHandles.set(host, entry);
+		return {
+			unmount: () => {
+				if (pageHandles.get(host) === entry) pageHandles.delete(host);
+				return handle.unmount();
+			},
+			updateProps: (p) => {
+				entry.mountProps = p;
+				handle.updateProps(p);
+			}
+		};
+	};
+	/**
+	* In-place prop update for one mounted layout instance: refresh the
+	* merged-input ref (so any layout re-render passes fresh props to `k:page`),
+	* push the merged loader props directly into the page mounted under *this*
+	* layout host (spread over its latest slot props so layout-provided extras
+	* survive), then update the layout island's own input. Page-first ordering
+	* lets a layout that *does* read its input re-render afterwards and win with
+	* its own fresher slot props.
+	*/
+	const layoutUpdateProps = (layoutHost, coreUpdate) => (p) => {
+		setLayoutMergedInput(p);
+		for (const [pageHost, entry] of pageHandles) if (layoutHost.contains(pageHost)) entry.handle.updateProps({
+			...entry.mountProps ?? {},
+			...p ?? {}
+		});
+		coreUpdate?.(p);
+	};
+	const layoutMount = Wrapped.mount.bind(Wrapped);
+	const layoutInternal = Wrapped[ISLAND_MOUNT_INTERNAL];
+	function prepareLayoutMountHost(host) {
+		preparePageMountHost(host, pageMountHost(host));
+	}
+	Wrapped.mount = (host, props) => {
+		setLayoutMergedInput(props);
+		prepareLayoutMountHost(host);
+		const unmount = layoutMount(host, props);
+		const core = ISLAND_MOUNT_HANDLES.get(host);
+		ISLAND_MOUNT_HANDLES.set(host, {
+			unmount,
+			updateProps: layoutUpdateProps(host, core?.updateProps)
+		});
+		return unmount;
+	};
+	Wrapped[ISLAND_MOUNT_INTERNAL] = (host, props) => {
+		setLayoutMergedInput(props);
+		prepareLayoutMountHost(host);
+		const base = typeof layoutInternal === "function" ? layoutInternal(host, props) : {
+			unmount: layoutMount(host, props),
+			updateProps: () => {}
+		};
+		const enhanced = {
+			unmount: base.unmount,
+			updateProps: layoutUpdateProps(host, base.updateProps)
+		};
+		ISLAND_MOUNT_HANDLES.set(host, enhanced);
+		return enhanced;
+	};
+	Wrapped.hydratable = async (props, opts) => {
+		if (!opts?.name) throw new Error("wrapLayout: hydratable requires options.name");
+		const resolvedProps = props ?? {};
+		setLayoutMergedInput(resolvedProps);
+		const pageBlock = await leafPage.hydratable(resolvedProps, opts);
+		const open = parseHydratableOpenTag(pageBlock);
+		if (!open) return pageBlock;
+		let slotContent = extractHydratableInnerHtml(pageBlock);
+		if (childWrapped) slotContent = await wrapLayoutSlotMarkup(childWrapped, leafPage, resolvedProps, opts);
+		const layoutInnerOut = injectKPageSlot(injectKPageSlot(layoutHtmlWithEmptyKPage(Wrapped, resolvedProps), "", "first"), slotContent, "first");
+		return `<${open.tag} ${open.attrs}>${layoutInnerOut}</${open.tag}>`;
+	};
+	return Wrapped;
+}
+function wrapError(handler, page) {
+	const Wrapper = ilha.render(() => {
+		try {
+			return page.toString();
+		} catch (e) {
+			const route = {
+				path: routePath(),
+				params: routeParams(),
+				search: routeSearch(),
+				hash: routeHash()
+			};
+			return handler({
+				message: e.message,
+				status: e.status,
+				stack: e.stack
+			}, route).toString();
+		}
+	});
+	Wrapper.mount = (host, props) => {
+		try {
+			return page.mount(host, props);
+		} catch (e) {
+			const route = {
+				path: routePath(),
+				params: routeParams(),
+				search: routeSearch(),
+				hash: routeHash()
+			};
+			const errorIsland = handler({
+				message: e.message,
+				status: e.status,
+				stack: e.stack
+			}, route);
+			host.innerHTML = errorIsland.toString();
+			return errorIsland.mount(host, props);
+		}
+	};
+	Wrapper[ISLAND_MOUNT_INTERNAL] = (host, props) => {
+		try {
+			const pageInternal = page[ISLAND_MOUNT_INTERNAL];
+			if (typeof pageInternal === "function") return pageInternal(host, props);
+			return {
+				unmount: page.mount(host, props),
+				updateProps: () => {}
+			};
+		} catch (e) {
+			const route = {
+				path: routePath(),
+				params: routeParams(),
+				search: routeSearch(),
+				hash: routeHash()
+			};
+			const errorIsland = handler({
+				message: e.message,
+				status: e.status,
+				stack: e.stack
+			}, route);
+			host.innerHTML = errorIsland.toString();
+			return {
+				unmount: errorIsland.mount(host, props),
+				updateProps: () => {}
+			};
+		}
+	};
+	Wrapper.hydratable = async (props, opts) => {
+		if (!opts?.name) throw new Error("wrapError: hydratable requires options.name");
+		return page.hydratable(props ?? {}, opts);
+	};
+	return Wrapper;
+}
+function defineLayout(layout) {
+	return layout;
+}
+function buildReverseRegistry(registry) {
+	const map = /* @__PURE__ */ new Map();
+	for (const [name, island] of Object.entries(registry)) if (!map.has(island)) map.set(island, name);
+	return map;
+}
+/** Path of the loader endpoint served by the Vite plugin / production adapter. */
+const LOADER_ENDPOINT = "/__ilha/loader";
+/** In-memory cache for prefetched loader data, keyed by path+search. */
+const prefetchCache = /* @__PURE__ */ new Map();
+/** How long a hover prefetch stays servable. Consumed-on-use regardless. */
+const PREFETCH_TTL_MS = 3e4;
+/** Mirrors the last router's `viewTransitions` option (module-level like `_notFound`). */
+let _viewTransitions = false;
+/**
+* Run a synchronous DOM mutation, wrapped in a view transition when enabled
+* and supported (the callback runs async — after the browser snapshots the old
+* view). Resolves with the mutation's result either way.
+*/
+async function withViewSwap(mutate) {
+	const start = document.startViewTransition?.bind(document);
+	if (!_viewTransitions || !start) return mutate();
+	let result;
+	let thrown;
+	let failed = false;
+	await start(() => {
+		try {
+			result = mutate();
+		} catch (e) {
+			failed = true;
+			thrown = e;
+			throw e;
+		}
+	}).updateCallbackDone?.catch(() => {});
+	if (failed) throw thrown;
+	return result;
+}
+/**
+* Execute a loader registered in the browser (manual `.route(p, island, loader)`
+* or FS-routing `loader.client`) and map its result to the loader endpoint's wire
+* shape, so all client mount paths handle both sources identically. Loader
+* `head` contributions are dropped, matching the endpoint fetch path.
+*/
+async function runLocalLoader(loader, matchParams, pathWithSearch, signal) {
+	const url = new URL(pathWithSearch, location.origin);
+	const params = extractParams(matchParams);
+	const headEntries = [];
+	const result = await executeLoader(loader, url, params, defaultRequest(url), signal ?? new AbortController().signal, (input) => headEntries.push(input));
+	signal?.throwIfAborted();
+	if (result.kind === "redirect") {
+		const safe = resolveRedirectTarget(result.to, url, _allowExternalRedirects);
+		if (!safe.ok) {
+			console.warn(`[ilha-router] Blocked unsafe redirect target "${result.to}". Set allowExternalRedirects: true to allow cross-origin redirects.`);
+			return {
+				kind: "error",
+				status: 500,
+				message: "Unsafe redirect target"
+			};
+		}
+		return {
+			kind: "redirect",
+			to: safe.to,
+			status: result.status
+		};
+	}
+	if (result.kind === "data") {
+		const data = envelopLoad(result.data);
+		return headEntries.length > 0 ? {
+			kind: "data",
+			data,
+			headEntries
+		} : {
+			kind: "data",
+			data
+		};
+	}
+	return result;
+}
+async function fetchLoaderData(pathWithSearch, signal) {
+	const cached = prefetchCache.get(pathWithSearch);
+	if (cached) {
+		prefetchCache.delete(pathWithSearch);
+		if (Date.now() <= cached.expires) try {
+			signal?.throwIfAborted();
+			const result = await cached.promise;
+			signal?.throwIfAborted();
+			return result;
+		} catch (e) {
+			if (e?.name === "AbortError") throw e;
+		}
+	}
+	const pathOnly = pathWithSearch.split("?")[0] ?? "";
+	const localMatch = matchRoute(_routes, pathOnly);
+	const localLoader = localMatch?.data?.clientLoader ?? localMatch?.data?.loader;
+	if (localLoader) return runLocalLoader(localLoader, localMatch?.params, pathWithSearch, signal);
+	const url = `${LOADER_ENDPOINT}?path=${encodeURIComponent(pathWithSearch)}`;
+	try {
+		const res = await fetch(url, {
+			signal,
+			headers: { accept: "application/json" }
+		});
+		if (!res.ok) {
+			try {
+				const body = await res.json();
+				if (body && typeof body === "object" && "kind" in body) return body;
+			} catch {}
+			return {
+				kind: "error",
+				status: res.status,
+				message: res.statusText
+			};
+		}
+		const parsed = await res.json();
+		if (parsed.kind === "data" && !localMatch?.data?.clientLoader && parsed.data && typeof parsed.data === "object" && !("load" in parsed.data)) return {
+			...parsed,
+			data: envelopLoad(parsed.data)
+		};
+		return parsed;
+	} catch (e) {
+		if (e?.name === "AbortError") throw e;
+		return {
+			kind: "error",
+			status: 0,
+			message: e?.message ?? "network error"
+		};
+	}
+}
+/**
+* Prefetch loader data for a given path. Safe to call repeatedly — a single
+* inflight request is reused until it either resolves (and is consumed by
+* navigation) or is superseded by another prefetch.
+*/
+function prefetch(pathWithSearch) {
+	if (!isBrowser) return;
+	const existing = prefetchCache.get(pathWithSearch);
+	if (existing && Date.now() <= existing.expires) return;
+	const pathOnly = pathWithSearch.split("?")[0] ?? "";
+	if (!matchRoute(_routes, pathOnly)?.data?.hasLoader) return;
+	const promise = fetchLoaderData(pathWithSearch).catch((e) => {
+		return {
+			kind: "error",
+			status: 0,
+			message: e?.message ?? "prefetch failed"
+		};
+	});
+	prefetchCache.set(pathWithSearch, {
+		promise,
+		expires: Date.now() + PREFETCH_TTL_MS
+	});
+}
+const noopRouteHandle = () => ({
+	unmount: () => {},
+	updateProps: null
+});
+/** Mount an island keeping the full internal handle so later same-island
+* navigations can push new loader props instead of remounting. */
+function mountIslandWithHandle(island, host, props) {
+	const internal = island[ISLAND_MOUNT_INTERNAL];
+	if (typeof internal === "function") {
+		const h = internal(host, props);
+		return {
+			unmount: () => void h.unmount(),
+			updateProps: (p) => h.updateProps(p)
+		};
+	}
+	return {
+		unmount: island.mount(host, props),
+		updateProps: null
+	};
+}
+/**
+* Same-island fast path: fetch fresh loader data and push it into the mounted
+* island via `updateProps` — ilha's fine-grained morph reconciles the DOM, so
+* focus, caret, selection, and scroll survive (the reason persistQuery-driven
+* filter inputs don't blur while typing). Returns "updated" when applied (or
+* redirected), "remount" when the caller must run the full teardown + mount
+* path (loader error / not-found need boundary DOM; the full path re-fetches,
+* accepted for these rare cases). Throws AbortError when superseded.
+*/
+async function updateRouteInPlace(handle, pathWithSearch, signal) {
+	if (!handle.updateProps) return "remount";
+	const result = !!matchRoute(_routes, pathWithSearch.split("?")[0] ?? "")?.data?.hasLoader ? await fetchLoaderData(pathWithSearch, signal) : {
+		kind: "data",
+		data: {}
+	};
+	signal.throwIfAborted();
+	if (result.kind === "redirect") {
+		clientRedirect(result.to);
+		return "updated";
+	}
+	if (result.kind !== "data") return "remount";
+	if (result.headEntries?.length) applyHeadEntriesToDocument([...result.headEntries]);
+	handle.updateProps(result.data);
+	return "updated";
+}
+/**
+* Mounts a route island with proper hydration for client-side navigation.
+* Looks up the island in the reverse registry, runs the loader (via fetch),
+* renders it with hydration markers, and mounts it for interactivity.
+*/
+async function mountRouteWithHydration(island, host, pathWithSearch, signal, registry, reverseRegistry) {
+	if (!island) {
+		if (_notFound) {
+			const nf = _notFound;
+			return withViewSwap(() => {
+				host.innerHTML = `<div data-router-view data-router-not-found>${nf.toString()}</div>`;
+				const nfHost = host.firstElementChild;
+				return {
+					unmount: nfHost ? nf.mount(nfHost) : () => {},
+					updateProps: null
+				};
+			});
+		}
+		await withViewSwap(() => {
+			host.innerHTML = `<div data-router-empty></div>`;
+		});
+		return noopRouteHandle();
+	}
+	const clientMatch = matchRoute(_routes, pathWithSearch.split("?")[0] ?? "");
+	const hasLoader = !!clientMatch?.data?.hasLoader;
+	let props = {};
+	const loaderResult = hasLoader ? await fetchLoaderData(pathWithSearch, signal) : {
+		kind: "data",
+		data: {}
+	};
+	if (loaderResult.kind === "redirect") {
+		clientRedirect(loaderResult.to);
+		return noopRouteHandle();
+	}
+	if (loaderResult.kind === "error") {
+		const boundary = clientMatch?.data?.errorHandler;
+		if (boundary) return withViewSwap(() => ({
+			unmount: mountLoaderErrorBoundary(boundary, host, loaderResult.status, loaderResult.message),
+			updateProps: null
+		}));
+		const escaped = escapeHtml(loaderResult.message);
+		await withViewSwap(() => {
+			host.innerHTML = `<div data-router-view data-router-error="${loaderResult.status}">${escaped}</div>`;
+		});
+		return noopRouteHandle();
+	}
+	if (loaderResult.kind === "not-found") {
+		await withViewSwap(() => {
+			host.innerHTML = `<div data-router-empty></div>`;
+		});
+		return noopRouteHandle();
+	}
+	props = loaderResult.data;
+	const headStore = { entries: [...loaderResult.headEntries ?? []] };
+	if (!registry) {
+		console.warn("[ilha-router] No registry provided for client-side navigation. Island will not be interactive.");
+		const html = await withHeadStore(headStore, () => island.toString(props));
+		await withViewSwap(() => {
+			applyHeadEntriesToDocument(headStore.entries);
+			host.innerHTML = `<div data-router-view>${html}</div>`;
+		});
+		return noopRouteHandle();
+	}
+	const name = reverseRegistry?.get(island) ?? Object.entries(registry).find(([, v]) => v === island)?.[0];
+	if (!name) {
+		console.warn("[ilha-router] Island not found in registry for client-side navigation.");
+		const html = await withHeadStore(headStore, () => island.toString(props));
+		await withViewSwap(() => {
+			applyHeadEntriesToDocument(headStore.entries);
+			host.innerHTML = `<div data-router-view>${html}</div>`;
+		});
+		return noopRouteHandle();
+	}
+	const html = await withHeadStore(headStore, () => island.hydratable(props, {
+		name,
+		as: "div",
+		snapshot: true
+	}));
+	return withViewSwap(() => {
+		applyHeadEntriesToDocument(headStore.entries);
+		host.innerHTML = `<div data-router-view>${html}</div>`;
+		const islandHost = host.querySelector(`[data-ilha="${name}"]`);
+		return islandHost ? mountIslandWithHandle(island, islandHost) : noopRouteHandle();
+	});
+}
+/** Render + mount a `+error` boundary island for a failed loader. */
+function mountLoaderErrorBoundary(boundary, host, status, message) {
+	try {
+		const errorIsland = boundary({
+			message,
+			status
+		}, {
+			path: routePath(),
+			params: routeParams(),
+			search: routeSearch(),
+			hash: routeHash()
+		});
+		host.innerHTML = `<div data-router-view data-router-error="${status}">${errorIsland.toString()}</div>`;
+		const ehHost = host.firstElementChild;
+		return ehHost ? errorIsland.mount(ehHost) : () => {};
+	} catch (e) {
+		console.error("[ilha-router] error boundary threw while rendering a loader error:", e);
+		host.innerHTML = `<div data-router-view data-router-error="${status}"></div>`;
+		return () => {};
+	}
+}
+let _routeAls = null;
+let _routeAlsInit = null;
+async function getRouteAlsAsync() {
+	if (_routeAls) return _routeAls;
+	if (!_routeAlsInit) _routeAlsInit = import("node:async_hooks").then(({ AsyncLocalStorage }) => {
+		_routeAls = new AsyncLocalStorage();
+		return _routeAls;
+	});
+	return _routeAlsInit;
+}
+if (!isBrowser) getRouteAlsAsync().catch(() => {});
+function activeRouteStore() {
+	if (isBrowser) return null;
+	return _routeAls?.getStore() ?? null;
+}
+function freshRouteStore() {
+	return {
+		path: "",
+		params: {},
+		search: "",
+		hash: "",
+		island: null
+	};
+}
+const _routePathSig = context("router.path", "");
+const _routeParamsSig = context("router.params", {});
+const _routeSearchSig = context("router.search", "");
+const _routeHashSig = context("router.hash", "");
+function routePath(value) {
+	const store = activeRouteStore();
+	if (arguments.length > 0) {
+		if (store) return store.path = value;
+		return _routePathSig(value), value;
+	}
+	return store ? store.path : _routePathSig();
+}
+function routeParams(value) {
+	const store = activeRouteStore();
+	if (arguments.length > 0) {
+		if (store) return store.params = value;
+		return _routeParamsSig(value), value;
+	}
+	return store ? store.params : _routeParamsSig();
+}
+function routeSearch(value) {
+	const store = activeRouteStore();
+	if (arguments.length > 0) {
+		if (store) return store.search = value;
+		return _routeSearchSig(value), value;
+	}
+	return store ? store.search : _routeSearchSig();
+}
+function routeHash(value) {
+	const store = activeRouteStore();
+	if (arguments.length > 0) {
+		if (store) return store.hash = value;
+		return _routeHashSig(value), value;
+	}
+	return store ? store.hash : _routeHashSig();
+}
+const _navigatingSig = context("router.navigating", 0);
+/** Reactive: `true` while a client navigation (loader fetch + view swap) is in flight. */
+function navigating() {
+	return _navigatingSig() > 0;
+}
+let _revalidate = null;
+/**
+* Re-run the current route's loader and re-render the view with fresh data —
+* e.g. after a mutation. Resolves when the view has updated. No-op on the
+* server or when no router is mounted.
+*/
+function invalidate() {
+	if (!isBrowser || !_revalidate) return Promise.resolve();
+	return _revalidate();
+}
+/** Mark a navigation as started; returns an idempotent settle callback. */
+function beginNavigation() {
+	if (!isBrowser) return () => {};
+	_navigatingSig(_navigatingSig() + 1);
+	document.documentElement.setAttribute("data-router-pending", "");
+	let done = false;
+	return () => {
+		if (done) return;
+		done = true;
+		_navigatingSig(Math.max(0, _navigatingSig() - 1));
+		if (_navigatingSig() === 0) document.documentElement.removeAttribute("data-router-pending");
+	};
+}
+const REQUEST_ALS_KEY = Symbol.for("ilha.requestAls");
+/**
+* The context seeding the current server-island render. Always returns an
+* object — check `.request` rather than the context itself. Never throws, so
+* render functions stay safe under plain `toString()` calls and in tests.
+*
+* Only meaningful inside `.server.tsx` render functions (page SSR or frame
+* rendering); client code never has a reason to call it.
+*/
+function useContext() {
+	return { request: globalThis[REQUEST_ALS_KEY]?.getStore?.() };
+}
+function useRoute() {
+	return {
+		path: routePath,
+		params: routeParams,
+		search: routeSearch,
+		hash: routeHash,
+		navigating
+	};
+}
+const _activeIslandSig = context("router.active", null);
+function activeIsland(value) {
+	const store = activeRouteStore();
+	if (arguments.length > 0) {
+		const next = value ?? null;
+		if (store) return store.island = next;
+		if (next === null) _activeIslandSig(null);
+		else _activeIslandSig(() => next);
+		return next;
+	}
+	return store ? store.island : _activeIslandSig();
+}
+let _routes = createRouteRegistry();
+/** Wrap loader data in the load envelope (plain, serializable). */
+function envelopLoad(data) {
+	return { load: {
+		loading: false,
+		value: data ?? {},
+		error: void 0
+	} };
+}
+function createRouteRegistry() {
+	return [];
+}
+function addRouteEntry(registry, pattern, data) {
+	const { segments, kinds } = parsePattern(pattern);
+	let index = 0;
+	while (index < registry.length) {
+		const other = registry[index].kinds;
+		let cmp = 0;
+		for (let i = 0; i < Math.min(kinds.length, other.length); i++) if (kinds[i] !== other[i]) {
+			cmp = kinds[i] - other[i];
+			break;
+		}
+		if (cmp === 0) cmp = other.length - kinds.length;
+		if (cmp > 0) break;
+		index++;
+	}
+	registry.splice(index, 0, {
+		pattern,
+		segments,
+		kinds,
+		data
+	});
+}
+function matchRoute(registry, pathname) {
+	for (const entry of registry) {
+		const params = matchSegments(entry.segments, pathname);
+		if (params) return {
+			data: entry.data,
+			params
+		};
+	}
+}
+function extractParams(matchParams) {
+	const params = {};
+	if (matchParams) for (const [k, v] of Object.entries(matchParams)) params[k] = safeDecode(v);
+	return params;
+}
+function syncRouteFromURL(url, routes = _routes) {
+	const parsed = typeof url === "string" ? new URL(url, "http://localhost") : url;
+	const match = matchRoute(routes, parsed.pathname);
+	routePath(parsed.pathname);
+	routeParams(extractParams(match?.params));
+	routeSearch(parsed.search);
+	routeHash(parsed.hash);
+	activeIsland(match?.data?.island ?? null);
+}
+/** Client-only fast path — reads directly from the history adapter (location in history mode, hash content in hash mode). */
+function syncRouteFromLocation() {
+	const loc = getAdapter().readLocation();
+	const match = matchRoute(_routes, loc.pathname);
+	routePath(loc.pathname);
+	routeParams(extractParams(match?.params));
+	routeSearch(loc.search);
+	routeHash(loc.hash);
+	activeIsland(match?.data?.island ?? null);
+}
+/**
+* Prime route context signals from the current `location` so that islands
+* hydrated by `ilha.mount()` see the correct route values on their first
+* render — preventing a mismatch morph that would destroy hydrated bindings.
+*/
+function prime() {
+	if (isBrowser) syncRouteFromLocation();
+}
+const _beforeNavigateHooks = /* @__PURE__ */ new Set();
+const _afterNavigateHooks = /* @__PURE__ */ new Set();
+/**
+* Run before a programmatic navigation commits. Call `nav.cancel()` to keep
+* the current URL (e.g. unsaved-changes guards). Not invoked for browser
+* back/forward — the URL has already changed by the time `popstate` fires.
+* Returns an unsubscribe function.
+*/
+function beforeNavigate(fn) {
+	_beforeNavigateHooks.add(fn);
+	return () => _beforeNavigateHooks.delete(fn);
+}
+/** Run after a navigation (push, replace, or pop) has committed. Returns an unsubscribe function. */
+function afterNavigate(fn) {
+	_afterNavigateHooks.add(fn);
+	return () => _afterNavigateHooks.delete(fn);
+}
+function runAfterNavigateHooks(nav) {
+	for (const fn of _afterNavigateHooks) try {
+		fn(nav);
+	} catch (e) {
+		console.error("[ilha-router] afterNavigate hook threw:", e);
+	}
+}
+const _scrollPositions = /* @__PURE__ */ new Map();
+let _navKeyCounter = 0;
+let _lastNavKey = 0;
+function currentNavKey() {
+	if (!isBrowser) return 0;
+	const s = history.state;
+	return typeof s?.__ilhaNavKey === "number" ? s.__ilhaNavKey : 0;
+}
+function saveScrollPosition() {
+	_scrollPositions.set(currentNavKey(), {
+		x: window.scrollX,
+		y: window.scrollY
+	});
+}
+function scrollAfterNavigate(hash) {
+	requestAnimationFrame(() => {
+		if (hash && hash !== "#") {
+			const el = document.getElementById(hash.slice(1)) ?? document.querySelector(`a[name="${cssEscapeAttr(hash.slice(1))}"]`);
+			if (el) {
+				el.scrollIntoView();
+				return;
+			}
+		}
+		window.scrollTo(0, 0);
+	});
+}
+/** Restore the saved position for the current history entry (popstate). */
+function restoreScrollPosition() {
+	const pos = _scrollPositions.get(currentNavKey());
+	if (!pos) return;
+	requestAnimationFrame(() => window.scrollTo(pos.x, pos.y));
+}
+function navigate(to, opts = {}) {
+	if (!isBrowser) return;
+	const adapter = getAdapter();
+	const cur = adapter.readLocation();
+	const current = cur.pathname + cur.search + cur.hash;
+	if (to === current) return;
+	const type = opts.replace ? "replace" : "push";
+	let cancelled = false;
+	for (const fn of _beforeNavigateHooks) try {
+		fn({
+			from: current,
+			to,
+			type,
+			cancel: () => cancelled = true
+		});
+	} catch (e) {
+		console.error("[ilha-router] beforeNavigate hook threw:", e);
+	}
+	if (cancelled) return;
+	if (opts.replace) adapter.replace(to, { __ilhaNavKey: currentNavKey() });
+	else {
+		saveScrollPosition();
+		_navKeyCounter = Math.max(_navKeyCounter + 1, currentNavKey() + 1);
+		adapter.push(to, { __ilhaNavKey: _navKeyCounter });
+	}
+	_lastNavKey = currentNavKey();
+	syncRouteFromLocation();
+	if (opts.scroll !== false) {
+		const dest = adapter.readLocation();
+		const fromMatch = matchRoute(_routes, cur.pathname);
+		const destMatch = matchRoute(_routes, dest.pathname);
+		if (!(fromMatch?.data?.island != null && destMatch?.data?.island === fromMatch.data.island) || dest.hash && dest.hash !== "#") scrollAfterNavigate(dest.hash);
+	}
+	runAfterNavigateHooks({
+		from: current,
+		to,
+		type
+	});
+}
+/**
+* Follow a loader redirect on the client. Same-origin absolute URLs collapse
+* to a logical path; external URLs perform a full document navigation (the
+* server has already applied the external-redirect policy).
+*/
+function clientRedirect(to) {
+	if (/^https?:\/\//i.test(to)) {
+		try {
+			const u = new URL(to);
+			if (u.origin === location.origin) {
+				navigate(u.pathname + u.search + u.hash, { replace: true });
+				return;
+			}
+		} catch {
+			return;
+		}
+		location.assign(to);
+		return;
+	}
+	navigate(to, { replace: true });
+}
+function enableLinkInterception(root = document, options = {}) {
+	if (!isBrowser) return () => {};
+	const prefetchEnabled = options.prefetch !== false;
+	/**
+	* Determine whether this anchor is a same-origin in-app link we should handle,
+	* and if so, the logical path to navigate to. Returns null when the link
+	* should be left to the browser (external, modifier held, target=_blank, etc).
+	*/
+	function logicalPathFor(target, e) {
+		const isBlank = target.getAttribute("target") === "_blank";
+		const hasModifier = !!e && (e.ctrlKey || e.metaKey || e.shiftKey || e.altKey);
+		const hasNoIntercept = target.hasAttribute("data-no-intercept");
+		const isDownload = target.hasAttribute("download");
+		const isExternalRel = /\bexternal\b/i.test(target.getAttribute("rel") ?? "");
+		if (isBlank || hasModifier || hasNoIntercept || isDownload || isExternalRel) return null;
+		return getAdapter().extractLogicalPath(target);
+	}
+	const clickHandler = (e) => {
+		if (e.defaultPrevented) return;
+		if (typeof e.button === "number" && e.button !== 0) return;
+		const target = e.target.closest("a");
+		if (!target) return;
+		const path = logicalPathFor(target, e);
+		if (path === null) return;
+		e.preventDefault();
+		navigate(path);
+	};
+	const hoverHandler = (e) => {
+		const target = e.target.closest("a");
+		if (!target) return;
+		const flag = target.getAttribute("data-prefetch");
+		if (flag === null || flag === "false") return;
+		const path = logicalPathFor(target);
+		if (path === null) return;
+		prefetch(path.split("#")[0] ?? path);
+	};
+	root.addEventListener("click", clickHandler);
+	if (prefetchEnabled) root.addEventListener("mouseover", hoverHandler, { passive: true });
+	return () => {
+		root.removeEventListener("click", clickHandler);
+		if (prefetchEnabled) root.removeEventListener("mouseover", hoverHandler);
+	};
+}
+/** Custom 404 island — set via `router({ notFound })`. Module-level because
+* RouterView is a module-level island (single active router per document). */
+let _notFound = null;
+/** Redirect policy for browser-executed loaders — mirrors the last router's
+* `allowExternalRedirects` option (module-level for the same reason as `_notFound`). */
+let _allowExternalRedirects = false;
+const RouterView = ilha.render(() => {
+	const island = activeIsland();
+	if (!island) {
+		if (_notFound) return `<div data-router-view data-router-not-found>${_notFound.toString()}</div>`;
+		return `<div data-router-empty></div>`;
+	}
+	return `<div data-router-view>${island.toString()}</div>`;
+});
+const RouterLink = ilha.state("href", "").state("label", "").on("[data-link]@click", ({ state, event }) => {
+	event.preventDefault();
+	navigate(state.href());
+}).on("[data-link]@mouseenter", ({ state }) => {
+	const href = state.href();
+	if (!href) return;
+	if (/^https?:\/\//i.test(href)) try {
+		const u = new URL(href);
+		if (u.origin !== location.origin) return;
+		prefetch(u.pathname + u.search);
+		return;
+	} catch {
+		return;
+	}
+	prefetch(href);
+}).render(({ state }) => html`<a data-link data-prefetch href="${() => getAdapter().toLinkHref(state.href())}"
+        >${state.label}</a
+      >`);
+function isActive(pattern, options = {}) {
+	if (options.exact === false) {
+		const path = routePath();
+		const base = pattern.endsWith("/") ? pattern.slice(0, -1) : pattern;
+		return path === base || path === base + "/" || path.startsWith(base + "/");
+	}
+	const match = matchRoute(_routes, routePath());
+	if (!match) return false;
+	return match.data.pattern === pattern;
+}
+const ILHA_HEAD_ATTR = "data-ilha-head";
+const ILHA_ROUTER_HTML_ATTR = "data-ilha-router-html";
+const ILHA_ROUTER_BODY_ATTR = "data-ilha-router-body";
+/** Browser-only fallback; SSR uses AsyncLocalStorage (see `withHeadStore`). */
+let _browserHeadStore = null;
+let _headAls = null;
+let _headAlsInit = null;
+/** ESM dynamic import — Nitro/Vite SSR workers have no `require`. */
+async function getHeadAlsAsync() {
+	if (_headAls) return _headAls;
+	if (!_headAlsInit) _headAlsInit = import("node:async_hooks").then(({ AsyncLocalStorage }) => {
+		_headAls = new AsyncLocalStorage();
+		return _headAls;
+	});
+	return _headAlsInit;
+}
+function activeHeadStore() {
+	if (isBrowser) return _browserHeadStore;
+	return _headAls?.getStore() ?? null;
+}
+/**
+* Contribute `<head>` data from inside an island's `.render()` body or a
+* layout. During SSR this collects into the active render window; on the
+* client, entries are collected when the router re-renders a route inside
+* `withHeadStore` and then applied to `document`. Prefer a loader's `ctx.head`
+* for data that depends on the request.
+*/
+function head(input) {
+	const store = activeHeadStore();
+	if (!store) {
+		if (!isBrowser) console.warn("[ilha-router] head() called outside an SSR render window — ignored.");
+		return;
+	}
+	store.entries.push(input);
+}
+function cssEscapeAttr(value) {
+	if (typeof CSS !== "undefined" && typeof CSS.escape === "function") return CSS.escape(value);
+	return value.replace(/\\/g, "\\\\").replace(/"/g, "\\\"");
+}
+function headManagedMetaSelector(tag) {
+	if ("charset" in tag) return `meta[charset][${ILHA_HEAD_ATTR}]`;
+	if ("name" in tag) return `meta[name="${cssEscapeAttr(tag.name)}"][${ILHA_HEAD_ATTR}]`;
+	if ("property" in tag) return `meta[property="${cssEscapeAttr(tag.property)}"][${ILHA_HEAD_ATTR}]`;
+	if ("http-equiv" in tag) return `meta[http-equiv="${cssEscapeAttr(tag["http-equiv"])}"][${ILHA_HEAD_ATTR}]`;
+	return null;
+}
+function headManagedLinkSelector(tag) {
+	if (tag.rel && tag.href) return `link[rel="${cssEscapeAttr(tag.rel)}"][href="${cssEscapeAttr(tag.href)}"][${ILHA_HEAD_ATTR}]`;
+	return null;
+}
+/**
+* Apply merged head entries on client navigations. Updates `document.title` and
+* managed meta/link nodes (`data-ilha-head`). Script tags from HeadInput are
+* SSR-only and are not re-injected here. Removes managed tags from the previous
+* route that are not part of this navigation's set.
+*/
+function applyHeadEntriesToDocument(entries) {
+	if (!isBrowser) return;
+	let title;
+	let titleTemplate;
+	const meta = [];
+	const link = [];
+	let htmlAttrs = {};
+	let bodyAttrs = {};
+	for (const entry of entries) {
+		if (entry.title !== void 0) title = entry.title;
+		if (entry.titleTemplate !== void 0) titleTemplate = entry.titleTemplate;
+		if (entry.meta) meta.push(...entry.meta);
+		if (entry.link) link.push(...entry.link);
+		if (entry.htmlAttrs) htmlAttrs = {
+			...htmlAttrs,
+			...entry.htmlAttrs
+		};
+		if (entry.bodyAttrs) bodyAttrs = {
+			...bodyAttrs,
+			...entry.bodyAttrs
+		};
+	}
+	const resolvedTitle = applyTitleTemplate(title, titleTemplate);
+	if (resolvedTitle !== void 0) document.title = resolvedTitle;
+	const metaTags = dedupByKey(meta, metaDedupKey);
+	const linkTags = dedupByKey(link, (t) => `${t.rel ?? ""}:${t.href ?? ""}`);
+	const keepManaged = /* @__PURE__ */ new Set();
+	for (const tag of metaTags) {
+		const selector = headManagedMetaSelector(tag);
+		if (!selector) continue;
+		let el = document.querySelector(selector);
+		if (!el) {
+			el = document.createElement("meta");
+			el.setAttribute(ILHA_HEAD_ATTR, "");
+			document.head.appendChild(el);
+		}
+		for (const [k, v] of Object.entries(tag)) el.setAttribute(k, v);
+		keepManaged.add(el);
+	}
+	for (const tag of linkTags) {
+		const selector = headManagedLinkSelector(tag);
+		let el = selector ? document.querySelector(selector) : null;
+		if (!el) {
+			el = document.createElement("link");
+			el.setAttribute(ILHA_HEAD_ATTR, "");
+			document.head.appendChild(el);
+		}
+		for (const [k, v] of Object.entries(tag)) el.setAttribute(k, v);
+		keepManaged.add(el);
+	}
+	for (const el of [...document.head.querySelectorAll(`[${ILHA_HEAD_ATTR}]`)]) if (!keepManaged.has(el)) el.remove();
+	const htmlEl = document.documentElement;
+	const prevHtmlKeys = (htmlEl.getAttribute(ILHA_ROUTER_HTML_ATTR) ?? "").split(/\s+/).filter(Boolean);
+	for (const k of prevHtmlKeys) htmlEl.removeAttribute(k);
+	const nextHtmlKeys = Object.keys(htmlAttrs);
+	for (const [k, v] of Object.entries(htmlAttrs)) htmlEl.setAttribute(k, v);
+	if (nextHtmlKeys.length) htmlEl.setAttribute(ILHA_ROUTER_HTML_ATTR, nextHtmlKeys.join(" "));
+	else htmlEl.removeAttribute(ILHA_ROUTER_HTML_ATTR);
+	const bodyEl = document.body;
+	const prevBodyKeys = (bodyEl.getAttribute(ILHA_ROUTER_BODY_ATTR) ?? "").split(/\s+/).filter(Boolean);
+	for (const k of prevBodyKeys) bodyEl.removeAttribute(k);
+	const nextBodyKeys = Object.keys(bodyAttrs);
+	for (const [k, v] of Object.entries(bodyAttrs)) bodyEl.setAttribute(k, v);
+	if (nextBodyKeys.length) bodyEl.setAttribute(ILHA_ROUTER_BODY_ATTR, nextBodyKeys.join(" "));
+	else bodyEl.removeAttribute(ILHA_ROUTER_BODY_ATTR);
+}
+async function withHeadStore(store, fn) {
+	if (isBrowser) {
+		const prev = _browserHeadStore;
+		_browserHeadStore = store;
+		try {
+			return await fn();
+		} finally {
+			_browserHeadStore = prev;
+		}
+	}
+	return await (await getHeadAlsAsync()).run(store, () => Promise.resolve(fn()));
+}
+const HEAD_ESC = {
+	"&": "&amp;",
+	"<": "&lt;",
+	">": "&gt;",
+	"\"": "&quot;",
+	"'": "&#39;"
+};
+function escapeHeadAttr(value) {
+	return String(value).replace(/[&<>"']/g, (c) => HEAD_ESC[c]);
+}
+/** Escape text content for inline HTML (loader error messages etc.). */
+function escapeHtml(value) {
+	return String(value).replace(/[&<>]/g, (c) => HEAD_ESC[c]);
+}
+function serializeAttrs(attrs) {
+	const parts = [];
+	for (const [k, v] of Object.entries(attrs)) {
+		if (!/^[A-Za-z_:][A-Za-z0-9:._-]*$/.test(k) || /^on[a-z]/i.test(k)) {
+			if (isDevEnv()) console.warn(`[ilha-router] Dropping unsafe head attribute "${k}".`);
+			continue;
+		}
+		parts.push(` ${k}="${escapeHeadAttr(v)}"`);
+	}
+	return parts.join("");
+}
+function isSafeUrl(value) {
+	const v = value.trim();
+	if (v === "") return true;
+	if (v.startsWith("//")) return false;
+	if (v.startsWith("#") || v.startsWith("/") || v.startsWith("./")) return true;
+	if (/^(?:javascript|vbscript|data):/i.test(v)) return false;
+	try {
+		const u = new URL(v, "http://localhost");
+		return u.protocol === "http:" || u.protocol === "https:";
+	} catch {
+		return false;
+	}
+}
+function metaDedupKey(tag) {
+	if ("charset" in tag) return "charset";
+	if ("name" in tag) return `name:${tag.name}`;
+	if ("property" in tag) return `property:${tag.property}`;
+	if ("http-equiv" in tag) return `http-equiv:${tag["http-equiv"]}`;
+	return JSON.stringify(tag);
+}
+function dedupByKey(tags, keyOf) {
+	const map = /* @__PURE__ */ new Map();
+	for (const tag of tags) map.set(keyOf(tag), tag);
+	return [...map.values()];
+}
+function applyTitleTemplate(title, template) {
+	if (template === void 0) return title;
+	if (typeof template === "function") return template(title);
+	return template.replace(/%s/g, title ?? "");
+}
+/**
+* Merge head entries in contribution order (loader first as the base, then
+* render-time outer→inner layouts, then the page) and serialize. Later entries
+* win on collision; the last `titleTemplate` wraps the resolved title.
+*/
+function serializeHead(entries) {
+	let title;
+	let titleTemplate;
+	const meta = [];
+	const link = [];
+	const script = [];
+	let htmlAttrs = {};
+	let bodyAttrs = {};
+	for (const entry of entries) {
+		if (entry.title !== void 0) title = entry.title;
+		if (entry.titleTemplate !== void 0) titleTemplate = entry.titleTemplate;
+		if (entry.meta) meta.push(...entry.meta);
+		if (entry.link) link.push(...entry.link);
+		if (entry.script) script.push(...entry.script);
+		if (entry.htmlAttrs) htmlAttrs = {
+			...htmlAttrs,
+			...entry.htmlAttrs
+		};
+		if (entry.bodyAttrs) bodyAttrs = {
+			...bodyAttrs,
+			...entry.bodyAttrs
+		};
+	}
+	const resolvedTitle = applyTitleTemplate(title, titleTemplate);
+	const parts = [];
+	if (resolvedTitle !== void 0) parts.push(`<title>${escapeHeadAttr(resolvedTitle)}</title>`);
+	for (const tag of dedupByKey(meta, metaDedupKey)) {
+		if (/^refresh$/i.test(tag["http-equiv"] ?? "") && !isSafeRefreshTarget(tag.content ?? "")) {
+			if (isDevEnv()) console.warn(`[ilha-router] Dropping unsafe meta refresh target "${tag.content}".`);
+			continue;
+		}
+		parts.push(`<meta${serializeAttrs({
+			...tag,
+			[ILHA_HEAD_ATTR]: ""
+		})} />`);
+	}
+	for (const tag of dedupByKey(link, (t) => `${t.rel ?? ""}:${t.href ?? ""}`)) {
+		if (tag.href !== void 0 && !isSafeUrl(tag.href)) {
+			if (isDevEnv()) console.warn(`[ilha-router] Dropping unsafe link href "${tag.href}".`);
+			continue;
+		}
+		parts.push(`<link${serializeAttrs({
+			...tag,
+			[ILHA_HEAD_ATTR]: ""
+		})} />`);
+	}
+	for (const tag of script) {
+		if (tag.src !== void 0 && !isSafeUrl(tag.src)) {
+			if (isDevEnv()) console.warn(`[ilha-router] Dropping unsafe script src "${tag.src}".`);
+			continue;
+		}
+		const { children, ...attrs } = tag;
+		const body = (children ?? "").replace(/<\/script/gi, "<\\/script");
+		parts.push(`<script${serializeAttrs(attrs)}>${body}<\/script>`);
+	}
+	return {
+		headTags: parts.join("\n  "),
+		htmlAttrs: serializeAttrs(htmlAttrs),
+		bodyAttrs: serializeAttrs(bodyAttrs)
+	};
+}
+function isSafeRefreshTarget(content) {
+	const match = /url\s*=\s*(['"]?)([^'";\s]+)\1/i.exec(content);
+	if (!match) return true;
+	return isSafeUrl(match[2] ?? "");
+}
+/**
+* Build an HTTP `Response` for SSR output with sensible security headers:
+* `Content-Type: text/html`, `X-Content-Type-Options: nosniff`,
+* `Referrer-Policy`, `Cache-Control: no-store`, and an optional CSP. This is
+* a low-level helper — prefer {@link RouterBuilder.respond} for the full
+* render+head+headers pipeline.
+*/
+function httpResponse(body, options = {}) {
+	const headers = new Headers(options.headers);
+	if (body != null && !headers.has("content-type")) headers.set("content-type", "text/html; charset=utf-8");
+	if (!headers.has("x-content-type-options")) headers.set("x-content-type-options", "nosniff");
+	if (!headers.has("referrer-policy")) headers.set("referrer-policy", "no-referrer");
+	if (!headers.has("cache-control")) headers.set("cache-control", "no-store");
+	const csp = options.contentSecurityPolicy ?? (options.cspNonce ? `default-src 'self'; script-src 'self' 'nonce-${options.cspNonce}'; style-src 'self' 'unsafe-inline'; img-src 'self' data:; object-src 'none'; base-uri 'self'; frame-ancestors 'self'` : void 0);
+	if (csp) headers.set("content-security-policy", csp);
+	return new Response(body, {
+		status: options.status ?? 200,
+		headers
+	});
+}
+const EMPTY_HEAD = {
+	headTags: "",
+	htmlAttrs: "",
+	bodyAttrs: ""
+};
+function resolveRequestUrl(urlOrRequest, request) {
+	if (urlOrRequest instanceof Request) return {
+		url: urlOrRequest.url,
+		request: urlOrRequest
+	};
+	return {
+		url: urlOrRequest,
+		request
+	};
+}
+function parsedURL(url) {
+	return typeof url === "string" ? new URL(url, "http://localhost") : url;
+}
+/** Dev detection for error-message redaction. Browser builds map `process` to `false`. */
+function isDevEnv() {
+	try {
+		return typeof process !== "undefined" && !!process.env && process.env.NODE_ENV !== "production";
+	} catch {
+		return false;
+	}
+}
+/**
+* Validate a loader redirect target. Relative paths always pass; same-origin
+* absolute URLs collapse to a path; cross-origin targets are rejected unless
+* `allowExternal`. Protocol-relative (`//host`) and unparsable targets are
+* always rejected.
+*/
+function resolveRedirectTarget(to, base, allowExternal) {
+	if (to.startsWith("/") && !to.startsWith("//")) return {
+		ok: true,
+		to
+	};
+	try {
+		const u = new URL(to, base);
+		if (!/^https?:$/.test(u.protocol)) return { ok: false };
+		if (u.origin === base.origin) return {
+			ok: true,
+			to: u.pathname + u.search + u.hash
+		};
+		return allowExternal ? {
+			ok: true,
+			to: u.href
+		} : { ok: false };
+	} catch {
+		return { ok: false };
+	}
+}
+/**
+* Build the loader's AbortSignal: aborts when the incoming request aborts or
+* when `timeout` (ms) elapses. Call `done()` when the loader settles.
+*/
+function loaderAbort(request, timeout) {
+	const ctrl = new AbortController();
+	const abort = () => ctrl.abort();
+	const reqSignal = request?.signal;
+	if (reqSignal) {
+		if (reqSignal.aborted) abort();
+		else reqSignal.addEventListener("abort", abort, { once: true });
+	}
+	let timer;
+	if (timeout && timeout > 0) timer = setTimeout(abort, timeout);
+	return {
+		signal: ctrl.signal,
+		done: () => {
+			if (timer !== void 0) clearTimeout(timer);
+			reqSignal?.removeEventListener("abort", abort);
+		}
+	};
+}
+function defaultRequest(url) {
+	try {
+		return new Request(url.toString());
+	} catch {
+		return {
+			url: url.toString(),
+			headers: new Headers()
+		};
+	}
+}
+async function executeLoader(loader, url, params, request, signal, onHead) {
+	const headEntries = [];
+	const head = onHead ?? ((input) => headEntries.push(input));
+	try {
+		const loaderPromise = Promise.resolve(loader({
+			params,
+			request,
+			url,
+			signal,
+			head
+		}));
+		loaderPromise.catch(() => {});
+		const out = {
+			kind: "data",
+			data: await Promise.race([loaderPromise, new Promise((_, reject) => {
+				const onAbort = () => reject(new LoaderError(504, "Loader aborted or timed out"));
+				if (signal.aborted) onAbort();
+				else signal.addEventListener("abort", onAbort, { once: true });
+			})]) ?? {}
+		};
+		if (headEntries.length > 0) out.head = serializeHead(headEntries);
+		return out;
+	} catch (e) {
+		if (e instanceof Redirect) return {
+			kind: "redirect",
+			to: e.to,
+			status: e.status
+		};
+		if (e instanceof LoaderError) return {
+			kind: "error",
+			status: e.status,
+			message: e.message
+		};
+		console.error("[ilha-router] loader failed:", e);
+		return {
+			kind: "error",
+			status: typeof e?.status === "number" ? e.status : 500,
+			message: isDevEnv() ? e?.message ?? "Loader failed" : "Internal error"
+		};
+	}
+}
+function router(options = {}) {
+	const mode = options.mode ?? "spa";
+	const defaultInterceptLinks = options.interceptLinks !== false;
+	const allowExternalRedirects = options.allowExternalRedirects === true;
+	const loaderTimeout = options.loaderTimeout;
+	const records = [];
+	const routes = createRouteRegistry();
+	const patternToData = /* @__PURE__ */ new Map();
+	const notFound = options.notFound ?? null;
+	_routes = routes;
+	_notFound = notFound;
+	_allowExternalRedirects = allowExternalRedirects;
+	_viewTransitions = options.viewTransitions === true;
+	let _navChangeCleanup = null;
+	let _linkCleanup = null;
+	const builder = {
+		route(pattern, island, loader) {
+			const hasLoader = !!loader;
+			const data = {
+				island,
+				pattern,
+				loader,
+				hasLoader
+			};
+			records.push({
+				pattern,
+				island,
+				loader,
+				hasLoader
+			});
+			addRouteEntry(routes, pattern, data);
+			patternToData.set(pattern, data);
+			return builder;
+		},
+		attachLoader(pattern, loader) {
+			const data = patternToData.get(pattern);
+			if (!data) {
+				console.warn(`[ilha-router] attachLoader("${pattern}", …): pattern was never registered via .route(). The loader will be ignored.`);
+				return builder;
+			}
+			data.loader = loader;
+			data.hasLoader = true;
+			const rec = records.find((r) => r.pattern === pattern);
+			if (rec) {
+				rec.loader = loader;
+				rec.hasLoader = true;
+			}
+			return builder;
+		},
+		clientLoader(pattern, loader) {
+			const data = patternToData.get(pattern);
+			if (!data) {
+				console.warn(`[ilha-router] clientLoader("${pattern}", …): pattern was never registered via .route(). The loader will be ignored.`);
+				return builder;
+			}
+			data.clientLoader = loader;
+			data.hasLoader = true;
+			const rec = records.find((r) => r.pattern === pattern);
+			if (rec) rec.hasLoader = true;
+			return builder;
+		},
+		errorBoundary(pattern, handler) {
+			const data = patternToData.get(pattern);
+			if (!data) {
+				console.warn(`[ilha-router] errorBoundary("${pattern}", …): pattern was never registered via .route(). The boundary will be ignored.`);
+				return builder;
+			}
+			data.errorHandler = handler;
+			return builder;
+		},
+		markLoader(pattern) {
+			const data = patternToData.get(pattern);
+			if (!data) {
+				console.warn(`[ilha-router] markLoader("${pattern}"): pattern was never registered via .route(). The loader marker will be ignored.`);
+				return builder;
+			}
+			data.hasLoader = true;
+			const rec = records.find((r) => r.pattern === pattern);
+			if (rec) rec.hasLoader = true;
+			return builder;
+		},
+		routes() {
+			return records.map((record) => ({ ...record }));
+		},
+		prime,
+		hydrateStatic(registry, options = {}) {
+			if (!isBrowser) return () => {};
+			const root = options.root ?? document.body;
+			prime();
+			const { unmount } = mount(registry, { root });
+			return unmount;
+		},
+		mount(target, { hydrate = false, registry, interceptLinks: mountInterceptLinks } = {}) {
+			if (!isBrowser) {
+				console.warn("[ilha-router] mount() called in a non-browser environment");
+				return () => {};
+			}
+			const host = typeof target === "string" ? document.querySelector(target) : target;
+			if (!host) {
+				console.warn(`[ilha-router] No element found for selector "${target}"`);
+				return () => {};
+			}
+			syncRouteFromLocation();
+			_lastNavKey = currentNavKey();
+			if (mode === "static") {
+				console.warn("[ilha-router] router.mount() called in static mode. Use router.hydrateStatic(registry) instead.");
+				return () => {};
+			}
+			let mounted = true;
+			const prevScrollRestoration = "scrollRestoration" in history ? history.scrollRestoration : null;
+			if (prevScrollRestoration !== null) history.scrollRestoration = "manual";
+			const popHandler = () => {
+				if (!mounted) return;
+				const prevPath = routePath() + routeSearch() + routeHash();
+				_scrollPositions.set(_lastNavKey, {
+					x: window.scrollX,
+					y: window.scrollY
+				});
+				_lastNavKey = currentNavKey();
+				syncRouteFromLocation();
+				restoreScrollPosition();
+				runAfterNavigateHooks({
+					from: prevPath,
+					to: routePath() + routeSearch() + routeHash(),
+					type: "pop"
+				});
+			};
+			_navChangeCleanup = getAdapter().onChange(popHandler);
+			_linkCleanup = mountInterceptLinks ?? defaultInterceptLinks ? enableLinkInterception(document) : null;
+			let unmountView = null;
+			let navAbort = null;
+			if (hydrate) {
+				if (getHistoryMode() === "hash") console.warn("[ilha-router] mount({ hydrate: true }) was called in hash mode. SSR + hydration assumes the server can render the active route, but in hash mode the server only ever sees the document URL. Use plain SPA mode (`mount(target)` without `hydrate: true`) for hash-mode apps.");
+				const viewHost = host.querySelector("[data-router-view]") ?? host;
+				let currentMountedIsland = activeIsland();
+				let currentMountedPath = routePath() + routeSearch();
+				let viewHandle = null;
+				const adoptHydratedHandle = () => {
+					const el = viewHost.querySelector("[data-ilha]");
+					if (!el) return null;
+					const h = ISLAND_MOUNT_HANDLES.get(el);
+					return h ? {
+						unmount: () => void h.unmount(),
+						updateProps: (p) => h.updateProps(p)
+					} : null;
+				};
+				const reverseRegistry = registry ? buildReverseRegistry(registry) : void 0;
+				let navVersion = 0;
+				const NavHandler = ilha.render(() => {
+					const current = activeIsland();
+					const pathWithSearch = routePath() + routeSearch();
+					if (current !== currentMountedIsland || pathWithSearch !== currentMountedPath) {
+						const thisNav = ++navVersion;
+						navAbort?.abort();
+						navAbort = new AbortController();
+						const signal = navAbort.signal;
+						queueMicrotask(async () => {
+							if (thisNav !== navVersion) return;
+							const settle = beginNavigation();
+							try {
+								if (current !== null && current === currentMountedIsland) {
+									const handle = viewHandle ?? adoptHydratedHandle();
+									if (handle?.updateProps) {
+										if (await updateRouteInPlace(handle, pathWithSearch, signal) === "updated") {
+											viewHandle = handle;
+											currentMountedPath = pathWithSearch;
+											return;
+										}
+									}
+								}
+								viewHandle?.unmount();
+								viewHandle = null;
+								viewHandle = await mountRouteWithHydration(current, viewHost, pathWithSearch, signal, registry, reverseRegistry);
+							} catch (e) {
+								if (e?.name === "AbortError") return;
+								console.error("[ilha-router] navigation failed:", e);
+								viewHost.innerHTML = `<div data-router-view data-router-error="500"></div>`;
+								return;
+							} finally {
+								settle();
+							}
+							currentMountedIsland = current;
+							currentMountedPath = pathWithSearch;
+						});
+					}
+					return "";
+				});
+				const navHost = document.createElement("div");
+				navHost.style.display = "none";
+				host.appendChild(navHost);
+				const unmountNavHandler = NavHandler.mount(navHost);
+				(async () => {
+					const island = activeIsland();
+					if (!island) return;
+					const loc = getAdapter().readLocation();
+					const pathWithSearch = loc.pathname + loc.search;
+					const clientMatch = matchRoute(_routes, loc.pathname);
+					if (clientMatch?.data?.clientLoader) {
+						const thisNav = ++navVersion;
+						const ac = new AbortController();
+						navAbort = ac;
+						try {
+							const um = await mountRouteWithHydration(island, viewHost, pathWithSearch, ac.signal, registry, reverseRegistry);
+							if (thisNav === navVersion) viewHandle = um;
+							else um.unmount();
+						} catch (e) {
+							if (e?.name !== "AbortError") console.error("[ilha-router] initial client loader render failed:", e);
+						}
+						return;
+					}
+					const loaderResult = !!clientMatch?.data?.hasLoader ? await fetchLoaderData(pathWithSearch) : {
+						kind: "data",
+						data: {}
+					};
+					if (loaderResult.kind === "redirect" || loaderResult.kind === "error") return;
+					const props = loaderResult.kind === "data" ? loaderResult.data : {};
+					const headStore = { entries: [...loaderResult.kind === "data" ? loaderResult.headEntries ?? [] : []] };
+					await withHeadStore(headStore, () => island.toString(props));
+					if (!mounted) return;
+					applyHeadEntriesToDocument(headStore.entries);
+				})();
+				_revalidate = async () => {
+					const island = activeIsland();
+					const thisNav = ++navVersion;
+					navAbort?.abort();
+					const ac = new AbortController();
+					navAbort = ac;
+					const settle = beginNavigation();
+					try {
+						const loc = getAdapter().readLocation();
+						const pathWithSearch = loc.pathname + loc.search;
+						if (island !== null && island === currentMountedIsland) {
+							const handle = viewHandle ?? adoptHydratedHandle();
+							if (handle?.updateProps) {
+								if (await updateRouteInPlace(handle, pathWithSearch, ac.signal) === "updated") {
+									if (thisNav === navVersion) {
+										viewHandle = handle;
+										currentMountedPath = pathWithSearch;
+									}
+									return;
+								}
+							}
+						}
+						const um = await mountRouteWithHydration(island, viewHost, pathWithSearch, ac.signal, registry, reverseRegistry);
+						if (thisNav === navVersion) {
+							viewHandle?.unmount();
+							viewHandle = um;
+							currentMountedIsland = island;
+							currentMountedPath = pathWithSearch;
+						} else um.unmount();
+					} catch (e) {
+						if (e?.name !== "AbortError") console.error("[ilha-router] invalidate failed:", e);
+					} finally {
+						settle();
+					}
+				};
+				return () => {
+					mounted = false;
+					++navVersion;
+					_revalidate = null;
+					navAbort?.abort();
+					unmountNavHandler();
+					navHost.remove();
+					viewHandle?.unmount();
+					_linkCleanup?.();
+					_navChangeCleanup?.();
+					_linkCleanup = null;
+					_navChangeCleanup = null;
+					if (prevScrollRestoration !== null) history.scrollRestoration = prevScrollRestoration;
+				};
+			}
+			let mountedHandle = null;
+			let mountedHandleIsland = null;
+			let currentMountedIsland = null;
+			let currentMountedPath = null;
+			let navVersion = 0;
+			unmountView = RouterView.mount(host);
+			/**
+			* Fetch loader data and mount the active island. SPA mode also fetches
+			* from the loader endpoint — otherwise navigation after the initial SSR
+			* render would have no access to loader data.
+			*/
+			async function mountActiveIsland(island, signal) {
+				const sameIsland = island !== null && island === mountedHandleIsland && mountedHandle?.updateProps != null;
+				const teardown = () => {
+					mountedHandle?.unmount();
+					mountedHandle = null;
+					mountedHandleIsland = null;
+				};
+				if (!sameIsland) teardown();
+				currentMountedIsland = island;
+				currentMountedPath = routePath() + routeSearch();
+				if (!island) {
+					const nfHost = host?.querySelector("[data-router-not-found]");
+					if (_notFound && nfHost) mountedHandle = {
+						unmount: _notFound.mount(nfHost),
+						updateProps: null
+					};
+					return;
+				}
+				const viewHost = host?.querySelector("[data-router-view]");
+				if (!viewHost) return;
+				const loc = getAdapter().readLocation();
+				const clientMatch = matchRoute(_routes, loc.pathname);
+				const result = !!clientMatch?.data?.hasLoader ? await fetchLoaderData(loc.pathname + loc.search, signal) : {
+					kind: "data",
+					data: {}
+				};
+				if (signal.aborted) return;
+				if (result.kind === "redirect") {
+					clientRedirect(result.to);
+					return;
+				}
+				if (result.kind === "error") {
+					if (sameIsland) teardown();
+					const boundary = clientMatch?.data?.errorHandler;
+					if (boundary) {
+						mountedHandle = await withViewSwap(() => ({
+							unmount: mountLoaderErrorBoundary(boundary, viewHost, result.status, result.message),
+							updateProps: null
+						}));
+						return;
+					}
+					const escaped = escapeHtml(result.message);
+					await withViewSwap(() => {
+						viewHost.innerHTML = `<div data-router-error="${result.status}">${escaped}</div>`;
+					});
+					return;
+				}
+				const props = result.kind === "data" ? result.data : {};
+				if (sameIsland && mountedHandle?.updateProps) {
+					if (result.kind === "data" && result.headEntries?.length) applyHeadEntriesToDocument([...result.headEntries]);
+					mountedHandle.updateProps(props);
+					return;
+				}
+				const headStore = { entries: [...result.kind === "data" ? result.headEntries ?? [] : []] };
+				const html = await withHeadStore(headStore, () => island.toString(props));
+				mountedHandle = await withViewSwap(() => {
+					applyHeadEntriesToDocument(headStore.entries);
+					viewHost.innerHTML = html;
+					return mountIslandWithHandle(island, viewHost, props);
+				});
+				mountedHandleIsland = island;
+			}
+			navAbort = new AbortController();
+			mountActiveIsland(activeIsland(), navAbort.signal).catch((e) => {
+				if (e?.name === "AbortError") return;
+				console.error("[ilha-router] initial mount failed:", e);
+			});
+			const NavHandler = ilha.render(() => {
+				const current = activeIsland();
+				const pathWithSearch = routePath() + routeSearch();
+				if (current !== currentMountedIsland || pathWithSearch !== currentMountedPath) {
+					const thisNav = ++navVersion;
+					navAbort?.abort();
+					navAbort = new AbortController();
+					const signal = navAbort.signal;
+					queueMicrotask(() => {
+						if (thisNav !== navVersion) return;
+						const settle = beginNavigation();
+						mountActiveIsland(current, signal).catch((e) => {
+							if (e?.name === "AbortError") return;
+							console.error("[ilha-router] navigation failed:", e);
+						}).finally(settle);
+					});
+				}
+				return "";
+			});
+			const navHost = document.createElement("div");
+			navHost.style.display = "none";
+			host.appendChild(navHost);
+			const unmountNavHandler = NavHandler.mount(navHost);
+			_revalidate = async () => {
+				++navVersion;
+				navAbort?.abort();
+				navAbort = new AbortController();
+				const settle = beginNavigation();
+				try {
+					await mountActiveIsland(activeIsland(), navAbort.signal);
+				} catch (e) {
+					if (e?.name !== "AbortError") console.error("[ilha-router] invalidate failed:", e);
+				} finally {
+					settle();
+				}
+			};
+			return () => {
+				mounted = false;
+				++navVersion;
+				_revalidate = null;
+				navAbort?.abort();
+				mountedHandle?.unmount();
+				unmountNavHandler();
+				navHost.remove();
+				unmountView?.();
+				_linkCleanup?.();
+				_navChangeCleanup?.();
+				_linkCleanup = null;
+				_navChangeCleanup = null;
+				if (prevScrollRestoration !== null) history.scrollRestoration = prevScrollRestoration;
+			};
+		},
+		render(url) {
+			const doRender = () => {
+				syncRouteFromURL(url, routes);
+				return RouterView.toString();
+			};
+			if (!isBrowser && _routeAls) return _routeAls.run(freshRouteStore(), doRender);
+			return doRender();
+		},
+		async renderHydratable(urlOrRequest, registry, options = {}, request) {
+			const { url, request: req } = resolveRequestUrl(urlOrRequest, request);
+			const response = await this.renderResponse(url, registry, options, req);
+			if (response.kind === "html") return response.html;
+			if (response.kind === "error") return response.html;
+			return `<meta http-equiv="refresh" content="0; url=${escapeHeadAttr(response.to)}">`;
+		},
+		async renderResponse(urlOrRequest, registry, options = {}, request) {
+			const { url, request: req } = resolveRequestUrl(urlOrRequest, request);
+			if (!isBrowser) {
+				const als = await getRouteAlsAsync();
+				if (!als.getStore()) return als.run(freshRouteStore(), () => renderResponseInner(url, registry, options, req));
+			}
+			return renderResponseInner(url, registry, options, req);
+		},
+		async respond(urlOrRequest, registry, options = {}) {
+			const { shell, headers, cspNonce, contentSecurityPolicy, status, ...renderOptions } = options;
+			const res = await this.renderResponse(urlOrRequest, registry, renderOptions, urlOrRequest instanceof Request ? urlOrRequest : void 0);
+			if (res.kind === "redirect") {
+				const h = new Headers(headers);
+				h.set("location", res.to);
+				return httpResponse(null, {
+					status: res.status,
+					headers: h,
+					cspNonce,
+					contentSecurityPolicy
+				});
+			}
+			const head = res.head ?? EMPTY_HEAD;
+			return httpResponse(shell ? shell(head, res.html) : res.html, {
+				status: status ?? res.status ?? 200,
+				headers,
+				cspNonce,
+				contentSecurityPolicy
+			});
+		},
+		async runLoader(urlOrRequest, request) {
+			const { url, request: req } = resolveRequestUrl(urlOrRequest, request);
+			const parsed = parsedURL(url);
+			const match = matchRoute(routes, parsed.pathname);
+			if (!match?.data?.island) return { kind: "not-found" };
+			if (!match.data.loader) return {
+				kind: "data",
+				data: {}
+			};
+			const params = extractParams(match.params);
+			const renderReq = req ?? defaultRequest(parsed);
+			const abort = loaderAbort(req, loaderTimeout);
+			const headStore = { entries: [] };
+			try {
+				const result = await executeLoader(match.data.loader, parsed, params, renderReq, abort.signal, (input) => headStore.entries.push(input));
+				if (result.kind === "redirect") {
+					const safe = resolveRedirectTarget(result.to, parsed, allowExternalRedirects);
+					if (!safe.ok) {
+						console.warn(`[ilha-router] Blocked unsafe redirect target "${result.to}". Set allowExternalRedirects: true to allow cross-origin redirects.`);
+						return {
+							kind: "error",
+							status: 500,
+							message: "Unsafe redirect target"
+						};
+					}
+					return {
+						...result,
+						to: safe.to
+					};
+				}
+				if (result.kind !== "data") return result;
+				const enveloped = {
+					...result,
+					data: { load: {
+						loading: false,
+						value: result.data ?? {},
+						error: void 0
+					} }
+				};
+				if (headStore.entries.length === 0) return enveloped;
+				return {
+					...enveloped,
+					head: serializeHead(headStore.entries),
+					headEntries: headStore.entries
+				};
+			} finally {
+				abort.done();
+			}
+		},
+		hydrate(registry, options = {}) {
+			if (!isBrowser) {
+				console.warn("[ilha-router] hydrate() called in a non-browser environment");
+				return () => {};
+			}
+			const root = options.root ?? document.body;
+			const target = options.target ?? root;
+			prime();
+			const { unmount } = mount(registry, { root });
+			const unmountRouter = this.mount(target, {
+				hydrate: true,
+				registry,
+				interceptLinks: options.interceptLinks
+			});
+			return () => {
+				unmount();
+				unmountRouter();
+			};
+		}
+	};
+	async function renderResponseInner(url, registry, options = {}, request) {
+		const { baseHead, ...renderOptions } = options;
+		const parsed = parsedURL(url);
+		syncRouteFromURL(parsed, routes);
+		const match = matchRoute(routes, parsed.pathname);
+		const island = match?.data?.island ?? null;
+		if (!island) {
+			const headStore = { entries: baseHead ? [baseHead] : [] };
+			if (notFound) return {
+				kind: "html",
+				html: `<div data-router-view data-router-not-found>${await withHeadStore(headStore, () => notFound.toString())}</div>`,
+				status: 404,
+				head: serializeHead(headStore.entries)
+			};
+			return {
+				kind: "html",
+				html: `<div data-router-empty></div>`,
+				status: 404,
+				head: baseHead ? serializeHead([baseHead]) : void 0
+			};
+		}
+		const headStore = { entries: baseHead ? [baseHead] : [] };
+		let props = {};
+		if (match?.data?.loader) {
+			const req = request ?? defaultRequest(parsed);
+			const abort = loaderAbort(request, loaderTimeout);
+			let result;
+			try {
+				result = await executeLoader(match.data.loader, parsed, routeParams(), req, abort.signal, (input) => headStore.entries.push(input));
+			} finally {
+				abort.done();
+			}
+			if (result.kind === "redirect") {
+				const safe = resolveRedirectTarget(result.to, parsed, allowExternalRedirects);
+				if (safe.ok) return {
+					kind: "redirect",
+					to: safe.to,
+					status: result.status
+				};
+				else {
+					console.warn(`[ilha-router] Blocked unsafe redirect target "${result.to}". Set allowExternalRedirects: true to allow cross-origin redirects.`);
+					result = {
+						kind: "error",
+						status: 500,
+						message: "Unsafe redirect target"
+					};
+				}
+			}
+			if (result.kind === "error") {
+				const boundary = match.data.errorHandler;
+				if (boundary) try {
+					const errorIsland = boundary({
+						message: result.message,
+						status: result.status
+					}, {
+						path: routePath(),
+						params: routeParams(),
+						search: routeSearch(),
+						hash: routeHash()
+					});
+					const html = await withHeadStore(headStore, () => errorIsland.toString());
+					return {
+						kind: "error",
+						status: result.status,
+						message: result.message,
+						html: `<div data-router-view data-router-error="${result.status}">${html}</div>`,
+						head: serializeHead(headStore.entries)
+					};
+				} catch (e) {
+					console.error("[ilha-router] error boundary threw while rendering a loader error:", e);
+				}
+				const escapedMessage = escapeHtml(result.message);
+				const html = `<div data-router-view data-router-error="${result.status}">${escapedMessage}</div>`;
+				return {
+					kind: "error",
+					status: result.status,
+					message: result.message,
+					html,
+					head: serializeHead(headStore.entries)
+				};
+			}
+			props = envelopLoad(result.data);
+		}
+		const name = buildReverseRegistry(registry).get(island);
+		if (!name) {
+			console.warn(`[ilha-router] renderHydratable: active island for "${routePath()}" is not in the registry. Falling back to plain SSR — the island will not be interactive on the client.`);
+			return {
+				kind: "html",
+				html: `<div data-router-view>${await withHeadStore(headStore, () => island.toString(props))}</div>`,
+				head: serializeHead(headStore.entries)
+			};
+		}
+		const islandAls = globalThis[REQUEST_ALS_KEY];
+		return {
+			kind: "html",
+			html: `<div data-router-view>${await (islandAls?.run && request ? islandAls.run(request, () => withHeadStore(headStore, () => island.hydratable(props, {
+				name,
+				as: "div",
+				snapshot: false,
+				...renderOptions
+			}))) : withHeadStore(headStore, () => island.hydratable(props, {
+				name,
+				as: "div",
+				snapshot: false,
+				...renderOptions
+			})))}</div>`,
+			head: serializeHead(headStore.entries)
+		};
+	}
+	return builder;
+}
+var src_default = {
+	router,
+	navigate,
+	useRoute,
+	isActive,
+	enableLinkInterception,
+	prime,
+	prefetch,
+	beforeNavigate,
+	afterNavigate,
+	RouterView,
+	RouterLink,
+	loader,
+	redirect,
+	error,
+	composeLoaders,
+	head
+};
+
+//#endregion
+export { useContext as A, routeHash as C, router as D, routeSearch as E, parsePattern as F, safeDecode as I, getHistoryMode as L, wrapError as M, wrapLayout as N, serializeHead as O, matchSegments as P, setHistoryMode as R, resolveRedirectTarget as S, routePath as T, navigate as _, RouterView as a, prime as b, composeLoaders as c, error as d, head as f, loader as g, isActive as h, RouterLink as i, useRoute as j, src_default as k, defineLayout as l, invalidate as m, LoaderError as n, afterNavigate as o, httpResponse as p, Redirect as r, beforeNavigate as s, LOADER_ENDPOINT as t, enableLinkInterception as u, navigating as v, routeParams as w, redirect as x, prefetch as y };