@askrjs/askr 0.0.64 → 0.0.66

package/README.md

@@ -54,16 +54,16 @@ Startup belongs in `@askrjs/askr/boot`. Routing helpers live in
 
 ```ts
 import { createSPA } from '@askrjs/askr/boot';
-import { getManifest, registerRoutes, route } from '@askrjs/askr/router';
+import { createRouteRegistry, route } from '@askrjs/askr/router';
 
-registerRoutes(() => {
-  route('/', () => <Home />);
-  route('/about', () => <About />);
+const registry = createRouteRegistry(() => {
+  route('/', Home);
+  route('/about', About);
 });
 
 createSPA({
   root: document.body,
-  manifest: getManifest(),
+  registry,
 });
 ```
 

package/dist/authoring-Di8MInO-.js

@@ -0,0 +1,200 @@
+import { f as getCurrentComponentInstance } from "./component-scope-CC3cojX9.js";
+import { T as getExecutionModel, x as createRouteHandler } from "./deferred-Eh9bCVGH.js";
+import { A as insertRecordSorted, C as getCurrentPathPrefix, I as computeRank, L as normalizeRouteSegmentName, M as pushRegistrationScope, O as hasActivePageScope, R as parseSegments, S as getCurrentPageScope, _ as getCurrentInheritedAuthRequirements, b as getCurrentLayoutChain, f as addRouteToStores, p as assertRouteRegistrationUnlocked, v as getCurrentInheritedMeta, w as getCurrentScopeKind, x as getCurrentPageChain, y as getCurrentInheritedPolicies } from "./route-matching-DLBWDeXX.js";
+import { allOf } from "@askrjs/auth";
+//#region src/router/access.ts
+function compileNodePolicies(node) {
+	return node.policies ? [...node.policies] : [];
+}
+//#endregion
+//#region src/router/authoring.ts
+function validateRoutePath(path) {
+	if (!path.startsWith("/")) throw new Error(`Route path must begin with "/". Got: "${path}"`);
+	if (/\/{2,}/.test(path)) throw new Error("Route path cannot contain consecutive slashes.");
+	if (/:([^/{}]+)/.test(path)) {
+		const suggested = path.replace(/:([^/{}]+)/g, "{$1}");
+		throw new Error(`Route parameter syntax uses {name} interpolation, not :name. Use "${suggested}" instead of "${path}".`);
+	}
+	const segments = path.split("/").filter(Boolean);
+	const seenParamNames = /* @__PURE__ */ new Set();
+	for (let index = 0; index < segments.length; index++) {
+		const segment = segments[index];
+		if (segment === "*") continue;
+		const hasOpenBrace = segment.includes("{");
+		const hasCloseBrace = segment.includes("}");
+		if (!hasOpenBrace && !hasCloseBrace) continue;
+		if (!(segment.startsWith("{") && segment.endsWith("}"))) throw new Error("Route parameter segments must use complete {name} interpolation.");
+		const rawParamName = normalizeRouteSegmentName(segment.slice(1, -1));
+		const isSplat = rawParamName.startsWith("*");
+		const paramName = isSplat ? normalizeRouteSegmentName(rawParamName.slice(1)) : rawParamName;
+		if (!paramName) throw new Error(isSplat ? "Route splat parameter name cannot be empty." : "Route parameter name cannot be empty.");
+		if (isSplat && paramName === "*") throw new Error("Route named splat parameter name cannot be \"*\".");
+		if (isSplat && index !== segments.length - 1) throw new Error("Route named splat parameters must be the final segment.");
+		if (seenParamNames.has(paramName)) throw new Error(`Route path cannot reuse duplicate parameter name "${paramName}".`);
+		seenParamNames.add(paramName);
+	}
+}
+function normalizeAbsoluteRoutePath(path) {
+	if (!path || path === "/") return "/";
+	return (path.endsWith("/") ? path.slice(0, -1) : path) || "/";
+}
+function joinRoutePaths(prefix, path) {
+	const normalizedPrefix = normalizeAbsoluteRoutePath(prefix || "/");
+	const normalizedPath = path.replace(/^\/+|\/+$/g, "");
+	if (!normalizedPath) return normalizedPrefix;
+	return normalizedPrefix === "/" ? `/${normalizedPath}` : `${normalizedPrefix}/${normalizedPath}`;
+}
+function resolvePageScopePath(path) {
+	if (!path) throw new Error("page(path, Component, fn) requires a non-empty path.");
+	if (path.startsWith("/")) {
+		validateRoutePath(path);
+		return normalizeAbsoluteRoutePath(path);
+	}
+	return joinRoutePaths(getCurrentPathPrefix(), path);
+}
+function resolveIndexPath() {
+	return normalizeAbsoluteRoutePath(getCurrentPathPrefix() || "/");
+}
+function resolveRouteRegistrationPath(path) {
+	if (path.startsWith("/")) {
+		if (hasActivePageScope()) throw new Error(`Child route paths inside page() must be relative. Use "${path.slice(1)}" instead of "${path}".`);
+		validateRoutePath(path);
+		return normalizeAbsoluteRoutePath(path);
+	}
+	const prefix = getCurrentPathPrefix();
+	if (!prefix) throw new Error(`Route path must begin with "/". Got: "${path}"`);
+	return joinRoutePaths(prefix, path);
+}
+function pushGroupScope(options, fn) {
+	const policies = compileNodePolicies(options);
+	pushRegistrationScope({
+		kind: "group",
+		pathPrefix: getCurrentPathPrefix(),
+		layout: options.layout,
+		auth: options.auth,
+		policies,
+		meta: options.meta
+	}, fn);
+}
+function pushPageScope(path, Component, options, fn) {
+	if (hasActivePageScope()) throw new Error("page() cannot be nested inside another page(). Use route() for child leaves or group() for inherited behavior inside the existing page scope.");
+	const policies = compileNodePolicies(options);
+	pushRegistrationScope({
+		kind: "page",
+		pathPrefix: resolvePageScopePath(path),
+		page: Component,
+		hasIndex: false,
+		auth: options.auth,
+		policies,
+		meta: options.meta
+	}, fn);
+}
+function normalizeRouteOptions(options) {
+	if (!options) return;
+	const loader = options.loader;
+	const preload = options.preload;
+	const policies = compileNodePolicies(options);
+	if (!loader && !preload && !options.entries && policies.length === 0 && !options.title && !options.namespace && !options.search && !options.meta && !options.actions && options.auth === void 0) return;
+	return {
+		...loader ? { loader } : {},
+		...preload ? { preload } : {},
+		...options.entries ? { entries: options.entries } : {},
+		...options.auth !== void 0 ? { auth: options.auth } : {},
+		...policies.length > 0 ? { policies } : {},
+		...options.title ? { title: options.title } : {},
+		...options.namespace ? { namespace: options.namespace } : {},
+		...options.search ? { search: options.search } : {},
+		...options.meta ? { meta: options.meta } : {},
+		...options.actions ? { actions: options.actions } : {}
+	};
+}
+function registerRouteAtResolvedPath(path, Component, options, metadata) {
+	validateRoutePath(path);
+	const chain = getCurrentLayoutChain();
+	const pageChain = getCurrentPageChain();
+	const segments = parseSegments(path);
+	const rank = computeRank(segments);
+	const isFallback = metadata?.isFallback ?? path === "/*";
+	const comp = Component;
+	const normalizedOptions = normalizeRouteOptions(options);
+	const policies = [...getCurrentInheritedPolicies(), ...normalizedOptions?.policies ?? []];
+	const authRequirements = [...getCurrentInheritedAuthRequirements(), ...normalizedOptions?.auth ? [normalizedOptions.auth] : []];
+	const auth = authRequirements.length === 0 ? void 0 : authRequirements.length === 1 ? authRequirements[0] : allOf(...authRequirements);
+	const metaChain = [...getCurrentInheritedMeta(), ...normalizedOptions?.meta ? [normalizedOptions.meta] : []];
+	const handler = createRouteHandler(comp, pageChain, chain);
+	const renderHandler = createRouteHandler(comp, pageChain, chain, true);
+	insertRecordSorted({
+		path,
+		component: comp,
+		segments,
+		rank,
+		layoutChain: chain,
+		pageChain,
+		options: normalizedOptions ? {
+			...normalizedOptions,
+			...auth ? { auth } : {},
+			...policies.length > 0 ? { policies } : {}
+		} : policies.length > 0 ? {
+			policies,
+			...auth ? { auth } : {}
+		} : auth ? { auth } : {},
+		...metaChain.length > 0 ? { metaChain } : {},
+		isFallback,
+		handler,
+		renderHandler,
+		...metadata?.fallbackPrefix ? { fallbackPrefix: metadata.fallbackPrefix } : {}
+	});
+	addRouteToStores({
+		path,
+		handler,
+		namespace: normalizedOptions?.namespace ?? options?.namespace,
+		...metadata?.fallbackPrefix ? { fallbackPrefix: metadata.fallbackPrefix } : {}
+	});
+}
+function group(options, fn) {
+	pushGroupScope(options, fn);
+}
+function page(path, Component, optionsOrFn, maybeFn) {
+	const options = typeof optionsOrFn === "function" ? {} : optionsOrFn;
+	const fn = typeof optionsOrFn === "function" ? optionsOrFn : maybeFn;
+	if (typeof Component !== "function") throw new Error("page(path, Component, fn) requires a component function as the second argument.");
+	if (typeof fn !== "function") throw new Error("page(path, Component, fn) requires a route definition callback as the final argument.");
+	pushPageScope(path, Component, options, fn);
+}
+function index(Component, options) {
+	const pageScope = getCurrentPageScope();
+	if (pageScope?.hasIndex) throw new Error("page() cannot declare multiple index routes.");
+	if (pageScope) pageScope.hasIndex = true;
+	registerRouteAtResolvedPath(resolveIndexPath(), Component, options);
+}
+function fallback(Component) {
+	if (hasActivePageScope()) {
+		if (getCurrentScopeKind() !== "page") throw new Error("fallback() inside page() must be declared directly in the page scope, not inside nested group().");
+		registerRouteAtResolvedPath(`${getCurrentPathPrefix()}/*`, Component, void 0, {
+			isFallback: true,
+			fallbackPrefix: getCurrentPathPrefix()
+		});
+		return;
+	}
+	if (!(getCurrentInheritedPolicies().length === 0 && getCurrentInheritedAuthRequirements().length === 0)) throw new Error("fallback() can only be registered at the root scope. Use route(\"/*\", Component) if you need compatibility behavior.");
+	registerRouteAtResolvedPath("/*", Component, void 0, {
+		isFallback: true,
+		fallbackPrefix: "/"
+	});
+}
+function route(path, Component, options) {
+	if (typeof path === "undefined") throw new Error("route() is only for route registration. Use currentRoute() inside components.");
+	if (getExecutionModel() === "islands") throw new Error("Routes are not supported with islands. Use createSPA (client) or createSSR (server) instead.");
+	const currentInst = getCurrentComponentInstance();
+	if (currentInst && currentInst.ssr) throw new Error("route() cannot be called during SSR rendering. Register routes at module load time instead.");
+	assertRouteRegistrationUnlocked();
+	if (typeof Component !== "function") throw new Error("route(path, Component) requires a component function as the second argument. Passing JSX elements or VNodes directly is not supported.");
+	if (options?.search && options.search.kind !== "object") throw new Error("route search must be an object schema.");
+	registerRouteAtResolvedPath(resolveRouteRegistrationPath(path), Component, options);
+	return Object.freeze({
+		path: resolveRouteRegistrationPath(path),
+		...options?.search ? { searchSchema: options.search } : {}
+	});
+}
+//#endregion
+export { route as a, page as i, group as n, index as r, fallback as t };

package/dist/benchmark.js

@@ -4,7 +4,7 @@ import { t as state } from "./state-Cc5HumQ0.js";
 import { t as selector } from "./selector-pApF_lGd.js";
 import { jsx, jsxs } from "./jsx-runtime.js";
 import { i as For } from "./control-KVP6LMEQ.js";
-import { t as createIsland } from "./boot-BwqMApN4.js";
+import { t as createIsland } from "./boot-B4UZumvB.js";
 //#region src/bench/components/benchmark-row.tsx
 function BenchmarkRow({ item, isSelected, onSelect, onRemove }) {
 	return /* @__PURE__ */ jsxs("tr", {
@@ -63,8 +63,8 @@ function BenchmarkTable({ rows, isSelected, onSelect, onRemove }) {
 installRendererBridge();
 const benchmarkMetadata = {
 	packageName: "@askrjs/askr",
-	packageVersion: "0.0.64",
-	buildLabel: "0.0.64-local"
+	packageVersion: "0.0.66",
+	buildLabel: "0.0.66-local"
 };
 function getBenchmarkMetadata() {
 	return { ...benchmarkMetadata };

package/dist/boot/index.d.ts

@@ -1,6 +1,6 @@
 import { s as ComponentFunction } from "../control-CMzFPMjr.js";
 import { v as DataRuntime } from "../index-Bki2rqcr.js";
-import { P as RouteRegistry, m as RouteAuthOptions, p as Route, x as RouteManifest } from "../router-Dz7ZoLja.js";
+import { N as RouteRegistry, p as RouteAuthOptions } from "../router-4EhVGcma.js";
 import { d as ScrollRestorationOptions } from "../navigate-BVDCzOuB.js";
 
 //#region src/boot/types.d.ts
@@ -17,28 +17,10 @@ type IslandsConfig = {
 };
 type BootRouteSource = {
   registry: RouteRegistry;
-  manifest?: RouteManifest;
-  routes?: Route[];
-} | {
-  manifest: RouteManifest;
-  registry?: RouteRegistry;
-  routes?: Route[];
-} | {
-  manifest?: RouteManifest;
-  registry?: RouteRegistry;
-  routes: Route[];
 };
 type SPAConfig = BootRouteSource & {
   root: Element | string;
-  cspNonce?: string;
-  /**
-   * Preferred: pass a route registry built via `createRouteRegistry(() => { ... })`.
-   * ```ts
-   * import { createRouteRegistry } from '@askrjs/askr/router';
-   * const registry = createRouteRegistry(() => { ... });
-   * await createSPA({ root: '#app', registry });
-   * ```
-   */
+  cspNonce?: string; /** Pass a route registry built via `createRouteRegistry(() => { ... })`. */
   auth?: RouteAuthOptions;
   scrollRestoration?: boolean | ScrollRestorationOptions;
   cleanupStrict?: boolean;
@@ -47,7 +29,7 @@ type SPAConfig = BootRouteSource & {
 type HydrateSPAConfig = BootRouteSource & {
   root: Element | string;
   cspNonce?: string;
-  dataRuntime?: DataRuntime; /** Preferred route input - see `SPAConfig`. */
+  dataRuntime?: DataRuntime; /** Pass the same explicit route registry used for the server render. */
   auth?: RouteAuthOptions;
   scrollRestoration?: boolean | ScrollRestorationOptions;
   cleanupStrict?: boolean;
@@ -75,23 +57,17 @@ declare function createIsland(config: IslandConfig): void;
  */
 declare function createIslands(config: IslandsConfig): void;
 /**
- * createSPA: Initializes router and mounts the app with the provided route manifest or route table.
- *
- * Preferred usage with manifest:
+ * createSPA: Initializes the router and mounts the app with an explicit route registry.
  * ```ts
- * import { getManifest } from '@askrjs/askr/router';
- * await createSPA({ root: '#app', manifest: getManifest() });
+ * import { createRouteRegistry } from '@askrjs/askr/router';
+ * const registry = createRouteRegistry(() => { ... });
+ * await createSPA({ root: '#app', registry });
  * ```
  *
- * Legacy usage with plain routes array (still supported):
- * ```ts
- * await createSPA({ root: '#app', routes: getRoutes() });
- * ```
  */
 declare function createSPA(config: SPAConfig): Promise<void>;
 /**
- * hydrateSPA: Hydrate server-rendered HTML.
- * Accepts either a `manifest` (preferred) or a legacy `routes` array.
+ * hydrateSPA: Hydrate server-rendered HTML with an explicit route registry.
  */
 declare function hydrateSPA(config: HydrateSPAConfig): Promise<void>;
 //#endregion

package/dist/boot/index.js

@@ -1,2 +1,2 @@
-import { a as cleanupApp, i as hydrateSPA, n as createIslands, o as hasApp, r as createSPA, t as createIsland } from "../boot-BwqMApN4.js";
+import { a as cleanupApp, i as hydrateSPA, n as createIslands, o as hasApp, r as createSPA, t as createIsland } from "../boot-B4UZumvB.js";
 export { cleanupApp, createIsland, createIslands, createSPA, hasApp, hydrateSPA };

package/dist/{boot-BwqMApN4.js → boot-B4UZumvB.js}

@@ -4,14 +4,14 @@ import { n as createComponentInstance, r as executeComponent } from "./component
 import { h as cleanupComponent, m as isPromiseLike } from "./component-lifecycle-DEMPihoZ.js";
 import { a as withIntrinsicHydrationAdoption, i as registerDeferredHydrationBoundary, n as activateHydrationBoundary$1, o as setStaticChildSlotsCacheEnabled, r as clearDeferredHydrationBoundaries, t as installRendererBridge } from "./renderer-aUD-acDe.js";
 import { _ as teardownNodeSubtree, d as removeAllListeners } from "./cleanup-B6KovDZZ.js";
-import { C as assertExecutionModel, S as route, a as resolveRouteMeta, c as registerAppInstance, d as clearRoutes, g as createAppRenderRuntime, h as setServerLocation, i as reconcileRouteMeta, l as unregisterAppInstance, s as configureScrollRestoration, t as initializeNavigation, u as _applyManifest } from "./navigate-CaFA0DdW.js";
+import { c as _applyManifest, d as getRouteRenderContext, f as getRouteRenderData, m as resolveRouteRequest, o as reviveDeferredValue, p as hasRouteRenderData, v as pageRenderEnvelope, w as assertExecutionModel } from "./deferred-Eh9bCVGH.js";
 import { a as startHydrationRenderPhase, s as stopHydrationRenderPhase } from "./render-context-Clw3rFiO.js";
 import { a as disposeDefaultPortalScope, t as DefaultPortal } from "./portal-D2tPWNrC.js";
 import { r as validateCspNonce, t as CspNonceScope } from "./csp-nonce-C-8E85El.js";
 import { i as getDefaultDataRuntime } from "./data-runtime-SJ1BSUvk.js";
 import { a as hydrateDataRuntime } from "./query-registry-CQIT4mXr.js";
-import { a as resolveRouteFromRoutes, d as _setActiveRouteAuthOptions, j as lockRouteRegistration, k as hasRegisteredRoutes } from "./route-matching-vJpvLVbX.js";
-import { _ as pageRenderEnvelope, d as hasRouteRenderData, f as resolveRouteRequest, l as getRouteRenderContext, o as reviveDeferredValue, u as getRouteRenderData, x as _preloadRouteHandler } from "./deferred-vBQJwHl5.js";
+import { d as _setActiveRouteAuthOptions, j as lockRouteRegistration, k as hasRegisteredRoutes, m as clearRouteState } from "./route-matching-DLBWDeXX.js";
+import { a as resolveRouteMeta, c as registerAppInstance, d as setServerLocation, f as createAppRenderRuntime, i as reconcileRouteMeta, l as unregisterAppInstance, s as configureScrollRestoration, t as initializeNavigation } from "./navigate-QMRcR581.js";
 import "./ssr-CbQO5xd3.js";
 //#region src/boot/hydration.ts
 const DEFERRED_PAYLOAD = "__askr_deferred__";
@@ -364,7 +364,7 @@ function cleanupApp(root) {
 		const wasRoutedRoot = routedRoots.delete(rootElement);
 		instancesByRoot.delete(rootElement);
 		clearRootCleanupCallbacks(rootElement);
-		if (wasRoutedRoot && routedRoots.size === 0) clearRoutes();
+		if (wasRoutedRoot && routedRoots.size === 0) clearRouteState();
 		try {
 			delete rootElement[CLEANUP_SYMBOL];
 		} catch {}
@@ -408,21 +408,12 @@ async function resolveInitialRoute(auth, source) {
 	for (let redirects = 0; redirects <= MAX_INITIAL_ROUTE_REDIRECTS; redirects++) {
 		if (visited.has(href)) throw new Error(`[Askr] Route redirect cycle detected at ${href}.`);
 		visited.add(href);
-		const resolved = source?.manifest ? await resolveRouteRequest(href, {
-			manifest: source.manifest,
+		if (!source?.registry) throw new TypeError("resolveInitialRoute requires a route registry.");
+		const resolved = await resolveRouteRequest(href, {
+			registry: source.registry,
 			auth,
 			load: source.load
-		}) : source?.routes ? await (() => {
-			const match = resolveRouteFromRoutes(path, source.routes);
-			if (!match) return null;
-			const lazyImport = _preloadRouteHandler(match.handler);
-			const result = {
-				kind: "render",
-				handler: match.handler,
-				params: match.params
-			};
-			return lazyImport ? lazyImport.then(() => result) : result;
-		})() : await resolveRouteRequest(href, { auth });
+		});
 		if (typeof window === "undefined" || !resolved || resolved.kind !== "redirect") return {
 			path,
 			href,
@@ -473,47 +464,34 @@ function createIslands(config) {
 	});
 }
 /**
-* createSPA: Initializes router and mounts the app with the provided route manifest or route table.
-*
-* Preferred usage with manifest:
+* createSPA: Initializes the router and mounts the app with an explicit route registry.
 * ```ts
-* import { getManifest } from '@askrjs/askr/router';
-* await createSPA({ root: '#app', manifest: getManifest() });
+* import { createRouteRegistry } from '@askrjs/askr/router';
+* const registry = createRouteRegistry(() => { ... });
+* await createSPA({ root: '#app', registry });
 * ```
 *
-* Legacy usage with plain routes array (still supported):
-* ```ts
-* await createSPA({ root: '#app', routes: getRoutes() });
-* ```
 */
 async function createSPA(config) {
 	assertExecutionModel("spa");
 	if (!config || typeof config !== "object") throw new Error("createSPA requires a config object");
 	validateCspNonce(config.cspNonce);
-	const manifest = config.manifest ?? config.registry?.manifest;
-	const routeTable = config.routes ?? config.registry?.routes;
-	const hasManifest = manifest != null && manifest.records.length > 0;
-	const hasRoutes = Array.isArray(routeTable) && routeTable.length > 0;
-	if (!hasManifest && !hasRoutes) throw new Error("createSPA requires a route manifest or route table. Pass `manifest: getManifest()` or `routes: getRoutes()`. If you are enhancing existing HTML, use createIsland instead.");
+	if (!config.registry) throw new Error("createSPA requires a route registry.");
+	const { manifest } = config.registry;
+	if (manifest.records.length === 0) throw new Error("createSPA requires a route registry with at least one route. If you are enhancing existing HTML, use createIsland instead.");
 	const rootElement = resolveRootElement(config.root);
 	if (!rootElement) throw new Error(`Root element not found: ${config.root}`);
 	configureScrollRestoration(config.scrollRestoration);
-	clearRoutes();
-	if (hasManifest) _applyManifest(manifest);
-	else for (const r of routeTable) route(r.path, r.handler);
-	const routeAuth = config.auth ?? manifest?.auth;
-	const activeManifest = hasManifest ? manifest : void 0;
+	clearRouteState();
+	_applyManifest(manifest);
+	const routeAuth = config.auth ?? manifest.auth;
 	const appRouteSource = {
-		manifest: activeManifest,
-		routes: hasManifest ? void 0 : routeTable,
+		registry: config.registry,
 		auth: routeAuth
 	};
 	_setActiveRouteAuthOptions(routeAuth);
 	if (isProductionEnvironment()) lockRouteRegistration();
-	const { path, resolved } = await resolveInitialRoute(routeAuth, {
-		manifest: activeManifest,
-		routes: hasManifest ? void 0 : routeTable
-	});
+	const { path, resolved } = await resolveInitialRoute(routeAuth, { registry: config.registry });
 	const appRuntime = createAppRenderRuntime(resolved?.kind === "render" && hasRouteRenderData(resolved) ? {
 		route: getRouteRenderData(resolved),
 		hasRoute: true
@@ -554,18 +532,15 @@ async function createSPA(config) {
 	await registerAppNavigation(rootElement, path, { ...appRouteSource });
 }
 /**
-* hydrateSPA: Hydrate server-rendered HTML.
-* Accepts either a `manifest` (preferred) or a legacy `routes` array.
+* hydrateSPA: Hydrate server-rendered HTML with an explicit route registry.
 */
 async function hydrateSPA(config) {
 	assertExecutionModel("spa");
 	if (!config || typeof config !== "object") throw new Error("hydrateSPA requires a config object");
 	validateCspNonce(config.cspNonce);
-	const manifest = config.manifest ?? config.registry?.manifest;
-	const routeTable = config.routes ?? config.registry?.routes;
-	const hasManifest = manifest != null && manifest.records.length > 0;
-	const hasRoutes = Array.isArray(routeTable) && routeTable.length > 0;
-	if (!hasManifest && !hasRoutes) throw new Error("hydrateSPA requires a route manifest or route table. Pass `manifest: getManifest()` or `routes: getRoutes()`. If you are enhancing existing HTML, use createIsland instead.");
+	if (!config.registry) throw new Error("hydrateSPA requires a route registry.");
+	const { manifest } = config.registry;
+	if (manifest.records.length === 0) throw new Error("hydrateSPA requires a route registry with at least one route. If you are enhancing existing HTML, use createIsland instead.");
 	const rootElement = resolveRootElement(config.root);
 	if (!rootElement) throw new Error(`Root element not found: ${config.root}`);
 	applyDeferredStreamPatches(rootElement);
@@ -574,14 +549,11 @@ async function hydrateSPA(config) {
 	if (hydrationQueryCache) hydrateDataRuntime(config.dataRuntime ?? getDefaultDataRuntime(), hydrationQueryCache);
 	const hydrationRenderDataForApp = hydrationRenderData;
 	configureScrollRestoration(config.scrollRestoration);
-	clearRoutes();
-	if (hasManifest) _applyManifest(manifest);
-	else for (const r of routeTable) route(r.path, r.handler);
-	const routeAuth = config.auth ?? manifest?.auth;
-	const activeManifest = hasManifest ? manifest : void 0;
+	clearRouteState();
+	_applyManifest(manifest);
+	const routeAuth = config.auth ?? manifest.auth;
 	const appRouteSource = {
-		manifest: activeManifest,
-		routes: hasManifest ? void 0 : routeTable,
+		registry: config.registry,
 		auth: routeAuth,
 		runtime: createAppRenderRuntime({
 			framework: hydrationRenderData?.framework,
@@ -591,8 +563,7 @@ async function hydrateSPA(config) {
 	};
 	_setActiveRouteAuthOptions(routeAuth);
 	const { path, href: currentUrl, resolved } = await resolveInitialRoute(routeAuth, {
-		manifest: activeManifest,
-		routes: hasManifest ? void 0 : routeTable,
+		registry: config.registry,
 		load: false
 	});
 	setServerLocation(currentUrl);
@@ -612,17 +583,11 @@ async function hydrateSPA(config) {
 		cspNonce: config.cspNonce
 	}));
 	if (shouldVerifyHydrationMarkup(config)) {
-		const legacyRouteTable = hasManifest ? manifest.records.map((r) => ({
-			...r,
-			path: r.path,
-			handler: r.handler,
-			namespace: r.options.namespace
-		})) : routeTable;
-		const { verifyHydrationSyncForUrl } = await import("./verify-hydration-DfsBcGSf.js");
+		const { verifyHydrationSyncForUrl } = await import("./verify-hydration-BcZXRU-q.js");
 		if (!verifyHydrationSyncForUrl({
 			root: rootElement,
 			url: currentUrl,
-			routes: legacyRouteTable,
+			registry: config.registry,
 			resolved: hydrationResolved,
 			options: {
 				data: hydrationRenderDataForApp?.resources,

package/dist/{deferred-vBQJwHl5.js → deferred-Eh9bCVGH.js}

@@ -6,7 +6,19 @@ import { n as getActiveRenderContext, r as getCurrentRenderData } from "./render
 import { t as resource } from "./resource-operation-Dz2Nxi1q.js";
 import { i as ROUTE_ROOT_COMPONENT } from "./csp-nonce-C-8E85El.js";
 import { c as withTelemetry, t as createQueryPrefetchContext } from "./query-registry-CQIT4mXr.js";
-import { E as getRouteRecords, h as getActiveRouteAuthOptions, i as getMatchingRouteRecord, o as buildRouteContext, s as buildRouteContextBase } from "./route-matching-vJpvLVbX.js";
+import { A as insertRecordSorted, D as getRouteRecords, E as getRouteList, F as snapshotRouteState, N as restoreRouteState, P as setDefaultRouteAuthOptions, T as getDefaultRouteAuthOptions, f as addRouteToStores, h as getActiveRouteAuthOptions, i as getMatchingRouteRecord, m as clearRouteState, o as buildRouteContext, s as buildRouteContextBase } from "./route-matching-DLBWDeXX.js";
+//#region src/runtime/execution-model.ts
+const EXECUTION_MODEL_KEY = Symbol.for("__ASKR_EXECUTION_MODEL__");
+function getExecutionModel() {
+	return globalThis[EXECUTION_MODEL_KEY];
+}
+function assertExecutionModel(model) {
+	const g = globalThis;
+	const cur = g[EXECUTION_MODEL_KEY];
+	if (cur && cur !== model) throw new Error(`[Askr] mixing execution models is not allowed (current: ${cur}, attempted: ${model}). Choose exactly one: createSPA, createSSR, or createIslands.`);
+	if (!cur) g[EXECUTION_MODEL_KEY] = model;
+}
+//#endregion
 //#region src/router/lazy.ts
 const pendingLazy = /* @__PURE__ */ new Set();
 const lazyStates = /* @__PURE__ */ new WeakMap();
@@ -55,13 +67,6 @@ function _preloadRouteRecord(record) {
 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);
@@ -111,6 +116,24 @@ function getRenderHandler(record) {
 	return record.renderHandler ?? createRouteHandler(record.component, record.pageChain, record.layoutChain, true);
 }
 //#endregion
+//#region src/router/auth.ts
+let clientAuth = Object.freeze({
+	authenticated: false,
+	principal: null,
+	session: null,
+	tenant: null
+});
+/** Return the identity resolved for the route currently being rendered. */
+function currentAuth() {
+	return getActiveRenderContext()?.authContext ?? clientAuth;
+}
+/** @internal Updated atomically with route resolution. */
+function setCurrentAuth(context) {
+	clientAuth = context;
+	const render = getActiveRenderContext();
+	if (render) render.authContext = context;
+}
+//#endregion
 //#region src/common/page-render-envelope.ts
 const PAGE_RENDER_ENVELOPE_VERSION = 1;
 function ownedRecord(value) {
@@ -148,24 +171,6 @@ function isEmptyPageRenderEnvelope(value) {
 	return value.route === void 0 && Object.keys(value.resources).length === 0 && Object.keys(value.framework).length === 0;
 }
 //#endregion
-//#region src/router/auth.ts
-let clientAuth = Object.freeze({
-	authenticated: false,
-	principal: null,
-	session: null,
-	tenant: null
-});
-/** Return the identity resolved for the route currently being rendered. */
-function currentAuth() {
-	return getActiveRenderContext()?.authContext ?? clientAuth;
-}
-/** @internal Updated atomically with route resolution. */
-function setCurrentAuth(context) {
-	clientAuth = context;
-	const render = getActiveRenderContext();
-	if (render) render.authContext = context;
-}
-//#endregion
 //#region src/router/resolution.ts
 const anonymous = () => ({
 	authenticated: false,
@@ -295,13 +300,15 @@ function resolveMatchedRoute(record, params, context, authOptions, request, tele
 	const decision = record.options.auth(context.auth);
 	return isPromiseLike(decision) ? Promise.resolve(decision).then(continueResolution) : continueResolution(decision);
 }
-function resolveRouteRequest(target, options = {}) {
+function resolveRouteRequest(target, options) {
+	if (!options?.registry) throw new TypeError("resolveRouteRequest requires options.registry.");
 	return withTelemetry(options.telemetry?.routeMatch, {}, () => {
-		const match = getMatchingRouteRecord(target, options.manifest?.records ?? getRouteRecords());
+		const records = options.registry.manifest.records;
+		const match = getMatchingRouteRecord(target, records);
 		if (!match) return null;
 		const mode = options.mode ?? getDefaultRouteMode();
 		const signal = options.signal ?? getActiveRenderContext()?.signal ?? new AbortController().signal;
-		const authOptions = getActiveRouteAuthOptions(options.auth ?? options.manifest?.auth);
+		const authOptions = getActiveRouteAuthOptions(options.auth ?? options.registry.manifest.auth);
 		const base = buildRouteContextBase(target, match.params, {
 			mode,
 			signal
@@ -321,6 +328,42 @@ function resolveRouteRequest(target, options = {}) {
 	});
 }
 //#endregion
+//#region src/router/manifest.ts
+function createRouteManifest() {
+	const auth = getDefaultRouteAuthOptions();
+	return {
+		records: [...getRouteRecords()],
+		...auth ? { auth } : {}
+	};
+}
+function _applyManifest(manifest) {
+	setDefaultRouteAuthOptions(manifest.auth);
+	for (const record of manifest.records) {
+		insertRecordSorted(record);
+		addRouteToStores({
+			path: record.path,
+			handler: record.handler,
+			namespace: record.options.namespace,
+			..."fallbackPrefix" in record && typeof record.fallbackPrefix === "string" ? { fallbackPrefix: record.fallbackPrefix } : {}
+		});
+	}
+}
+function createRouteRegistry(definition, options = {}) {
+	const previous = snapshotRouteState();
+	clearRouteState();
+	try {
+		setDefaultRouteAuthOptions(options.auth);
+		definition();
+		const manifest = createRouteManifest();
+		return Object.freeze({
+			manifest,
+			routes: getRouteList()
+		});
+	} finally {
+		restoreRouteState(previous);
+	}
+}
+//#endregion
 //#region src/router/deferred.tsx
 const DEFERRED_VALUE = Symbol.for("@askrjs/askr/deferred-value");
 const DEFERRED_BOUNDARY = Symbol.for("@askrjs/askr/deferred-boundary");
@@ -450,4 +493,4 @@ function Resolve(props) {
 	return props.children(result.value);
 }
 //#endregion
-export { lazy as S, pageRenderEnvelope as _, resolveDeferredValues as a, getRenderHandler as b, bindResolvedRouteData as c, hasRouteRenderData as d, resolveRouteRequest as f, isPageRenderEnvelope as g, isEmptyPageRenderEnvelope as h, isDeferred as i, getRouteRenderContext as l, createPageRenderEnvelope as m, Resolve as n, reviveDeferredValue as o, currentAuth as p, defer as r, routeData as s, DEFERRED_BOUNDARY as t, getRouteRenderData as u, Outlet as v, _preloadRouteHandler as x, createRouteHandler as y };
+export { lazy as C, getRenderHandler as S, getExecutionModel as T, isPageRenderEnvelope as _, resolveDeferredValues as a, Outlet as b, _applyManifest as c, getRouteRenderContext as d, getRouteRenderData as f, isEmptyPageRenderEnvelope as g, createPageRenderEnvelope as h, isDeferred as i, createRouteRegistry as l, resolveRouteRequest as m, Resolve as n, reviveDeferredValue as o, hasRouteRenderData as p, defer as r, routeData as s, DEFERRED_BOUNDARY as t, bindResolvedRouteData as u, pageRenderEnvelope as v, assertExecutionModel as w, createRouteHandler as x, currentAuth as y };