@askrjs/askr 0.0.52 → 0.0.53

package/dist/navigate-CmPLSXyw.js

@@ -0,0 +1,1449 @@
+import { b as isDevelopmentEnvironment, r as flushRuntimeScheduler, v as logger, x as isProductionEnvironment } from "./access-Bg4RJNC8.js";
+import { f as notifyReadableReaders, i as cleanupReadableSubscriptionSources, l as markReactivePropsDirtySource, p as recordReadableRead, u as markReadableDerivedSubscribersDirty } from "./fastlane-Dw8SOBr9.js";
+import { n as Fragment, t as ELEMENT_TYPE } from "./jsx-CUpRxrLH.js";
+import { r as mountComponent } from "./component-internal-B3z7GXlD.js";
+import { d as getCurrentAppRenderRuntime, f as getCurrentComponentInstance } from "./component-scope-CC3cojX9.js";
+import { g as cleanupComponentGeneration, h as cleanupComponent, i as beginLifecycleCommitBatch, l as flushLifecycleCommitBatch, m as isPromiseLike, o as discardLifecycleCommitBatch, s as drainLifecycleCommitErrors } from "./component-lifecycle-CO4hXlP4.js";
+import { _ as teardownNodeSubtree } from "./cleanup-COv77su2.js";
+import { n as getActiveRenderContext } from "./render-context-Clw3rFiO.js";
+import { n as syncRouteActivitySnapshot } from "./route-activity-CNJfpwx-.js";
+import { r as clearDefaultPortalForInstance, t as DefaultPortal } from "./portal-CyU3Ucf2.js";
+import { A as insertRecordSorted, C as getCurrentPathPrefix, D as getRoutes, E as getRouteRecords, F as snapshotRouteState, I as computeRank, L as normalizeRouteSegmentName, M as pushRegistrationScope, N as restoreRouteState, O as hasActivePageScope, P as setDefaultRouteAuthOptions, R as parseSegments, S as getCurrentPageScope, T as getDefaultRouteAuthOptions, _ as getCurrentInheritedAuthRequirements, a as resolveRouteFromRoutes, b as getCurrentLayoutChain, c as deepFreeze, f as addRouteToStores, g as getActiveRoutes, j as lockRouteRegistration, l as makeQuery, m as clearRouteState, n as computeMatchesFromRoutes, p as assertRouteRegistrationUnlocked, r as computeRouteActivityMatches, u as parseLocation, v as getCurrentInheritedMeta, w as getCurrentScopeKind, x as getCurrentPageChain, y as getCurrentInheritedPolicies } from "./route-matching-vJpvLVbX.js";
+import { d as hasRouteRenderData, f as resolveRouteRequest, l as getRouteRenderContext, u as getRouteRenderData, y as createRouteHandler } from "./deferred-lKE8uR0z.js";
+import { allOf } from "@askrjs/auth";
+//#region src/runtime/execution-model.ts
+const EXECUTION_MODEL_KEY = Symbol.for("__ASKR_EXECUTION_MODEL__");
+function getExecutionModel() {
+	return globalThis[EXECUTION_MODEL_KEY];
+}
+function assertExecutionModel(model) {
+	const g = globalThis;
+	const cur = g[EXECUTION_MODEL_KEY];
+	if (cur && cur !== model) throw new Error(`[Askr] mixing execution models is not allowed (current: ${cur}, attempted: ${model}). Choose exactly one: createSPA, createSSR, or createIslands.`);
+	if (!cur) g[EXECUTION_MODEL_KEY] = model;
+}
+//#endregion
+//#region src/router/access.ts
+function compileNodePolicies(node) {
+	return node.policies ? [...node.policies] : [];
+}
+//#endregion
+//#region src/router/authoring.ts
+function validateRoutePath(path) {
+	if (!path.startsWith("/")) throw new Error(`Route path must begin with "/". Got: "${path}"`);
+	if (/\/{2,}/.test(path)) throw new Error("Route path cannot contain consecutive slashes.");
+	if (/:([^/{}]+)/.test(path)) {
+		const suggested = path.replace(/:([^/{}]+)/g, "{$1}");
+		throw new Error(`Route parameter syntax uses {name} interpolation, not :name. Use "${suggested}" instead of "${path}".`);
+	}
+	const segments = path.split("/").filter(Boolean);
+	const seenParamNames = /* @__PURE__ */ new Set();
+	for (let index = 0; index < segments.length; index++) {
+		const segment = segments[index];
+		if (segment === "*") continue;
+		const hasOpenBrace = segment.includes("{");
+		const hasCloseBrace = segment.includes("}");
+		if (!hasOpenBrace && !hasCloseBrace) continue;
+		if (!(segment.startsWith("{") && segment.endsWith("}"))) throw new Error("Route parameter segments must use complete {name} interpolation.");
+		const rawParamName = normalizeRouteSegmentName(segment.slice(1, -1));
+		const isSplat = rawParamName.startsWith("*");
+		const paramName = isSplat ? normalizeRouteSegmentName(rawParamName.slice(1)) : rawParamName;
+		if (!paramName) throw new Error(isSplat ? "Route splat parameter name cannot be empty." : "Route parameter name cannot be empty.");
+		if (isSplat && paramName === "*") throw new Error("Route named splat parameter name cannot be \"*\".");
+		if (isSplat && index !== segments.length - 1) throw new Error("Route named splat parameters must be the final segment.");
+		if (seenParamNames.has(paramName)) throw new Error(`Route path cannot reuse duplicate parameter name "${paramName}".`);
+		seenParamNames.add(paramName);
+	}
+}
+function normalizeAbsoluteRoutePath(path) {
+	if (!path || path === "/") return "/";
+	return (path.endsWith("/") ? path.slice(0, -1) : path) || "/";
+}
+function joinRoutePaths(prefix, path) {
+	const normalizedPrefix = normalizeAbsoluteRoutePath(prefix || "/");
+	const normalizedPath = path.replace(/^\/+|\/+$/g, "");
+	if (!normalizedPath) return normalizedPrefix;
+	return normalizedPrefix === "/" ? `/${normalizedPath}` : `${normalizedPrefix}/${normalizedPath}`;
+}
+function resolvePageScopePath(path) {
+	if (!path) throw new Error("page(path, Component, fn) requires a non-empty path.");
+	if (path.startsWith("/")) {
+		validateRoutePath(path);
+		return normalizeAbsoluteRoutePath(path);
+	}
+	return joinRoutePaths(getCurrentPathPrefix(), path);
+}
+function resolveIndexPath() {
+	return normalizeAbsoluteRoutePath(getCurrentPathPrefix() || "/");
+}
+function resolveRouteRegistrationPath(path) {
+	if (path.startsWith("/")) {
+		if (hasActivePageScope()) throw new Error(`Child route paths inside page() must be relative. Use "${path.slice(1)}" instead of "${path}".`);
+		validateRoutePath(path);
+		return normalizeAbsoluteRoutePath(path);
+	}
+	const prefix = getCurrentPathPrefix();
+	if (!prefix) throw new Error(`Route path must begin with "/". Got: "${path}"`);
+	return joinRoutePaths(prefix, path);
+}
+function pushGroupScope(options, fn) {
+	const policies = compileNodePolicies(options);
+	pushRegistrationScope({
+		kind: "group",
+		pathPrefix: getCurrentPathPrefix(),
+		layout: options.layout,
+		auth: options.auth,
+		policies,
+		meta: options.meta
+	}, fn);
+}
+function pushPageScope(path, Component, options, fn) {
+	if (hasActivePageScope()) throw new Error("page() cannot be nested inside another page(). Use route() for child leaves or group() for inherited behavior inside the existing page scope.");
+	const policies = compileNodePolicies(options);
+	pushRegistrationScope({
+		kind: "page",
+		pathPrefix: resolvePageScopePath(path),
+		page: Component,
+		hasIndex: false,
+		auth: options.auth,
+		policies,
+		meta: options.meta
+	}, fn);
+}
+function normalizeRouteOptions(options) {
+	if (!options) return;
+	const loader = options.loader;
+	const preload = options.preload;
+	const policies = compileNodePolicies(options);
+	if (!loader && !preload && !options.entries && policies.length === 0 && !options.title && !options.namespace && !options.search && !options.meta && !options.actions && options.auth === void 0) return;
+	return {
+		...loader ? { loader } : {},
+		...preload ? { preload } : {},
+		...options.entries ? { entries: options.entries } : {},
+		...options.auth !== void 0 ? { auth: options.auth } : {},
+		...policies.length > 0 ? { policies } : {},
+		...options.title ? { title: options.title } : {},
+		...options.namespace ? { namespace: options.namespace } : {},
+		...options.search ? { search: options.search } : {},
+		...options.meta ? { meta: options.meta } : {},
+		...options.actions ? { actions: options.actions } : {}
+	};
+}
+function registerRouteAtResolvedPath(path, Component, options, metadata) {
+	validateRoutePath(path);
+	const chain = getCurrentLayoutChain();
+	const pageChain = getCurrentPageChain();
+	const segments = parseSegments(path);
+	const rank = computeRank(segments);
+	const isFallback = metadata?.isFallback ?? path === "/*";
+	const comp = Component;
+	const normalizedOptions = normalizeRouteOptions(options);
+	const policies = [...getCurrentInheritedPolicies(), ...normalizedOptions?.policies ?? []];
+	const authRequirements = [...getCurrentInheritedAuthRequirements(), ...normalizedOptions?.auth ? [normalizedOptions.auth] : []];
+	const auth = authRequirements.length === 0 ? void 0 : authRequirements.length === 1 ? authRequirements[0] : allOf(...authRequirements);
+	const metaChain = [...getCurrentInheritedMeta(), ...normalizedOptions?.meta ? [normalizedOptions.meta] : []];
+	const handler = createRouteHandler(comp, pageChain, chain);
+	const renderHandler = createRouteHandler(comp, pageChain, chain, true);
+	insertRecordSorted({
+		path,
+		component: comp,
+		segments,
+		rank,
+		layoutChain: chain,
+		pageChain,
+		options: normalizedOptions ? {
+			...normalizedOptions,
+			...auth ? { auth } : {},
+			...policies.length > 0 ? { policies } : {}
+		} : policies.length > 0 ? {
+			policies,
+			...auth ? { auth } : {}
+		} : auth ? { auth } : {},
+		...metaChain.length > 0 ? { metaChain } : {},
+		isFallback,
+		handler,
+		renderHandler,
+		...metadata?.fallbackPrefix ? { fallbackPrefix: metadata.fallbackPrefix } : {}
+	});
+	addRouteToStores({
+		path,
+		handler,
+		namespace: normalizedOptions?.namespace ?? options?.namespace,
+		...metadata?.fallbackPrefix ? { fallbackPrefix: metadata.fallbackPrefix } : {}
+	});
+}
+function group(options, fn) {
+	pushGroupScope(options, fn);
+}
+function page(path, Component, optionsOrFn, maybeFn) {
+	const options = typeof optionsOrFn === "function" ? {} : optionsOrFn;
+	const fn = typeof optionsOrFn === "function" ? optionsOrFn : maybeFn;
+	if (typeof Component !== "function") throw new Error("page(path, Component, fn) requires a component function as the second argument.");
+	if (typeof fn !== "function") throw new Error("page(path, Component, fn) requires a route definition callback as the final argument.");
+	pushPageScope(path, Component, options, fn);
+}
+function index(Component, options) {
+	const pageScope = getCurrentPageScope();
+	if (pageScope?.hasIndex) throw new Error("page() cannot declare multiple index routes.");
+	if (pageScope) pageScope.hasIndex = true;
+	registerRouteAtResolvedPath(resolveIndexPath(), Component, options);
+}
+function fallback(Component) {
+	if (hasActivePageScope()) {
+		if (getCurrentScopeKind() !== "page") throw new Error("fallback() inside page() must be declared directly in the page scope, not inside nested group().");
+		registerRouteAtResolvedPath(`${getCurrentPathPrefix()}/*`, Component, void 0, {
+			isFallback: true,
+			fallbackPrefix: getCurrentPathPrefix()
+		});
+		return;
+	}
+	if (!(getCurrentInheritedPolicies().length === 0 && getCurrentInheritedAuthRequirements().length === 0)) throw new Error("fallback() can only be registered at the root scope. Use route(\"/*\", Component) if you need compatibility behavior.");
+	registerRouteAtResolvedPath("/*", Component, void 0, {
+		isFallback: true,
+		fallbackPrefix: "/"
+	});
+}
+function registerRoutes(definition, options = {}) {
+	setDefaultRouteAuthOptions(options.auth);
+	definition();
+}
+function route(path, Component, options) {
+	if (typeof path === "undefined") throw new Error("route() is only for route registration. Use currentRoute() inside components.");
+	if (getExecutionModel() === "islands") throw new Error("Routes are not supported with islands. Use createSPA (client) or createSSR (server) instead.");
+	const currentInst = getCurrentComponentInstance();
+	if (currentInst && currentInst.ssr) throw new Error("route() cannot be called during SSR rendering. Register routes at module load time instead.");
+	assertRouteRegistrationUnlocked();
+	if (typeof Component !== "function") throw new Error("route(path, Component) requires a component function as the second argument. Passing JSX elements or VNodes directly is not supported.");
+	if (options?.search && options.search.kind !== "object") throw new Error("route search must be an object schema.");
+	registerRouteAtResolvedPath(resolveRouteRegistrationPath(path), Component, options);
+	return Object.freeze({
+		path: resolveRouteRegistrationPath(path),
+		...options?.search ? { searchSchema: options.search } : {}
+	});
+}
+//#endregion
+//#region src/common/app-render-runtime.ts
+const stagedRouteLocations = /* @__PURE__ */ new WeakMap();
+function createAppRenderRuntime(input = {}) {
+	return {
+		framework: Object.freeze({ ...input.framework }),
+		route: input.route,
+		hasRoute: input.hasRoute ?? false
+	};
+}
+function stageAppRenderRouteLocation(runtime, href) {
+	stagedRouteLocations.set(runtime, href);
+}
+function getStagedAppRenderRouteLocation(runtime) {
+	return runtime ? stagedRouteLocations.get(runtime) : void 0;
+}
+function clearStagedAppRenderRouteLocation(runtime) {
+	if (runtime) stagedRouteLocations.delete(runtime);
+}
+//#endregion
+//#region src/router/activity.ts
+let currentRouteSnapshot = buildRouteSnapshot("/", "", "");
+const currentRouteSource = (() => currentRouteSnapshot);
+currentRouteSource._readers = /* @__PURE__ */ new Map();
+let serverLocation = null;
+function setServerLocation(url) {
+	serverLocation = url;
+	if (url) {
+		const parsed = parseLocation(url);
+		syncRouteActivitySnapshot(parsed.pathname, computeMatchesFromRoutes(parsed.pathname, getActiveRoutes()));
+		return;
+	}
+	syncRouteActivitySnapshot(currentRouteSnapshot.path, currentRouteSnapshot.matches);
+}
+function buildRouteSnapshot(pathname, search, hash) {
+	const query = makeQuery(search);
+	const matches = computeMatchesFromRoutes(pathname, getActiveRoutes());
+	return Object.freeze({
+		path: pathname,
+		params: deepFreeze({ ...matches[0]?.params }),
+		query,
+		hash: hash || null,
+		matches: Object.freeze(matches)
+	});
+}
+function setCurrentRouteSnapshot(pathname, search, hash, activityMatches) {
+	currentRouteSnapshot = buildRouteSnapshot(pathname, search, hash);
+	syncRouteActivitySnapshot(pathname, activityMatches ?? currentRouteSnapshot.matches);
+	const instance = getCurrentComponentInstance();
+	markReadableDerivedSubscribersDirty(currentRouteSource);
+	markReactivePropsDirtySource(currentRouteSource);
+	notifyReadableReaders(currentRouteSource, instance);
+}
+function readCurrentRouteLocation() {
+	const renderContext = getActiveRenderContext();
+	if (renderContext?.url) return parseLocation(renderContext.url);
+	const stagedRouteLocation = getStagedAppRenderRouteLocation(getCurrentAppRenderRuntime());
+	if (stagedRouteLocation) return parseLocation(stagedRouteLocation);
+	if (typeof window !== "undefined" && window.location) return {
+		pathname: window.location.pathname || "/",
+		search: window.location.search || "",
+		hash: window.location.hash || ""
+	};
+	if (serverLocation) return parseLocation(serverLocation);
+	return {
+		pathname: currentRouteSnapshot.path,
+		search: "",
+		hash: currentRouteSnapshot.hash ?? ""
+	};
+}
+function readCurrentRouteSnapshot() {
+	if (!getCurrentComponentInstance()) throw new Error("currentRoute() can only be called during component render execution. Call currentRoute() from inside your component function.");
+	const { pathname, search, hash } = readCurrentRouteLocation();
+	const query = makeQuery(search);
+	const matches = computeMatchesFromRoutes(pathname, getActiveRoutes());
+	const params = deepFreeze({ ...getActiveRenderContext()?.params ?? matches[0]?.params ?? {} });
+	return Object.freeze({
+		path: pathname,
+		params,
+		query,
+		hash: hash || null,
+		matches: Object.freeze(matches)
+	});
+}
+function currentRoute() {
+	const instance = getCurrentComponentInstance();
+	if (!instance) throw new Error("currentRoute() can only be called during component render execution. Call currentRoute() from inside your component function.");
+	if (typeof window === "undefined" || instance.ssr) return readCurrentRouteSnapshot();
+	recordReadableRead(currentRouteSource);
+	return readCurrentRouteSnapshot();
+}
+function syncCurrentRouteSnapshot(pathname, search, hash, activityMatches) {
+	setCurrentRouteSnapshot(pathname, search, hash, activityMatches);
+}
+//#endregion
+//#region src/router/lazy.ts
+const pendingLazy = /* @__PURE__ */ new Set();
+const registryLazyImports = /* @__PURE__ */ new WeakMap();
+const manifestLazyImports = /* @__PURE__ */ new WeakMap();
+function lazy(factory) {
+	let resolved = null;
+	let loadError = null;
+	const promise = factory().then((mod) => {
+		resolved = typeof mod === "function" ? mod : mod.default;
+		pendingLazy.delete(promise);
+	}, (err) => {
+		loadError = err;
+		pendingLazy.delete(promise);
+	});
+	pendingLazy.add(promise);
+	return ((params) => {
+		if (loadError) throw loadError;
+		if (!resolved) throw new Error("lazy() component used before it was resolved. Await createSPA() / hydrateSPA() to ensure all chunks load first.");
+		return resolved(params);
+	});
+}
+function _snapshotLazy() {
+	return [...pendingLazy];
+}
+function _snapshotRouteSourceLazy(source) {
+	const imports = /* @__PURE__ */ new Set();
+	if (source.registry) for (const lazyImport of registryLazyImports.get(source.registry) ?? []) imports.add(lazyImport);
+	const manifest = source.manifest ?? source.registry?.manifest;
+	if (manifest) for (const lazyImport of manifestLazyImports.get(manifest) ?? []) imports.add(lazyImport);
+	return [...imports];
+}
+function _drainLazy(additionalPending = []) {
+	const combined = /* @__PURE__ */ new Set([...additionalPending, ...pendingLazy]);
+	if (combined.size === 0) return Promise.resolve();
+	return Promise.allSettled(combined).then(() => void 0);
+}
+function associateRouteSourceLazy(registry, manifest, lazyImports) {
+	if (lazyImports.length === 0) return;
+	registryLazyImports.set(registry, lazyImports);
+	manifestLazyImports.set(manifest, lazyImports);
+}
+function clearPendingLazy() {
+	pendingLazy.clear();
+}
+function restorePendingLazy(lazyImports) {
+	pendingLazy.clear();
+	for (const lazyImport of lazyImports) pendingLazy.add(lazyImport);
+}
+//#endregion
+//#region src/router/manifest.ts
+function getManifest() {
+	const auth = getDefaultRouteAuthOptions();
+	return {
+		records: [...getRouteRecords()],
+		...auth ? { auth } : {}
+	};
+}
+function _applyManifest(manifest) {
+	setDefaultRouteAuthOptions(manifest.auth);
+	for (const record of manifest.records) {
+		insertRecordSorted(record);
+		addRouteToStores({
+			path: record.path,
+			handler: record.handler,
+			namespace: record.options.namespace,
+			..."fallbackPrefix" in record && typeof record.fallbackPrefix === "string" ? { fallbackPrefix: record.fallbackPrefix } : {}
+		});
+	}
+}
+function clearRoutes() {
+	clearRouteState();
+	clearPendingLazy();
+}
+function createRouteRegistry(definition, options = {}) {
+	const previous = snapshotRouteState();
+	const previousLazy = _snapshotLazy();
+	clearRoutes();
+	try {
+		registerRoutes(definition, options);
+		const manifest = getManifest();
+		const registry = Object.freeze({
+			manifest,
+			routes: getRoutes()
+		});
+		associateRouteSourceLazy(registry, manifest, _snapshotLazy());
+		return registry;
+	} finally {
+		restoreRouteState(previous);
+		restorePendingLazy(previousLazy);
+	}
+}
+//#endregion
+//#region src/router/navigation-registry.ts
+let currentInstance = null;
+let currentPathname = "/";
+let currentHref = "/";
+let navigationRegistryHost = null;
+const registeredApps = [];
+function configureNavigationRegistryHost(host) {
+	navigationRegistryHost = host;
+}
+function getCurrentPathname() {
+	return currentPathname;
+}
+function getCurrentHref() {
+	return currentHref;
+}
+function setCurrentRouteLocation(pathname, href) {
+	currentPathname = pathname;
+	currentHref = href;
+}
+function getWindowHref$1() {
+	if (typeof window === "undefined") return currentHref;
+	return `${window.location.pathname}${window.location.search}${window.location.hash}`;
+}
+function parseTargetUrl(path) {
+	const pathname = window.location.pathname || "/";
+	const search = window.location.search || "";
+	const hash = window.location.hash || "";
+	const href = typeof window.location.href === "string" ? window.location.href : "";
+	const base = href && href !== "about:blank" && !href.startsWith("about:") && !href.startsWith("data:") ? href : `http://localhost${pathname}${search}${hash}`;
+	return new URL(path, base);
+}
+function getRegisteredAppsSnapshot() {
+	return [...registeredApps];
+}
+function hasRegisteredApps() {
+	return registeredApps.length > 0;
+}
+function syncAppRegistrationLocation(app, pathname, href) {
+	app.pathname = pathname;
+	app.href = href;
+}
+function collectRouteActivityMatches(pathname, apps = registeredApps) {
+	const matches = [];
+	const seenPaths = /* @__PURE__ */ new Set();
+	for (const app of apps) {
+		const appMatches = computeRouteActivityMatches(pathname, {
+			manifest: app.manifest,
+			routes: app.routes
+		});
+		for (const match of appMatches) {
+			if (seenPaths.has(match.path)) continue;
+			seenPaths.add(match.path);
+			matches.push(match);
+		}
+	}
+	return matches;
+}
+function syncRegisteredRouteSnapshot() {
+	if (typeof window === "undefined") return;
+	const pathname = window.location.pathname || "/";
+	syncCurrentRouteSnapshot(pathname, window.location.search || "", window.location.hash || "", collectRouteActivityMatches(pathname));
+}
+function registerAppInstance(instance, path, source = {}) {
+	const existingIndex = registeredApps.findIndex((app) => app.instance === instance);
+	const registration = {
+		instance,
+		pathname: path,
+		href: getWindowHref$1(),
+		...source
+	};
+	if (existingIndex >= 0) registeredApps[existingIndex] = registration;
+	else registeredApps.push(registration);
+	currentInstance = instance;
+	currentPathname = path;
+	currentHref = getWindowHref$1();
+	syncRegisteredRouteSnapshot();
+	if (isProductionEnvironment()) lockRouteRegistration();
+}
+function unregisterAppInstance(instance) {
+	const existingIndex = registeredApps.findIndex((app) => app.instance === instance);
+	if (existingIndex >= 0) registeredApps.splice(existingIndex, 1);
+	syncRegisteredRouteSnapshot();
+	if (currentInstance !== instance) return;
+	const nextApp = registeredApps.length > 0 ? registeredApps[registeredApps.length - 1] : null;
+	currentInstance = nextApp?.instance ?? null;
+	if (nextApp) {
+		currentPathname = nextApp.pathname;
+		currentHref = nextApp.href;
+		syncRegisteredRouteSnapshot();
+		return;
+	}
+	navigationRegistryHost?.cancelRouteRequests();
+	currentPathname = "/";
+	currentHref = "/";
+	if (typeof window === "undefined") syncCurrentRouteSnapshot("/", "", "", []);
+}
+//#endregion
+//#region src/router/navigation-scroll.ts
+const DEFAULT_SCROLL_RESTORATION = {
+	enabled: true,
+	navigation: "top",
+	history: "restore"
+};
+let scrollRestorationOptions = { ...DEFAULT_SCROLL_RESTORATION };
+const scrollPositions = /* @__PURE__ */ new Map();
+function getWindowHref() {
+	if (typeof window === "undefined") return "/";
+	return `${window.location.pathname}${window.location.search}${window.location.hash}`;
+}
+function normalizeScrollRestorationOptions(options) {
+	if (options === false) return {
+		enabled: false,
+		navigation: DEFAULT_SCROLL_RESTORATION.navigation,
+		history: DEFAULT_SCROLL_RESTORATION.history
+	};
+	if (options === true || options === void 0) return { ...DEFAULT_SCROLL_RESTORATION };
+	return {
+		enabled: true,
+		navigation: options.navigation ?? DEFAULT_SCROLL_RESTORATION.navigation,
+		history: options.history ?? DEFAULT_SCROLL_RESTORATION.history
+	};
+}
+function readScrollPosition() {
+	if (typeof window === "undefined") return {
+		x: 0,
+		y: 0
+	};
+	return {
+		x: typeof window.scrollX === "number" ? window.scrollX : typeof window.pageXOffset === "number" ? window.pageXOffset : 0,
+		y: typeof window.scrollY === "number" ? window.scrollY : typeof window.pageYOffset === "number" ? window.pageYOffset : 0
+	};
+}
+function writeHistoryScrollPosition(href, position) {
+	if (typeof window === "undefined" || getWindowHref() !== href) return;
+	if (typeof window.history?.replaceState !== "function") return;
+	const state = window.history.state && typeof window.history.state === "object" ? window.history.state : {};
+	window.history.replaceState({
+		...state,
+		path: href,
+		scroll: position
+	}, "", href);
+}
+function saveScrollPosition(href) {
+	if (!scrollRestorationOptions.enabled || typeof window === "undefined") return;
+	const position = readScrollPosition();
+	scrollPositions.set(href, position);
+	writeHistoryScrollPosition(href, position);
+}
+function scrollToPosition(position) {
+	if (typeof window === "undefined" || typeof window.scrollTo !== "function") return;
+	window.scrollTo(position.x, position.y);
+}
+function applyNavigationScroll(behavior) {
+	const nextBehavior = behavior ?? scrollRestorationOptions.navigation;
+	if (!scrollRestorationOptions.enabled || nextBehavior === "preserve") return;
+	scrollToPosition({
+		x: 0,
+		y: 0
+	});
+}
+function applyHistoryScroll(href, state) {
+	if (!scrollRestorationOptions.enabled) return;
+	if (scrollRestorationOptions.history === "preserve") return;
+	if (scrollRestorationOptions.history === "top") {
+		scrollToPosition({
+			x: 0,
+			y: 0
+		});
+		return;
+	}
+	const fromState = state && typeof state === "object" && "scroll" in state ? state.scroll : void 0;
+	scrollToPosition((fromState && typeof fromState.x === "number" && typeof fromState.y === "number" ? {
+		x: fromState.x,
+		y: fromState.y
+	} : scrollPositions.get(href)) ?? {
+		x: 0,
+		y: 0
+	});
+}
+function configureScrollRestoration(options) {
+	scrollRestorationOptions = normalizeScrollRestorationOptions(options);
+	if (typeof window === "undefined") return;
+	if ("scrollRestoration" in window.history) try {
+		window.history.scrollRestoration = scrollRestorationOptions.enabled ? "manual" : "auto";
+	} catch {}
+}
+//#endregion
+//#region src/router/metadata.ts
+function freezeMeta(meta) {
+	if (meta.openGraph) Object.freeze(meta.openGraph);
+	if (meta.links) {
+		for (const link of meta.links) Object.freeze(link);
+		Object.freeze(meta.links);
+	}
+	if (Array.isArray(meta.jsonLd)) Object.freeze(meta.jsonLd);
+	if (meta.html) Object.freeze(meta.html);
+	return Object.freeze(meta);
+}
+function mergeMeta(current, next) {
+	return {
+		...current.title !== void 0 ? { title: current.title } : {},
+		...current.description !== void 0 ? { description: current.description } : {},
+		...current.canonical !== void 0 ? { canonical: current.canonical } : {},
+		...current.robots !== void 0 ? { robots: current.robots } : {},
+		...next.title !== void 0 ? { title: next.title } : {},
+		...next.description !== void 0 ? { description: next.description } : {},
+		...next.canonical !== void 0 ? { canonical: next.canonical } : {},
+		...next.robots !== void 0 ? { robots: next.robots } : {},
+		...current.openGraph || next.openGraph ? { openGraph: {
+			...current.openGraph,
+			...next.openGraph
+		} } : {},
+		...current.links || next.links ? { links: [...current.links ?? [], ...next.links ?? []] } : {},
+		...current.jsonLd || next.jsonLd ? { jsonLd: [...current.jsonLd === void 0 ? [] : Array.isArray(current.jsonLd) ? current.jsonLd : [current.jsonLd], ...next.jsonLd === void 0 ? [] : Array.isArray(next.jsonLd) ? next.jsonLd : [next.jsonLd]] } : {},
+		...current.html || next.html ? { html: {
+			...current.html,
+			...next.html
+		} } : {}
+	};
+}
+function metadataSources(record) {
+	if (record.metaChain) return record.metaChain;
+	return record.options.meta ? [record.options.meta] : [];
+}
+async function resolveRouteMeta(record, context) {
+	let resolved = record.options.title ? { title: record.options.title } : {};
+	for (const source of metadataSources(record)) {
+		const next = typeof source === "function" ? await source(context) : source;
+		resolved = mergeMeta(resolved, next);
+	}
+	return freezeMeta(resolved);
+}
+/** Replace only Askr-owned head nodes after a successful client navigation. */
+function reconcileRouteMeta(meta, target = document) {
+	for (const node of Array.from(target.head.querySelectorAll("[data-askr-head]"))) node.remove();
+	const template = target.createElement("template");
+	template.innerHTML = serializeRouteMeta(meta);
+	target.head.append(template.content);
+	if (meta.html?.lang) target.documentElement.setAttribute("lang", meta.html.lang);
+	if (meta.html?.dir) target.documentElement.setAttribute("dir", meta.html.dir);
+}
+function escapeAttribute(value) {
+	return value.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&#39;");
+}
+function escapeText(value) {
+	return value.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+}
+function ownedAttribute() {
+	return " data-askr-head=\"\"";
+}
+function serializeLink(link) {
+	const entries = Object.entries(link).filter(([name]) => /^[a-zA-Z][a-zA-Z0-9:_-]*$/.test(name)).sort(([left], [right]) => {
+		const order = (name) => name === "rel" ? 0 : name === "href" ? 1 : 2;
+		return order(left) - order(right) || left.localeCompare(right);
+	});
+	return `<link${ownedAttribute()}${entries.map(([name, value]) => ` ${name}="${escapeAttribute(value)}"`).join("")}>`;
+}
+function serializeJsonLd(value) {
+	const json = JSON.stringify(value).replace(/</g, "\\u003c").replace(/>/g, "\\u003e").replace(/&/g, "\\u0026").replace(/\u2028/g, "\\u2028").replace(/\u2029/g, "\\u2029");
+	return `<script${ownedAttribute()} type="application/ld+json">${json}<\/script>`;
+}
+function serializeRouteMeta(meta) {
+	const output = [];
+	if (meta.title !== void 0) output.push(`<title${ownedAttribute()}>${escapeText(meta.title)}</title>`);
+	if (meta.description !== void 0) output.push(`<meta${ownedAttribute()} name="description" content="${escapeAttribute(meta.description)}">`);
+	if (meta.canonical !== void 0) output.push(`<link${ownedAttribute()} rel="canonical" href="${escapeAttribute(meta.canonical)}">`);
+	if (meta.robots !== void 0) output.push(`<meta${ownedAttribute()} name="robots" content="${escapeAttribute(meta.robots)}">`);
+	for (const [property, content] of Object.entries(meta.openGraph ?? {}).sort(([left], [right]) => left.localeCompare(right))) {
+		const name = property.startsWith("og:") ? property : `og:${property}`;
+		output.push(`<meta${ownedAttribute()} property="${escapeAttribute(name)}" content="${escapeAttribute(content)}">`);
+	}
+	for (const link of meta.links ?? []) output.push(serializeLink(link));
+	if (meta.jsonLd !== void 0) {
+		const values = Array.isArray(meta.jsonLd) ? meta.jsonLd : [meta.jsonLd];
+		for (const value of values) output.push(serializeJsonLd(value));
+	}
+	return output.join("");
+}
+//#endregion
+//#region src/router/navigation-targets.ts
+const MAX_NAVIGATION_REDIRECTS = 20;
+let activeRouteRequestId = 0;
+let activeRouteRequestController = null;
+function beginRouteRequest() {
+	activeRouteRequestId += 1;
+	activeRouteRequestController?.abort();
+	activeRouteRequestController = new AbortController();
+	return {
+		id: activeRouteRequestId,
+		signal: activeRouteRequestController.signal
+	};
+}
+function isStaleRouteRequest(requestId) {
+	return requestId !== activeRouteRequestId;
+}
+function cancelRouteRequests() {
+	activeRouteRequestId += 1;
+	activeRouteRequestController?.abort();
+	activeRouteRequestController = null;
+}
+function isRenderResult(result) {
+	return result !== null && result.kind === "render";
+}
+function createNavigationTarget(app, resolved) {
+	if (!isRenderResult(resolved) || !resolved.record) return {
+		app,
+		resolved
+	};
+	if (!Boolean(resolved.record.options.title || resolved.record.options.meta || resolved.record.metaChain?.length)) return {
+		app,
+		resolved
+	};
+	const context = getRouteRenderContext(resolved);
+	if (!context) return {
+		app,
+		resolved
+	};
+	return resolveRouteMeta(resolved.record, context).then((metadata) => ({
+		app,
+		resolved,
+		metadata
+	}));
+}
+function reconcileNavigationMetadata(targets) {
+	for (let index = targets.length - 1; index >= 0; index -= 1) {
+		const metadata = targets[index]?.metadata;
+		if (metadata) {
+			reconcileRouteMeta(metadata);
+			return;
+		}
+	}
+}
+function getRedirectHistoryMode(replace) {
+	return replace === false ? "push" : "replace";
+}
+function getNavigationHistoryMode(options) {
+	if (options.history) return options.history;
+	return options.replace ? "replace" : "push";
+}
+function createDeniedResolvedRoute(status) {
+	return {
+		handler: () => ({
+			type: "div",
+			props: { "data-route-denied": String(status) },
+			children: [String(status)]
+		}),
+		params: {}
+	};
+}
+function bindResolvedRouteHandler(resolved) {
+	return () => resolved.handler(resolved.params);
+}
+function wrapRootRouteHandler(componentFn) {
+	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" });
+	return wrappedFn;
+}
+function flattenLifecycleErrors(error, result) {
+	if (error instanceof AggregateError) {
+		for (const nested of error.errors) flattenLifecycleErrors(nested, result);
+		return;
+	}
+	result.push(error);
+}
+function reportRouteCleanupErrors(errors) {
+	for (const error of errors) {
+		const flattened = [];
+		flattenLifecycleErrors(error, flattened);
+		for (const cleanupError of flattened.length > 0 ? flattened : [error]) logger.error("[Askr] route cleanup failed:", cleanupError);
+	}
+}
+function captureRouteDom(root) {
+	if (!root) return null;
+	const nodes = [];
+	const visit = (node) => {
+		nodes.push({
+			node,
+			children: Array.from(node.childNodes),
+			attributes: node instanceof Element ? Array.from(node.attributes).map((attribute) => [attribute.name, attribute.value]) : null,
+			nodeValue: node.nodeValue
+		});
+		for (const child of Array.from(node.childNodes)) visit(child);
+	};
+	visit(root);
+	return {
+		root,
+		nodes
+	};
+}
+function collectProvisionalRouteNodes(snapshot) {
+	const originalNodes = new Set(snapshot.nodes.map((entry) => entry.node));
+	const provisional = [];
+	const visit = (node) => {
+		if (!originalNodes.has(node)) {
+			provisional.push(node);
+			return;
+		}
+		for (const child of Array.from(node.childNodes)) visit(child);
+	};
+	for (const child of Array.from(snapshot.root.childNodes)) visit(child);
+	return provisional;
+}
+function restoreRouteDom(snapshot) {
+	if (!snapshot) return [];
+	const errors = [];
+	for (const node of collectProvisionalRouteNodes(snapshot)) try {
+		teardownNodeSubtree(node, { strict: true });
+	} catch (error) {
+		errors.push(error);
+	}
+	for (const entry of snapshot.nodes) {
+		const { node, attributes } = entry;
+		try {
+			if (attributes && node instanceof Element) {
+				const expected = new Map(attributes);
+				for (const attribute of Array.from(node.attributes)) if (!expected.has(attribute.name)) node.removeAttribute(attribute.name);
+				for (const [name, value] of attributes) if (node.getAttribute(name) !== value) node.setAttribute(name, value);
+			} else if (!(node instanceof Element)) node.nodeValue = entry.nodeValue;
+			if (node instanceof Element || node instanceof DocumentFragment) node.replaceChildren(...entry.children);
+		} catch (error) {
+			errors.push(error);
+		}
+	}
+	return errors;
+}
+function collectHostInstances(root) {
+	const instances = [];
+	const seen = /* @__PURE__ */ new Set();
+	const pending = [root];
+	while (pending.length > 0) {
+		const node = pending.pop();
+		const host = node;
+		for (const instance of host.__ASKR_INSTANCES ?? []) if (!seen.has(instance)) {
+			seen.add(instance);
+			instances.push(instance);
+		}
+		if (host.__ASKR_INSTANCE && !seen.has(host.__ASKR_INSTANCE)) {
+			seen.add(host.__ASKR_INSTANCE);
+			instances.push(host.__ASKR_INSTANCE);
+		}
+		for (let child = node.lastChild; child; child = child.previousSibling) pending.push(child);
+	}
+	return instances;
+}
+function captureDeferredRouteCleanup(instance) {
+	return {
+		instance,
+		previousOwnershipGeneration: instance._ownershipGeneration,
+		previousFn: instance.fn,
+		previousProps: instance.props,
+		previousExpectedStateIndices: instance.expectedStateIndices,
+		previousFirstRenderComplete: instance.firstRenderComplete,
+		previousStateIndexCheck: instance.stateIndexCheck,
+		previousErrorBoundaryState: instance.errorBoundaryState,
+		previousTarget: instance.target,
+		previousDom: captureRouteDom(instance.target),
+		previousStateValues: instance.stateValues,
+		previousCleanupFns: instance.cleanupFns,
+		previousOwnedChildScopes: instance._ownedChildScopes,
+		previousAbortController: instance.abortController,
+		previousMountOperations: instance.mountOperations,
+		previousCommitOperations: instance.commitOperations,
+		previousLifecycleSlots: instance.lifecycleSlots,
+		previousLifecycleGeneration: instance.lifecycleGeneration,
+		previousEvaluationGeneration: instance.evaluationGeneration,
+		previousHasPendingUpdate: instance.hasPendingUpdate,
+		previousNotifyUpdate: instance.notifyUpdate,
+		previousPlaceholder: instance._placeholder,
+		previousMounted: instance.mounted,
+		previousCurrentRenderToken: instance._currentRenderToken,
+		previousLastRenderToken: instance.lastRenderToken,
+		previousPendingReadSources: instance._pendingReadSources,
+		previousPendingReadSourceVersions: instance._pendingReadSourceVersions,
+		previousLastReadSources: instance._lastReadSources,
+		previousReaderEntries: Array.from(instance._lastReadSources ?? []).map((source) => ({
+			source,
+			reader: source._readers?.get(instance)
+		})),
+		previousAppRenderRuntime: instance._appRenderRuntime,
+		previousInstances: instance.target ? collectHostInstances(instance.target) : [],
+		previousDisposed: false
+	};
+}
+function restoreDeferredRouteInstance(deferred) {
+	const instance = deferred.instance;
+	const errors = [];
+	const activeGeneration = instance._ownershipGeneration;
+	const activeReadSources = instance._lastReadSources;
+	if (activeGeneration !== deferred.previousOwnershipGeneration) {
+		try {
+			cleanupReadableSubscriptionSources(instance, activeReadSources, activeGeneration);
+		} catch (error) {
+			errors.push(error);
+		}
+		instance._lastReadSources = void 0;
+		try {
+			cleanupComponent(instance);
+		} catch (error) {
+			errors.push(error);
+		}
+	}
+	errors.push(...restoreRouteDom(deferred.previousDom));
+	instance.fn = deferred.previousFn;
+	instance._ownershipGeneration = deferred.previousOwnershipGeneration;
+	instance.props = deferred.previousProps;
+	instance.expectedStateIndices = deferred.previousExpectedStateIndices;
+	instance.firstRenderComplete = deferred.previousFirstRenderComplete;
+	instance.stateIndexCheck = deferred.previousStateIndexCheck;
+	instance.errorBoundaryState = deferred.previousErrorBoundaryState;
+	instance.target = deferred.previousTarget;
+	instance.stateValues = deferred.previousStateValues;
+	instance.cleanupFns = deferred.previousCleanupFns;
+	instance._ownedChildScopes = deferred.previousOwnedChildScopes;
+	instance.abortController = deferred.previousAbortController;
+	instance.mountOperations = deferred.previousMountOperations;
+	instance.commitOperations = deferred.previousCommitOperations;
+	instance.lifecycleSlots = deferred.previousLifecycleSlots;
+	instance.lifecycleGeneration = deferred.previousLifecycleGeneration;
+	instance.evaluationGeneration = deferred.previousEvaluationGeneration;
+	instance.hasPendingUpdate = deferred.previousHasPendingUpdate;
+	instance.notifyUpdate = deferred.previousNotifyUpdate;
+	instance._placeholder = deferred.previousPlaceholder;
+	instance.mounted = deferred.previousMounted;
+	instance._currentRenderToken = deferred.previousCurrentRenderToken;
+	instance.lastRenderToken = deferred.previousLastRenderToken;
+	instance._pendingReadSources = deferred.previousPendingReadSources;
+	instance._pendingReadSourceVersions = deferred.previousPendingReadSourceVersions;
+	instance._lastReadSources = deferred.previousLastReadSources;
+	instance._appRenderRuntime = deferred.previousAppRenderRuntime;
+	const previousSources = new Set(deferred.previousReaderEntries.map(({ source }) => source));
+	for (const source of activeReadSources ?? []) {
+		if (previousSources.has(source)) continue;
+		if ((source._readers?.get(instance))?.generation === activeGeneration) {
+			if (source._readers?.delete(instance) && false);
+		}
+	}
+	for (const { source, reader } of deferred.previousReaderEntries) {
+		if (!reader) {
+			if (source._readers?.delete(instance) && false);
+			continue;
+		}
+		let readers = source._readers;
+		if (!readers) {
+			readers = /* @__PURE__ */ new Map();
+			source._readers = readers;
+		}
+		readers.has(instance);
+		readers.set(instance, reader);
+	}
+	return errors;
+}
+function restoreDeferredRouteInstances(deferredCleanups) {
+	const errors = [];
+	for (let index = deferredCleanups.length - 1; index >= 0; index -= 1) errors.push(...restoreDeferredRouteInstance(deferredCleanups[index]));
+	if (errors.length > 0) reportRouteCleanupErrors(errors);
+}
+function cleanupDeferredRouteInstance(deferred) {
+	const errors = [];
+	const instance = deferred.instance;
+	if (!deferred.previousDisposed) {
+		deferred.previousDisposed = true;
+		try {
+			cleanupComponentGeneration(instance, {
+				ownershipGeneration: deferred.previousOwnershipGeneration,
+				cleanupFns: deferred.previousCleanupFns,
+				ownedChildScopes: deferred.previousOwnedChildScopes,
+				abortController: deferred.previousAbortController,
+				readSources: deferred.previousLastReadSources
+			});
+		} catch (error) {
+			errors.push(error);
+		}
+	}
+	const root = instance.target;
+	const liveInstances = root ? new Set(collectHostInstances(root)) : /* @__PURE__ */ new Set();
+	for (let index = deferred.previousInstances.length - 1; index >= 0; index--) {
+		const previous = deferred.previousInstances[index];
+		if (previous === instance || liveInstances.has(previous)) continue;
+		try {
+			cleanupComponent(previous);
+		} catch (error) {
+			errors.push(error);
+		}
+	}
+	return errors;
+}
+function remountResolvedRoute(instance, resolved, pathname, href, existingSnapshot) {
+	const deferredCleanup = existingSnapshot ?? captureDeferredRouteCleanup(instance);
+	clearDefaultPortalForInstance(instance);
+	instance.fn = wrapRootRouteHandler(bindResolvedRouteHandler(resolved));
+	instance.props = {};
+	instance._ownershipGeneration = {};
+	instance.stateValues = [];
+	instance.expectedStateIndices = [];
+	instance.firstRenderComplete = false;
+	instance.stateIndexCheck = -1;
+	instance.evaluationGeneration++;
+	instance.lifecycleGeneration++;
+	instance.notifyUpdate = null;
+	instance.mountOperations = [];
+	instance.commitOperations = [];
+	instance.lifecycleSlots = [];
+	instance.cleanupFns = [];
+	instance._ownedChildScopes = /* @__PURE__ */ new Set();
+	instance._placeholder = void 0;
+	instance.hasPendingUpdate = false;
+	instance._currentRenderToken = void 0;
+	instance.lastRenderToken = 0;
+	instance._pendingReadSources = void 0;
+	instance._lastReadSources = void 0;
+	instance.abortController = null;
+	mountComponent(instance);
+	setCurrentRouteLocation(pathname, href);
+	return deferredCleanup;
+}
+function rerenderResolvedRoute(instance, pathname, href) {
+	setCurrentRouteLocation(pathname, href);
+	instance._enqueueRun?.();
+	return true;
+}
+function resolveAppRouteRequest(app, pathname, href, signal) {
+	if (app.manifest) return resolveRouteRequest(href, {
+		manifest: app.manifest,
+		auth: app.auth,
+		signal
+	});
+	if (app.routes) {
+		const resolved = resolveRouteFromRoutes(pathname, app.routes);
+		if (!resolved) return null;
+		return {
+			kind: "render",
+			handler: resolved.handler,
+			params: resolved.params
+		};
+	}
+	return resolveRouteRequest(href, {
+		auth: app.auth,
+		signal
+	});
+}
+function getResolvedRouteHandler(resolved) {
+	if (!resolved) throw new Error("[Askr] cannot prepare an unmatched navigation target");
+	if (resolved.kind === "deny") return createDeniedResolvedRoute(resolved.status);
+	if (!isRenderResult(resolved)) throw new Error("[Askr] cannot prepare a redirect as a destination root");
+	return {
+		handler: resolved.handler,
+		params: resolved.params
+	};
+}
+function updateRouteRuntime(instance, resolved, href) {
+	const current = instance._appRenderRuntime;
+	const runtime = createAppRenderRuntime({
+		framework: current?.framework,
+		route: resolved?.kind === "render" ? getRouteRenderData(resolved) : void 0,
+		hasRoute: resolved?.kind === "render" && hasRouteRenderData(resolved)
+	});
+	stageAppRenderRouteLocation(runtime, href);
+	instance._appRenderRuntime = runtime;
+}
+function clearStagedRouteLocations(targets) {
+	for (const target of targets) clearStagedAppRenderRouteLocation(target.app.instance._appRenderRuntime);
+}
+function resolveNavigationTargetsForApps(pathname, href, signal) {
+	const apps = getRegisteredAppsSnapshot();
+	if (apps.length === 1) {
+		const app = apps[0];
+		const resolved = resolveAppRouteRequest(app, pathname, href, signal);
+		if (isPromiseLike(resolved)) return Promise.resolve(resolved).then((next) => {
+			const target = createNavigationTarget(app, next);
+			return isPromiseLike(target) ? Promise.resolve(target).then((ready) => [ready]) : [target];
+		});
+		const target = createNavigationTarget(app, resolved);
+		return isPromiseLike(target) ? Promise.resolve(target).then((next) => [next]) : [target];
+	}
+	const syncTargets = [];
+	const pendingTargets = [];
+	for (const app of apps) {
+		const resolved = resolveAppRouteRequest(app, pathname, href, signal);
+		if (isPromiseLike(resolved)) {
+			pendingTargets.push(Promise.resolve(resolved).then((next) => createNavigationTarget(app, next)));
+			continue;
+		}
+		const target = createNavigationTarget(app, resolved);
+		if (isPromiseLike(target)) pendingTargets.push(Promise.resolve(target));
+		else syncTargets.push(target);
+	}
+	if (pendingTargets.length === 0) return syncTargets;
+	return Promise.all([...syncTargets.map((target) => Promise.resolve(target)), ...pendingTargets]);
+}
+function applyNavigationTargets(requestId, path, options, redirectState, pathname, href, targets, navigateWithRedirectState) {
+	if (isStaleRouteRequest(requestId)) return;
+	const previousPathname = getCurrentPathname();
+	const previousHref = getCurrentHref();
+	for (const target of targets) {
+		const resolved = target.resolved;
+		if (!resolved || resolved.kind !== "redirect") continue;
+		const redirectTarget = parseTargetUrl(resolved.to);
+		const redirectHref = `${redirectTarget.pathname}${redirectTarget.search}${redirectTarget.hash}`;
+		if (redirectHref === href) {
+			if (isDevelopmentEnvironment()) logger.warn(`Navigation guard redirected to the same path: ${redirectHref}`);
+			return;
+		}
+		if (redirectState.visited.has(redirectHref)) throw new Error(`[Askr] Navigation redirect cycle detected at ${redirectHref}.`);
+		if (redirectState.redirects >= MAX_NAVIGATION_REDIRECTS) throw new Error(`[Askr] Navigation redirect limit exceeded (${MAX_NAVIGATION_REDIRECTS}).`);
+		redirectState.visited.add(redirectHref);
+		redirectState.redirects++;
+		navigateWithRedirectState(redirectHref, { history: getRedirectHistoryMode(resolved.replace) }, redirectState);
+		return;
+	}
+	const matchedTargets = targets.filter((target) => target.resolved !== null);
+	if (matchedTargets.length === 0) {
+		if (isDevelopmentEnvironment()) logger.warn(`No route found for path: ${path}`);
+		return;
+	}
+	if (isStaleRouteRequest(requestId)) return;
+	const samePathTargets = [];
+	const rootsToPrepare = [];
+	for (const target of matchedTargets) {
+		const resolved = target.resolved;
+		if (resolved.kind === "redirect") continue;
+		if (pathname === target.app.pathname && isRenderResult(resolved)) {
+			samePathTargets.push(target);
+			continue;
+		}
+		rootsToPrepare.push(target);
+	}
+	const rollbackSnapshots = matchedTargets.map((target) => captureDeferredRouteCleanup(target.app.instance));
+	const rollbackSnapshotByInstance = new Map(rollbackSnapshots.map((snapshot) => [snapshot.instance, snapshot]));
+	const deferredCleanups = [];
+	const cleanupErrors = [];
+	const previousAppLocations = matchedTargets.map((target) => ({
+		app: target.app,
+		pathname: target.app.pathname,
+		href: target.app.href
+	}));
+	const restoreOnExit = () => {
+		if (!navigationBatchClosed) {
+			discardLifecycleCommitBatch(navigationBatch);
+			navigationBatchClosed = true;
+		}
+		restoreDeferredRouteInstances(rollbackSnapshots);
+		for (const previous of previousAppLocations) {
+			previous.app.pathname = previous.pathname;
+			previous.app.href = previous.href;
+		}
+		setCurrentRouteLocation(previousPathname, previousHref);
+	};
+	const navigationBatch = beginLifecycleCommitBatch();
+	let navigationBatchClosed = false;
+	try {
+		for (const target of rootsToPrepare) {
+			if (isStaleRouteRequest(requestId)) {
+				restoreOnExit();
+				return;
+			}
+			updateRouteRuntime(target.app.instance, target.resolved, href);
+			const deferredCleanup = remountResolvedRoute(target.app.instance, getResolvedRouteHandler(target.resolved), pathname, href, rollbackSnapshotByInstance.get(target.app.instance));
+			deferredCleanups.push(deferredCleanup);
+		}
+		if (isStaleRouteRequest(requestId)) {
+			restoreOnExit();
+			return;
+		}
+		flushRuntimeScheduler();
+		cleanupErrors.push(...drainLifecycleCommitErrors());
+		if (isStaleRouteRequest(requestId)) {
+			restoreOnExit();
+			return;
+		}
+		for (const target of samePathTargets) {
+			if (isStaleRouteRequest(requestId)) {
+				restoreOnExit();
+				return;
+			}
+			updateRouteRuntime(target.app.instance, target.resolved, href);
+			rerenderResolvedRoute(target.app.instance, pathname, href);
+		}
+		flushRuntimeScheduler();
+		cleanupErrors.push(...drainLifecycleCommitErrors());
+		if (isStaleRouteRequest(requestId)) {
+			restoreOnExit();
+			return;
+		}
+		flushLifecycleCommitBatch(navigationBatch);
+		navigationBatchClosed = true;
+		cleanupErrors.push(...drainLifecycleCommitErrors());
+		for (const target of matchedTargets) if (target.resolved && target.resolved.kind !== "redirect") syncAppRegistrationLocation(target.app, pathname, href);
+		if (isStaleRouteRequest(requestId)) {
+			restoreOnExit();
+			return;
+		}
+		saveScrollPosition(previousHref);
+		const historyMethod = getNavigationHistoryMode(options) === "replace" ? "replaceState" : "pushState";
+		window.history[historyMethod]({ path: href }, "", href);
+		setCurrentRouteLocation(pathname, href);
+		clearStagedRouteLocations(matchedTargets);
+		syncRegisteredRouteSnapshot();
+		reconcileNavigationMetadata(matchedTargets);
+		if (pathname !== previousPathname) applyNavigationScroll(options.scroll);
+		for (const deferredCleanup of deferredCleanups) cleanupErrors.push(...cleanupDeferredRouteInstance(deferredCleanup));
+		for (const error of cleanupErrors) reportRouteCleanupErrors([error]);
+	} catch (error) {
+		restoreOnExit();
+		logger.error("[Askr] navigation failed:", error);
+		throw error;
+	}
+}
+function applyPopStateNavigationTargets(requestId, previousHref, previousState, pathname, href, state, targets, navigate) {
+	if (isStaleRouteRequest(requestId)) return;
+	const matchedTargets = targets.filter((target) => target.resolved !== null);
+	if (matchedTargets.length === 0) {
+		if (isDevelopmentEnvironment()) logger.warn(`No route found for path: ${pathname}`);
+		return;
+	}
+	for (const target of matchedTargets) {
+		const resolved = target.resolved;
+		if (resolved.kind !== "redirect") continue;
+		navigate(resolved.to, { history: getRedirectHistoryMode(resolved.replace) });
+		return;
+	}
+	const samePathTargets = [];
+	const rootsToPrepare = [];
+	for (const target of matchedTargets) {
+		const resolved = target.resolved;
+		if (pathname === target.app.pathname && isRenderResult(resolved)) {
+			samePathTargets.push(target);
+			continue;
+		}
+		if (resolved.kind === "redirect") continue;
+		rootsToPrepare.push(target);
+	}
+	const previousPathname = getCurrentPathname();
+	const rollbackSnapshots = matchedTargets.map((target) => captureDeferredRouteCleanup(target.app.instance));
+	const rollbackSnapshotByInstance = new Map(rollbackSnapshots.map((snapshot) => [snapshot.instance, snapshot]));
+	const deferredCleanups = [];
+	const cleanupErrors = [];
+	const previousAppLocations = matchedTargets.map((target) => ({
+		app: target.app,
+		pathname: target.app.pathname,
+		href: target.app.href
+	}));
+	const restoreOnExit = () => {
+		if (!navigationBatchClosed) {
+			discardLifecycleCommitBatch(navigationBatch);
+			navigationBatchClosed = true;
+		}
+		restoreDeferredRouteInstances(rollbackSnapshots);
+		for (const previous of previousAppLocations) {
+			previous.app.pathname = previous.pathname;
+			previous.app.href = previous.href;
+		}
+		setCurrentRouteLocation(previousPathname, previousHref);
+	};
+	const navigationBatch = beginLifecycleCommitBatch();
+	let navigationBatchClosed = false;
+	try {
+		for (const target of rootsToPrepare) {
+			if (isStaleRouteRequest(requestId)) {
+				restoreOnExit();
+				return;
+			}
+			updateRouteRuntime(target.app.instance, target.resolved, href);
+			const deferredCleanup = remountResolvedRoute(target.app.instance, getResolvedRouteHandler(target.resolved), pathname, href, rollbackSnapshotByInstance.get(target.app.instance));
+			deferredCleanups.push(deferredCleanup);
+		}
+		if (isStaleRouteRequest(requestId)) {
+			restoreOnExit();
+			return;
+		}
+		flushRuntimeScheduler();
+		cleanupErrors.push(...drainLifecycleCommitErrors());
+		if (isStaleRouteRequest(requestId)) {
+			restoreOnExit();
+			return;
+		}
+		for (const target of samePathTargets) {
+			if (isStaleRouteRequest(requestId)) {
+				restoreOnExit();
+				return;
+			}
+			updateRouteRuntime(target.app.instance, target.resolved, href);
+			rerenderResolvedRoute(target.app.instance, pathname, href);
+		}
+		flushRuntimeScheduler();
+		cleanupErrors.push(...drainLifecycleCommitErrors());
+		if (isStaleRouteRequest(requestId)) {
+			restoreOnExit();
+			return;
+		}
+		flushLifecycleCommitBatch(navigationBatch);
+		navigationBatchClosed = true;
+		cleanupErrors.push(...drainLifecycleCommitErrors());
+		for (const target of matchedTargets) if (target.resolved && target.resolved.kind !== "redirect") syncAppRegistrationLocation(target.app, pathname, href);
+		if (isStaleRouteRequest(requestId)) {
+			restoreOnExit();
+			return;
+		}
+		setCurrentRouteLocation(pathname, href);
+		clearStagedRouteLocations(matchedTargets);
+		syncRegisteredRouteSnapshot();
+		reconcileNavigationMetadata(matchedTargets);
+		applyHistoryScroll(href, state);
+		for (const deferredCleanup of deferredCleanups) cleanupErrors.push(...cleanupDeferredRouteInstance(deferredCleanup));
+		for (const error of cleanupErrors) reportRouteCleanupErrors([error]);
+	} catch (error) {
+		restoreOnExit();
+		try {
+			window.history.replaceState(previousState, "", previousHref);
+			syncRegisteredRouteSnapshot();
+		} catch (rollbackError) {
+			logger.error("[Askr] failed to restore URL after popstate failure:", rollbackError);
+		}
+		throw error;
+	}
+}
+//#endregion
+//#region src/router/route-query.ts
+function getRouteQueryHistoryMode(options) {
+	if (options.history) return options.history;
+	return options.replace === false ? "push" : "replace";
+}
+function setRouteQueryValue(searchParams, key, value) {
+	searchParams.delete(key);
+	if (Array.isArray(value)) {
+		for (const entry of value) {
+			if (entry === null || entry === void 0) continue;
+			searchParams.append(key, String(entry));
+		}
+		return;
+	}
+	if (value === null || value === void 0) return;
+	searchParams.set(key, String(value));
+}
+function applyRouteQueryUpdates(searchParams, updates) {
+	if (typeof updates === "function") {
+		updates(searchParams);
+		return;
+	}
+	for (const [key, value] of Object.entries(updates)) setRouteQueryValue(searchParams, key, value);
+}
+function updateRouteQuery(updates, options = {}) {
+	if (typeof window === "undefined") return;
+	const url = parseTargetUrl(getWindowHref$1());
+	applyRouteQueryUpdates(url.searchParams, updates);
+	const href = `${url.pathname}${url.search}${url.hash}`;
+	if (href === getWindowHref$1()) return;
+	const historyMode = getRouteQueryHistoryMode(options);
+	if (historyMode === "push") saveScrollPosition(getCurrentHref());
+	const state = window.history.state && typeof window.history.state === "object" ? window.history.state : {};
+	window.history[historyMode === "replace" ? "replaceState" : "pushState"]({
+		...state,
+		path: href
+	}, "", href);
+	setCurrentRouteLocation(url.pathname, href);
+	for (const app of getRegisteredAppsSnapshot()) syncAppRegistrationLocation(app, url.pathname, href);
+	syncRegisteredRouteSnapshot();
+}
+//#endregion
+//#region src/router/navigate.ts
+/**
+* Client-side navigation with History API
+*/
+let navigationInitialized = false;
+configureNavigationRegistryHost({ cancelRouteRequests });
+function navigate(path, options = {}) {
+	if (typeof window === "undefined") return;
+	const initialTarget = parseTargetUrl(path);
+	navigateWithRedirectState(path, options, {
+		redirects: 0,
+		visited: /* @__PURE__ */ new Set([`${initialTarget.pathname}${initialTarget.search}${initialTarget.hash}`])
+	});
+}
+function navigateWithRedirectState(path, options, redirectState) {
+	if (typeof window === "undefined") return;
+	const request = beginRouteRequest();
+	const target = parseTargetUrl(path);
+	const pathname = target.pathname;
+	const href = `${target.pathname}${target.search}${target.hash}`;
+	const resolvedTargets = resolveNavigationTargetsForApps(pathname, href, request.signal);
+	if (isPromiseLike(resolvedTargets)) {
+		Promise.resolve(resolvedTargets).then((targets) => {
+			if (isStaleRouteRequest(request.id)) return;
+			try {
+				applyNavigationTargets(request.id, path, options, redirectState, pathname, href, targets, navigateWithRedirectState);
+			} catch (error) {
+				logger.error("[Askr] navigation failed:", error);
+			}
+		}, (error) => {
+			logger.error("[Askr] navigation failed:", error);
+		});
+		return;
+	}
+	applyNavigationTargets(request.id, path, options, redirectState, pathname, href, resolvedTargets, navigateWithRedirectState);
+}
+function handlePopState(event) {
+	const request = beginRouteRequest();
+	const previousHref = getCurrentHref();
+	const pathname = window.location.pathname;
+	const href = `${window.location.pathname}${window.location.search}${window.location.hash}`;
+	if (!hasRegisteredApps()) return;
+	const applyResolved = (targets) => {
+		try {
+			applyPopStateNavigationTargets(request.id, previousHref, { path: previousHref }, pathname, href, event.state, targets, navigate);
+		} catch (error) {
+			logger.error("[Askr] popstate navigation failed:", error);
+		}
+	};
+	const resolvedTargets = resolveNavigationTargetsForApps(pathname, href, request.signal);
+	if (isPromiseLike(resolvedTargets)) {
+		Promise.resolve(resolvedTargets).then((next) => {
+			applyResolved(next);
+		}, (error) => {
+			logger.error("[Askr] popstate navigation failed:", error);
+		});
+		return;
+	}
+	applyResolved(resolvedTargets);
+}
+function initializeNavigation() {
+	if (typeof window === "undefined" || navigationInitialized) return;
+	navigationInitialized = true;
+	window.addEventListener("popstate", handlePopState);
+}
+//#endregion
+export { index as C, assertExecutionModel as D, route as E, group as S, registerRoutes as T, lazy as _, resolveRouteMeta as a, createAppRenderRuntime as b, registerAppInstance as c, clearRoutes as d, createRouteRegistry as f, _snapshotRouteSourceLazy as g, _snapshotLazy as h, reconcileRouteMeta as i, unregisterAppInstance as l, _drainLazy as m, navigate as n, serializeRouteMeta as o, getManifest as p, updateRouteQuery as r, configureScrollRestoration as s, initializeNavigation as t, _applyManifest as u, currentRoute as v, page as w, fallback as x, setServerLocation as y };