@askrjs/askr 0.0.50 → 0.0.52

package/dist/router/navigation-targets.js

@@ -1,17 +1,20 @@
 import { isDevelopmentEnvironment } from "../common/env.js";
-import { logger } from "../dev/logger.js";
+import { logger } from "../common/logger.js";
+import { flushRuntimeScheduler } from "../runtime/access.js";
 import { ELEMENT_TYPE, Fragment } from "../common/jsx.js";
 import { cleanupComponent } from "../runtime/component-cleanup.js";
 import { isPromiseLike } from "../common/promise.js";
+import { beginLifecycleCommitBatch, discardLifecycleCommitBatch, drainLifecycleCommitErrors, flushLifecycleCommitBatch } from "../runtime/lifecycle-batch.js";
 import { mountComponent } from "../runtime/component-internal.js";
-import "../runtime/component.js";
-import { cleanupInstancesUnder } from "../renderer/cleanup.js";
-import { applyHistoryScroll, applyNavigationScroll, saveScrollPosition } from "./navigation-scroll.js";
-import { resolveRouteFromRoutes, resolveRouteRequest } from "./resolution.js";
+import { DefaultPortal, clearDefaultPortalForInstance } from "../runtime/portal.js";
+import "../runtime/index.js";
+import { teardownNodeSubtree } from "../renderer/cleanup.js";
+import "../jsx/index.js";
+import { resolveRouteFromRoutes } from "./route-matching.js";
+import { resolveRouteRequest } from "./resolution.js";
 import "./route.js";
 import { getCurrentHref, getCurrentPathname, getRegisteredAppsSnapshot, parseTargetUrl, setCurrentRouteLocation, syncAppRegistrationLocation, syncRegisteredRouteSnapshot } from "./navigation-registry.js";
-import { DefaultPortal, clearDefaultPortalForInstance } from "../foundations/structures/portal.js";
-import "../jsx/index.js";
+import { applyHistoryScroll, applyNavigationScroll, saveScrollPosition } from "./navigation-scroll.js";
 //#region src/router/navigation-targets.ts
 const MAX_NAVIGATION_REDIRECTS = 20;
 let activeRouteRequestId = 0;
@@ -63,7 +66,7 @@ function wrapRootRouteHandler(componentFn) {
 		const portalVNode = {
 			$$typeof: ELEMENT_TYPE,
 			type: DefaultPortal,
-			props: {},
+			props: { __askrAutoDefaultPortal: true },
 			key: "__default_portal"
 		};
 		return {
@@ -75,24 +78,249 @@ function wrapRootRouteHandler(componentFn) {
 	Object.defineProperty(wrappedFn, "name", { value: componentFn.name || "Component" });
 	return wrappedFn;
 }
-function cleanupRouteOwnership(instance) {
-	const cleanupErrors = [];
-	const children = instance.target ? Array.from(instance.target.childNodes) : [];
-	for (const child of children) try {
-		cleanupInstancesUnder(child, { strict: instance.cleanupStrict });
+function flattenLifecycleErrors(error, result) {
+	if (error instanceof AggregateError) {
+		for (const nested of error.errors) flattenLifecycleErrors(nested, result);
+		return;
+	}
+	result.push(error);
+}
+function reportRouteCleanupErrors(errors) {
+	for (const error of errors) {
+		const flattened = [];
+		flattenLifecycleErrors(error, flattened);
+		for (const cleanupError of flattened.length > 0 ? flattened : [error]) logger.error("[Askr] route cleanup failed:", cleanupError);
+	}
+}
+function captureRouteDom(root) {
+	if (!root) return null;
+	const nodes = [];
+	const visit = (node) => {
+		nodes.push({
+			node,
+			children: Array.from(node.childNodes),
+			attributes: node instanceof Element ? Array.from(node.attributes).map((attribute) => [attribute.name, attribute.value]) : null,
+			nodeValue: node.nodeValue
+		});
+		for (const child of Array.from(node.childNodes)) visit(child);
+	};
+	visit(root);
+	return {
+		root,
+		nodes
+	};
+}
+function collectProvisionalRouteNodes(snapshot) {
+	const originalNodes = new Set(snapshot.nodes.map((entry) => entry.node));
+	const provisional = [];
+	const visit = (node) => {
+		if (!originalNodes.has(node)) {
+			provisional.push(node);
+			return;
+		}
+		for (const child of Array.from(node.childNodes)) visit(child);
+	};
+	for (const child of Array.from(snapshot.root.childNodes)) visit(child);
+	return provisional;
+}
+function restoreRouteDom(snapshot) {
+	if (!snapshot) return [];
+	const errors = [];
+	for (const node of collectProvisionalRouteNodes(snapshot)) try {
+		teardownNodeSubtree(node, { strict: true });
 	} catch (error) {
-		cleanupErrors.push(error);
+		errors.push(error);
+	}
+	for (const entry of snapshot.nodes) {
+		const { node, attributes } = entry;
+		try {
+			if (attributes && node instanceof Element) {
+				const expected = new Map(attributes);
+				for (const attribute of Array.from(node.attributes)) if (!expected.has(attribute.name)) node.removeAttribute(attribute.name);
+				for (const [name, value] of attributes) if (node.getAttribute(name) !== value) node.setAttribute(name, value);
+			} else if (!(node instanceof Element)) node.nodeValue = entry.nodeValue;
+			if (node instanceof Element || node instanceof DocumentFragment) node.replaceChildren(...entry.children);
+		} catch (error) {
+			errors.push(error);
+		}
 	}
+	return errors;
+}
+function collectHostInstances(root) {
+	const instances = [];
+	const seen = /* @__PURE__ */ new Set();
+	const pending = [root];
+	while (pending.length > 0) {
+		const node = pending.pop();
+		if (node instanceof Element) {
+			const host = node;
+			for (const instance of host.__ASKR_INSTANCES ?? []) if (!seen.has(instance)) {
+				seen.add(instance);
+				instances.push(instance);
+			}
+			if (host.__ASKR_INSTANCE && !seen.has(host.__ASKR_INSTANCE)) {
+				seen.add(host.__ASKR_INSTANCE);
+				instances.push(host.__ASKR_INSTANCE);
+			}
+		} else {
+			const instance = node.__ASKR_INSTANCE;
+			if (instance && !seen.has(instance)) {
+				seen.add(instance);
+				instances.push(instance);
+			}
+		}
+		for (let child = node.lastChild; child; child = child.previousSibling) pending.push(child);
+	}
+	return instances;
+}
+function captureDeferredRouteCleanup(instance) {
+	return {
+		instance,
+		previousFn: instance.fn,
+		previousProps: instance.props,
+		previousExpectedStateIndices: instance.expectedStateIndices,
+		previousFirstRenderComplete: instance.firstRenderComplete,
+		previousStateIndexCheck: instance.stateIndexCheck,
+		previousErrorBoundaryState: instance.errorBoundaryState,
+		previousTarget: instance.target,
+		previousDom: captureRouteDom(instance.target),
+		previousStateValues: instance.stateValues,
+		previousCleanupFns: instance.cleanupFns,
+		previousOwnedChildScopes: instance._ownedChildScopes,
+		previousAbortController: instance.abortController,
+		previousMountOperations: instance.mountOperations,
+		previousCommitOperations: instance.commitOperations,
+		previousLifecycleSlots: instance.lifecycleSlots,
+		previousLifecycleGeneration: instance.lifecycleGeneration,
+		previousEvaluationGeneration: instance.evaluationGeneration,
+		previousHasPendingUpdate: instance.hasPendingUpdate,
+		previousNotifyUpdate: instance.notifyUpdate,
+		previousPlaceholder: instance._placeholder,
+		previousMounted: instance.mounted,
+		previousCurrentRenderToken: instance._currentRenderToken,
+		previousLastRenderToken: instance.lastRenderToken,
+		previousPendingReadSources: instance._pendingReadSources,
+		previousPendingReadSourceVersions: instance._pendingReadSourceVersions,
+		previousLastReadSources: instance._lastReadSources,
+		previousInstances: instance.target ? collectHostInstances(instance.target) : []
+	};
+}
+function restoreDeferredRouteInstance(deferred) {
+	const instance = deferred.instance;
+	const errors = restoreRouteDom(deferred.previousDom);
+	instance.fn = deferred.previousFn;
+	instance.props = deferred.previousProps;
+	instance.expectedStateIndices = deferred.previousExpectedStateIndices;
+	instance.firstRenderComplete = deferred.previousFirstRenderComplete;
+	instance.stateIndexCheck = deferred.previousStateIndexCheck;
+	instance.errorBoundaryState = deferred.previousErrorBoundaryState;
+	instance.target = deferred.previousTarget;
+	instance.stateValues = deferred.previousStateValues;
+	instance.cleanupFns = deferred.previousCleanupFns;
+	instance._ownedChildScopes = deferred.previousOwnedChildScopes;
+	instance.abortController = deferred.previousAbortController;
+	instance.mountOperations = deferred.previousMountOperations;
+	instance.commitOperations = deferred.previousCommitOperations;
+	instance.lifecycleSlots = deferred.previousLifecycleSlots;
+	instance.lifecycleGeneration = deferred.previousLifecycleGeneration;
+	instance.evaluationGeneration = deferred.previousEvaluationGeneration;
+	instance.hasPendingUpdate = deferred.previousHasPendingUpdate;
+	instance.notifyUpdate = deferred.previousNotifyUpdate;
+	instance._placeholder = deferred.previousPlaceholder;
+	instance.mounted = deferred.previousMounted;
+	instance._currentRenderToken = deferred.previousCurrentRenderToken;
+	instance.lastRenderToken = deferred.previousLastRenderToken;
+	instance._pendingReadSources = deferred.previousPendingReadSources;
+	instance._pendingReadSourceVersions = deferred.previousPendingReadSourceVersions;
+	instance._lastReadSources = deferred.previousLastReadSources;
+	return errors;
+}
+function restoreDeferredRouteInstances(deferredCleanups) {
+	const errors = [];
+	for (let index = deferredCleanups.length - 1; index >= 0; index -= 1) errors.push(...restoreDeferredRouteInstance(deferredCleanups[index]));
+	if (errors.length > 0) reportRouteCleanupErrors(errors);
+}
+function cleanupDeferredRouteInstance(deferred) {
+	const errors = [];
+	const instance = deferred.instance;
+	const current = {
+		stateValues: instance.stateValues,
+		cleanupFns: instance.cleanupFns,
+		ownedChildScopes: instance._ownedChildScopes,
+		abortController: instance.abortController,
+		mountOperations: instance.mountOperations,
+		commitOperations: instance.commitOperations,
+		lifecycleSlots: instance.lifecycleSlots,
+		lifecycleGeneration: instance.lifecycleGeneration,
+		evaluationGeneration: instance.evaluationGeneration,
+		hasPendingUpdate: instance.hasPendingUpdate,
+		notifyUpdate: instance.notifyUpdate,
+		placeholder: instance._placeholder,
+		mounted: instance.mounted,
+		currentRenderToken: instance._currentRenderToken,
+		lastRenderToken: instance.lastRenderToken,
+		pendingReadSources: instance._pendingReadSources,
+		pendingReadSourceVersions: instance._pendingReadSourceVersions,
+		lastReadSources: instance._lastReadSources
+	};
+	instance.stateValues = deferred.previousStateValues;
+	instance.cleanupFns = deferred.previousCleanupFns;
+	instance._ownedChildScopes = deferred.previousOwnedChildScopes;
+	instance.abortController = deferred.previousAbortController;
+	instance.mountOperations = deferred.previousMountOperations;
+	instance.commitOperations = deferred.previousCommitOperations;
+	instance.lifecycleSlots = deferred.previousLifecycleSlots;
+	instance.lifecycleGeneration = deferred.previousLifecycleGeneration;
+	instance.evaluationGeneration = deferred.previousEvaluationGeneration;
+	instance.hasPendingUpdate = deferred.previousHasPendingUpdate;
+	instance.notifyUpdate = deferred.previousNotifyUpdate;
+	instance._placeholder = deferred.previousPlaceholder;
+	instance.mounted = deferred.previousMounted;
+	instance._currentRenderToken = deferred.previousCurrentRenderToken;
+	instance.lastRenderToken = deferred.previousLastRenderToken;
+	instance._pendingReadSources = deferred.previousPendingReadSources;
+	instance._pendingReadSourceVersions = deferred.previousPendingReadSourceVersions;
+	instance._lastReadSources = deferred.previousLastReadSources;
 	try {
 		cleanupComponent(instance);
 	} catch (error) {
-		cleanupErrors.push(error);
+		errors.push(error);
+	} finally {
+		instance.stateValues = current.stateValues;
+		instance.cleanupFns = current.cleanupFns;
+		instance._ownedChildScopes = current.ownedChildScopes;
+		instance.abortController = current.abortController;
+		instance.mountOperations = current.mountOperations;
+		instance.commitOperations = current.commitOperations;
+		instance.lifecycleSlots = current.lifecycleSlots;
+		instance.lifecycleGeneration = current.lifecycleGeneration;
+		instance.evaluationGeneration = current.evaluationGeneration;
+		instance.hasPendingUpdate = current.hasPendingUpdate;
+		instance.notifyUpdate = current.notifyUpdate;
+		instance._placeholder = current.placeholder;
+		instance.mounted = current.mounted;
+		instance._currentRenderToken = current.currentRenderToken;
+		instance.lastRenderToken = current.lastRenderToken;
+		instance._pendingReadSources = current.pendingReadSources;
+		instance._pendingReadSourceVersions = current.pendingReadSourceVersions;
+		instance._lastReadSources = current.lastReadSources;
 	}
-	if (cleanupErrors.length > 0) throw new AggregateError(cleanupErrors, "Route cleanup failed");
+	const root = instance.target;
+	const liveInstances = root ? new Set(collectHostInstances(root)) : /* @__PURE__ */ new Set();
+	for (let index = deferred.previousInstances.length - 1; index >= 0; index--) {
+		const previous = deferred.previousInstances[index];
+		if (previous === instance || liveInstances.has(previous)) continue;
+		try {
+			cleanupComponent(previous);
+		} catch (error) {
+			errors.push(error);
+		}
+	}
+	return errors;
 }
-function remountResolvedRoute(instance, resolved, pathname, href) {
+function remountResolvedRoute(instance, resolved, pathname, href, existingSnapshot) {
+	const deferredCleanup = existingSnapshot ?? captureDeferredRouteCleanup(instance);
 	clearDefaultPortalForInstance(instance);
-	cleanupRouteOwnership(instance);
 	instance.fn = wrapRootRouteHandler(bindResolvedRouteHandler(resolved));
 	instance.props = {};
 	instance.stateValues = [];
@@ -105,6 +333,7 @@ function remountResolvedRoute(instance, resolved, pathname, href) {
 	instance.commitOperations = [];
 	instance.lifecycleSlots = [];
 	instance.cleanupFns = [];
+	instance._ownedChildScopes = /* @__PURE__ */ new Set();
 	instance._placeholder = void 0;
 	instance.hasPendingUpdate = false;
 	instance._currentRenderToken = void 0;
@@ -114,7 +343,7 @@ function remountResolvedRoute(instance, resolved, pathname, href) {
 	instance.abortController = null;
 	mountComponent(instance);
 	setCurrentRouteLocation(pathname, href);
-	return true;
+	return deferredCleanup;
 }
 function rerenderResolvedRoute(instance, pathname, href) {
 	setCurrentRouteLocation(pathname, href);
@@ -141,6 +370,15 @@ function resolveAppRouteRequest(app, pathname, href, signal) {
 		signal
 	});
 }
+function getResolvedRouteHandler(resolved) {
+	if (!resolved) throw new Error("[Askr] cannot prepare an unmatched navigation target");
+	if (resolved.kind === "deny") return createDeniedResolvedRoute(resolved.status);
+	if (!isRenderResult(resolved)) throw new Error("[Askr] cannot prepare a redirect as a destination root");
+	return {
+		handler: resolved.handler,
+		params: resolved.params
+	};
+}
 function resolveNavigationTargetsForApps(pathname, href, signal) {
 	const apps = getRegisteredAppsSnapshot();
 	if (apps.length === 1) {
@@ -174,8 +412,10 @@ function resolveNavigationTargetsForApps(pathname, href, signal) {
 	if (pendingTargets.length === 0) return syncTargets;
 	return Promise.all([...syncTargets.map((target) => Promise.resolve(target)), ...pendingTargets]);
 }
-function applyNavigationTargets(path, options, redirectState, pathname, href, targets, navigateWithRedirectState) {
+function applyNavigationTargets(requestId, path, options, redirectState, pathname, href, targets, navigateWithRedirectState) {
+	if (isStaleRouteRequest(requestId)) return;
 	const previousPathname = getCurrentPathname();
+	const previousHref = getCurrentHref();
 	for (const target of targets) {
 		const resolved = target.resolved;
 		if (!resolved || resolved.kind !== "redirect") continue;
@@ -197,27 +437,96 @@ function applyNavigationTargets(path, options, redirectState, pathname, href, ta
 		if (isDevelopmentEnvironment()) logger.warn(`No route found for path: ${path}`);
 		return;
 	}
-	saveScrollPosition(getCurrentHref());
-	const historyMethod = getNavigationHistoryMode(options) === "replace" ? "replaceState" : "pushState";
-	window.history[historyMethod]({ path: href }, "", href);
-	syncRegisteredRouteSnapshot();
+	if (isStaleRouteRequest(requestId)) return;
+	const samePathTargets = [];
+	const rootsToPrepare = [];
 	for (const target of matchedTargets) {
 		const resolved = target.resolved;
 		if (resolved.kind === "redirect") continue;
 		if (pathname === target.app.pathname && isRenderResult(resolved)) {
-			rerenderResolvedRoute(target.app.instance, pathname, href);
-			syncAppRegistrationLocation(target.app, pathname, href);
+			samePathTargets.push(target);
 			continue;
 		}
-		remountResolvedRoute(target.app.instance, resolved.kind === "deny" ? createDeniedResolvedRoute(resolved.status) : {
-			handler: resolved.handler,
-			params: resolved.params
-		}, pathname, href);
-		syncAppRegistrationLocation(target.app, pathname, href);
+		rootsToPrepare.push(target);
+	}
+	const rollbackSnapshots = matchedTargets.map((target) => captureDeferredRouteCleanup(target.app.instance));
+	const rollbackSnapshotByInstance = new Map(rollbackSnapshots.map((snapshot) => [snapshot.instance, snapshot]));
+	const deferredCleanups = [];
+	const cleanupErrors = [];
+	const previousAppLocations = matchedTargets.map((target) => ({
+		app: target.app,
+		pathname: target.app.pathname,
+		href: target.app.href
+	}));
+	const restoreOnExit = () => {
+		if (!navigationBatchClosed) {
+			discardLifecycleCommitBatch(navigationBatch);
+			navigationBatchClosed = true;
+		}
+		restoreDeferredRouteInstances(rollbackSnapshots);
+		for (const previous of previousAppLocations) {
+			previous.app.pathname = previous.pathname;
+			previous.app.href = previous.href;
+		}
+		setCurrentRouteLocation(previousPathname, previousHref);
+	};
+	const navigationBatch = beginLifecycleCommitBatch();
+	let navigationBatchClosed = false;
+	try {
+		for (const target of rootsToPrepare) {
+			if (isStaleRouteRequest(requestId)) {
+				restoreOnExit();
+				return;
+			}
+			const deferredCleanup = remountResolvedRoute(target.app.instance, getResolvedRouteHandler(target.resolved), pathname, href, rollbackSnapshotByInstance.get(target.app.instance));
+			deferredCleanups.push(deferredCleanup);
+		}
+		if (isStaleRouteRequest(requestId)) {
+			restoreOnExit();
+			return;
+		}
+		flushRuntimeScheduler();
+		cleanupErrors.push(...drainLifecycleCommitErrors());
+		if (isStaleRouteRequest(requestId)) {
+			restoreOnExit();
+			return;
+		}
+		for (const target of samePathTargets) {
+			if (isStaleRouteRequest(requestId)) {
+				restoreOnExit();
+				return;
+			}
+			rerenderResolvedRoute(target.app.instance, pathname, href);
+		}
+		flushRuntimeScheduler();
+		cleanupErrors.push(...drainLifecycleCommitErrors());
+		if (isStaleRouteRequest(requestId)) {
+			restoreOnExit();
+			return;
+		}
+		flushLifecycleCommitBatch(navigationBatch);
+		navigationBatchClosed = true;
+		cleanupErrors.push(...drainLifecycleCommitErrors());
+		for (const target of matchedTargets) if (target.resolved && target.resolved.kind !== "redirect") syncAppRegistrationLocation(target.app, pathname, href);
+		if (isStaleRouteRequest(requestId)) {
+			restoreOnExit();
+			return;
+		}
+		saveScrollPosition(previousHref);
+		const historyMethod = getNavigationHistoryMode(options) === "replace" ? "replaceState" : "pushState";
+		window.history[historyMethod]({ path: href }, "", href);
+		setCurrentRouteLocation(pathname, href);
+		syncRegisteredRouteSnapshot();
+		if (pathname !== previousPathname) applyNavigationScroll(options.scroll);
+		for (const deferredCleanup of deferredCleanups) cleanupErrors.push(...cleanupDeferredRouteInstance(deferredCleanup));
+		for (const error of cleanupErrors) reportRouteCleanupErrors([error]);
+	} catch (error) {
+		restoreOnExit();
+		logger.error("[Askr] navigation failed:", error);
+		throw error;
 	}
-	if (pathname !== previousPathname) applyNavigationScroll(options.scroll);
 }
-function applyPopStateNavigationTargets(requestId, pathname, href, state, targets, navigate) {
+function applyPopStateNavigationTargets(requestId, previousHref, previousState, pathname, href, state, targets, navigate) {
 	if (isStaleRouteRequest(requestId)) return;
 	const matchedTargets = targets.filter((target) => target.resolved !== null);
 	if (matchedTargets.length === 0) {
@@ -230,24 +539,96 @@ function applyPopStateNavigationTargets(requestId, pathname, href, state, target
 		navigate(resolved.to, { history: getRedirectHistoryMode(resolved.replace) });
 		return;
 	}
-	syncRegisteredRouteSnapshot();
+	const samePathTargets = [];
+	const rootsToPrepare = [];
 	for (const target of matchedTargets) {
 		const resolved = target.resolved;
 		if (pathname === target.app.pathname && isRenderResult(resolved)) {
-			rerenderResolvedRoute(target.app.instance, pathname, href);
-			syncAppRegistrationLocation(target.app, pathname, href);
+			samePathTargets.push(target);
 			continue;
 		}
 		if (resolved.kind === "redirect") continue;
-		remountResolvedRoute(target.app.instance, resolved.kind === "deny" ? createDeniedResolvedRoute(resolved.status) : {
-			handler: resolved.handler,
-			params: resolved.params
-		}, pathname, href);
-		syncAppRegistrationLocation(target.app, pathname, href);
+		rootsToPrepare.push(target);
+	}
+	const previousPathname = getCurrentPathname();
+	const rollbackSnapshots = matchedTargets.map((target) => captureDeferredRouteCleanup(target.app.instance));
+	const rollbackSnapshotByInstance = new Map(rollbackSnapshots.map((snapshot) => [snapshot.instance, snapshot]));
+	const deferredCleanups = [];
+	const cleanupErrors = [];
+	const previousAppLocations = matchedTargets.map((target) => ({
+		app: target.app,
+		pathname: target.app.pathname,
+		href: target.app.href
+	}));
+	const restoreOnExit = () => {
+		if (!navigationBatchClosed) {
+			discardLifecycleCommitBatch(navigationBatch);
+			navigationBatchClosed = true;
+		}
+		restoreDeferredRouteInstances(rollbackSnapshots);
+		for (const previous of previousAppLocations) {
+			previous.app.pathname = previous.pathname;
+			previous.app.href = previous.href;
+		}
+		setCurrentRouteLocation(previousPathname, previousHref);
+	};
+	const navigationBatch = beginLifecycleCommitBatch();
+	let navigationBatchClosed = false;
+	try {
+		for (const target of rootsToPrepare) {
+			if (isStaleRouteRequest(requestId)) {
+				restoreOnExit();
+				return;
+			}
+			const deferredCleanup = remountResolvedRoute(target.app.instance, getResolvedRouteHandler(target.resolved), pathname, href, rollbackSnapshotByInstance.get(target.app.instance));
+			deferredCleanups.push(deferredCleanup);
+		}
+		if (isStaleRouteRequest(requestId)) {
+			restoreOnExit();
+			return;
+		}
+		flushRuntimeScheduler();
+		cleanupErrors.push(...drainLifecycleCommitErrors());
+		if (isStaleRouteRequest(requestId)) {
+			restoreOnExit();
+			return;
+		}
+		for (const target of samePathTargets) {
+			if (isStaleRouteRequest(requestId)) {
+				restoreOnExit();
+				return;
+			}
+			rerenderResolvedRoute(target.app.instance, pathname, href);
+		}
+		flushRuntimeScheduler();
+		cleanupErrors.push(...drainLifecycleCommitErrors());
+		if (isStaleRouteRequest(requestId)) {
+			restoreOnExit();
+			return;
+		}
+		flushLifecycleCommitBatch(navigationBatch);
+		navigationBatchClosed = true;
+		cleanupErrors.push(...drainLifecycleCommitErrors());
+		for (const target of matchedTargets) if (target.resolved && target.resolved.kind !== "redirect") syncAppRegistrationLocation(target.app, pathname, href);
+		if (isStaleRouteRequest(requestId)) {
+			restoreOnExit();
+			return;
+		}
+		setCurrentRouteLocation(pathname, href);
+		syncRegisteredRouteSnapshot();
+		applyHistoryScroll(href, state);
+		for (const deferredCleanup of deferredCleanups) cleanupErrors.push(...cleanupDeferredRouteInstance(deferredCleanup));
+		for (const error of cleanupErrors) reportRouteCleanupErrors([error]);
+	} catch (error) {
+		restoreOnExit();
+		try {
+			window.history.replaceState(previousState, "", previousHref);
+			syncRegisteredRouteSnapshot();
+		} catch (rollbackError) {
+			logger.error("[Askr] failed to restore URL after popstate failure:", rollbackError);
+		}
+		throw error;
 	}
-	applyHistoryScroll(href, state);
 }
 //#endregion
 export { applyNavigationTargets, applyPopStateNavigationTargets, beginRouteRequest, cancelRouteRequests, getRedirectHistoryMode, isStaleRouteRequest, resolveNavigationTargetsForApps };
-
-//# sourceMappingURL=navigation-targets.js.map

package/dist/router/policy.d.ts

@@ -24,5 +24,4 @@ declare function requireRole(role: string): RoutePolicy;
 declare function requirePermission(permission: string): RoutePolicy;
 declare function evaluateRoutePolicy(policy: RoutePolicy, context: RouteContext): Promise<AccessDecision>;
 //#endregion
-export { BuiltInRoutePolicyKind, BuiltInRoutePolicyMetadata, allow, deny, forbidden, notFound, redirect, requireAuth, requirePermission, requireRole, unauthorized };
-//# sourceMappingURL=policy.d.ts.map
+export { BuiltInRoutePolicyKind, BuiltInRoutePolicyMetadata, allow, deny, forbidden, notFound, redirect, requireAuth, requirePermission, requireRole, unauthorized };

package/dist/router/policy.js

@@ -128,5 +128,3 @@ function requirePermission(permission) {
 }
 //#endregion
 export { _getBuiltInRoutePolicy, allow, deny, forbidden, notFound, redirect, requireAuth, requireGuest, requirePermission, requireRole, unauthorized, withRouteAuthOptions };
-
-//# sourceMappingURL=policy.js.map

package/dist/router/rendering.d.ts

@@ -6,5 +6,4 @@ declare function Outlet(): JSXElement;
 declare function createRouteHandler(component: RouteComponent, pageChain: readonly PageScopeRecord[], layoutChain: readonly LayoutScopeRecord[], deferComponents?: boolean): RouteHandler;
 declare function getRenderHandler(record: RouteRecord): RouteHandler;
 //#endregion
-export { Outlet };
-//# sourceMappingURL=rendering.d.ts.map
+export { Outlet };

package/dist/router/rendering.js

@@ -1,5 +1,6 @@
 import { ELEMENT_TYPE, Fragment } from "../common/jsx.js";
 import { defineContext, readContext } from "../runtime/context.js";
+import "../runtime/index.js";
 import { ROUTE_ROOT_COMPONENT } from "../common/router-internal.js";
 //#region src/router/rendering.ts
 const outletContext = defineContext(null);
@@ -32,7 +33,10 @@ function createRouteHandler(component, pageChain, layoutChain, deferComponents =
 	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 });
+		for (let i = layoutChain.length - 1; i >= 0; i--) {
+			const layout = layoutChain[i].component;
+			content = layout({ children: content });
+		}
 		return content;
 	};
 }
@@ -41,5 +45,3 @@ function getRenderHandler(record) {
 }
 //#endregion
 export { Outlet, createRouteHandler, getRenderHandler };
-
-//# sourceMappingURL=rendering.js.map

package/dist/router/resolution.d.ts

@@ -1,17 +1,3 @@
-import { ResolvedRoute, Route, RouteManifest, RouteMatch, RouteRecord, RouteRequestOptions, RouteRequestResult } from "../common/router.js";
-
+import { RouteRequestOptions, RouteRequestResult } from "../common/router.js";
 //#region src/router/resolution.d.ts
-declare function computeMatchesFromRoutes(pathname: string, routesList: readonly Route[]): RouteMatch[];
-declare function computeMatchesFromRouteRecords(pathname: string, routeRecords: readonly RouteRecord[]): RouteMatch[];
-declare function computeRouteActivityMatches(pathname: string, options?: {
-  manifest?: RouteManifest;
-  routes?: readonly Route[];
-}): RouteMatch[];
-declare function resolveRoute(pathname: string): ResolvedRoute | null;
-declare function resolveRouteRequest(target: string, options?: RouteRequestOptions): RouteRequestResult | Promise<RouteRequestResult>;
-declare function resolveRouteFromRoutes(pathname: string, routeList: readonly Route[]): ResolvedRoute | null;
-declare function _resolveRouteMatchFromRoutes(pathname: string, routeList: readonly Route[]): {
-  route: Route;
-  params: Record<string, string>;
-} | null;
-//# sourceMappingURL=resolution.d.ts.map
+declare function resolveRouteRequest(target: string, options?: RouteRequestOptions): RouteRequestResult | Promise<RouteRequestResult>;