@askrjs/askr 0.3.0 → 0.4.0

package/dist/resolution-Cx82-xjW.js

@@ -0,0 +1,1244 @@
+import { n as Fragment, t as ELEMENT_TYPE } from "./jsx-DRS-qjiN.js";
+import { r as currentAppRuntime } from "./hooks-BimKStr4.js";
+import { r as readScope, t as defineScope } from "./scope-CwpVSHVf.js";
+import { S as replacePageRoute, n as getActiveRenderContext, w as withPageFramework } from "./render-context-DGHnEveC.js";
+import { n as isPromiseLike } from "./promise-Dz8iIHAm.js";
+import { c as withTelemetry, l as jsonTransportPropertyPath, p as isDeferred, t as createQueryPrefetchContext, u as validateJsonTransportValue } from "./query-registry-WMCN0BJL.js";
+import { c as resolveNavigationUrl, i as formatNavigationUrl } from "./url-CnbfpX0K.js";
+//#region src/router/route-hydration.ts
+function isDeferredHydrationValue(value) {
+	return isDeferred(value);
+}
+const omissionGuards = /* @__PURE__ */ new WeakMap();
+const propertyPath = jsonTransportPropertyPath;
+/** Validate the exact value that will enter the route hydration envelope. */
+function validateRouteHydrationData(value, route) {
+	validateJsonTransportValue(value, `Route hydration data for "${route}"`, "Return JSON-compatible data or use route(..., { dehydrate(data) { ... } }) to omit server-only values.");
+}
+function omissionMap(complete, selected, ancestors = /* @__PURE__ */ new Set()) {
+	if (!complete || typeof complete !== "object" || isDeferredHydrationValue(complete)) return void 0;
+	if (ancestors.has(complete)) return void 0;
+	ancestors.add(complete);
+	const selectedObject = selected && typeof selected === "object" ? selected : void 0;
+	const output = Object.create(null);
+	try {
+		for (const key of Object.keys(complete)) {
+			if (!selectedObject || !Object.prototype.hasOwnProperty.call(selectedObject, key)) {
+				output[key] = 1;
+				continue;
+			}
+			const completeDescriptor = Object.getOwnPropertyDescriptor(complete, key);
+			const selectedDescriptor = Object.getOwnPropertyDescriptor(selectedObject, key);
+			if (!completeDescriptor || !selectedDescriptor) continue;
+			if (!("value" in completeDescriptor) || !("value" in selectedDescriptor)) continue;
+			const nested = omissionMap(completeDescriptor.value, selectedDescriptor.value, ancestors);
+			if (nested) output[key] = nested;
+		}
+	} finally {
+		ancestors.delete(complete);
+	}
+	return Object.keys(output).length > 0 ? Object.freeze(output) : void 0;
+}
+function prepareRouteHydrationData(complete, dehydrate, context, route = context.href || context.pathname) {
+	const selected = dehydrate ? dehydrate(complete, context) : complete;
+	if (isPromiseLike(selected)) throw new TypeError(`[Askr] Route dehydrate() for "${route}" returned a Promise. dehydrate(data, context) must be synchronous.`);
+	validateRouteHydrationData(selected, route);
+	return {
+		data: selected,
+		metadata: Object.freeze({
+			r: route,
+			...dehydrate ? { o: omissionMap(complete, selected) } : {}
+		})
+	};
+}
+function readMetadata(framework) {
+	const value = framework["rh"];
+	if (!value || typeof value !== "object" || Array.isArray(value)) return;
+	const metadata = value;
+	return typeof metadata.r === "string" ? metadata : void 0;
+}
+function omittedRead(route, path) {
+	throw new Error(`[Askr] routeData() read "${path}" on the initial hydration of "${route}", but that branch was intentionally omitted by dehydrate(). Keep initial hydrated rendering within the selected data, or wait for a client navigation that reruns the loader with the complete result.`);
+}
+function guardOmissions(value, omissions, route, path = "$") {
+	if (!omissions || !value || typeof value !== "object" || isDeferredHydrationValue(value)) return value;
+	let guards = omissionGuards.get(value);
+	if (!guards) {
+		guards = /* @__PURE__ */ new WeakMap();
+		omissionGuards.set(value, guards);
+	}
+	const cached = guards.get(omissions);
+	if (cached) return cached;
+	const guarded = new Proxy(value, { get(target, property, receiver) {
+		if (typeof property === "string") {
+			const omitted = omissions[property];
+			if (omitted && !Object.prototype.hasOwnProperty.call(target, property)) omittedRead(route, propertyPath(path, property));
+			const child = Reflect.get(target, property, receiver);
+			return omitted === 1 ? child : guardOmissions(child, omitted, route, propertyPath(path, property));
+		}
+		return Reflect.get(target, property, receiver);
+	} });
+	guards.set(omissions, guarded);
+	return guarded;
+}
+function guardHydratedRouteData(value, framework) {
+	const metadata = readMetadata(framework);
+	return metadata ? guardOmissions(value, metadata.o, metadata.r) : value;
+}
+function getRouteHydrationMetadata(framework) {
+	return readMetadata(framework);
+}
+/** @internal Remove initial-only omission guards after a client loader reruns. */
+function withoutRouteHydrationMetadata(framework) {
+	if (!framework || !("rh" in framework)) return framework;
+	const next = { ...framework };
+	delete next["rh"];
+	return next;
+}
+//#endregion
+//#region src/router/match.ts
+function splitPathSegments(path) {
+	const normalized = path.endsWith("/") && path !== "/" ? path.slice(0, -1) : path;
+	if (!normalized || normalized === "/") return [];
+	const withoutLeadingSlash = normalized.startsWith("/") ? normalized.slice(1) : normalized;
+	return withoutLeadingSlash.length === 0 ? [] : withoutLeadingSlash.split("/");
+}
+function normalizeRouteSegmentName(value) {
+	return value.trim();
+}
+/**
+* Parse a route template path into typed segments.
+*
+* @example
+* parseSegments('/users/{id}')  // [{kind:'static',value:'users'},{kind:'param',value:'id'}]
+* parseSegments('/*')           // [{kind:'catchall',value:'*'}]
+* parseSegments('/posts/*')     // [{kind:'static',value:'posts'},{kind:'wildcard',value:'*'}]
+* parseSegments('/files/{*path}') // [{kind:'static',value:'files'},{kind:'splat',value:'path'}]
+*/
+function parseSegments(path) {
+	const parts = (path.endsWith("/") && path !== "/" ? path.slice(0, -1) : path).split("/").filter(Boolean);
+	if (parts.length === 1 && parts[0] === "*") return [{
+		kind: "catchall",
+		value: "*"
+	}];
+	return parts.map((segment) => {
+		if (segment.startsWith("{") && segment.endsWith("}")) {
+			const value = normalizeRouteSegmentName(segment.slice(1, -1));
+			if (value.startsWith("*")) return {
+				kind: "splat",
+				value: normalizeRouteSegmentName(value.slice(1))
+			};
+			return {
+				kind: "param",
+				value
+			};
+		}
+		if (segment === "*") return {
+			kind: "wildcard",
+			value: "*"
+		};
+		return {
+			kind: "static",
+			value: segment
+		};
+	});
+}
+/**
+* Per-segment specificity weights. Routes are compared segment by segment and
+* the first differing segment decides: static > param > wildcard > (end of
+* route) > splat. "End of route" only ever meets a splat at the same position
+* for routes that match the same URL, so an exact route beats an empty splat.
+*/
+const SEGMENT_WEIGHT = {
+	static: 4,
+	param: 3,
+	wildcard: 2,
+	splat: 0,
+	catchall: 0
+};
+const END_OF_ROUTE_WEIGHT = 1;
+const RANK_BASE = 8;
+function segmentWeight(segment) {
+	if (segment === void 0) return END_OF_ROUTE_WEIGHT;
+	return SEGMENT_WEIGHT[segment.kind];
+}
+function isCatchAll(segments) {
+	return segments.length === 1 && segments[0].kind === "catchall";
+}
+/**
+* Order two parsed routes by specificity: negative when `a` is more specific
+* than `b`, positive when less, `0` when they tie (declaration order decides).
+*
+* Segments are compared left to right and the first differing segment decides
+* (static > param > wildcard > splat); the bare `/*` catch-all is always last.
+*/
+function compareRouteSpecificity(a, b) {
+	const aCatchAll = isCatchAll(a);
+	const bCatchAll = isCatchAll(b);
+	if (aCatchAll || bCatchAll) return Number(aCatchAll) - Number(bCatchAll);
+	const length = Math.max(a.length, b.length);
+	for (let i = 0; i < length; i++) {
+		const difference = segmentWeight(b[i]) - segmentWeight(a[i]);
+		if (difference !== 0) return difference;
+	}
+	return 0;
+}
+/**
+* Key for the set of URLs a route matches, used to reject duplicate
+* registrations. Parameter and splat names do not affect matching, a `*`
+* wildcard matches exactly one segment like a param (and always loses to it),
+* static segments compare decoded (see {@link staticSegmentMatches}), and a
+* scoped fallback matches exactly what a splat at its prefix matches, so
+* routes with equal keys match the same URLs and the later one could never be
+* reached.
+*/
+function routeMatchKey(segments, fallbackPrefix) {
+	const parts = (fallbackPrefix === void 0 ? segments : parseSegments(fallbackPrefix)).map((segment) => {
+		switch (segment.kind) {
+			case "static": return encodePathSegment(decodePathSegment(segment.value));
+			case "param":
+			case "wildcard": return "{}";
+			case "splat":
+			case "catchall": return "{*}";
+		}
+	});
+	if (fallbackPrefix !== void 0) parts.push("{*}");
+	return "/" + parts.join("/");
+}
+/**
+* Compute a numeric specificity rank from a parsed segment list.
+*
+* The rank encodes the segment-by-segment order of
+* {@link compareRouteSpecificity} as base-8 digits (higher = more specific);
+* the bare `/*` catch-all is `-1`. It is informational: route ordering uses
+* `compareRouteSpecificity` so arbitrarily deep routes compare exactly.
+*/
+function computeRank(segments) {
+	if (isCatchAll(segments)) return -1;
+	let rank = 0;
+	let scale = 1;
+	for (const segment of segments) {
+		scale /= RANK_BASE;
+		rank += segmentWeight(segment) * scale;
+	}
+	return rank + END_OF_ROUTE_WEIGHT * scale / 7;
+}
+/** Reused frozen empty params object — returned for purely-static (no-capture) routes. */
+const emptyParams = Object.freeze(Object.create(null));
+Object.freeze({
+	matched: false,
+	params: emptyParams
+});
+/**
+* Encoded path separators (`/` and backslash) that stay percent-encoded when a URL
+* segment is decoded, so a capture never gains a separator the URL did not
+* have (`..%2F..%2Fetc` must not become `../../etc`).
+*/
+const ENCODED_SEPARATOR = /(%2F|%5C)/i;
+function decodeSegmentPiece(piece) {
+	if (!piece.includes("%")) return piece;
+	try {
+		return decodeURIComponent(piece);
+	} catch {
+		return piece;
+	}
+}
+/**
+* Decode one URL path segment, keeping encoded separators as upper-case
+* `%2F`/`%5C` and malformed encodings as written.
+*/
+function decodePathSegment(part) {
+	if (!part.includes("%")) return part;
+	return part.split(ENCODED_SEPARATOR).map((piece, index) => index % 2 === 1 ? piece.toUpperCase() : decodeSegmentPiece(piece)).join("");
+}
+/**
+* Percent-encode one path segment value, the inverse of
+* {@link decodePathSegment}: kept `%2F`/`%5C` separators pass through so a
+* capture round-trips to the URL it came from.
+*/
+function encodePathSegment(value) {
+	return value.split(ENCODED_SEPARATOR).map((piece, index) => index % 2 === 1 ? piece.toUpperCase() : encodeURIComponent(piece)).join("");
+}
+/**
+* Compare a static route segment with a URL segment. URL parts arrive
+* percent-encoded (`caf%C3%A9`), so decoded forms are compared and `/café`,
+* `/a b` and reserved-character routes match.
+*/
+function staticSegmentMatches(value, part) {
+	return value === part || decodePathSegment(value) === decodePathSegment(part);
+}
+/**
+* Format the `*` capture of a catch-all or fallback from the remaining URL
+* parts, decoding each segment like param and splat captures.
+*/
+function formatCatchAllCapture(parts) {
+	if (parts.length === 0) return "/";
+	if (parts.length === 1) return decodePathSegment(parts[0]);
+	return "/" + parts.map(decodePathSegment).join("/");
+}
+/**
+* Match pre-split URL parts against pre-parsed route segments.
+*
+* This is the hot-path matcher used by `resolveRoute` and
+* `resolveRouteFromRoutes`. Callers split the URL path **once** and reuse
+* `urlParts` across all route comparisons in a single resolution call.
+*
+* - Returns a params object (possibly the shared `{}`) on match.
+* - Returns `null` on no match.
+* - Params are allocated lazily — purely-static routes return the frozen
+*   empty sentinel without any heap allocation.
+*/
+function matchSegments(urlParts, segments) {
+	if (segments.length === 1 && segments[0].kind === "catchall") return { "*": formatCatchAllCapture(urlParts) };
+	const splatIndex = segments.findIndex((segment) => segment.kind === "splat");
+	if (splatIndex !== -1) {
+		if (splatIndex !== segments.length - 1) return null;
+		if (urlParts.length < splatIndex) return null;
+	} else if (urlParts.length !== segments.length) return null;
+	let params = null;
+	const normalizeCapturedSplatParts = (parts) => {
+		let start = 0;
+		while (start < parts.length && parts[start] === "") start += 1;
+		return start === 0 ? parts : parts.slice(start);
+	};
+	for (let i = 0; i < segments.length; i++) {
+		const seg = segments[i];
+		const part = urlParts[i];
+		if (seg.kind === "static") {
+			if (!staticSegmentMatches(seg.value, part)) return null;
+		} else if (seg.kind === "splat") {
+			if (params === null) params = {};
+			params[seg.value] = normalizeCapturedSplatParts(urlParts.slice(i).map(decodePathSegment)).join("/");
+			return params;
+		} else {
+			if (params === null) params = {};
+			if (seg.kind === "param") params[seg.value] = decodePathSegment(part);
+			else params["*"] = decodePathSegment(part);
+		}
+	}
+	return params ?? emptyParams;
+}
+//#endregion
+//#region src/common/router-internal.ts
+const ROUTE_ROOT_COMPONENT = Symbol.for("askr.route-root-component");
+//#endregion
+//#region src/router/route-data-loader.ts
+/** Rejection of a `lazyRouteData()` loader whose import or `select` failed; wraps the original `cause`. */
+var RouteDataLoadError = class extends Error {
+	constructor(route, phase, cause) {
+		const detail = cause instanceof Error ? cause.message : String(cause);
+		super("[Askr] Route data loader failed for \"" + route + "\" during " + phase + " loading: " + detail);
+		this.name = "RouteDataLoadError";
+		this.route = route;
+		this.phase = phase;
+		this.cause = cause;
+	}
+};
+function isAbortError(error) {
+	return typeof error === "object" && error !== null && "name" in error && error.name === "AbortError";
+}
+function loadPhase(mode) {
+	if (mode === "spa") return "client";
+	if (mode === "ssg") return "ssg";
+	return "server";
+}
+/** @internal Add route context to failures from lazyRouteData(). */
+function _wrapRouteDataLoadError(error, context) {
+	if (error instanceof RouteDataLoadError || isAbortError(error)) throw error;
+	throw new RouteDataLoadError(context.href || context.pathname, loadPhase(context.mode), error);
+}
+//#endregion
+//#region src/router/lazy.ts
+const pendingLazy = /* @__PURE__ */ new Set();
+const lazyStates = /* @__PURE__ */ new WeakMap();
+const handlerLazyComponents = /* @__PURE__ */ new WeakMap();
+function startLazyLoad(state) {
+	if (state.promise) return state.promise;
+	let promise;
+	promise = Promise.resolve().then(state.factory).then((mod) => {
+		state.resolved = typeof mod === "function" ? mod : mod.default;
+		state.loadError = null;
+		state.hasLoadError = false;
+	}, (err) => {
+		state.loadError = err;
+		state.hasLoadError = true;
+	}).finally(() => {
+		if (state.hasLoadError) state.promise = null;
+		pendingLazy.delete(promise);
+	});
+	state.promise = promise;
+	pendingLazy.add(promise);
+	return promise;
+}
+/** Wrap a dynamic-import factory as a {@link LazyRouteComponent}, loaded on first use. */
+function lazy(factory) {
+	const state = {
+		factory,
+		promise: null,
+		resolved: null,
+		loadError: null,
+		hasLoadError: false
+	};
+	const component = ((params) => {
+		if (state.hasLoadError) throw state.loadError;
+		if (!state.resolved) throw new Error("lazy() component used before it was resolved. Matched routes load automatically; call component.preload() for explicit preloading.");
+		return state.resolved(params);
+	});
+	Object.defineProperty(component, "preload", { value: () => startLazyLoad(state) });
+	lazyStates.set(component, state);
+	return component;
+}
+/**
+* Create a cached route loader backed by a dynamic import. The module is only
+* requested when the owning route matches, unless preload() is called.
+*/
+function lazyRouteData(factory, select) {
+	let imported = null;
+	const load = () => {
+		if (imported) return imported;
+		imported = Promise.resolve().then(factory).catch((error) => {
+			imported = null;
+			throw error;
+		});
+		return imported;
+	};
+	const loader = ((context) => load().then((module) => select ? select(module, context) : module).catch((error) => _wrapRouteDataLoadError(error, context)));
+	Object.defineProperty(loader, "preload", { value: () => load().then(() => void 0) });
+	return loader;
+}
+function _preloadRouteRecord(record) {
+	const imports = [
+		record.component,
+		...record.pageChain.map((scope) => scope.component),
+		...record.layoutChain.map((scope) => scope.component)
+	].flatMap((component) => {
+		const state = lazyStates.get(component);
+		return state && !state.resolved ? [startLazyLoad(state)] : [];
+	});
+	return imports.length > 0 ? Promise.all(imports).then(() => void 0) : null;
+}
+function _associateLazyHandler(handler, components) {
+	handlerLazyComponents.set(handler, components);
+}
+function _preloadRouteHandler(handler) {
+	const imports = (handlerLazyComponents.get(handler) ?? []).flatMap((component) => {
+		const state = lazyStates.get(component);
+		return state ? [startLazyLoad(state)] : [];
+	});
+	return imports.length > 0 ? Promise.all(imports).then(() => void 0) : null;
+}
+//#endregion
+//#region src/router/rendering.ts
+const outletScope = defineScope(null);
+const clientLayouts = /* @__PURE__ */ new WeakMap();
+function clientLayout(layout) {
+	let wrapped = clientLayouts.get(layout);
+	if (!wrapped) {
+		wrapped = (props) => {
+			const output = layout(props);
+			return typeof Node !== "undefined" && output instanceof Node ? null : output;
+		};
+		clientLayouts.set(layout, wrapped);
+	}
+	return wrapped;
+}
+/** Renders the nested route content for the enclosing layout or page scope. */
+function Outlet() {
+	return {
+		$$typeof: ELEMENT_TYPE,
+		type: Fragment,
+		props: { children: readScope(outletScope) },
+		key: null
+	};
+}
+function applyPageChain(pageChain, params, content, deferComponents = false) {
+	let nextContent = content;
+	for (let i = pageChain.length - 1; i >= 0; i--) nextContent = outletScope({
+		value: nextContent,
+		children: deferComponents ? createRouteComponentVNode(pageChain[i].component, params) : pageChain[i].component(params)
+	});
+	return nextContent;
+}
+function createRouteComponentVNode(component, params, routeRoot = false) {
+	return {
+		$$typeof: ELEMENT_TYPE,
+		type: component,
+		props: params,
+		key: routeRoot ? currentAppRuntime()?.lifetime ?? null : null,
+		...routeRoot ? { [ROUTE_ROOT_COMPONENT]: true } : {}
+	};
+}
+function createRouteHandler(component, pageChain, layoutChain, deferComponents = false) {
+	const handler = (params) => {
+		let content = deferComponents ? createRouteComponentVNode(component, params, true) : component(params);
+		content = applyPageChain(pageChain, params, content, deferComponents);
+		for (let i = layoutChain.length - 1; i >= 0; i--) {
+			const layout = layoutChain[i].component;
+			const rendered = deferComponents ? {
+				$$typeof: ELEMENT_TYPE,
+				type: clientLayout(layout),
+				props: { children: content },
+				key: null
+			} : layout({ children: content });
+			content = typeof Node !== "undefined" && rendered instanceof Node ? null : rendered;
+		}
+		return content;
+	};
+	_associateLazyHandler(handler, [
+		component,
+		...pageChain.map((scope) => scope.component),
+		...layoutChain.map((scope) => scope.component)
+	]);
+	return handler;
+}
+function getRenderHandler(record) {
+	return record.renderHandler ?? createRouteHandler(record.component, record.pageChain, record.layoutChain, true);
+}
+//#endregion
+//#region src/router/store.ts
+function createRouteTable() {
+	return {
+		routes: [],
+		records: [],
+		namespaces: /* @__PURE__ */ new Set(),
+		routesByDepth: /* @__PURE__ */ new Map(),
+		registrationScopeStack: [],
+		registrationLocked: false,
+		defaultRouteAuthOptions: void 0,
+		activeClientRouteAuthOptions: void 0,
+		defaultRouteBasePath: ""
+	};
+}
+let activeTable = createRouteTable();
+/** Run `fn` with `table` as the registration target, then restore the previous one. */
+function withRouteTable(table, fn) {
+	const previous = activeTable;
+	activeTable = table;
+	try {
+		return fn();
+	} finally {
+		activeTable = previous;
+	}
+}
+function getDepth(path) {
+	const normalized = path.endsWith("/") && path !== "/" ? path.slice(0, -1) : path;
+	return normalized === "/" ? 0 : normalized.split("/").filter(Boolean).length;
+}
+function getRouteRecords() {
+	return activeTable.records;
+}
+function isRouteStoreRoutes(routeList) {
+	return routeList === activeTable.routes;
+}
+function insertRecordSorted(record) {
+	let lo = 0;
+	let hi = activeTable.records.length;
+	while (lo < hi) {
+		const mid = lo + hi >>> 1;
+		if (compareRouteSpecificity(activeTable.records[mid].segments, record.segments) <= 0) lo = mid + 1;
+		else hi = mid;
+	}
+	activeTable.records.splice(lo, 0, record);
+}
+function addRouteToStores(routeObj) {
+	activeTable.routes.push(routeObj);
+	const depth = getDepth(routeObj.path);
+	let depthRoutes = activeTable.routesByDepth.get(depth);
+	if (!depthRoutes) {
+		depthRoutes = [];
+		activeTable.routesByDepth.set(depth, depthRoutes);
+	}
+	depthRoutes.push(routeObj);
+	if (routeObj.namespace) activeTable.namespaces.add(routeObj.namespace);
+}
+function getActiveRoutes() {
+	return getActiveRenderContext()?.routes ?? currentAppRuntime()?.routeRegistry?.routes ?? activeTable.routes;
+}
+function getActiveRouteAuthOptions(override) {
+	if (override !== void 0) return override;
+	const renderContext = getActiveRenderContext();
+	if (renderContext) return renderContext.routeAuth;
+	const appRuntime = currentAppRuntime();
+	if (appRuntime) return appRuntime.routeAuth;
+	return activeTable.activeClientRouteAuthOptions ?? activeTable.defaultRouteAuthOptions;
+}
+function _setActiveRouteAuthOptions(auth) {
+	activeTable.activeClientRouteAuthOptions = auth;
+}
+function getDefaultRouteAuthOptions() {
+	return activeTable.defaultRouteAuthOptions;
+}
+function setDefaultRouteAuthOptions(auth) {
+	activeTable.defaultRouteAuthOptions = auth;
+}
+function getDefaultRouteBasePath() {
+	return activeTable.defaultRouteBasePath;
+}
+function setDefaultRouteBasePath(basePath) {
+	activeTable.defaultRouteBasePath = basePath;
+}
+function getActiveRouteBasePath() {
+	const renderContext = getActiveRenderContext();
+	if (renderContext?.basePath !== void 0) return renderContext.basePath;
+	const appRegistry = currentAppRuntime()?.routeRegistry;
+	if (appRegistry) return appRegistry.manifest.basePath ?? "";
+	return activeTable.defaultRouteBasePath;
+}
+function getCurrentLayoutChain() {
+	const layoutChain = [];
+	for (const scope of activeTable.registrationScopeStack) if (scope.layout) layoutChain.push({ component: scope.layout });
+	return layoutChain;
+}
+function getCurrentPageChain() {
+	const pageChain = [];
+	for (const scope of activeTable.registrationScopeStack) if (scope.page) pageChain.push({ component: scope.page });
+	return pageChain;
+}
+function hasActivePageScope() {
+	return activeTable.registrationScopeStack.some((scope) => !!scope.page);
+}
+function getCurrentPageScope() {
+	for (let index = activeTable.registrationScopeStack.length - 1; index >= 0; index -= 1) {
+		const scope = activeTable.registrationScopeStack[index];
+		if (scope.kind === "page") return scope;
+	}
+	return null;
+}
+function getCurrentScopeKind() {
+	return activeTable.registrationScopeStack[activeTable.registrationScopeStack.length - 1]?.kind ?? null;
+}
+function getCurrentPathPrefix() {
+	return activeTable.registrationScopeStack[activeTable.registrationScopeStack.length - 1]?.pathPrefix ?? "";
+}
+function getCurrentInheritedPolicies() {
+	const policies = [];
+	for (const scope of activeTable.registrationScopeStack) if (scope.policies.length > 0) policies.push(...scope.policies);
+	return policies;
+}
+function getCurrentInheritedAuthRequirements() {
+	return activeTable.registrationScopeStack.flatMap((scope) => scope.auth ? [scope.auth] : []);
+}
+function getCurrentInheritedMeta() {
+	return activeTable.registrationScopeStack.flatMap((scope) => scope.meta ? [scope.meta] : []);
+}
+function pushRegistrationScope(scope, fn) {
+	activeTable.registrationScopeStack.push(scope);
+	try {
+		fn();
+	} finally {
+		activeTable.registrationScopeStack.pop();
+	}
+}
+function lockRouteRegistration() {
+	activeTable.registrationLocked = true;
+}
+function assertRouteRegistrationUnlocked() {
+	if (activeTable.registrationLocked) throw new Error("Route registration is locked after app startup. Register routes at module load time before calling createSPA or hydrateSPA.");
+}
+function getRouteList() {
+	return [...activeTable.routes];
+}
+function hasRegisteredRoutes() {
+	return activeTable.routes.length > 0 || activeTable.records.length > 0;
+}
+function clearRouteState() {
+	activeTable.routes.length = 0;
+	activeTable.records.length = 0;
+	activeTable.namespaces.clear();
+	activeTable.routesByDepth.clear();
+	activeTable.registrationScopeStack.length = 0;
+	activeTable.registrationLocked = false;
+	activeTable.defaultRouteAuthOptions = void 0;
+	activeTable.activeClientRouteAuthOptions = void 0;
+	activeTable.defaultRouteBasePath = "";
+}
+//#endregion
+//#region src/router/route-context.ts
+function parseLocation(url) {
+	try {
+		const parsedUrl = new URL(url, "http://localhost");
+		return {
+			pathname: parsedUrl.pathname,
+			search: parsedUrl.search,
+			hash: parsedUrl.hash
+		};
+	} catch {
+		return {
+			pathname: "/",
+			search: "",
+			hash: ""
+		};
+	}
+}
+function deepFreeze(obj) {
+	if (obj && typeof obj === "object" && !Object.isFrozen(obj)) {
+		Object.freeze(obj);
+		for (const key of Object.keys(obj)) {
+			const value = obj[key];
+			if (value && typeof value === "object") deepFreeze(value);
+		}
+	}
+	return obj;
+}
+function makeQuery(search) {
+	const searchParams = new URLSearchParams(search || "");
+	const mapping = /* @__PURE__ */ new Map();
+	for (const [key, value] of searchParams.entries()) {
+		const existing = mapping.get(key);
+		if (existing) existing.push(value);
+		else mapping.set(key, [value]);
+	}
+	return deepFreeze({
+		get(key) {
+			const values = mapping.get(key);
+			return values ? values[0] : null;
+		},
+		getAll(key) {
+			const values = mapping.get(key);
+			return values ? [...values] : [];
+		},
+		has(key) {
+			return mapping.has(key);
+		},
+		toJSON() {
+			const output = {};
+			for (const [key, values] of mapping.entries()) output[key] = values.length > 1 ? [...values] : values[0];
+			return output;
+		}
+	});
+}
+function buildRouteContextBase(target, params, options) {
+	const parsed = parseLocation(target);
+	const href = `${parsed.pathname}${parsed.search}${parsed.hash}`;
+	return {
+		mode: options.mode,
+		params,
+		pathname: parsed.pathname,
+		search: parsed.search,
+		hash: parsed.hash,
+		href,
+		signal: options.signal
+	};
+}
+function buildRouteContext(target, params, options) {
+	return {
+		...buildRouteContextBase(target, params, options),
+		auth: options.authContext
+	};
+}
+//#endregion
+//#region src/router/base-path.ts
+/** Normalize the public mount point used by one route registry. */
+function normalizeRouteBasePath(value) {
+	if (value === void 0 || value === "" || value === "/") return "";
+	if (!value.startsWith("/") || /\/{2,}/.test(value) || value.includes("?") || value.includes("#") || value.includes("\\")) throw new TypeError(`Route basePath must be an absolute pathname without a query or hash. Received: ${JSON.stringify(value)}`);
+	const normalized = value.endsWith("/") ? value.slice(0, -1) : value;
+	if (normalized.split("/").some((segment) => segment === "." || segment === "..")) throw new TypeError("Route basePath must not contain dot segments.");
+	return normalized;
+}
+function parsedTarget(target) {
+	return new URL(target, "http://askr.invalid");
+}
+/**
+* Strip `basePath` from a pathname, comparing segments in decoded form so an
+* encoded pathname (`/caf%C3%A9/menu`) matches its base (`/café`). Returns the
+* remaining pathname (at least `/`), or `undefined` outside the base.
+*/
+function stripRouteBasePath(pathname, basePath) {
+	const pathParts = pathname.split("/");
+	const baseParts = basePath.split("/");
+	if (pathParts.length < baseParts.length) return void 0;
+	for (let i = 1; i < baseParts.length; i++) if (!staticSegmentMatches(baseParts[i], pathParts[i])) return void 0;
+	return `/${pathParts.slice(baseParts.length).join("/")}`;
+}
+/**
+* Add a registry mount point to one logical root-relative route target. The
+* target is always logical, so `/app/settings` under `/app` becomes
+* `/app/app/settings`; callers holding a public href must not pass it here.
+*/
+function addRouteBasePath(target, basePath) {
+	if (!basePath || !target.startsWith("/") || target.startsWith("//")) return target;
+	const parsed = parsedTarget(target);
+	if (parsed.origin !== "http://askr.invalid") return target;
+	return `${basePath}${parsed.pathname}${parsed.search}${parsed.hash}`;
+}
+/**
+* Add the mount point to an app-supplied string target (`navigate()`,
+* `<Link href>`, `redirect()`). In development, warn when the target already
+* starts with the base: strings are logical, so it gains the base again.
+*/
+function addLogicalRouteBasePath(target, basePath) {
+	return addRouteBasePath(target, basePath);
+}
+/** Remove a registry mount point and retain query/hash for logical matching. */
+function removeRouteBasePath(target, basePath) {
+	const parsed = parsedTarget(target);
+	if (!basePath) return `${parsed.pathname}${parsed.search}${parsed.hash}`;
+	const logicalPath = stripRouteBasePath(parsed.pathname, basePath);
+	if (logicalPath === void 0) return void 0;
+	return `${logicalPath}${parsed.search}${parsed.hash}`;
+}
+//#endregion
+//#region src/router/route-matching.ts
+const routeSegsCache = /* @__PURE__ */ new WeakMap();
+const sortedListCache = /* @__PURE__ */ new WeakMap();
+function cachedSegs(route) {
+	let segments = routeSegsCache.get(route);
+	if (!segments) {
+		segments = parseSegments(route.path);
+		routeSegsCache.set(route, segments);
+	}
+	return segments;
+}
+function cachedSortedList(routeList) {
+	let sorted = sortedListCache.get(routeList);
+	if (!sorted) {
+		sorted = [...routeList].sort((a, b) => compareRouteSpecificity(cachedSegs(a), cachedSegs(b)));
+		sortedListCache.set(routeList, sorted);
+	}
+	return sorted;
+}
+const prefixSegsCache = /* @__PURE__ */ new Map();
+function cachedPrefixSegs(prefix) {
+	let segments = prefixSegsCache.get(prefix);
+	if (!segments) {
+		segments = parseSegments(prefix);
+		prefixSegsCache.set(prefix, segments);
+	}
+	return segments;
+}
+/**
+* Match a scoped fallback's page prefix against the start of `pathname`.
+* Prefix segments match like route segments, so a fallback inside
+* `page('/{lang}')` matches `/en/...` and captures `lang`; the rest of the
+* path is the `*` capture.
+*/
+function matchFallbackPrefix(pathname, fallbackPrefix) {
+	const urlParts = splitPathSegments(pathname);
+	const prefixSegments = cachedPrefixSegs(fallbackPrefix);
+	if (urlParts.length < prefixSegments.length) return null;
+	const prefixParams = matchSegments(urlParts.slice(0, prefixSegments.length), prefixSegments);
+	if (prefixParams === null) return null;
+	return {
+		...prefixParams,
+		"*": formatCatchAllCapture(urlParts.slice(prefixSegments.length))
+	};
+}
+function findBestResolvedRouteFromRoutes(pathname, routeList) {
+	const normalized = pathname.endsWith("/") && pathname !== "/" ? pathname.slice(0, -1) : pathname;
+	const urlParts = splitPathSegments(normalized);
+	for (const route of cachedSortedList(routeList)) {
+		if (route.fallbackPrefix) continue;
+		const params = matchSegments(urlParts, cachedSegs(route));
+		if (params !== null) return {
+			route,
+			params
+		};
+	}
+	const fallback = findDeepestFallback(normalized, routeList);
+	return fallback ? {
+		route: fallback.entry,
+		params: fallback.params
+	} : null;
+}
+/**
+* Pick the scoped fallback whose prefix matches `pathname` with the most
+* segments. Depth is counted in segments, not characters, so an encoded prefix
+* such as `/caf%C3%A9` does not outrank a deeper `/café/x`; equal depths are
+* ordered by segment specificity.
+*/
+function findDeepestFallback(pathname, entries) {
+	let best = null;
+	let bestSegments = [];
+	for (const entry of entries) {
+		if (!entry.fallbackPrefix) continue;
+		const params = matchFallbackPrefix(pathname, entry.fallbackPrefix);
+		if (params === null) continue;
+		const segments = cachedPrefixSegs(entry.fallbackPrefix);
+		if (best === null || segments.length > bestSegments.length || segments.length === bestSegments.length && compareRouteSpecificity(segments, bestSegments) < 0) {
+			best = {
+				entry,
+				params
+			};
+			bestSegments = segments;
+		}
+	}
+	return best;
+}
+function findBestScopedFallbackRecord(pathname, routeRecords) {
+	const fallback = findDeepestFallback(pathname, routeRecords);
+	return fallback ? {
+		record: fallback.entry,
+		params: fallback.params
+	} : null;
+}
+function getMatchingRouteRecord(target, routeRecords) {
+	const location = parseLocation(target);
+	const normalized = location.pathname.endsWith("/") && location.pathname !== "/" ? location.pathname.slice(0, -1) : location.pathname;
+	const urlParts = splitPathSegments(normalized);
+	for (const record of routeRecords) {
+		if (record.fallbackPrefix) continue;
+		const params = matchSegments(urlParts, record.segments);
+		if (params !== null) return {
+			record,
+			params
+		};
+	}
+	return findBestScopedFallbackRecord(normalized, routeRecords);
+}
+function computeMatchesFromRoutes(pathname, routesList) {
+	const bestMatch = isRouteStoreRoutes(routesList) ? getMatchingRouteRecord(pathname, getRouteRecords()) : findBestResolvedRouteFromRoutes(pathname, routesList);
+	if (!bestMatch) return [];
+	return [{
+		path: "route" in bestMatch ? bestMatch.route.path : bestMatch.record.path,
+		params: deepFreeze({ ...bestMatch.params }),
+		name: "route" in bestMatch ? bestMatch.route.name : void 0,
+		namespace: "route" in bestMatch ? bestMatch.route.namespace : bestMatch.record.options.namespace
+	}];
+}
+function computeMatchesFromRouteRecords(pathname, routeRecords) {
+	const bestMatch = getMatchingRouteRecord(pathname, routeRecords);
+	if (!bestMatch) return [];
+	return [{
+		path: bestMatch.record.path,
+		params: deepFreeze({ ...bestMatch.params }),
+		namespace: bestMatch.record.options.namespace
+	}];
+}
+function computeRouteActivityMatches(pathname, options) {
+	const logicalPath = removeRouteBasePath(pathname, normalizeRouteBasePath(options.registry.manifest.basePath));
+	if (logicalPath === void 0) return [];
+	return computeMatchesFromRouteRecords(logicalPath, options.registry.manifest.records);
+}
+/** Match a path against a route registry without resolving route policies or loading data. */
+function matchRoute(pathname, options) {
+	if (!options?.registry) throw new TypeError("matchRoute requires options.registry.");
+	return computeRouteActivityMatches(pathname, options)[0] ?? null;
+}
+function resolveRoute(pathname) {
+	const normalized = pathname.endsWith("/") && pathname !== "/" ? pathname.slice(0, -1) : pathname;
+	const urlParts = splitPathSegments(normalized);
+	const records = getRouteRecords();
+	for (const record of records) {
+		if (record.fallbackPrefix) continue;
+		const params = matchSegments(urlParts, record.segments);
+		if (params !== null) return {
+			handler: record.handler,
+			params
+		};
+	}
+	const fallbackMatch = findBestScopedFallbackRecord(normalized, records);
+	return fallbackMatch ? {
+		handler: fallbackMatch.record.handler,
+		params: fallbackMatch.params
+	} : null;
+}
+function resolveRouteFromRoutes(pathname, routeList) {
+	if (isRouteStoreRoutes(routeList)) return resolveRoute(pathname);
+	const match = findBestResolvedRouteFromRoutes(pathname, routeList);
+	return match ? {
+		handler: match.route.handler,
+		params: match.params
+	} : null;
+}
+const anonymous = Object.freeze({
+	authenticated: false,
+	principal: null,
+	session: null,
+	tenant: null
+});
+let clientAuth = anonymous;
+let hydratedAuth;
+/** Return the identity resolved for the route currently being rendered. */
+function currentAuth() {
+	const render = getActiveRenderContext();
+	if (render) return render.authContext ?? anonymous;
+	return clientAuth;
+}
+/** @internal Updated atomically with route resolution. */
+function setCurrentAuth(context, mode) {
+	const render = getActiveRenderContext();
+	if (render) {
+		render.authContext = context;
+		return;
+	}
+	if (mode === "spa") clientAuth = context;
+}
+/**
+* @internal Read and validate the server's opted-in identity snapshot. It
+* decides the initial route the server already authorized and, when the app
+* configures no `resolve`, stays the client identity for navigations. It is
+* never a credential; the server enforces access.
+*/
+function readHydratedAuth(envelope) {
+	hydratedAuth = void 0;
+	const value = envelope?.framework["au"];
+	if (value === void 0) return void 0;
+	const { authenticated, principal, tenant, scopes } = value ?? {};
+	if (typeof authenticated !== "boolean" || principal !== null && typeof principal?.id !== "string" || tenant !== null && typeof tenant !== "string" || scopes !== void 0 && !(Array.isArray(scopes) && scopes.every((s) => typeof s === "string"))) throw new TypeError("[Askr] Malformed hydration auth snapshot.");
+	return hydratedAuth = Object.freeze({
+		authenticated,
+		principal,
+		session: null,
+		tenant,
+		...scopes ? { scopes } : {}
+	});
+}
+/** @internal The hydration envelope without the auth snapshot. */
+function withoutHydratedAuth(envelope) {
+	if (!envelope || !("au" in envelope.framework)) return envelope;
+	const framework = { ...envelope.framework };
+	delete framework["au"];
+	return withPageFramework(envelope, framework);
+}
+/** @internal Identity for a request when no `resolve` is configured. */
+function unresolvedAuth(mode) {
+	return mode === "spa" && !getActiveRenderContext() && hydratedAuth || anonymous;
+}
+//#endregion
+//#region src/router/policy.ts
+/**
+* Records the public href of a redirect built from `to()`. It is an own
+* enumerable symbol, so `{ ...redirect(to(route)), status: 303 }` keeps it;
+* it only applies while `to` still equals that href. Trade-off: the key is
+* visible to `toEqual()` and `util.inspect()`, while `structuredClone()` and
+* JSON drop it, so a cloned decision is treated as logical and re-prefixed.
+*/
+const PUBLIC_REDIRECT_HREF = Symbol("askr.publicRedirectHref");
+/**
+* Validate a non-allow access decision before it leaves route resolution: a
+* redirect to a path-like target that resolves to another origin throws.
+*/
+function checkAccessDecision(decision) {
+	if (decision.kind === "redirect") resolveNavigationUrl(decision.to);
+	return decision;
+}
+/** Build a redirect decision; a typed destination's href is kept public. */
+function redirectDecision(to, init = {}, mapHref = (href) => href) {
+	const decision = {
+		kind: "redirect",
+		to: mapHref(typeof to === "string" ? to : to.href),
+		...init.status ? { status: init.status } : {},
+		...init.replace !== void 0 ? { replace: init.replace } : {}
+	};
+	if (typeof to !== "string") decision[PUBLIC_REDIRECT_HREF] = decision.to;
+	return checkAccessDecision(decision);
+}
+/**
+* Expose a redirect with a public target: a logical string gains the registry
+* `basePath`, while a typed destination is already public.
+*/
+function exposeRedirectDecision(decision, basePath) {
+	const publicHref = decision[PUBLIC_REDIRECT_HREF];
+	if (publicHref !== void 0 && publicHref === decision.to) return decision;
+	return {
+		...decision,
+		to: addLogicalRouteBasePath(decision.to, basePath)
+	};
+}
+/** Policy decision: allow the route to render. */
+function allow() {
+	return { kind: "allow" };
+}
+/**
+* Policy decision: redirect the visitor to `to`. A string is a logical path
+* that gains the registry `basePath`; a `to()` destination is used as-is.
+*/
+function redirect(to, init = {}) {
+	return redirectDecision(to, init);
+}
+/** Policy decision: deny the request with the given HTTP status. */
+function deny(status) {
+	return {
+		kind: "deny",
+		status
+	};
+}
+/** Policy decision: deny with 401 Unauthorized. */
+function unauthorized() {
+	return deny(401);
+}
+/** Policy decision: deny with 403 Forbidden. */
+function forbidden() {
+	return deny(403);
+}
+/** Policy decision: deny with 404 Not Found. */
+function notFound() {
+	return deny(404);
+}
+//#endregion
+//#region src/router/resolution.ts
+const routeRenderContexts = /* @__PURE__ */ new WeakMap();
+const routeRenderData = /* @__PURE__ */ new WeakMap();
+function getRouteRenderContext(result) {
+	return routeRenderContexts.get(result);
+}
+function getRouteRenderData(result) {
+	return routeRenderData.get(result);
+}
+function createRouteRenderResult(record, params, context, handler) {
+	const result = {
+		kind: "render",
+		handler,
+		params
+	};
+	Object.defineProperty(result, "record", {
+		value: record,
+		enumerable: false
+	});
+	routeRenderContexts.set(result, context);
+	return result;
+}
+function getDefaultRouteMode() {
+	return typeof window !== "undefined" ? "spa" : "ssr";
+}
+function withoutInitialRouteHydrationMetadata(envelope) {
+	return withPageFramework(envelope, withoutRouteHydrationMetadata(envelope.framework) ?? {});
+}
+/** @internal Bind resolved loader output to one route subtree and its hydration envelope. */
+function bindResolvedRouteData(handler, data, hydration) {
+	return (params, context) => {
+		const renderContext = getActiveRenderContext();
+		if (renderContext) {
+			const envelope = replacePageRoute(renderContext.renderData, data);
+			renderContext.renderData = hydration ? envelope : withoutInitialRouteHydrationMetadata(envelope);
+			const hydrationEnvelope = replacePageRoute(renderContext.hydrationData, hydration?.data ?? data);
+			renderContext.hydrationData = hydration ? withPageFramework(hydrationEnvelope, {
+				...hydrationEnvelope.framework,
+				["rh"]: hydration.metadata
+			}) : withoutInitialRouteHydrationMetadata(hydrationEnvelope);
+		}
+		return handler(params, context);
+	};
+}
+function hasRouteRenderData(result) {
+	return routeRenderData.has(result);
+}
+function buildRenderResult(record, params, context, request, telemetry, load, dataRuntime) {
+	const lazyImport = _preloadRouteRecord(record);
+	if (lazyImport) return lazyImport.then(() => buildLoadedRenderResult(record, params, context, request, telemetry, load, dataRuntime));
+	return buildLoadedRenderResult(record, params, context, request, telemetry, load, dataRuntime);
+}
+function buildLoadedRenderResult(record, params, context, request, telemetry, load, dataRuntime) {
+	const renderHandler = getRenderHandler(record);
+	const loader = context.mode !== "ssg" && load ? record.options?.loader : void 0;
+	const preload = record.options?.preload;
+	const active = getActiveRenderContext();
+	const prefetch = active?.queryPrefetch ?? createQueryPrefetchContext({
+		mode: context.mode === "ssg" ? "ssr" : context.mode,
+		request,
+		signal: context.signal,
+		runtime: active?.dataRuntime ?? dataRuntime,
+		telemetry
+	});
+	const runPreload = preload ? Promise.resolve(preload({
+		...context,
+		params,
+		request,
+		data: prefetch
+	})).then(() => void 0) : void 0;
+	if (loader) {
+		const load = () => withTelemetry(telemetry?.loader, { route: record.path }, () => loader({
+			...context,
+			params,
+			request
+		}));
+		const loaded = runPreload ? runPreload.then(load) : load();
+		const finalize = (data) => {
+			const hydration = context.mode === "ssr" ? prepareRouteHydrationData(data, record.options?.dehydrate, {
+				...context,
+				params,
+				request
+			}, context.href || context.pathname || record.path) : void 0;
+			const result = createRouteRenderResult(record, params, context, bindResolvedRouteData(renderHandler, data, hydration));
+			routeRenderData.set(result, data);
+			return result;
+		};
+		return isPromiseLike(loaded) ? Promise.resolve(loaded).then(finalize) : finalize(loaded);
+	}
+	if (runPreload) return runPreload.then(() => createRouteRenderResult(record, params, context, renderHandler));
+	return createRouteRenderResult(record, params, context, renderHandler);
+}
+function runPolicies(policies, context, record, params, request, telemetry, load, dataRuntime, start = 0) {
+	for (let index = start; index < policies.length; index += 1) {
+		const result = policies[index](context);
+		if (isPromiseLike(result)) return Promise.resolve(result).then((decision) => decision.kind === "allow" ? runPolicies(policies, context, record, params, request, telemetry, load, dataRuntime, index + 1) : checkAccessDecision(decision));
+		if (result.kind !== "allow") return checkAccessDecision(result);
+	}
+	return buildRenderResult(record, params, context, request, telemetry, load, dataRuntime);
+}
+function resolvePath(value, fallback, context) {
+	return typeof value === "function" ? value(context) : value ?? fallback;
+}
+function appendNext(path, href) {
+	const target = resolveNavigationUrl(path);
+	target.searchParams.set("next", href);
+	return formatNavigationUrl(target);
+}
+function mapAuthDecision(decision, context, options) {
+	if (decision.allowed) return { kind: "allow" };
+	if (decision.reason === "forbidden") return {
+		kind: "deny",
+		status: 403
+	};
+	const target = resolvePath(decision.reason === "unauthenticated" ? options?.loginPath : options?.authenticatedRedirectTo, decision.reason === "unauthenticated" ? "/login" : "/", context);
+	const finalize = (path) => redirectDecision(path, { replace: decision.reason === "unauthenticated" ? context.mode === "spa" : true }, (href) => decision.reason === "unauthenticated" ? appendNext(href, context.href) : href);
+	return isPromiseLike(target) ? Promise.resolve(target).then(finalize) : finalize(target);
+}
+function resolveMatchedRoute(record, params, context, authOptions, request, telemetry, load, dataRuntime) {
+	const continueResolution = (decision) => {
+		if (decision) {
+			const access = mapAuthDecision(decision, context, authOptions);
+			if (isPromiseLike(access)) return Promise.resolve(access).then((next) => next.kind === "allow" ? runPolicies(record.options.policies ?? [], context, record, params, request, telemetry, load, dataRuntime) : next);
+			if (access.kind !== "allow") return access;
+		}
+		return runPolicies(record.options.policies ?? [], context, record, params, request, telemetry, load, dataRuntime);
+	};
+	if (!record.options.auth) return continueResolution();
+	const decision = record.options.auth(context.auth);
+	return isPromiseLike(decision) ? Promise.resolve(decision).then(continueResolution) : continueResolution(decision);
+}
+/**
+* Callers may omit `signal`, and `RouteRequestOptions.signal` is optional in the
+* published contract. Route context still needs an `AbortSignal`, so this stands
+* in for "this caller supplied no cancellation". It never aborts: a route loader
+* receiving it cannot be cancelled through `context.signal`. Prefer passing a
+* real signal.
+*/
+const NEVER_ABORTED = new AbortController().signal;
+/** Resolve `target` against a route registry, applying auth/policies to produce a render/redirect/deny result. */
+function resolveRouteRequest(target, options) {
+	if (!options?.registry) throw new TypeError("resolveRouteRequest requires options.registry.");
+	const basePath = normalizeRouteBasePath(options.registry.manifest.basePath);
+	const logicalTarget = removeRouteBasePath(target, basePath);
+	if (logicalTarget === void 0) return null;
+	return withTelemetry(options.telemetry?.routeMatch, {}, () => {
+		const records = options.registry.manifest.records;
+		const match = getMatchingRouteRecord(logicalTarget, records);
+		if (!match) return null;
+		const mode = options.mode ?? getDefaultRouteMode();
+		const signal = options.signal ?? getActiveRenderContext()?.signal ?? NEVER_ABORTED;
+		const authOptions = getActiveRouteAuthOptions(options.auth ?? options.registry.manifest.auth);
+		const base = buildRouteContextBase(logicalTarget, match.params, {
+			mode,
+			signal
+		});
+		const exposeRedirect = (result) => result?.kind === "redirect" ? exposeRedirectDecision(result, basePath) : result;
+		const finalize = (authContext) => {
+			if (!signal.aborted) setCurrentAuth(authContext, mode);
+			const result = resolveMatchedRoute(match.record, match.params, buildRouteContext(logicalTarget, match.params, {
+				mode,
+				signal,
+				authContext
+			}), authOptions, options.request, options.telemetry, options.load !== false, options.dataRuntime);
+			if (!basePath) return result;
+			return isPromiseLike(result) ? Promise.resolve(result).then(exposeRedirect) : exposeRedirect(result);
+		};
+		if (options.authContext) return finalize(options.authContext);
+		if (!authOptions?.resolve) return finalize(unresolvedAuth(mode));
+		const resolved = authOptions.resolve(base);
+		return isPromiseLike(resolved) ? Promise.resolve(resolved).then(finalize) : finalize(resolved);
+	});
+}
+//#endregion
+export { withRouteTable as $, clearRouteState as A, getCurrentPathPrefix as B, removeRouteBasePath as C, _setActiveRouteAuthOptions as D, parseLocation as E, getCurrentInheritedMeta as F, getRouteRecords as G, getDefaultRouteAuthOptions as H, getCurrentInheritedPolicies as I, insertRecordSorted as J, hasActivePageScope as K, getCurrentLayoutChain as L, getActiveRouteBasePath as M, getActiveRoutes as N, addRouteToStores as O, getCurrentInheritedAuthRequirements as P, setDefaultRouteBasePath as Q, getCurrentPageChain as R, normalizeRouteBasePath as S, makeQuery as T, getDefaultRouteBasePath as U, getCurrentScopeKind as V, getRouteList as W, pushRegistrationScope as X, lockRouteRegistration as Y, setDefaultRouteAuthOptions as Z, getMatchingRouteRecord as _, resolveRouteRequest as a, lazyRouteData as at, addLogicalRouteBasePath as b, forbidden as c, encodePathSegment as ct, unauthorized as d, routeMatchKey as dt, Outlet as et, currentAuth as f, getRouteHydrationMetadata as ft, computeRouteActivityMatches as g, withoutRouteHydrationMetadata as gt, computeMatchesFromRoutes as h, validateRouteHydrationData as ht, hasRouteRenderData as i, lazy as it, createRouteTable as j, assertRouteRegistrationUnlocked as k, notFound as l, normalizeRouteSegmentName as lt, withoutHydratedAuth as m, prepareRouteHydrationData as mt, getRouteRenderContext as n, getRenderHandler as nt, allow as o, RouteDataLoadError as ot, readHydratedAuth as p, guardHydratedRouteData as pt, hasRegisteredRoutes as q, getRouteRenderData as r, _preloadRouteHandler as rt, deny as s, computeRank as st, bindResolvedRouteData as t, createRouteHandler as tt, redirect as u, parseSegments as ut, matchRoute as v, deepFreeze as w, addRouteBasePath as x, resolveRouteFromRoutes as y, getCurrentPageScope as z };