@askrjs/askr 0.0.48 → 0.0.50

package/dist/router/route.js

@@ -1,854 +1,8 @@
-import { ELEMENT_TYPE, Fragment } from "../common/jsx.js";
-import { defineContext, readContext } from "../runtime/context.js";
-import { markReactivePropsDirtySource, markReadableDerivedSubscribersDirty, notifyReadableReaders, recordReadableRead } from "../runtime/readable.js";
-import { isPromiseLike } from "../common/promise.js";
-import { getCurrentComponentInstance } from "../runtime/component.js";
-import { ROUTE_ROOT_COMPONENT } from "../common/router-internal.js";
-import { computeRank, matchSegments, normalizeRouteSegmentName, parseSegments, splitPathSegments } from "./match.js";
-import { requireAuth, requireGuest, requirePermission, requireRole } from "./policy.js";
-import { buildRouteContext, buildRouteContextBase, deepFreeze, makeQuery, parseLocation } from "./route-context.js";
-import { getExecutionModel } from "../runtime/execution-model.js";
-import { getRenderContext } from "../ssr/context.js";
-import { syncRouteActivitySnapshot } from "../common/route-activity.js";
-//#region src/router/route.ts
-/**
-* Route definition, registration, and matching.
-*
-* Primary public authoring:
-*   - `registerRoutes(() => { ... }, options?)`
-*   - `group(options, () => { ... })`
-*   - `page(path, Component, () => { ... })`
-*   - `index(Component, options?)`
-*   - `route(path, Component, options?)`
-*   - `fallback(Component)`
-*   - `Outlet()` for page child rendering
-*   - `currentRoute()` for render-time access
-*
-*/
-const routes = [];
-/** Normalized route records built by the declarative registration API. */
-const records = [];
-/** Active registration scope stack during module-load-time registration. */
-const registrationScopeStack = [];
-const registrationSessionStack = [];
-const namespaces = /* @__PURE__ */ new Set();
-let registrationLocked = false;
-let defaultRouteAuthOptions;
-let activeClientRouteAuthOptions;
-const HAS_ROUTES_KEY = Symbol.for("__ASKR_HAS_ROUTES__");
-function setHasRoutes(value) {
-	try {
-		const g = globalThis;
-		g[HAS_ROUTES_KEY] = value;
-	} catch {}
-}
-setHasRoutes(false);
-const routesByDepth = /* @__PURE__ */ new Map();
-/**
-* Parse route path depth
-*/
-function getDepth(path) {
-	const normalized = path.endsWith("/") && path !== "/" ? path.slice(0, -1) : path;
-	return normalized === "/" ? 0 : normalized.split("/").filter(Boolean).length;
-}
-/** Pre-parsed segments for an externally supplied Route object. */
-const routeSegsCache = /* @__PURE__ */ new WeakMap();
-/** Pre-computed rank for an externally supplied Route object. */
-const routeRankCache = /* @__PURE__ */ new WeakMap();
-/** A rank-descending sorted copy of an external readonly Route array. */
-const sortedListCache = /* @__PURE__ */ new WeakMap();
-function cachedSegs(r) {
-	let s = routeSegsCache.get(r);
-	if (!s) {
-		s = parseSegments(r.path);
-		routeSegsCache.set(r, s);
-	}
-	return s;
-}
-function cachedRank(r) {
-	let n = routeRankCache.get(r);
-	if (n === void 0) {
-		n = computeRank(cachedSegs(r));
-		routeRankCache.set(r, n);
-	}
-	return n;
-}
-function cachedSortedList(routeList) {
-	let sorted = sortedListCache.get(routeList);
-	if (!sorted) {
-		sorted = [...routeList].sort((a, b) => cachedRank(b) - cachedRank(a));
-		sortedListCache.set(routeList, sorted);
-	}
-	return sorted;
-}
-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 matchFallbackPrefix(pathname, fallbackPrefix) {
-	const normalizedPath = pathname.endsWith("/") && pathname !== "/" ? pathname.slice(0, -1) : pathname;
-	const normalizedPrefix = fallbackPrefix.endsWith("/") && fallbackPrefix !== "/" ? fallbackPrefix.slice(0, -1) : fallbackPrefix;
-	if (normalizedPrefix === "/") {
-		const urlParts = splitPathSegments(normalizedPath);
-		return { "*": urlParts.length === 0 ? "/" : urlParts.length === 1 ? urlParts[0] : "/" + urlParts.join("/") };
-	}
-	if (normalizedPath !== normalizedPrefix && !normalizedPath.startsWith(`${normalizedPrefix}/`)) return null;
-	const remainderParts = splitPathSegments(normalizedPath === normalizedPrefix ? "/" : normalizedPath.slice(normalizedPrefix.length));
-	return { "*": remainderParts.length === 0 ? "/" : remainderParts.length === 1 ? remainderParts[0] : "/" + remainderParts.join("/") };
-}
-function computeMatchesFromRoutes(pathname, routesList) {
-	const bestMatch = routesList === routes ? getMatchingRecord(pathname, records) : 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 = getMatchingRecord(pathname, routeRecords);
-	if (!bestMatch) return [];
-	return [{
-		path: bestMatch.record.path,
-		params: deepFreeze({ ...bestMatch.params }),
-		namespace: bestMatch.record.options.namespace
-	}];
-}
-function computeRouteActivityMatches(pathname, options = {}) {
-	if (options.routes) return computeMatchesFromRoutes(pathname, options.routes);
-	if (options.manifest) return computeMatchesFromRouteRecords(pathname, options.manifest.records);
-	return computeMatchesFromRoutes(pathname, getActiveRoutes());
-}
-function findBestResolvedRouteFromRoutes(pathname, routeList) {
-	const normalized = pathname.endsWith("/") && pathname !== "/" ? pathname.slice(0, -1) : pathname;
-	const urlParts = splitPathSegments(normalized);
-	const sorted = cachedSortedList(routeList);
-	let bestRoute = null;
-	let bestParams = {};
-	let bestRank = -Infinity;
-	for (const route of sorted) {
-		if (route.fallbackPrefix) continue;
-		const rank = cachedRank(route);
-		if (rank < bestRank) break;
-		if (bestRoute !== null && rank === bestRank) continue;
-		const params = matchSegments(urlParts, cachedSegs(route));
-		if (params !== null) {
-			bestRoute = route;
-			bestParams = params;
-			bestRank = rank;
-		}
-	}
-	if (bestRoute !== null) return {
-		route: bestRoute,
-		params: bestParams
-	};
-	let bestFallback = null;
-	let bestFallbackParams = null;
-	let bestPrefixLength = -1;
-	for (const route of routeList) {
-		const internalRoute = route;
-		if (!internalRoute.fallbackPrefix) continue;
-		const params = matchFallbackPrefix(normalized, internalRoute.fallbackPrefix);
-		if (params === null) continue;
-		if (internalRoute.fallbackPrefix.length > bestPrefixLength) {
-			bestFallback = internalRoute;
-			bestFallbackParams = params;
-			bestPrefixLength = internalRoute.fallbackPrefix.length;
-		}
-	}
-	return bestFallback && bestFallbackParams ? {
-		route: bestFallback,
-		params: bestFallbackParams
-	} : null;
-}
-function getActiveRoutes() {
-	return getRenderContext()?.routes ?? routes;
-}
-function getActiveRouteAuthOptions(override) {
-	if (override) return override;
-	return getRenderContext()?.routeAuth ?? activeClientRouteAuthOptions ?? defaultRouteAuthOptions;
-}
-function _setActiveRouteAuthOptions(auth) {
-	activeClientRouteAuthOptions = auth;
-}
-function getCurrentRegistrationSession() {
-	return registrationSessionStack[registrationSessionStack.length - 1] ?? { authConfigured: !!defaultRouteAuthOptions?.resolve };
-}
-function getCurrentAccessScopeState() {
-	return registrationScopeStack[registrationScopeStack.length - 1]?.state ?? {
-		guestOnly: false,
-		authenticated: false
-	};
-}
-function getCurrentLayoutChain() {
-	const layoutChain = [];
-	for (const scope of registrationScopeStack) if (scope.layout) layoutChain.push({ component: scope.layout });
-	return layoutChain;
-}
-function getCurrentPageChain() {
-	const pageChain = [];
-	for (const scope of registrationScopeStack) if (scope.page) pageChain.push({ component: scope.page });
-	return pageChain;
-}
-function hasActivePageScope() {
-	return registrationScopeStack.some((scope) => !!scope.page);
-}
-function getCurrentPageScope() {
-	for (let index = registrationScopeStack.length - 1; index >= 0; index -= 1) {
-		const scope = registrationScopeStack[index];
-		if (scope.kind === "page") return scope;
-	}
-	return null;
-}
-function getCurrentScopeKind() {
-	return registrationScopeStack[registrationScopeStack.length - 1]?.kind ?? null;
-}
-function getCurrentPathPrefix() {
-	return registrationScopeStack[registrationScopeStack.length - 1]?.pathPrefix ?? "";
-}
-function getCurrentInheritedPolicies() {
-	const policies = [];
-	for (const scope of registrationScopeStack) if (scope.policies.length > 0) policies.push(...scope.policies);
-	return policies;
-}
-/**
-* Prevent route registrations after the app has started.
-* Enforced in production; tests may unlock explicitly.
-*/
-function lockRouteRegistration() {
-	registrationLocked = true;
-}
-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 insertRecordSorted(record) {
-	let lo = 0;
-	let hi = records.length;
-	while (lo < hi) {
-		const mid = lo + hi >>> 1;
-		if (records[mid].rank >= record.rank) lo = mid + 1;
-		else hi = mid;
-	}
-	records.splice(lo, 0, record);
-}
-function addRouteToStores(routeObj) {
-	routes.push(routeObj);
-	setHasRoutes(true);
-	const depth = getDepth(routeObj.path);
-	let depthRoutes = routesByDepth.get(depth);
-	if (!depthRoutes) {
-		depthRoutes = [];
-		routesByDepth.set(depth, depthRoutes);
-	}
-	depthRoutes.push(routeObj);
-	if (routeObj.namespace) namespaces.add(routeObj.namespace);
-}
-/** Promises from in-flight lazy() imports, drained by createSPA / hydrateSPA. */
-const pendingLazy = /* @__PURE__ */ new Set();
-const outletContext = defineContext(null);
-function Outlet() {
-	return {
-		$$typeof: ELEMENT_TYPE,
-		type: Fragment,
-		props: { children: readContext(outletContext) },
-		key: null
-	};
-}
-/**
-* Snapshot the current in-flight lazy() imports.
-* Boot uses this before clearing route state so manifest-based startup can
-* still await chunks that were kicked off during route module evaluation.
-*/
-function _snapshotLazy() {
-	return [...pendingLazy];
-}
-/**
-* Declare a code-split route component. The `import()` fires immediately at
-* module evaluation time (creating a bundler split point), and the resolved
-* chunk is guaranteed to be available before the app mounts — so the renderer
-* always receives a plain synchronous function.
-*
-* ```ts
-* registerRoutes(() => {
-*   group({ layout: AppLayout }, () => {
-*     route('/', lazy(() => import('./pages/landing')));
-*     route('/dashboard', lazy(() => import('./pages/dashboard')));
-*   });
-* });
-* ```
-*
-* The module must export the component as its **default** export:
-* ```ts
-* // pages/dashboard.tsx
-* export default function DashboardPage() { … }
-* ```
-*/
-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);
-	});
-}
-/**
-* Wait for all pending `lazy()` imports to settle.
-* Called automatically by `createSPA` / `hydrateSPA` before mounting.
-*/
-function _drainLazy(additionalPending = []) {
-	const combined = new Set([...additionalPending, ...pendingLazy]);
-	if (combined.size === 0) return Promise.resolve();
-	return Promise.allSettled(combined).then(() => void 0);
-}
-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 (!registrationScopeStack.every((scope) => scope.policies.length === 0 && !scope.state.guestOnly && !scope.state.authenticated)) 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 pushRegistrationScope(scope, fn) {
-	registrationScopeStack.push(scope);
-	try {
-		fn();
-	} finally {
-		registrationScopeStack.pop();
-	}
-}
-function pushGroupScope(options, fn) {
-	validateAccessMetadata(options, {
-		authConfigured: getCurrentRegistrationSession().authConfigured,
-		state: getCurrentAccessScopeState()
-	});
-	const policies = compileNodePolicies(options);
-	pushRegistrationScope({
-		kind: "group",
-		pathPrefix: getCurrentPathPrefix(),
-		layout: options.layout,
-		policies,
-		state: nextAccessScopeState(options, getCurrentAccessScopeState())
-	}, 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.");
-	validateAccessMetadata(options, {
-		authConfigured: getCurrentRegistrationSession().authConfigured,
-		state: getCurrentAccessScopeState()
-	});
-	const policies = compileNodePolicies(options);
-	pushRegistrationScope({
-		kind: "page",
-		pathPrefix: resolvePageScopePath(path),
-		page: Component,
-		hasIndex: false,
-		policies,
-		state: nextAccessScopeState(options, getCurrentAccessScopeState())
-	}, fn);
-}
-function hasBuiltInAuthMetadata(node) {
-	return node.auth !== void 0 || !!node.role || !!node.permission;
-}
-function validateSameNodeAccessMetadata(node) {
-	if (node.auth === "guest" && (!!node.role || !!node.permission)) throw new Error("Guest-only routes cannot be combined with role or permission requirements.");
-}
-function validateAccessMetadata(node, context) {
-	validateSameNodeAccessMetadata(node);
-	const requiresAuthenticated = node.auth === true || !!node.role || !!node.permission;
-	if (node.auth === "guest" && (context.state.authenticated || !!node.role || !!node.permission)) throw new Error("Guest-only routes cannot be combined with authenticated access requirements.");
-	if (context.state.guestOnly && requiresAuthenticated) throw new Error("Child routes cannot weaken a guest-only access scope with authenticated requirements.");
-	if (hasBuiltInAuthMetadata(node) && !context.authConfigured) throw new Error("Routes using `auth`, `role`, or `permission` require `auth.resolve` in registerRoutes(...).");
-}
-function nextAccessScopeState(node, state) {
-	const requiresAuthenticated = node.auth === true || !!node.role || !!node.permission;
-	return {
-		guestOnly: state.guestOnly || node.auth === "guest",
-		authenticated: state.authenticated || requiresAuthenticated
-	};
-}
-function compileNodePolicies(node) {
-	validateSameNodeAccessMetadata(node);
-	const compiled = [];
-	if (node.auth === true) compiled.push(requireAuth());
-	else if (node.auth === "guest") compiled.push(requireGuest());
-	if (node.role) compiled.push(requireRole(node.role));
-	if (node.permission) compiled.push(requirePermission(node.permission));
-	if (node.policies?.length) compiled.push(...node.policies);
-	return compiled;
-}
-function normalizeRouteOptions(options) {
-	if (!options) return;
-	const loader = options.loader;
-	const policies = compileNodePolicies(options);
-	if (!loader && !options.entries && policies.length === 0 && !options.title && !options.namespace && options.auth === void 0 && !options.role && !options.permission) return;
-	return {
-		...loader ? { loader } : {},
-		...options.entries ? { entries: options.entries } : {},
-		...options.auth !== void 0 ? { auth: options.auth } : {},
-		...options.role ? { role: options.role } : {},
-		...options.permission ? { permission: options.permission } : {},
-		...policies.length > 0 ? { policies } : {},
-		...options.title ? { title: options.title } : {},
-		...options.namespace ? { namespace: options.namespace } : {}
-	};
-}
-function applyPageChain(pageChain, params, content, deferComponents = false) {
-	let nextContent = content;
-	for (let i = pageChain.length - 1; i >= 0; i--) nextContent = outletContext.Scope({
-		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: null,
-		...routeRoot ? { [ROUTE_ROOT_COMPONENT]: true } : {}
-	};
-}
-function createRouteHandler(component, pageChain, layoutChain, deferComponents = false) {
-	return (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--) content = layoutChain[i].component({ children: content });
-		return content;
-	};
-}
-function getRenderHandler(record) {
-	return record.renderHandler ?? createRouteHandler(record.component, record.pageChain, record.layoutChain, true);
-}
-function registerRouteAtResolvedPath(path, Component, options, metadata) {
-	validateRoutePath(path);
-	validateAccessMetadata(options ?? {}, {
-		authConfigured: getCurrentRegistrationSession().authConfigured,
-		state: getCurrentAccessScopeState()
-	});
-	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 handler = createRouteHandler(comp, pageChain, chain);
-	const renderHandler = createRouteHandler(comp, pageChain, chain, true);
-	insertRecordSorted({
-		path,
-		component: comp,
-		segments,
-		rank,
-		layoutChain: chain,
-		pageChain,
-		options: normalizedOptions ? {
-			...normalizedOptions,
-			...policies.length > 0 ? { policies } : {}
-		} : policies.length > 0 ? { policies } : {},
-		isFallback,
-		handler,
-		renderHandler,
-		...metadata?.fallbackPrefix ? { fallbackPrefix: metadata.fallbackPrefix } : {}
-	});
-	addRouteToStores({
-		path,
-		handler,
-		namespace: normalizedOptions?.namespace ?? options?.namespace,
-		...metadata?.fallbackPrefix ? { fallbackPrefix: metadata.fallbackPrefix } : {}
-	});
-}
-function registerRoutes(definition, options = {}) {
-	defaultRouteAuthOptions = options.auth;
-	registrationSessionStack.push({ authConfigured: !!options.auth?.resolve });
-	try {
-		definition();
-	} finally {
-		registrationSessionStack.pop();
-	}
-}
-function readCurrentRouteSnapshot() {
-	const instance = getCurrentComponentInstance();
-	if (!instance) throw new Error("currentRoute() can only be called during component render execution. Call currentRoute() from inside your component function.");
-	let pathname = "/";
-	let search = "";
-	let hash = "";
-	const renderContext = getRenderContext();
-	if (instance.ssr && renderContext?.url) {
-		const parsed = parseLocation(renderContext.url);
-		pathname = parsed.pathname;
-		search = parsed.search;
-		hash = parsed.hash;
-	} else if (typeof window !== "undefined" && window.location) {
-		pathname = window.location.pathname || "/";
-		search = window.location.search || "";
-		hash = window.location.hash || "";
-	} else if (serverLocation) {
-		const parsed = parseLocation(serverLocation);
-		pathname = parsed.pathname;
-		search = parsed.search;
-		hash = parsed.hash;
-	}
-	const query = makeQuery(search);
-	const matches = computeMatchesFromRoutes(pathname, getActiveRoutes());
-	const instanceParams = instance.props;
-	const params = deepFreeze({ ...Object.keys(instanceParams).length > 0 ? instanceParams : 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);
-}
-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.");
-	if (registrationLocked) throw new Error("Route registration is locked after app startup. Register routes at module load time before calling createSPA or createSSR.");
-	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.");
-	registerRouteAtResolvedPath(resolveRouteRegistrationPath(path), Component, options);
-}
-/**
-* Return the normalized route manifest built from registered route definitions.
-*
-* Pass this to `createSPA`, `hydrateSPA`, or `renderToString` as the
-* authoritative routing input:
-*
-* ```ts
-* import { getManifest } from '@askrjs/askr/router';
-* await createSPA({ root: '#app', manifest: getManifest() });
-* ```
-*/
-function getManifest() {
-	return {
-		records: [...records],
-		...defaultRouteAuthOptions ? { auth: defaultRouteAuthOptions } : {}
-	};
-}
-/**
-* Internal: apply a pre-built manifest to the runtime stores without running
-* route() again. Called by createSPA / hydrateSPA when a manifest is passed.
-*/
-function _applyManifest(manifest) {
-	defaultRouteAuthOptions = 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 } : {}
-		});
-	}
-}
-/**
-* Get all registered routes (flat list, insertion order).
-* Prefer `getManifest()` when metadata (loader, policies, entries) is needed.
-*/
-function getRoutes() {
-	return [...routes];
-}
-/** Clear all registered routes and records (testing / boot reset). */
-function clearRoutes() {
-	routes.length = 0;
-	records.length = 0;
-	namespaces.clear();
-	routesByDepth.clear();
-	registrationScopeStack.length = 0;
-	registrationSessionStack.length = 0;
-	registrationLocked = false;
-	defaultRouteAuthOptions = void 0;
-	activeClientRouteAuthOptions = void 0;
-	setHasRoutes(false);
-	pendingLazy.clear();
-}
-function findBestScopedFallbackRecord(pathname, routeRecords) {
-	let bestRecord = null;
-	let bestParams = null;
-	let bestPrefixLength = -1;
-	for (const routeRecord of routeRecords) {
-		const record = routeRecord;
-		if (!record.fallbackPrefix) continue;
-		const params = matchFallbackPrefix(pathname, record.fallbackPrefix);
-		if (params === null) continue;
-		if (record.fallbackPrefix.length > bestPrefixLength) {
-			bestRecord = record;
-			bestParams = params;
-			bestPrefixLength = record.fallbackPrefix.length;
-		}
-	}
-	return bestRecord && bestParams ? {
-		record: bestRecord,
-		params: bestParams
-	} : null;
-}
-/**
-* Resolve a path to a route handler.
-*
-* Hot path: walks the module-level `records[]` array which is kept sorted by
-* rank descending at registration time — so the first `matchSegments` hit is
-* always the most specific match.  No per-call allocations for the common
-* case of purely-static routes.
-*/
-function resolveRoute(pathname) {
-	const normalized = pathname.endsWith("/") && pathname !== "/" ? pathname.slice(0, -1) : pathname;
-	const urlParts = splitPathSegments(normalized);
-	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 getMatchingRecord(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 getRoutePolicies(options) {
-	if (!options) return [];
-	if (options.policies?.length) return options.policies;
-	return compileNodePolicies(options);
-}
-function getDefaultRouteMode() {
-	if (typeof window !== "undefined") return "spa";
-	return "ssr";
-}
-function createRenderDataAwareHandler(handler, data) {
-	return (params, context) => {
-		const renderContext = getRenderContext();
-		if (renderContext) renderContext.renderData = data ?? null;
-		return handler(params, context);
-	};
-}
-function buildRenderResult(record, params, mode) {
-	const renderHandler = getRenderHandler(record);
-	const loader = mode === "ssr" ? record.options?.loader : void 0;
-	if (loader) {
-		const loaded = loader({ params });
-		const finalize = (data) => ({
-			kind: "render",
-			handler: createRenderDataAwareHandler(renderHandler, data),
-			params
-		});
-		if (isPromiseLike(loaded)) return Promise.resolve(loaded).then((data) => finalize(data));
-		return finalize(loaded);
-	}
-	return {
-		kind: "render",
-		handler: renderHandler,
-		params
-	};
-}
-function continueRoutePolicies(policies, context, record, params, startIndex = 0) {
-	for (let index = startIndex; index < policies.length; index += 1) {
-		const policyResult = policies[index](context);
-		if (isPromiseLike(policyResult)) return Promise.resolve(policyResult).then((next) => {
-			if (next.kind !== "allow") return next;
-			return continueRoutePolicies(policies, context, record, params, index + 1);
-		});
-		if (policyResult.kind !== "allow") return policyResult;
-	}
-	return buildRenderResult(record, params, context.mode);
-}
-function resolveRouteRequest(target, options = {}) {
-	const match = getMatchingRecord(target, options.manifest?.records ?? records);
-	if (!match) return null;
-	const { record, params } = match;
-	const policies = getRoutePolicies(record.options);
-	const mode = options.mode ?? getDefaultRouteMode();
-	if (policies.length === 0) return buildRenderResult(record, params, mode);
-	const signal = options.signal ?? getRenderContext()?.signal ?? new AbortController().signal;
-	const auth = getActiveRouteAuthOptions(options.auth ?? options.manifest?.auth);
-	const baseContext = buildRouteContextBase(target, params, {
-		mode,
-		signal
-	});
-	const finalize = (authState) => continueRoutePolicies(policies, buildRouteContext(target, params, {
-		mode,
-		signal,
-		auth,
-		session: authState.session,
-		user: authState.user
-	}), record, params);
-	if (!auth?.resolve) return finalize({
-		session: null,
-		user: null
-	});
-	const authState = auth.resolve(baseContext);
-	if (isPromiseLike(authState)) return Promise.resolve(authState).then((next) => finalize(next));
-	return finalize(authState);
-}
-/**
-* Resolve a path against an explicit route list (e.g. an SSR per-render
-* context).  When called with the global `routes` array this delegates to
-* the faster `resolveRoute` which uses pre-sorted `records[]`.
-*
-* For externally supplied lists the function:
-*   1. Builds a rank-sorted copy of the list on first call and caches it
-*      in a WeakMap so subsequent resolutions against the same list pay
-*      zero sort cost.
-*   2. Uses pre-parsed `ParsedSegment[]` from a WeakMap cache so no string
-*      splitting or segment parsing occurs on the hot path.
-*   3. Uses a running-best with an early-exit once the sorted list reaches
-*      a rank that cannot beat the current best match.
-*/
-function resolveRouteFromRoutes(pathname, routeList) {
-	if (routeList === routes) return resolveRoute(pathname);
-	const match = findBestResolvedRouteFromRoutes(pathname, routeList);
-	return match ? {
-		handler: match.route.handler,
-		params: match.params
-	} : null;
-}
-function _resolveRouteMatchFromRoutes(pathname, routeList) {
-	return findBestResolvedRouteFromRoutes(pathname, routeList);
-}
-//#endregion
-export { Outlet, _applyManifest, _drainLazy, _resolveRouteMatchFromRoutes, _setActiveRouteAuthOptions, _snapshotLazy, clearRoutes, computeRouteActivityMatches, currentRoute, fallback, getManifest, getRoutes, group, index, lazy, lockRouteRegistration, page, registerRoutes, resolveRouteFromRoutes, resolveRouteRequest, route, setServerLocation, syncCurrentRouteSnapshot };
-
-//# sourceMappingURL=route.js.map
+import { Outlet } from "./rendering.js";
+import { _setActiveRouteAuthOptions, getRoutes, hasRegisteredRoutes, lockRouteRegistration } from "./store.js";
+import { fallback, group, index, page, registerRoutes, route } from "./authoring.js";
+import { computeRouteActivityMatches, resolveRouteFromRoutes, resolveRouteRequest } from "./resolution.js";
+import { currentRoute, setServerLocation, syncCurrentRouteSnapshot } from "./activity.js";
+import { _drainLazy, _snapshotLazy, _snapshotRouteSourceLazy, lazy } from "./lazy.js";
+import { _applyManifest, clearRoutes, createRouteRegistry, getManifest } from "./manifest.js";
+export { Outlet, _applyManifest, _drainLazy, _setActiveRouteAuthOptions, _snapshotLazy, _snapshotRouteSourceLazy, clearRoutes, computeRouteActivityMatches, createRouteRegistry, currentRoute, fallback, getManifest, getRoutes, group, hasRegisteredRoutes, index, lazy, lockRouteRegistration, page, registerRoutes, resolveRouteFromRoutes, resolveRouteRequest, route, setServerLocation, syncCurrentRouteSnapshot };