@askrjs/askr 0.2.4 → 0.3.1

package/dist/resources/index.d.ts

@@ -1,6 +1,26 @@
-import { $ as routeActive, G as TimerOptions, J as WatchSource, K as WatchCallback, Q as on, U as ActivityPredicate, W as ListenerTarget, X as capture, Y as WatchValues, Z as documentVisible, et as task, nt as watch, pt as getSignal, q as WatchContext, rt as windowFocused, tt as timer } from "../index-Dgjbo2gU.js";
-import { i as onRouteChange, n as RouteChangeOptions, t as RouteChangeCleanup } from "../activity-DooIuxQO.js";
-//#region src/runtime/resource-operation.d.ts
+import {
+  routeActive,
+  TimerOptions,
+  WatchSource,
+  WatchCallback,
+  on,
+  ActivityPredicate,
+  ListenerTarget,
+  capture,
+  WatchValues,
+  documentVisible,
+  task,
+  watch,
+  getSignal,
+  WatchContext,
+  windowFocused,
+  timer,
+} from '../core.js';
+import {
+  onRouteChange,
+  RouteChangeOptions,
+  RouteChangeCleanup,
+} from '../route-activity.js';
 /** Reactive result of a {@link resource}: current value, loading state, and controls. */
 interface ResourceResult<T> {
   value: T | null;
@@ -9,13 +29,17 @@ interface ResourceResult<T> {
   refresh(): void;
 }
 /** Creates a render-scoped async resource with cancellation and refresh; SSR has special data rules. */
-declare function resource<T, const TDeps extends readonly unknown[]>(fn: (opts: {
-  signal: AbortSignal;
-}) => PromiseLike<T> | T, deps: TDeps): ResourceResult<T>;
-//#endregion
-//#region src/runtime/stream-operation.d.ts
+declare function resource<T, const TDeps extends readonly unknown[]>(
+  fn: (opts: { signal: AbortSignal }) => PromiseLike<T> | T,
+  deps: TDeps
+): ResourceResult<T>;
 /** Connection status of a {@link stream}. */
-type StreamStatus = 'connecting' | 'connected' | 'reconnecting' | 'closed' | 'error';
+type StreamStatus =
+  | 'connecting'
+  | 'connected'
+  | 'reconnecting'
+  | 'closed'
+  | 'error';
 /** Reactive result of a {@link stream}: current value, connection status, and controls. */
 interface StreamResult<T> {
   value: T | null;
@@ -35,6 +59,34 @@ type StreamSource<T> = (context: {
   signal: AbortSignal;
 }) => AsyncIterable<T> | PromiseLike<AsyncIterable<T>>;
 /** Subscribe to a streaming data source for the current component's lifetime, with auto reconnect/cleanup. */
-declare function stream<T>(source: StreamSource<T>, options?: StreamOptions<T>): StreamResult<T>;
-//#endregion
-export { type ActivityPredicate, type ListenerTarget, type ResourceResult, type RouteChangeCleanup, type RouteChangeOptions, type StreamOptions, type StreamResult, type StreamStatus, type TimerOptions, type WatchCallback, type WatchContext, type WatchSource, type WatchValues, capture, documentVisible, getSignal, on, onRouteChange, resource, routeActive, stream, task, timer, watch, windowFocused };
+declare function stream<T>(
+  source: StreamSource<T>,
+  options?: StreamOptions<T>
+): StreamResult<T>;
+export {
+  type ActivityPredicate,
+  type ListenerTarget,
+  type ResourceResult,
+  type RouteChangeCleanup,
+  type RouteChangeOptions,
+  type StreamOptions,
+  type StreamResult,
+  type StreamStatus,
+  type TimerOptions,
+  type WatchCallback,
+  type WatchContext,
+  type WatchSource,
+  type WatchValues,
+  capture,
+  documentVisible,
+  getSignal,
+  on,
+  onRouteChange,
+  resource,
+  routeActive,
+  stream,
+  task,
+  timer,
+  watch,
+  windowFocused,
+};

package/dist/resources/index.js

@@ -1,10 +1,12 @@
-import { t as enqueueRuntimeLane } from "../access-BucjYZcX.js";
-import { f as getCurrentComponentInstance, g as getSignal, i as claimHookIndex } from "../component-scope-4I3yEMkb.js";
-import { a as registerCommitOperation } from "../component-internal-C4hKKQBF.js";
-import { t as resource } from "../resource-operation-Vz1S5h2k.js";
-import { a as task, c as windowFocused, i as routeActive, n as documentVisible, o as timer, r as on, s as watch, t as capture } from "../lifecycle-operations-Q0k3EFnG.js";
-import { n as onRouteChange } from "../activity-FirwPXA_.js";
-//#region src/runtime/stream-operation.ts
+import { t as enqueueRuntimeLane } from "../access-CEA2pOry.js";
+import { a as registerCommitOperation, u as routeComponentErrorToBoundary } from "../instance-VAFYVJOa.js";
+import { O as ownCleanup, f as getCurrentComponentInstance, h as getSignal, i as claimHookIndex } from "../scope-Cq_iYbTR.js";
+import { n as getComponentLifecycleSlot } from "../capabilities-Bbf0mlp9.js";
+import { t as createFineGrainedEffect } from "../effect-C3Zsc1k6.js";
+import { t as resource } from "../resource-18-sFRl9.js";
+import { a as routeActive, i as windowFocused, n as documentVisible, r as resolveListenerTarget, t as timer } from "../timer-C7uqnJVt.js";
+import { n as onRouteChange } from "../activity-oy2YFTFF.js";
+//#region src/runtime/lifecycle/stream.ts
 function toError(value) {
 	return value instanceof Error ? value : new Error(String(value));
 }
@@ -190,7 +192,7 @@ function commitSlot(instance, slot) {
 	if (firstCommit) slot.activated = true;
 	if (!slot.cleanupRegistered) {
 		slot.cleanupRegistered = true;
-		(instance.cleanupFns ??= []).push(() => disposeSlot(slot));
+		ownCleanup(instance.owner, () => disposeSlot(slot));
 	}
 	if (!slot.explicitlyClosed && (firstCommit || depsChanged && wasRunning)) queueStart(slot);
 }
@@ -216,4 +218,208 @@ function stream(source, options = {}) {
 	return slot.snapshot;
 }
 //#endregion
+//#region src/runtime/lifecycle/listener.ts
+function normalizeListenerOptions(options) {
+	if (options === void 0 || typeof options === "boolean") return options;
+	return {
+		...options.capture !== void 0 ? { capture: options.capture } : {},
+		...options.once !== void 0 ? { once: options.once } : {},
+		...options.passive !== void 0 ? { passive: options.passive } : {},
+		...options.signal !== void 0 ? { signal: options.signal } : {}
+	};
+}
+function listenerOptionsEqual(a, b) {
+	if (a === b) return true;
+	if (typeof a === "boolean" || typeof b === "boolean") return a === b;
+	if (!a || !b) return a === b;
+	return a.capture === b.capture && a.once === b.once && a.passive === b.passive && a.signal === b.signal;
+}
+function detachListenerSlot(slot) {
+	if (!slot.attached || !slot.target) return;
+	slot.target.removeEventListener(slot.event, slot.listener, slot.options);
+	slot.attached = false;
+}
+function commitListenerSlot(instance, slot) {
+	slot.handler = slot.pendingHandler;
+	const resolvedTarget = resolveListenerTarget(slot.pendingTarget);
+	if (!slot.attached || slot.target !== resolvedTarget || slot.event !== slot.pendingEvent || !listenerOptionsEqual(slot.options, slot.pendingOptions)) {
+		detachListenerSlot(slot);
+		slot.target = resolvedTarget;
+		slot.event = slot.pendingEvent;
+		slot.options = slot.pendingOptions;
+		if (slot.target) {
+			slot.target.addEventListener(slot.event, slot.listener, slot.options);
+			slot.attached = true;
+		}
+	}
+	if (!slot.cleanupRegistered) {
+		slot.cleanupRegistered = true;
+		ownCleanup(instance.owner, () => {
+			detachListenerSlot(slot);
+			slot.cleanupRegistered = false;
+		});
+	}
+}
+/** Attach an owned event listener to `target` for the current component's lifetime. */
+function on(target, event, handler, options) {
+	const instance = getCurrentComponentInstance();
+	if (!instance) return;
+	const index = claimHookIndex(instance, "on");
+	const normalizedOptions = normalizeListenerOptions(options);
+	const slot = getComponentLifecycleSlot(instance, index, "listener", () => {
+		const createdSlot = {
+			kind: "listener",
+			target: null,
+			event,
+			handler,
+			listener: ((evt) => {
+				createdSlot.handler.call(createdSlot.target, evt);
+			}),
+			options: void 0,
+			pendingTarget: target,
+			pendingEvent: event,
+			pendingHandler: handler,
+			pendingOptions: normalizedOptions,
+			attached: false,
+			cleanupRegistered: false
+		};
+		return createdSlot;
+	});
+	slot.pendingTarget = target;
+	slot.pendingEvent = event;
+	slot.pendingHandler = handler;
+	slot.pendingOptions = normalizedOptions;
+	registerCommitOperation(() => {
+		commitListenerSlot(instance, slot);
+	});
+}
+//#endregion
+//#region src/runtime/lifecycle/task.ts
+/** Runs an owned task after commit. */
+function task(fn) {
+	const instance = getCurrentComponentInstance();
+	if (!instance) return;
+	const index = claimHookIndex(instance, "task");
+	const slot = getComponentLifecycleSlot(instance, index, "task", () => ({
+		kind: "task",
+		started: false,
+		task: fn
+	}));
+	if (!slot.started) {
+		slot.task = fn;
+		registerCommitOperation(async () => {
+			if (slot.started) return;
+			slot.started = true;
+			return await slot.task();
+		});
+	}
+}
+/**
+* Capture the result of a synchronous expression at call time and return a
+* thunk that returns the captured value later. This is a low-level helper for
+* cases where async continuations need to observe a snapshot of values at the
+* moment scheduling occurred.
+*
+* Usage (public API):
+* const snapshot = capture(() => someState());
+* Promise.resolve().then(() => { use(snapshot()); });
+*/
+function capture(fn) {
+	const value = fn();
+	return () => value;
+}
+//#endregion
+//#region src/runtime/lifecycle/watch.ts
+function watchValuesEqual(previous, next) {
+	if (previous.length !== next.length) return false;
+	for (let index = 0; index < previous.length; index += 1) if (!Object.is(previous[index], next[index])) return false;
+	return true;
+}
+function stopWatchGeneration(slot) {
+	const controller = slot.controller;
+	slot.controller = null;
+	if (controller && !controller.signal.aborted) controller.abort();
+	const cleanup = slot.cleanup;
+	slot.cleanup = null;
+	cleanup?.();
+}
+function stopWatchSlot(slot) {
+	stopWatchGeneration(slot);
+	slot.effect?.cleanup();
+	slot.effect = null;
+}
+function reportWatchError(instance, error) {
+	if (!routeComponentErrorToBoundary(instance, error)) throw error;
+}
+function commitWatchSlot(instance, slot) {
+	slot.callback = slot.pendingCallback;
+	slot.sources = slot.pendingSources;
+	const compute = () => {
+		const values = slot.sources.map((source) => source());
+		return values.length === 1 ? values[0] : values;
+	};
+	const observe = (value, previous) => {
+		stopWatchGeneration(slot);
+		const controller = new AbortController();
+		slot.controller = controller;
+		const initial = !slot.hasObserved;
+		slot.hasObserved = true;
+		let result;
+		try {
+			result = slot.callback(value, {
+				initial,
+				previous,
+				signal: controller.signal
+			});
+		} catch (error) {
+			reportWatchError(instance, error);
+			return;
+		}
+		if (typeof result === "function") {
+			slot.cleanup = result;
+			return;
+		}
+		if (result && typeof result.then === "function") Promise.resolve(result).catch((error) => {
+			if (!controller.signal.aborted) reportWatchError(instance, error);
+		});
+	};
+	if (!slot.effect) slot.effect = createFineGrainedEffect({
+		lane: "post",
+		compute,
+		commit: observe,
+		equals: (previous, next) => Array.isArray(previous) && Array.isArray(next) ? watchValuesEqual(previous, next) : Object.is(previous, next),
+		onError: (error) => reportWatchError(instance, error)
+	});
+	else slot.effect.updateCompute(compute);
+	if (!slot.cleanupRegistered) {
+		slot.cleanupRegistered = true;
+		ownCleanup(instance.owner, () => {
+			stopWatchSlot(slot);
+			slot.cleanupRegistered = false;
+		});
+	}
+}
+function watch(sourceOrSources, callback) {
+	const instance = getCurrentComponentInstance();
+	if (!instance) return;
+	const index = claimHookIndex(instance, "watch");
+	const sources = Array.isArray(sourceOrSources) ? sourceOrSources : [sourceOrSources];
+	const slot = getComponentLifecycleSlot(instance, index, "watch", () => ({
+		kind: "watch",
+		sources,
+		pendingSources: sources,
+		callback,
+		pendingCallback: callback,
+		effect: null,
+		controller: null,
+		cleanup: null,
+		cleanupRegistered: false,
+		hasObserved: false
+	}));
+	slot.pendingSources = sources;
+	slot.pendingCallback = callback;
+	if (instance.ssr) return;
+	registerCommitOperation(() => commitWatchSlot(instance, slot));
+}
+//#endregion
 export { capture, documentVisible, getSignal, on, onRouteChange, resource, routeActive, stream, task, timer, watch, windowFocused };

package/dist/route-activity.d.ts

@@ -0,0 +1,21 @@
+import { RouteSnapshot, RouteParams } from './core.js';
+/** Options for {@link onRouteChange}. */
+interface RouteChangeOptions {
+  immediate?: boolean;
+}
+/** Optional cleanup returned by an {@link onRouteChange} callback, run before the next change. */
+type RouteChangeCleanup = void | (() => void);
+/** Register a callback to run whenever the active route changes, with optional cleanup. */
+declare function onRouteChange(
+  fn: (
+    current: RouteSnapshot,
+    previous: RouteSnapshot | null
+  ) => RouteChangeCleanup,
+  options?: RouteChangeOptions
+): void;
+/** Read the currently active route's {@link RouteSnapshot}; reactive during component render. */
+declare function currentRoute<
+  TParams extends RouteParams = RouteParams,
+  TState = unknown,
+>(): RouteSnapshot<TParams, TState>;
+export { onRouteChange, RouteChangeOptions, currentRoute, RouteChangeCleanup };

package/dist/{route-matching-Bo6UqG-5.js → route-matching-CUzZ31gT.js}

@@ -1,4 +1,4 @@
-import { d as getCurrentAppRenderRuntime } from "./component-scope-4I3yEMkb.js";
+import { d as getCurrentAppRenderRuntime } from "./scope-Cq_iYbTR.js";
 import { n as getActiveRenderContext } from "./render-context-B7ohlh6t.js";
 //#region src/router/match.ts
 function splitPathSegments(path) {
@@ -120,48 +120,63 @@ function matchSegments(urlParts, segments) {
 }
 //#endregion
 //#region src/router/store.ts
-const routes = [];
-const records = [];
-const namespaces = /* @__PURE__ */ new Set();
-const routesByDepth = /* @__PURE__ */ new Map();
-const registrationScopeStack = [];
-let registrationLocked = false;
-let defaultRouteAuthOptions;
-let activeClientRouteAuthOptions;
-let defaultRouteBasePath = "";
+function createRouteTable() {
+	return {
+		routes: [],
+		records: [],
+		namespaces: /* @__PURE__ */ new Set(),
+		routesByDepth: /* @__PURE__ */ new Map(),
+		registrationScopeStack: [],
+		registrationLocked: false,
+		defaultRouteAuthOptions: void 0,
+		activeClientRouteAuthOptions: void 0,
+		defaultRouteBasePath: ""
+	};
+}
+let activeTable = createRouteTable();
+/** Run `fn` with `table` as the registration target, then restore the previous one. */
+function withRouteTable(table, fn) {
+	const previous = activeTable;
+	activeTable = table;
+	try {
+		return fn();
+	} finally {
+		activeTable = previous;
+	}
+}
 function getDepth(path) {
 	const normalized = path.endsWith("/") && path !== "/" ? path.slice(0, -1) : path;
 	return normalized === "/" ? 0 : normalized.split("/").filter(Boolean).length;
 }
 function getRouteRecords() {
-	return records;
+	return activeTable.records;
 }
 function isRouteStoreRoutes(routeList) {
-	return routeList === routes;
+	return routeList === activeTable.routes;
 }
 function insertRecordSorted(record) {
 	let lo = 0;
-	let hi = records.length;
+	let hi = activeTable.records.length;
 	while (lo < hi) {
 		const mid = lo + hi >>> 1;
-		if (records[mid].rank >= record.rank) lo = mid + 1;
+		if (activeTable.records[mid].rank >= record.rank) lo = mid + 1;
 		else hi = mid;
 	}
-	records.splice(lo, 0, record);
+	activeTable.records.splice(lo, 0, record);
 }
 function addRouteToStores(routeObj) {
-	routes.push(routeObj);
+	activeTable.routes.push(routeObj);
 	const depth = getDepth(routeObj.path);
-	let depthRoutes = routesByDepth.get(depth);
+	let depthRoutes = activeTable.routesByDepth.get(depth);
 	if (!depthRoutes) {
 		depthRoutes = [];
-		routesByDepth.set(depth, depthRoutes);
+		activeTable.routesByDepth.set(depth, depthRoutes);
 	}
 	depthRoutes.push(routeObj);
-	if (routeObj.namespace) namespaces.add(routeObj.namespace);
+	if (routeObj.namespace) activeTable.namespaces.add(routeObj.namespace);
 }
 function getActiveRoutes() {
-	return getActiveRenderContext()?.routes ?? getCurrentAppRenderRuntime()?.routeRegistry?.routes ?? routes;
+	return getActiveRenderContext()?.routes ?? getCurrentAppRenderRuntime()?.routeRegistry?.routes ?? activeTable.routes;
 }
 function getActiveRouteAuthOptions(override) {
 	if (override !== void 0) return override;
@@ -169,126 +184,97 @@ function getActiveRouteAuthOptions(override) {
 	if (renderContext) return renderContext.routeAuth;
 	const appRuntime = getCurrentAppRenderRuntime();
 	if (appRuntime) return appRuntime.routeAuth;
-	return activeClientRouteAuthOptions ?? defaultRouteAuthOptions;
+	return activeTable.activeClientRouteAuthOptions ?? activeTable.defaultRouteAuthOptions;
 }
 function _setActiveRouteAuthOptions(auth) {
-	activeClientRouteAuthOptions = auth;
+	activeTable.activeClientRouteAuthOptions = auth;
 }
 function getDefaultRouteAuthOptions() {
-	return defaultRouteAuthOptions;
+	return activeTable.defaultRouteAuthOptions;
 }
 function setDefaultRouteAuthOptions(auth) {
-	defaultRouteAuthOptions = auth;
+	activeTable.defaultRouteAuthOptions = auth;
 }
 function getDefaultRouteBasePath() {
-	return defaultRouteBasePath;
+	return activeTable.defaultRouteBasePath;
 }
 function setDefaultRouteBasePath(basePath) {
-	defaultRouteBasePath = basePath;
+	activeTable.defaultRouteBasePath = basePath;
 }
 function getActiveRouteBasePath() {
 	const renderContext = getActiveRenderContext();
 	if (renderContext?.basePath !== void 0) return renderContext.basePath;
 	const appRegistry = getCurrentAppRenderRuntime()?.routeRegistry;
 	if (appRegistry) return appRegistry.manifest.basePath ?? "";
-	return defaultRouteBasePath;
+	return activeTable.defaultRouteBasePath;
 }
 function getCurrentLayoutChain() {
 	const layoutChain = [];
-	for (const scope of registrationScopeStack) if (scope.layout) layoutChain.push({ component: scope.layout });
+	for (const scope of activeTable.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 });
+	for (const scope of activeTable.registrationScopeStack) if (scope.page) pageChain.push({ component: scope.page });
 	return pageChain;
 }
 function hasActivePageScope() {
-	return registrationScopeStack.some((scope) => !!scope.page);
+	return activeTable.registrationScopeStack.some((scope) => !!scope.page);
 }
 function getCurrentPageScope() {
-	for (let index = registrationScopeStack.length - 1; index >= 0; index -= 1) {
-		const scope = registrationScopeStack[index];
+	for (let index = activeTable.registrationScopeStack.length - 1; index >= 0; index -= 1) {
+		const scope = activeTable.registrationScopeStack[index];
 		if (scope.kind === "page") return scope;
 	}
 	return null;
 }
 function getCurrentScopeKind() {
-	return registrationScopeStack[registrationScopeStack.length - 1]?.kind ?? null;
+	return activeTable.registrationScopeStack[activeTable.registrationScopeStack.length - 1]?.kind ?? null;
 }
 function getCurrentPathPrefix() {
-	return registrationScopeStack[registrationScopeStack.length - 1]?.pathPrefix ?? "";
+	return activeTable.registrationScopeStack[activeTable.registrationScopeStack.length - 1]?.pathPrefix ?? "";
 }
 function getCurrentInheritedPolicies() {
 	const policies = [];
-	for (const scope of registrationScopeStack) if (scope.policies.length > 0) policies.push(...scope.policies);
+	for (const scope of activeTable.registrationScopeStack) if (scope.policies.length > 0) policies.push(...scope.policies);
 	return policies;
 }
 function getCurrentInheritedAuthRequirements() {
-	return registrationScopeStack.flatMap((scope) => scope.auth ? [scope.auth] : []);
+	return activeTable.registrationScopeStack.flatMap((scope) => scope.auth ? [scope.auth] : []);
 }
 function getCurrentInheritedMeta() {
-	return registrationScopeStack.flatMap((scope) => scope.meta ? [scope.meta] : []);
+	return activeTable.registrationScopeStack.flatMap((scope) => scope.meta ? [scope.meta] : []);
 }
 function pushRegistrationScope(scope, fn) {
-	registrationScopeStack.push(scope);
+	activeTable.registrationScopeStack.push(scope);
 	try {
 		fn();
 	} finally {
-		registrationScopeStack.pop();
+		activeTable.registrationScopeStack.pop();
 	}
 }
 function lockRouteRegistration() {
-	registrationLocked = true;
+	activeTable.registrationLocked = true;
 }
 function assertRouteRegistrationUnlocked() {
-	if (registrationLocked) throw new Error("Route registration is locked after app startup. Register routes at module load time before calling createSPA or createSSR.");
+	if (activeTable.registrationLocked) throw new Error("Route registration is locked after app startup. Register routes at module load time before calling createSPA or createSSR.");
 }
 function getRouteList() {
-	return [...routes];
+	return [...activeTable.routes];
 }
 function hasRegisteredRoutes() {
-	return routes.length > 0 || records.length > 0;
+	return activeTable.routes.length > 0 || activeTable.records.length > 0;
 }
 function clearRouteState() {
-	routes.length = 0;
-	records.length = 0;
-	namespaces.clear();
-	routesByDepth.clear();
-	registrationScopeStack.length = 0;
-	registrationLocked = false;
-	defaultRouteAuthOptions = void 0;
-	activeClientRouteAuthOptions = void 0;
-	defaultRouteBasePath = "";
-}
-function snapshotRouteState() {
-	return {
-		routes: [...routes],
-		records: [...records],
-		namespaces: [...namespaces],
-		registrationLocked,
-		defaultRouteAuthOptions,
-		activeClientRouteAuthOptions,
-		defaultRouteBasePath,
-		routesByDepth: [...routesByDepth.entries()].map(([depth, depthRoutes]) => [depth, [...depthRoutes]]),
-		registrationScopeStack: [...registrationScopeStack]
-	};
-}
-function restoreRouteState(snapshot) {
-	routes.length = 0;
-	routes.push(...snapshot.routes);
-	records.length = 0;
-	records.push(...snapshot.records);
-	namespaces.clear();
-	for (const namespace of snapshot.namespaces) namespaces.add(namespace);
-	routesByDepth.clear();
-	for (const [depth, depthRoutes] of snapshot.routesByDepth) routesByDepth.set(depth, [...depthRoutes]);
-	registrationScopeStack.length = 0;
-	registrationScopeStack.push(...snapshot.registrationScopeStack);
-	registrationLocked = snapshot.registrationLocked;
-	defaultRouteAuthOptions = snapshot.defaultRouteAuthOptions;
-	activeClientRouteAuthOptions = snapshot.activeClientRouteAuthOptions;
-	defaultRouteBasePath = snapshot.defaultRouteBasePath;
+	activeTable.routes.length = 0;
+	activeTable.records.length = 0;
+	activeTable.namespaces.clear();
+	activeTable.routesByDepth.clear();
+	activeTable.registrationScopeStack.length = 0;
+	activeTable.registrationLocked = false;
+	activeTable.defaultRouteAuthOptions = void 0;
+	activeTable.activeClientRouteAuthOptions = void 0;
+	activeTable.defaultRouteBasePath = "";
 }
 //#endregion
 //#region src/router/route-context.ts
@@ -562,4 +548,4 @@ function _resolveRouteMatchFromRoutes(pathname, routeList) {
 	return findBestResolvedRouteFromRoutes(pathname, routeList);
 }
 //#endregion
-export { getDefaultRouteBasePath as A, setDefaultRouteBasePath as B, getCurrentInheritedPolicies as C, getCurrentPathPrefix as D, getCurrentPageScope as E, insertRecordSorted as F, computeRank as H, lockRouteRegistration as I, pushRegistrationScope as L, getRouteRecords as M, hasActivePageScope as N, getCurrentScopeKind as O, hasRegisteredRoutes as P, restoreRouteState as R, getCurrentInheritedMeta as S, getCurrentPageChain as T, normalizeRouteSegmentName as U, snapshotRouteState as V, parseSegments as W, clearRouteState as _, resolveRouteFromRoutes as a, getActiveRoutes as b, removeRouteBasePath as c, deepFreeze as d, makeQuery as f, assertRouteRegistrationUnlocked as g, addRouteToStores as h, getMatchingRouteRecord as i, getRouteList as j, getDefaultRouteAuthOptions as k, buildRouteContext as l, _setActiveRouteAuthOptions as m, computeMatchesFromRoutes as n, addRouteBasePath as o, parseLocation as p, computeRouteActivityMatches as r, normalizeRouteBasePath as s, _resolveRouteMatchFromRoutes as t, buildRouteContextBase as u, getActiveRouteAuthOptions as v, getCurrentLayoutChain as w, getCurrentInheritedAuthRequirements as x, getActiveRouteBasePath as y, setDefaultRouteAuthOptions as z };
+export { getDefaultRouteAuthOptions as A, setDefaultRouteBasePath as B, getCurrentInheritedMeta as C, getCurrentPageScope as D, getCurrentPageChain as E, hasRegisteredRoutes as F, computeRank as H, insertRecordSorted as I, lockRouteRegistration as L, getRouteList as M, getRouteRecords as N, getCurrentPathPrefix as O, hasActivePageScope as P, pushRegistrationScope as R, getCurrentInheritedAuthRequirements as S, getCurrentLayoutChain as T, normalizeRouteSegmentName as U, withRouteTable as V, parseSegments as W, clearRouteState as _, resolveRouteFromRoutes as a, getActiveRouteBasePath as b, removeRouteBasePath as c, deepFreeze as d, makeQuery as f, assertRouteRegistrationUnlocked as g, addRouteToStores as h, getMatchingRouteRecord as i, getDefaultRouteBasePath as j, getCurrentScopeKind as k, buildRouteContext as l, _setActiveRouteAuthOptions as m, computeMatchesFromRoutes as n, addRouteBasePath as o, parseLocation as p, computeRouteActivityMatches as r, normalizeRouteBasePath as s, _resolveRouteMatchFromRoutes as t, buildRouteContextBase as u, createRouteTable as v, getCurrentInheritedPolicies as w, getActiveRoutes as x, getActiveRouteAuthOptions as y, setDefaultRouteAuthOptions as z };