@askrjs/askr 0.0.51 → 0.0.53

package/dist/boot-j2KoN6ss.js

@@ -0,0 +1,647 @@
+import { b as isDevelopmentEnvironment, r as flushRuntimeScheduler, v as logger, x as isProductionEnvironment } from "./access-Bg4RJNC8.js";
+import { n as Fragment, t as ELEMENT_TYPE } from "./jsx-CUpRxrLH.js";
+import { n as createComponentInstance, r as mountComponent } from "./component-internal-B3z7GXlD.js";
+import { h as cleanupComponent, m as isPromiseLike } from "./component-lifecycle-CO4hXlP4.js";
+import { a as withIntrinsicHydrationAdoption, i as registerDeferredHydrationBoundary, n as activateHydrationBoundary$1, o as setStaticChildSlotsCacheEnabled, r as clearDeferredHydrationBoundaries, t as installRendererBridge } from "./renderer-DzPjeLby.js";
+import { _ as teardownNodeSubtree, d as removeAllListeners } from "./cleanup-COv77su2.js";
+import { D as assertExecutionModel, E as route, a as resolveRouteMeta, b as createAppRenderRuntime, c as registerAppInstance, d as clearRoutes, g as _snapshotRouteSourceLazy, h as _snapshotLazy, i as reconcileRouteMeta, l as unregisterAppInstance, m as _drainLazy, s as configureScrollRestoration, t as initializeNavigation, u as _applyManifest, y as setServerLocation } from "./navigate-CmPLSXyw.js";
+import { a as startHydrationRenderPhase, s as stopHydrationRenderPhase } from "./render-context-Clw3rFiO.js";
+import { a as disposeDefaultPortalScope, t as DefaultPortal } from "./portal-CyU3Ucf2.js";
+import { i as getDefaultDataRuntime } from "./data-runtime-SJ1BSUvk.js";
+import { a as hydrateDataRuntime } from "./query-registry-CQIT4mXr.js";
+import { a as resolveRouteFromRoutes, d as _setActiveRouteAuthOptions, j as lockRouteRegistration, k as hasRegisteredRoutes } from "./route-matching-vJpvLVbX.js";
+import { _ as pageRenderEnvelope, d as hasRouteRenderData, f as resolveRouteRequest, l as getRouteRenderContext, o as reviveDeferredValue, u as getRouteRenderData } from "./deferred-lKE8uR0z.js";
+import "./ssr-CbQO5xd3.js";
+//#region src/boot/hydration.ts
+const DEFERRED_PAYLOAD = "__askr_deferred__";
+function applyDeferredStreamPatches(rootElement) {
+	const patches = Array.from(rootElement.querySelectorAll("template[data-askr-deferred-patch]"));
+	for (const template of patches) {
+		const id = template.getAttribute("data-askr-deferred-patch");
+		if (!id) continue;
+		const boundary = Array.from(rootElement.querySelectorAll("askr-resolve[data-askr-deferred]")).find((candidate) => candidate.getAttribute("data-askr-deferred") === id);
+		if (boundary) boundary.replaceWith(template.content.cloneNode(true));
+		template.remove();
+		for (const script of Array.from(rootElement.querySelectorAll("script[data-askr-deferred-apply]"))) if (script.getAttribute("data-askr-deferred-apply") === id) script.remove();
+	}
+}
+function hydrationReviver(_key, value) {
+	if (!value || typeof value !== "object") return value;
+	const payload = value;
+	if (payload[DEFERRED_PAYLOAD] === "fulfilled") return reviveDeferredValue("fulfilled", payload.value, void 0);
+	if (payload[DEFERRED_PAYLOAD] === "rejected") return reviveDeferredValue("rejected", void 0, payload.error);
+	return value;
+}
+function takeHydrationRenderData(rootElement) {
+	for (const child of Array.from(rootElement.children)) if (child instanceof HTMLScriptElement && child.getAttribute("data-askr-render-data") === "true") {
+		const raw = child.textContent ?? "";
+		child.remove();
+		if (!raw) return pageRenderEnvelope(void 0);
+		try {
+			return pageRenderEnvelope(JSON.parse(raw, hydrationReviver));
+		} catch (err) {
+			const error = /* @__PURE__ */ new Error("[Askr] Failed to parse embedded SSR render data during hydration.");
+			error.cause = err;
+			throw error;
+		}
+	}
+	return null;
+}
+function markSkippedElements(root, skipSelectors) {
+	if (skipSelectors.length === 0) return;
+	const selectorList = Array.from(new Set(skipSelectors)).join(", ");
+	root.querySelectorAll(selectorList).forEach((el) => el.setAttribute("data-skip-hydrate", "true"));
+}
+function collectDeferredBelowFoldBoundaries(root, foldY) {
+	const boundaries = [];
+	const stack = [];
+	for (let index = root.children.length - 1; index >= 0; index -= 1) stack.push(root.children[index]);
+	while (stack.length > 0) {
+		const element = stack.pop();
+		if (element.hasAttribute("data-skip-hydrate")) continue;
+		if (element.getBoundingClientRect().top >= foldY) {
+			element.setAttribute("data-skip-hydrate", "true");
+			registerDeferredHydrationBoundary(root, element);
+			boundaries.push(element);
+			continue;
+		}
+		for (let index = element.children.length - 1; index >= 0; index -= 1) stack.push(element.children[index]);
+	}
+	return boundaries;
+}
+function activateVisibleDeferredBoundaries(root, boundaries, foldY, activate) {
+	let activated = false;
+	let remaining = 0;
+	for (const element of boundaries) {
+		if (!element.hasAttribute("data-skip-hydrate")) continue;
+		if (element.getBoundingClientRect().top < foldY) try {
+			if (activate(root, element)) activated = true;
+		} catch {}
+		if (element.hasAttribute("data-skip-hydrate")) remaining += 1;
+	}
+	return {
+		activated,
+		remaining
+	};
+}
+function queueIdleWork(work) {
+	return new Promise((resolve) => {
+		if (typeof requestIdleCallback !== "undefined") {
+			requestIdleCallback(() => {
+				work();
+				resolve();
+			}, { timeout: 2e3 });
+			return;
+		}
+		setTimeout(() => {
+			work();
+			resolve();
+		}, 0);
+	});
+}
+function shouldVerifyHydrationMarkup(config) {
+	const explicit = config.hydrate?.verifyMarkup;
+	if (typeof explicit === "boolean") return explicit;
+	return !isProductionEnvironment();
+}
+async function applySelectiveHydration(rootElement, resolved, path, cleanupStrict, hydrateOptions, source, hooks) {
+	const hasPermanentSkips = (hydrateOptions.skipSelectors?.length ?? 0) > 0;
+	const hasBelowFoldDeferral = !!hydrateOptions.deferBelowFold;
+	const hasSelectiveBoundaries = hasPermanentSkips || hasBelowFoldDeferral;
+	let staticChildSlotsCacheSuspended = false;
+	let releaseSelectiveHydrationResources = () => {};
+	const restoreStaticChildSlotsCache = () => {
+		if (!staticChildSlotsCacheSuspended) return;
+		setStaticChildSlotsCacheEnabled(true);
+		staticChildSlotsCacheSuspended = false;
+	};
+	if (hydrateOptions.skipSelectors?.length) markSkippedElements(rootElement, hydrateOptions.skipSelectors);
+	let deferredBoundaries = [];
+	if (hydrateOptions.deferBelowFold) {
+		setStaticChildSlotsCacheEnabled(false);
+		staticChildSlotsCacheSuspended = true;
+		const foldY = hydrateOptions.foldThreshold ?? window.innerHeight;
+		deferredBoundaries = collectDeferredBelowFoldBoundaries(rootElement, foldY);
+		let selectiveHydrationResourcesReleased = false;
+		let unregisterRootCleanupCallback = () => {};
+		function handleScroll() {
+			const { activated, remaining } = activateVisibleDeferredBoundaries(rootElement, deferredBoundaries, foldY, hooks.activateHydrationBoundary);
+			if (!activated) return;
+			if (remaining === 0) releaseSelectiveHydrationResources();
+		}
+		releaseSelectiveHydrationResources = () => {
+			if (selectiveHydrationResourcesReleased) return;
+			selectiveHydrationResourcesReleased = true;
+			unregisterRootCleanupCallback();
+			window.removeEventListener("scroll", handleScroll);
+			restoreStaticChildSlotsCache();
+		};
+		unregisterRootCleanupCallback = hooks.registerRootCleanupCallback(rootElement, releaseSelectiveHydrationResources);
+		window.addEventListener("scroll", handleScroll, { passive: true });
+	}
+	if (hydrateOptions.deferUntilIdle && !hasSelectiveBoundaries) {
+		await queueIdleWork(() => {
+			hooks.mountOrUpdate(rootElement, (() => resolved.handler(resolved.params)), {
+				cleanupStrict,
+				appRuntime: source?.runtime
+			});
+		});
+		await hooks.registerAppNavigation(rootElement, path, source);
+		return;
+	}
+	try {
+		hooks.mountOrUpdate(rootElement, (() => resolved.handler(resolved.params)), {
+			cleanupStrict,
+			appRuntime: source?.runtime
+		});
+		await hooks.registerAppNavigation(rootElement, path, source);
+	} catch (error) {
+		releaseSelectiveHydrationResources();
+		throw error;
+	}
+	if (hydrateOptions.deferUntilIdle && deferredBoundaries.length > 0) await queueIdleWork(() => {
+		try {
+			activateVisibleDeferredBoundaries(rootElement, deferredBoundaries, Number.POSITIVE_INFINITY, hooks.activateHydrationBoundary);
+		} finally {
+			releaseSelectiveHydrationResources();
+		}
+	});
+	if (deferredBoundaries.length === 0) releaseSelectiveHydrationResources();
+}
+//#endregion
+//#region src/boot/root-element.ts
+function resolveRootElement(root) {
+	if (typeof root !== "string") return root;
+	const id = root.startsWith("#") ? root.slice(1) : root;
+	return document.getElementById(id);
+}
+//#endregion
+//#region src/boot/root-lifecycle.ts
+installRendererBridge();
+let componentIdCounter = 0;
+const instancesByRoot = /* @__PURE__ */ new WeakMap();
+const routedRoots = /* @__PURE__ */ new Set();
+const CLEANUP_SYMBOL = Symbol.for("__askrCleanup__");
+const ROOT_CLEANUP_CALLBACKS_SYMBOL = Symbol.for("__askrRootCleanupCallbacks__");
+function clearRootCleanupCallbacks(rootElement) {
+	try {
+		delete rootElement[ROOT_CLEANUP_CALLBACKS_SYMBOL];
+	} catch {
+		rootElement[ROOT_CLEANUP_CALLBACKS_SYMBOL]?.clear();
+	}
+}
+function registerRootCleanupCallback(rootElement, callback) {
+	const elementWithCleanup = rootElement;
+	const callbacks = elementWithCleanup[ROOT_CLEANUP_CALLBACKS_SYMBOL] ?? /* @__PURE__ */ new Set();
+	callbacks.add(callback);
+	elementWithCleanup[ROOT_CLEANUP_CALLBACKS_SYMBOL] = callbacks;
+	return () => {
+		callbacks.delete(callback);
+		if (callbacks.size === 0) clearRootCleanupCallbacks(rootElement);
+	};
+}
+function runRootCleanupCallbacks(rootElement, errors) {
+	const callbacks = rootElement[ROOT_CLEANUP_CALLBACKS_SYMBOL];
+	if (!callbacks || callbacks.size === 0) {
+		clearRootCleanupCallbacks(rootElement);
+		return;
+	}
+	clearRootCleanupCallbacks(rootElement);
+	for (const callback of callbacks) try {
+		callback();
+	} catch (e) {
+		errors.push(e);
+	}
+}
+function cleanupRootInstance(rootElement, instance, options) {
+	const errors = [];
+	try {
+		teardownNodeSubtree(rootElement);
+	} catch (e) {
+		errors.push(e);
+	}
+	try {
+		cleanupComponent(instance);
+	} catch (e) {
+		errors.push(e);
+	}
+	runRootCleanupCallbacks(rootElement, errors);
+	clearDeferredHydrationBoundaries(rootElement);
+	if (!options?.preserveInstance) {
+		unregisterAppInstance(instance);
+		instancesByRoot.delete(rootElement);
+		clearRootCleanupCallbacks(rootElement);
+		try {
+			delete rootElement[CLEANUP_SYMBOL];
+		} catch {}
+	}
+	if (errors.length > 0) {
+		if (instance.cleanupStrict) throw new AggregateError(errors, `cleanup failed for app root`);
+		else if (isDevelopmentEnvironment()) for (const err of errors) logger.warn("[Askr] cleanup error:", err);
+	}
+}
+function attachCleanupForRoot(rootElement, instance) {
+	rootElement[CLEANUP_SYMBOL] = (options) => {
+		cleanupRootInstance(rootElement, instance, options);
+	};
+	try {
+		const descriptor = Object.getOwnPropertyDescriptor(rootElement, "innerHTML") || Object.getOwnPropertyDescriptor(Object.getPrototypeOf(rootElement), "innerHTML") || Object.getOwnPropertyDescriptor(Element.prototype, "innerHTML");
+		if (descriptor && (descriptor.get || descriptor.set)) Object.defineProperty(rootElement, "innerHTML", {
+			get: descriptor.get ? function() {
+				return descriptor.get.call(this);
+			} : void 0,
+			set: function(value) {
+				if (value === "" && instancesByRoot.get(this) === instance) cleanupRootInstance(rootElement, instance);
+				if (descriptor.set) return descriptor.set.call(this, value);
+			},
+			configurable: true
+		});
+	} catch {}
+}
+function mountOrUpdate(rootElement, componentFn, options) {
+	const wrappedFn = (props, ctx) => {
+		const out = componentFn(props, ctx);
+		if (isPromiseLike(out)) throw new Error("Async components are not supported. Components must return synchronously.");
+		const portalVNode = {
+			$$typeof: ELEMENT_TYPE,
+			type: DefaultPortal,
+			props: { __askrAutoDefaultPortal: true },
+			key: "__default_portal"
+		};
+		return {
+			$$typeof: ELEMENT_TYPE,
+			type: Fragment,
+			props: { children: out === void 0 || out === null ? [portalVNode] : [out, portalVNode] }
+		};
+	};
+	Object.defineProperty(wrappedFn, "name", { value: componentFn.name || "Component" });
+	const existingCleanup = rootElement[CLEANUP_SYMBOL];
+	const reusedExistingInstance = typeof existingCleanup === "function";
+	if (reusedExistingInstance) existingCleanup({ preserveInstance: true });
+	let instance = instancesByRoot.get(rootElement);
+	if (instance) {
+		const shouldResetHookState = instance._rootComponentFn !== componentFn;
+		if (!reusedExistingInstance) {
+			removeAllListeners(rootElement);
+			try {
+				cleanupComponent(instance);
+			} catch (e) {
+				if (isDevelopmentEnvironment()) logger.warn("[Askr] prior cleanup threw:", e);
+			}
+		}
+		instance.fn = wrappedFn;
+		instance._rootComponentFn = componentFn;
+		instance.evaluationGeneration++;
+		instance.mounted = false;
+		instance.expectedStateIndices = [];
+		instance.firstRenderComplete = false;
+		instance.isRoot = true;
+		instance.portalScope = instance;
+		instance._appRenderRuntime = options?.appRuntime;
+		if (shouldResetHookState) {
+			instance.stateValues = [];
+			instance.hasPendingUpdate = false;
+			instance.notifyUpdate = null;
+			instance.stateIndexCheck = -1;
+			instance.mountOperations = void 0;
+			instance.commitOperations = void 0;
+			instance.lifecycleSlots = void 0;
+			instance.cleanupFns = void 0;
+			instance._currentRenderToken = void 0;
+			instance.lastRenderToken = 0;
+			instance._pendingReadSources = void 0;
+			instance._lastReadSources = void 0;
+			instance._placeholder = void 0;
+			instance.errorBoundaryState = void 0;
+			instance.devWarningsEmitted = void 0;
+		}
+		if (options && typeof options.cleanupStrict === "boolean") instance.cleanupStrict = options.cleanupStrict;
+	} else {
+		instance = createComponentInstance(String(++componentIdCounter), wrappedFn, {}, rootElement);
+		instancesByRoot.set(rootElement, instance);
+		instance.isRoot = true;
+		instance._rootComponentFn = componentFn;
+		instance.portalScope = instance;
+		instance._appRenderRuntime = options?.appRuntime;
+		if (options && typeof options.cleanupStrict === "boolean") instance.cleanupStrict = options.cleanupStrict;
+	}
+	attachCleanupForRoot(rootElement, instance);
+	registerRootCleanupCallback(rootElement, () => {
+		disposeDefaultPortalScope(instance.portalScope ?? instance);
+	});
+	mountComponent(instance);
+	flushRuntimeScheduler();
+}
+/** @internal Activate one deferred boundary without rerunning its root. */
+function activateHydrationBoundary(rootElement, boundary) {
+	if (!instancesByRoot.has(rootElement)) return false;
+	const activated = activateHydrationBoundary$1(boundary);
+	if (activated) flushRuntimeScheduler();
+	return activated;
+}
+async function registerAppNavigation(rootElement, path, source) {
+	const instance = instancesByRoot.get(rootElement);
+	if (!instance) throw new Error("Internal error: app instance missing");
+	routedRoots.add(rootElement);
+	registerAppInstance(instance, path, source);
+	initializeNavigation();
+}
+function cleanupApp(root) {
+	const rootElement = resolveRootElement(root);
+	if (!rootElement) return;
+	const cleanupFn = rootElement[CLEANUP_SYMBOL];
+	try {
+		if (typeof cleanupFn === "function") cleanupFn();
+	} finally {
+		const wasRoutedRoot = routedRoots.delete(rootElement);
+		instancesByRoot.delete(rootElement);
+		clearRootCleanupCallbacks(rootElement);
+		if (wasRoutedRoot && routedRoots.size === 0) clearRoutes();
+		try {
+			delete rootElement[CLEANUP_SYMBOL];
+		} catch {}
+	}
+}
+function hasApp(root) {
+	const rootElement = resolveRootElement(root);
+	if (!rootElement) return false;
+	return instancesByRoot.has(rootElement);
+}
+//#endregion
+//#region src/boot/route-startup.ts
+const MAX_INITIAL_ROUTE_REDIRECTS = 20;
+function bindResolvedRouteHandler(resolved) {
+	return () => resolved.handler(resolved.params);
+}
+function createDeniedStatusNode(status) {
+	return {
+		type: "div",
+		props: { "data-route-denied": String(status) },
+		children: [String(status)]
+	};
+}
+function bindDeniedStatus(status) {
+	return () => createDeniedStatusNode(status);
+}
+function bindDeniedRouteHandler(status) {
+	return () => createDeniedStatusNode(status);
+}
+async function reconcileInitialRouteMetadata(resolved) {
+	if (resolved?.kind !== "render" || !resolved.record) return;
+	if (!resolved.record.options.title && !resolved.record.options.meta && !resolved.record.metaChain?.length) return;
+	const context = getRouteRenderContext(resolved);
+	if (!context) return;
+	reconcileRouteMeta(await resolveRouteMeta(resolved.record, context));
+}
+async function resolveInitialRoute(auth, source) {
+	let path = typeof window !== "undefined" ? window.location.pathname : "/";
+	let href = typeof window !== "undefined" ? `${window.location.pathname}${window.location.search}${window.location.hash}` : path;
+	const visited = /* @__PURE__ */ new Set();
+	for (let redirects = 0; redirects <= MAX_INITIAL_ROUTE_REDIRECTS; redirects++) {
+		if (visited.has(href)) throw new Error(`[Askr] Route redirect cycle detected at ${href}.`);
+		visited.add(href);
+		const resolved = source?.manifest ? await resolveRouteRequest(href, {
+			manifest: source.manifest,
+			auth,
+			load: source.load
+		}) : source?.routes ? (() => {
+			const match = resolveRouteFromRoutes(path, source.routes);
+			return match ? {
+				kind: "render",
+				handler: match.handler,
+				params: match.params
+			} : null;
+		})() : await resolveRouteRequest(href, { auth });
+		if (typeof window === "undefined" || !resolved || resolved.kind !== "redirect") return {
+			path,
+			href,
+			resolved
+		};
+		const redirectTarget = new URL(resolved.to, window.location.href);
+		const redirectHref = `${redirectTarget.pathname}${redirectTarget.search}${redirectTarget.hash}`;
+		window.history.replaceState({ path: redirectHref }, "", redirectHref);
+		path = redirectTarget.pathname;
+		href = redirectHref;
+	}
+	throw new Error(`[Askr] Route redirect limit exceeded (${MAX_INITIAL_ROUTE_REDIRECTS}).`);
+}
+//#endregion
+//#region src/boot/index.ts
+/**
+* App bootstrap and mount
+*/
+/**
+* createIsland: Enhances existing DOM (no router, mounts once)
+*/
+function createIsland(config) {
+	assertExecutionModel("islands");
+	if (!config || typeof config !== "object") throw new Error("createIsland requires a config object");
+	if (typeof config.component !== "function") throw new Error("createIsland: component must be a function");
+	const rootElement = resolveRootElement(config.root);
+	if (!rootElement) throw new Error(`Root element not found: ${config.root}`);
+	if ("routes" in config) throw new Error("createIsland does not accept routes; use createSPA for routed apps");
+	if (hasRegisteredRoutes()) throw new Error("Routes are not supported with islands. Use createSPA (client) or createSSR (server) instead.");
+	mountOrUpdate(rootElement, config.component, { cleanupStrict: config.cleanupStrict });
+}
+/**
+* createIslands: Enhances one or more existing DOM roots (no router).
+* The only public islands constructor.
+*/
+function createIslands(config) {
+	assertExecutionModel("islands");
+	if (!config || typeof config !== "object") throw new Error("createIslands requires a config object");
+	if (!Array.isArray(config.islands) || config.islands.length === 0) throw new Error("createIslands requires a non-empty islands array");
+	for (const island of config.islands) createIsland(island);
+}
+/**
+* createSPA: Initializes router and mounts the app with the provided route manifest or route table.
+*
+* Preferred usage with manifest:
+* ```ts
+* import { getManifest } from '@askrjs/askr/router';
+* await createSPA({ root: '#app', manifest: getManifest() });
+* ```
+*
+* Legacy usage with plain routes array (still supported):
+* ```ts
+* await createSPA({ root: '#app', routes: getRoutes() });
+* ```
+*/
+async function createSPA(config) {
+	assertExecutionModel("spa");
+	if (!config || typeof config !== "object") throw new Error("createSPA requires a config object");
+	const manifest = config.manifest ?? config.registry?.manifest;
+	const routeTable = config.routes ?? config.registry?.routes;
+	const hasManifest = manifest != null && manifest.records.length > 0;
+	const hasRoutes = Array.isArray(routeTable) && routeTable.length > 0;
+	if (!hasManifest && !hasRoutes) throw new Error("createSPA requires a route manifest or route table. Pass `manifest: getManifest()` or `routes: getRoutes()`. If you are enhancing existing HTML, use createIsland instead.");
+	const rootElement = resolveRootElement(config.root);
+	if (!rootElement) throw new Error(`Root element not found: ${config.root}`);
+	const pendingLazyAtBoot = [..._snapshotLazy(), ..._snapshotRouteSourceLazy({
+		registry: config.registry,
+		manifest
+	})];
+	configureScrollRestoration(config.scrollRestoration);
+	clearRoutes();
+	if (hasManifest) _applyManifest(manifest);
+	else for (const r of routeTable) route(r.path, r.handler);
+	const routeAuth = config.auth ?? manifest?.auth;
+	const activeManifest = hasManifest ? manifest : void 0;
+	const appRouteSource = {
+		manifest: activeManifest,
+		routes: hasManifest ? void 0 : routeTable,
+		auth: routeAuth
+	};
+	_setActiveRouteAuthOptions(routeAuth);
+	await _drainLazy(pendingLazyAtBoot);
+	if (isProductionEnvironment()) lockRouteRegistration();
+	const { path, resolved } = await resolveInitialRoute(routeAuth, {
+		manifest: activeManifest,
+		routes: hasManifest ? void 0 : routeTable
+	});
+	const appRuntime = createAppRenderRuntime(resolved?.kind === "render" && hasRouteRenderData(resolved) ? {
+		route: getRouteRenderData(resolved),
+		hasRoute: true
+	} : {});
+	if (!resolved) {
+		mountOrUpdate(rootElement, () => ({
+			type: "div",
+			children: []
+		}), {
+			cleanupStrict: config.cleanupStrict,
+			appRuntime
+		});
+		await registerAppNavigation(rootElement, path, { ...appRouteSource });
+		return;
+	}
+	if (resolved.kind === "redirect") {
+		mountOrUpdate(rootElement, () => ({
+			type: "div",
+			children: []
+		}), {
+			cleanupStrict: config.cleanupStrict,
+			appRuntime
+		});
+		await registerAppNavigation(rootElement, path, { ...appRouteSource });
+		return;
+	}
+	await reconcileInitialRouteMetadata(resolved);
+	mountOrUpdate(rootElement, resolved.kind === "deny" ? bindDeniedStatus(resolved.status) : bindResolvedRouteHandler({
+		handler: resolved.handler,
+		params: resolved.params
+	}), {
+		cleanupStrict: config.cleanupStrict,
+		appRuntime
+	});
+	await registerAppNavigation(rootElement, path, { ...appRouteSource });
+}
+/**
+* hydrateSPA: Hydrate server-rendered HTML.
+* Accepts either a `manifest` (preferred) or a legacy `routes` array.
+*/
+async function hydrateSPA(config) {
+	assertExecutionModel("spa");
+	if (!config || typeof config !== "object") throw new Error("hydrateSPA requires a config object");
+	const manifest = config.manifest ?? config.registry?.manifest;
+	const routeTable = config.routes ?? config.registry?.routes;
+	const hasManifest = manifest != null && manifest.records.length > 0;
+	const hasRoutes = Array.isArray(routeTable) && routeTable.length > 0;
+	if (!hasManifest && !hasRoutes) throw new Error("hydrateSPA requires a route manifest or route table. Pass `manifest: getManifest()` or `routes: getRoutes()`. If you are enhancing existing HTML, use createIsland instead.");
+	const rootElement = resolveRootElement(config.root);
+	if (!rootElement) throw new Error(`Root element not found: ${config.root}`);
+	applyDeferredStreamPatches(rootElement);
+	const hydrationRenderData = takeHydrationRenderData(rootElement);
+	const hydrationQueryCache = hydrationRenderData?.resources;
+	if (hydrationQueryCache) hydrateDataRuntime(config.dataRuntime ?? getDefaultDataRuntime(), hydrationQueryCache);
+	const hydrationRenderDataForApp = hydrationRenderData;
+	const pendingLazyAtHydrationBoot = [..._snapshotLazy(), ..._snapshotRouteSourceLazy({
+		registry: config.registry,
+		manifest
+	})];
+	configureScrollRestoration(config.scrollRestoration);
+	clearRoutes();
+	if (hasManifest) _applyManifest(manifest);
+	else for (const r of routeTable) route(r.path, r.handler);
+	const routeAuth = config.auth ?? manifest?.auth;
+	const activeManifest = hasManifest ? manifest : void 0;
+	const appRouteSource = {
+		manifest: activeManifest,
+		routes: hasManifest ? void 0 : routeTable,
+		auth: routeAuth,
+		runtime: createAppRenderRuntime({
+			framework: hydrationRenderData?.framework,
+			route: hydrationRenderData?.route,
+			hasRoute: hydrationRenderData !== null
+		})
+	};
+	_setActiveRouteAuthOptions(routeAuth);
+	await _drainLazy(pendingLazyAtHydrationBoot);
+	const { path, href: currentUrl, resolved } = await resolveInitialRoute(routeAuth, {
+		manifest: activeManifest,
+		routes: hasManifest ? void 0 : routeTable,
+		load: false
+	});
+	setServerLocation(currentUrl);
+	if (isProductionEnvironment()) lockRouteRegistration();
+	if (!resolved) throw new Error(`hydrateSPA: no route found for current path (${path}).`);
+	if (resolved.kind === "redirect") throw new Error(`hydrateSPA: unresolved redirect for current path (${path}).`);
+	await reconcileInitialRouteMetadata(resolved);
+	const hydrationResolved = resolved.kind === "deny" ? {
+		handler: bindDeniedRouteHandler(resolved.status),
+		params: {}
+	} : {
+		handler: resolved.handler,
+		params: resolved.params
+	};
+	const mountHydratedRoot = (...args) => withIntrinsicHydrationAdoption(() => mountOrUpdate(...args));
+	if (shouldVerifyHydrationMarkup(config)) {
+		const legacyRouteTable = hasManifest ? manifest.records.map((r) => ({
+			...r,
+			path: r.path,
+			handler: r.handler,
+			namespace: r.options.namespace
+		})) : routeTable;
+		const { verifyHydrationSyncForUrl } = await import("./verify-hydration-io9ahUeq.js");
+		if (!verifyHydrationSyncForUrl({
+			root: rootElement,
+			url: currentUrl,
+			routes: legacyRouteTable,
+			resolved: hydrationResolved,
+			options: {
+				data: hydrationRenderDataForApp?.resources,
+				dataRuntime: config.dataRuntime ?? getDefaultDataRuntime(),
+				envelope: hydrationRenderDataForApp ?? void 0
+			}
+		})) throw new Error("[Askr] Hydration mismatch detected. Server HTML does not match expected server-render output.");
+	}
+	const hydrateOptions = config.hydrate;
+	if (hydrateOptions) {
+		if (hydrateOptions.deferUntilIdle || hydrateOptions.deferBelowFold) {
+			if (hydrationRenderDataForApp) startHydrationRenderPhase(hydrationRenderDataForApp);
+			try {
+				await applySelectiveHydration(rootElement, hydrationResolved, path, config.cleanupStrict, hydrateOptions, appRouteSource, {
+					mountOrUpdate: mountHydratedRoot,
+					registerAppNavigation,
+					registerRootCleanupCallback,
+					activateHydrationBoundary
+				});
+			} finally {
+				if (hydrationRenderDataForApp) stopHydrationRenderPhase();
+			}
+			return;
+		}
+		if (hydrateOptions.skipSelectors?.length) markSkippedElements(rootElement, hydrateOptions.skipSelectors);
+	}
+	if (hydrationRenderDataForApp) startHydrationRenderPhase(hydrationRenderDataForApp);
+	try {
+		mountHydratedRoot(rootElement, resolved.kind === "deny" ? bindDeniedStatus(resolved.status) : bindResolvedRouteHandler(hydrationResolved), {
+			cleanupStrict: config.cleanupStrict,
+			appRuntime: appRouteSource.runtime
+		});
+	} finally {
+		if (hydrationRenderDataForApp) stopHydrationRenderPhase();
+	}
+	await registerAppNavigation(rootElement, path, { ...appRouteSource });
+}
+//#endregion
+export { cleanupApp as a, hydrateSPA as i, createIslands as n, hasApp as o, createSPA as r, createIsland as t };