@ilha/router 0.8.0 → 0.8.2

package/dist/src-C_n-faIh.js

@@ -0,0 +1,1926 @@
+import ilha, { ISLAND_MOUNT_INTERNAL, context, html, mount } from "ilha";
+import { addRoute, createRouter, findRoute } from "rou3";
+
+//#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/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.
+*/
+function loader(fn) {
+	return fn;
+}
+var Redirect = class {
+	__ilhaRedirect = true;
+	to;
+	status;
+	constructor(to, status = 302) {
+		this.to = to;
+		this.status = status;
+	}
+};
+var LoaderError = class {
+	__ilhaLoaderError = true;
+	status;
+	message;
+	constructor(status, message) {
+		this.status = status;
+		this.message = message;
+	}
+};
+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");
+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);
+}
+/** Layout shell HTML with an empty `k:page` — avoids scanning MDX/twoslash inside `Wrapped.toString()`. */
+function layoutHtmlWithEmptyKPage(wrappedLayout, props) {
+	const handler = wrappedLayout[WRAP_LAYOUT_HANDLER];
+	if (!handler) return wrappedLayout.toString(props);
+	const leaf = wrappedLayout[WRAP_LAYOUT_LEAF] ?? wrappedLayout;
+	return handler(Object.assign(leaf.key("page"), { toString: () => "" })).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 ? page : null;
+	const Wrapped = layout(Object.assign(page.key("page"), { toString: page.toString.bind(page) }));
+	Wrapped[WRAP_LAYOUT_LEAF] = leafPage;
+	Wrapped[WRAP_LAYOUT_HANDLER] = layout;
+	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 layoutMount = Wrapped.mount.bind(Wrapped);
+	const layoutInternal = Wrapped[ISLAND_MOUNT_INTERNAL];
+	function prepareLayoutMountHost(host) {
+		preparePageMountHost(host, pageMountHost(host));
+	}
+	Wrapped.mount = (host, props) => {
+		prepareLayoutMountHost(host);
+		return layoutMount(host, props);
+	};
+	Wrapped[ISLAND_MOUNT_INTERNAL] = (host, props) => {
+		prepareLayoutMountHost(host);
+		if (typeof layoutInternal === "function") return layoutInternal(host, props);
+		return {
+			unmount: layoutMount(host, props),
+			updateProps: () => {}
+		};
+	};
+	Wrapped.hydratable = async (props, opts) => {
+		if (!opts?.name) throw new Error("wrapLayout: hydratable requires options.name");
+		const resolvedProps = props ?? {};
+		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 `clientLoad`) 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") return headEntries.length > 0 ? {
+		kind: "data",
+		data: result.data,
+		headEntries
+	} : {
+		kind: "data",
+		data: result.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 = findRoute(_rou3, "GET", 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
+			};
+		}
+		return await res.json();
+	} 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 (!findRoute(_rou3, "GET", 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
+	});
+}
+/**
+* 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 nfHost ? nf.mount(nfHost) : () => {};
+			});
+		}
+		await withViewSwap(() => {
+			host.innerHTML = `<div data-router-empty></div>`;
+		});
+		return () => {};
+	}
+	const clientMatch = findRoute(_rou3, "GET", 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 () => {};
+	}
+	if (loaderResult.kind === "error") {
+		const boundary = clientMatch?.data?.errorHandler;
+		if (boundary) return withViewSwap(() => mountLoaderErrorBoundary(boundary, host, loaderResult.status, loaderResult.message));
+		const escaped = escapeHtml(loaderResult.message);
+		await withViewSwap(() => {
+			host.innerHTML = `<div data-router-view data-router-error="${loaderResult.status}">${escaped}</div>`;
+		});
+		return () => {};
+	}
+	if (loaderResult.kind === "not-found") {
+		await withViewSwap(() => {
+			host.innerHTML = `<div data-router-empty></div>`;
+		});
+		return () => {};
+	}
+	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 () => {};
+	}
+	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 () => {};
+	}
+	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 ? island.mount(islandHost) : () => {};
+	});
+}
+/** 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);
+	let done = false;
+	return () => {
+		if (done) return;
+		done = true;
+		_navigatingSig(Math.max(0, _navigatingSig() - 1));
+	};
+}
+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) {
+		if (store) return store.island = value ?? null;
+		return _activeIslandSig(value ?? null), value ?? null;
+	}
+	return store ? store.island : _activeIslandSig();
+}
+let _rou3 = createRouter();
+function extractParams(matchParams) {
+	const params = {};
+	if (matchParams) for (const [k, v] of Object.entries(matchParams)) params[k] = decodeURIComponent(v);
+	return params;
+}
+function syncRouteFromURL(url, rou3 = _rou3) {
+	const parsed = typeof url === "string" ? new URL(url, "http://localhost") : url;
+	const match = findRoute(rou3, "GET", 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 = findRoute(_rou3, "GET", 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) scrollAfterNavigate(adapter.readLocation().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 = findRoute(_rou3, "GET", 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) {
+	return Object.entries(attrs).map(([k, v]) => ` ${k}="${escapeHeadAttr(v)}"`).join("");
+}
+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)) parts.push(`<meta${serializeAttrs({
+		...tag,
+		[ILHA_HEAD_ATTR]: ""
+	})} />`);
+	for (const tag of dedupByKey(link, (t) => `${t.rel ?? ""}:${t.href ?? ""}`)) parts.push(`<link${serializeAttrs({
+		...tag,
+		[ILHA_HEAD_ATTR]: ""
+	})} />`);
+	for (const tag of script) {
+		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 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 rou3 = createRouter();
+	const patternToData = /* @__PURE__ */ new Map();
+	const notFound = options.notFound ?? null;
+	_rou3 = rou3;
+	_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
+			});
+			addRoute(rou3, "GET", 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();
+				const reverseRegistry = registry ? buildReverseRegistry(registry) : void 0;
+				let navVersion = 0;
+				const NavHandler = ilha.render(() => {
+					const current = activeIsland();
+					if (current !== currentMountedIsland) {
+						const thisNav = ++navVersion;
+						navAbort?.abort();
+						navAbort = new AbortController();
+						const signal = navAbort.signal;
+						queueMicrotask(async () => {
+							if (thisNav !== navVersion) return;
+							const settle = beginNavigation();
+							unmountView?.();
+							unmountView = null;
+							try {
+								const loc = getAdapter().readLocation();
+								unmountView = await mountRouteWithHydration(current, viewHost, loc.pathname + loc.search, 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;
+						});
+					}
+					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 = findRoute(_rou3, "GET", 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) unmountView = um;
+							else um();
+						} 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 um = await mountRouteWithHydration(island, viewHost, loc.pathname + loc.search, ac.signal, registry, reverseRegistry);
+						if (thisNav === navVersion) {
+							unmountView?.();
+							unmountView = um;
+							currentMountedIsland = island;
+						} else um();
+					} 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();
+					unmountView?.();
+					_linkCleanup?.();
+					_navChangeCleanup?.();
+					_linkCleanup = null;
+					_navChangeCleanup = null;
+					if (prevScrollRestoration !== null) history.scrollRestoration = prevScrollRestoration;
+				};
+			}
+			let unmountIsland = null;
+			let currentMountedIsland = 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) {
+				unmountIsland?.();
+				unmountIsland = null;
+				currentMountedIsland = island;
+				if (!island) {
+					const nfHost = host?.querySelector("[data-router-not-found]");
+					if (_notFound && nfHost) unmountIsland = _notFound.mount(nfHost);
+					return;
+				}
+				const viewHost = host?.querySelector("[data-router-view]");
+				if (!viewHost) return;
+				const loc = getAdapter().readLocation();
+				const clientMatch = findRoute(_rou3, "GET", 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") {
+					const boundary = clientMatch?.data?.errorHandler;
+					if (boundary) {
+						unmountIsland = await withViewSwap(() => mountLoaderErrorBoundary(boundary, viewHost, result.status, result.message));
+						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 : {};
+				const headStore = { entries: [...result.kind === "data" ? result.headEntries ?? [] : []] };
+				const html = await withHeadStore(headStore, () => island.toString(props));
+				unmountIsland = await withViewSwap(() => {
+					applyHeadEntriesToDocument(headStore.entries);
+					viewHost.innerHTML = html;
+					return island.mount(viewHost, props);
+				});
+			}
+			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();
+				if (current !== currentMountedIsland) {
+					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();
+				unmountIsland?.();
+				unmountNavHandler();
+				navHost.remove();
+				unmountView?.();
+				_linkCleanup?.();
+				_navChangeCleanup?.();
+				_linkCleanup = null;
+				_navChangeCleanup = null;
+				if (prevScrollRestoration !== null) history.scrollRestoration = prevScrollRestoration;
+			};
+		},
+		render(url) {
+			const doRender = () => {
+				syncRouteFromURL(url, rou3);
+				return RouterView.toString();
+			};
+			if (!isBrowser && _routeAls) return _routeAls.run(freshRouteStore(), doRender);
+			return doRender();
+		},
+		async renderHydratable(url, registry, options = {}, request) {
+			const response = await this.renderResponse(url, registry, options, request);
+			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(url, registry, options = {}, request) {
+			if (!isBrowser) {
+				const als = await getRouteAlsAsync();
+				if (!als.getStore()) return als.run(freshRouteStore(), () => renderResponseInner(url, registry, options, request));
+			}
+			return renderResponseInner(url, registry, options, request);
+		},
+		async runLoader(url, request) {
+			const parsed = parsedURL(url);
+			const match = findRoute(rou3, "GET", parsed.pathname);
+			if (!match?.data?.island) return { kind: "not-found" };
+			if (!match.data.loader) return {
+				kind: "data",
+				data: {}
+			};
+			const params = extractParams(match.params);
+			const req = request ?? defaultRequest(parsed);
+			const abort = loaderAbort(request, loaderTimeout);
+			const headStore = { entries: [] };
+			try {
+				const result = await executeLoader(match.data.loader, parsed, params, req, 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;
+				if (headStore.entries.length === 0) return result;
+				return {
+					...result,
+					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, rou3);
+		const match = findRoute(rou3, "GET", 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) {
+					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"
+					};
+				} else return {
+					kind: "redirect",
+					to: safe.to,
+					status: result.status
+				};
+			}
+			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 = 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)
+			};
+		}
+		return {
+			kind: "html",
+			html: `<div data-router-view>${await withHeadStore(headStore, () => island.hydratable(props, {
+				name,
+				as: "div",
+				snapshot: true,
+				...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 { wrapLayout as A, routePath as C, src_default as D, serializeHead as E, setHistoryMode as M, useRoute as O, routeParams as S, router as T, navigating as _, RouterView as a, redirect as b, composeLoaders as c, error as d, head as f, navigate as g, loader as h, RouterLink as i, getHistoryMode as j, wrapError as k, defineLayout as l, isActive as m, LoaderError as n, afterNavigate as o, invalidate as p, Redirect as r, beforeNavigate as s, LOADER_ENDPOINT as t, enableLinkInterception as u, prefetch as v, routeSearch as w, routeHash as x, prime as y };