@askrjs/askr 0.0.28 → 0.0.30

package/dist/router/route.js

@@ -1 +1,599 @@
-import{match as R}from"./match.js";import{getCurrentComponentInstance as b}from"../runtime/component.js";import{getExecutionModel as N}from"../runtime/execution-model.js";import{getRenderContext as k}from"../ssr/context.js";const a=[],m=new Set,P=Symbol.for("__ASKR_HAS_ROUTES__");function y(e){try{const o=globalThis;o[P]=e}catch{}}y(!1);const h=new Map;function x(e){const o=e.endsWith("/")&&e!=="/"?e.slice(0,-1):e;return o==="/"?0:o.split("/").filter(Boolean).length}function v(e){const o=e.endsWith("/")&&e!=="/"?e.slice(0,-1):e;if(o==="/*")return 0;const r=o.split("/").filter(Boolean);let i=0;for(const t of r)t.startsWith("{")&&t.endsWith("}")?i+=2:t==="*"?i+=1:i+=3;return i}let w=null;function q(e){w=e}function z(e){try{const o=new URL(e,"http://localhost");return{pathname:o.pathname,search:o.search,hash:o.hash}}catch{return{pathname:"/",search:"",hash:""}}}function g(e){if(e&&typeof e=="object"&&!Object.isFrozen(e)){Object.freeze(e);for(const o of Object.keys(e)){const r=e[o];r&&typeof r=="object"&&g(r)}}return e}function C(e){const o=new URLSearchParams(e||""),r=new Map;for(const[t,s]of o.entries()){const n=r.get(t);n?n.push(s):r.set(t,[s])}return g({get(t){const s=r.get(t);return s?s[0]:null},getAll(t){const s=r.get(t);return s?[...s]:[]},has(t){return r.has(t)},toJSON(){const t={};for(const[s,n]of r.entries())t[s]=n.length>1?[...n]:n[0];return t}})}function B(e,o){const r=[];function i(t){const s=t.endsWith("/")&&t!=="/"?t.slice(0,-1):t;if(s==="/*")return 0;const n=s.split("/").filter(Boolean);let c=0;for(const u of n)u.startsWith("{")&&u.endsWith("}")?c+=2:u==="*"?c+=1:c+=3;return c}for(const t of o){const s=R(e,t.path);s.matched&&r.push({pattern:t.path,params:s.params,name:t.name,namespace:t.namespace,specificity:i(t.path)})}return r.sort((t,s)=>s.specificity-t.specificity),r.map(t=>({path:t.pattern,params:g({...t.params}),name:t.name,namespace:t.namespace}))}function F(){return k()?.routes??a}let p=!1;function D(){p=!0}function V(){p=!0}function X(){p=!1}function E(e,o,r){if(N()==="islands")throw new Error("Routes are not supported with islands. Use createSPA (client) or createSSR (server) instead.");if(typeof e>"u"){const c=b();if(!c)throw new Error("route() can only be called during component render execution. Call route() from inside your component function.");let u="/",l="",d="";const S=k();if(c.ssr&&S?.url){const f=z(S.url);u=f.pathname,l=f.search,d=f.hash}else if(typeof window<"u"&&window.location)u=window.location.pathname||"/",l=window.location.search||"",d=window.location.hash||"";else if(w){const f=z(w);u=f.pathname,l=f.search,d=f.hash}const O=g({...c.props||{}}),W=C(l),A=B(u,F());return Object.freeze({path:u,params:O,query:W,hash:d||null,matches:Object.freeze(A)})}const i=b();if(i&&i.ssr)throw new Error("route() cannot be called during SSR rendering. Register routes at module load time instead.");if(p)throw new Error("Route registration is locked after app startup. Register routes at module load time before calling createSPA or createSSR.");if(typeof o!="function")throw new Error("route(path, handler) requires a function handler that returns a VNode (e.g. () => <Page />). Passing JSX elements or VNodes directly is not supported.");const t={path:e,handler:o,namespace:r};a.push(t),y(!0);const s=x(e);let n=h.get(s);n||(n=[],h.set(s,n)),n.push(t),r&&m.add(r)}function $(){return[...a]}function I(e){return a.filter(o=>o.namespace===e)}function K(e){const o=a.length;for(let r=a.length-1;r>=0;r--)if(a[r].namespace===e){const i=a[r];a.splice(r,1);const t=x(i.path),s=h.get(t);if(s){const n=s.indexOf(i);n>=0&&s.splice(n,1)}}return m.delete(e),o-a.length}function Q(){a.length=0,m.clear(),h.clear(),p=!1,y(!1)}function _(e){if(e!=null&&typeof e=="function")return(o,r)=>{try{return e(o,r)}catch{return e(o)}}}function L(e,o,...r){const i=!e.startsWith("/"),t={path:e,handler:o,children:r.filter(Boolean),_isDescriptor:!0};if(!i){const s=_(o);if(o!=null&&!s)throw new Error("registerRoute(path, handler) requires a function handler. Passing JSX elements or VNodes directly is not supported.");s&&E(e,s);for(const n of t.children||[]){const u=`${e==="/"?"":e.replace(/\/$/,"")}/${n.path.replace(/^\//,"")}`.replace(/\/\//g,"/");if(n.handler){const l=_(n.handler);if(!l)throw new Error("registerRoute child handler must be a function. Passing JSX elements directly is not supported.");l&&E(u,l)}n.children&&n.children.length&&L(u,null,...n.children)}return t}return t}function Y(){return Array.from(m)}function G(e){return T(e,a)}function T(e,o){const r=e.endsWith("/")&&e!=="/"?e.slice(0,-1):e,i=r==="/"?0:r.split("/").filter(Boolean).length,t=[],s=o===a?h.get(i):void 0;if(s)for(const n of s){const c=R(r,n.path);c.matched&&t.push({route:n,specificity:v(n.path),params:c.params})}for(const n of o){if(s?.includes(n))continue;const c=R(r,n.path);c.matched&&t.push({route:n,specificity:v(n.path),params:c.params})}if(t.sort((n,c)=>c.specificity-n.specificity),t.length>0){const n=t[0];return{handler:n.route.handler,params:n.params}}return null}export{V as _lockRouteRegistrationForTests,X as _unlockRouteRegistrationForTests,Q as clearRoutes,Y as getLoadedNamespaces,I as getNamespaceRoutes,$ as getRoutes,D as lockRouteRegistration,L as registerRoute,G as resolveRoute,T as resolveRouteFromRoutes,E as route,q as setServerLocation,K as unloadNamespace};
+import { getCurrentComponentInstance } from "../runtime/component.js";
+import { computeRank, matchSegments, parseSegments } 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";
+//#region src/router/route.ts
+/**
+* Route definition, registration, and matching.
+*
+* Primary public authoring:
+*   - `registerRoutes(() => { ... }, options?)`
+*   - `group(options, () => { ... })`
+*   - `route(path, Component, options?)`
+*   - `fallback(Component)`
+*   - `currentRoute()` for render-time access
+*
+*/
+/** Legacy flat route array — kept for resolver and route() accessor backward compat. */
+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 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 serverLocation = null;
+function setServerLocation(url) {
+	serverLocation = url;
+}
+function isPromise(value) {
+	return value instanceof Promise;
+}
+function computeMatchesFromRoutes(pathname, routesList) {
+	const matches = [];
+	const normalized = pathname.endsWith("/") && pathname !== "/" ? pathname.slice(0, -1) : pathname;
+	const urlParts = normalized === "/" ? [] : normalized.split("/").filter(Boolean);
+	for (const r of routesList) {
+		const params = matchSegments(urlParts, cachedSegs(r));
+		if (params !== null) matches.push({
+			pattern: r.path,
+			params,
+			name: r.name,
+			namespace: r.namespace,
+			rank: cachedRank(r)
+		});
+	}
+	matches.sort((a, b) => b.rank - a.rank);
+	return matches.map((m) => ({
+		path: m.pattern,
+		params: deepFreeze({ ...m.params }),
+		name: m.name,
+		namespace: m.namespace
+	}));
+}
+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 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.
+*/
+let registrationLocked = false;
+function lockRouteRegistration() {
+	registrationLocked = true;
+}
+function validateRoutePath(path) {
+	if (!path.startsWith("/")) throw new Error(`Route path must begin with "/". Got: "${path}"`);
+	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}".`);
+	}
+}
+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();
+/**
+* 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 fallback(Component) {
+	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.");
+	route("/*", Component);
+}
+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({
+		layout: options.layout,
+		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 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() {
+	return readCurrentRouteSnapshot();
+}
+function route(path, Component, options) {
+	if (getExecutionModel() === "islands") throw new Error("Routes are not supported with islands. Use createSPA (client) or createSSR (server) instead.");
+	if (typeof path === "undefined") throw new Error("route() is only for route registration. Use currentRoute() inside components.");
+	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.");
+	validateRoutePath(path);
+	validateAccessMetadata(options ?? {}, {
+		authConfigured: getCurrentRegistrationSession().authConfigured,
+		state: getCurrentAccessScopeState()
+	});
+	const chain = getCurrentLayoutChain();
+	const segments = parseSegments(path);
+	const rank = computeRank(segments);
+	const isFallback = path === "/*";
+	const comp = Component;
+	const normalizedOptions = normalizeRouteOptions(options);
+	const policies = [...getCurrentInheritedPolicies(), ...normalizedOptions?.policies ?? []];
+	const handler = (params) => {
+		let content = comp(params);
+		for (let i = chain.length - 1; i >= 0; i--) content = chain[i].component({ children: content });
+		return content;
+	};
+	insertRecordSorted({
+		path,
+		component: comp,
+		segments,
+		rank,
+		layoutChain: chain,
+		options: normalizedOptions ? {
+			...normalizedOptions,
+			...policies.length > 0 ? { policies } : {}
+		} : policies.length > 0 ? { policies } : {},
+		isFallback,
+		handler
+	});
+	addRouteToStores({
+		path,
+		handler,
+		namespace: normalizedOptions?.namespace ?? options?.namespace
+	});
+}
+/**
+* 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) {
+		records.push(record);
+		addRouteToStores({
+			path: record.path,
+			handler: record.handler,
+			namespace: record.options.namespace
+		});
+	}
+	records.sort((a, b) => b.rank - a.rank);
+}
+/**
+* Get all registered routes (flat list, insertion order).
+* Prefer `getManifest()` when metadata (loader, policies, entries) is needed.
+*/
+function getRoutes() {
+	return [...routes];
+}
+/** Get routes for a specific namespace. */
+function getNamespaceRoutes(namespace) {
+	return routes.filter((r) => r.namespace === namespace);
+}
+/** Unload all routes from a namespace (for MFE unmounting). */
+function unloadNamespace(namespace) {
+	const before = routes.length;
+	for (let i = routes.length - 1; i >= 0; i--) if (routes[i].namespace === namespace) {
+		const removed = routes[i];
+		routes.splice(i, 1);
+		const depth = getDepth(removed.path);
+		const depthRoutes = routesByDepth.get(depth);
+		if (depthRoutes) {
+			const idx = depthRoutes.indexOf(removed);
+			if (idx >= 0) depthRoutes.splice(idx, 1);
+		}
+	}
+	for (let i = records.length - 1; i >= 0; i--) if (records[i].options.namespace === namespace) records.splice(i, 1);
+	namespaces.delete(namespace);
+	return before - routes.length;
+}
+/** 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();
+}
+/**
+* Get all loaded namespaces (MFE identifiers)
+*/
+function getLoadedNamespaces() {
+	return Array.from(namespaces);
+}
+/**
+* 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 = normalized === "/" ? [] : normalized.split("/").filter(Boolean);
+	for (const record of records) {
+		const params = matchSegments(urlParts, record.segments);
+		if (params !== null) return {
+			handler: record.handler,
+			params
+		};
+	}
+	return 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 = normalized === "/" ? [] : normalized.split("/").filter(Boolean);
+	for (const record of routeRecords) {
+		const params = matchSegments(urlParts, record.segments);
+		if (params !== null) return {
+			record,
+			params
+		};
+	}
+	return null;
+}
+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 buildRenderResult(record, params) {
+	return {
+		kind: "render",
+		handler: record.handler,
+		params
+	};
+}
+function continueRoutePolicies(policies, context, record, params, startIndex = 0) {
+	for (let index = startIndex; index < policies.length; index += 1) {
+		const policyResult = policies[index](context);
+		if (isPromise(policyResult)) return 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);
+}
+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);
+	if (policies.length === 0) return buildRenderResult(record, params);
+	const signal = options.signal ?? getRenderContext()?.signal ?? new AbortController().signal;
+	const mode = options.mode ?? getDefaultRouteMode();
+	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 (isPromise(authState)) return 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 normalized = pathname.endsWith("/") && pathname !== "/" ? pathname.slice(0, -1) : pathname;
+	const urlParts = normalized === "/" ? [] : normalized.split("/").filter(Boolean);
+	const sorted = cachedSortedList(routeList);
+	let bestHandler = null;
+	let bestParams = {};
+	let bestRank = -Infinity;
+	for (const r of sorted) {
+		const rank = cachedRank(r);
+		if (rank < bestRank) break;
+		if (bestHandler !== null && rank === bestRank) continue;
+		const params = matchSegments(urlParts, cachedSegs(r));
+		if (params !== null) {
+			bestHandler = r.handler;
+			bestParams = params;
+			bestRank = rank;
+		}
+	}
+	return bestHandler !== null ? {
+		handler: bestHandler,
+		params: bestParams
+	} : null;
+}
+//#endregion
+export { _applyManifest, _drainLazy, _setActiveRouteAuthOptions, _snapshotLazy, clearRoutes, currentRoute, fallback, getLoadedNamespaces, getManifest, getNamespaceRoutes, getRoutes, group, lazy, lockRouteRegistration, registerRoutes, resolveRoute, resolveRouteFromRoutes, resolveRouteRequest, route, setServerLocation, unloadNamespace };
+
+//# sourceMappingURL=route.js.map