@askrjs/askr 0.2.3 → 0.3.0

package/dist/{navigate-C46GtScG.js → navigate-prC5V8XV.js}

@@ -1,15 +1,19 @@
-import { S as isProductionEnvironment, r as flushRuntimeScheduler, x as isDevelopmentEnvironment, y as logger } from "./access-Rr7CMa06.js";
-import { n as Fragment, t as ELEMENT_TYPE } from "./jsx-DRS-qjiN.js";
-import { r as executeComponent } from "./component-internal-Dl02WQKS.js";
-import { t as cleanupReadableSubscriptionSources } from "./readable-CEcteIDE.js";
-import { n as cleanupComponentGeneration, t as cleanupComponent } from "./component-cleanup-DjpwO9WX.js";
-import { i as drainLifecycleCommitErrors, p as isPromiseLike, r as discardLifecycleCommitBatch, s as flushLifecycleCommitBatch, t as beginLifecycleCommitBatch } from "./lifecycle-batch-Be-CLDjV.js";
-import { _ as teardownNodeSubtree } from "./cleanup-DsrbV-rr.js";
-import { t as CspNonceScope } from "./csp-nonce-C9OuML0U.js";
-import { I as lockRouteRegistration, o as addRouteBasePath, r as computeRouteActivityMatches, y as getActiveRouteBasePath } from "./route-matching-Bo6UqG-5.js";
-import { a as resolveRouteRequest, i as hasRouteRenderData, n as getRouteRenderContext, r as getRouteRenderData, u as withoutRouteHydrationMetadata } from "./resolution-t8J0yNaU.js";
-import { a as clearStagedAppRenderRouteLocation, i as syncCurrentRouteSnapshot, o as createAppRenderRuntime, s as stageAppRenderRouteLocation } from "./activity-ZxJXI9hF.js";
-import { r as getDefaultPortalHost, t as clearRegisteredDefaultPortalForInstance } from "./default-portal-runtime-DvMvWJVp.js";
+import { T as isProductionEnvironment, r as flushRuntimeScheduler, u as isRuntimeSchedulerExecuting, v as logger, w as isDevelopmentEnvironment } from "./access-CEA2pOry.js";
+import { P as isPromiseLike } from "./instance-VAFYVJOa.js";
+import { i as commitTransaction, l as registerCommitParticipant, o as discardTransaction, r as beginCommitTransaction } from "./notify-DxxuDPeY.js";
+import { i as syncCurrentRouteSnapshot } from "./activity-oy2YFTFF.js";
+import { a as resolveRouteRequest, i as hasRouteRenderData, n as getRouteRenderContext, r as getRouteRenderData } from "./resolution-3DskUkjG.js";
+import { L as lockRouteRegistration, b as getActiveRouteBasePath, o as addRouteBasePath, r as computeRouteActivityMatches } from "./route-matching-CUzZ31gT.js";
+//#region src/common/root-update.ts
+let rootUpdateHost;
+function configureRootUpdateHost(host) {
+	rootUpdateHost = host;
+}
+function prepareRootUpdate(root, input) {
+	if (!rootUpdateHost) throw new Error("[Askr] Root update host is not configured.");
+	return rootUpdateHost.prepare(root, input);
+}
+//#endregion
 //#region src/router/navigation-registry.ts
 let currentInstance = null;
 let currentPathname = "/";
@@ -112,6 +116,58 @@ const DEFAULT_SCROLL_RESTORATION = {
 };
 let scrollRestorationOptions = { ...DEFAULT_SCROLL_RESTORATION };
 const scrollPositions = /* @__PURE__ */ new Map();
+let capturedActivationFocus;
+let pendingNavigationFocus;
+let focusAtHistoryNavigationStart = null;
+function readFocusDescriptor() {
+	if (typeof document === "undefined" || !(document.activeElement instanceof HTMLElement)) return;
+	const active = document.activeElement;
+	for (const attribute of [
+		"data-askr-focus-key",
+		"id",
+		"name",
+		"aria-label"
+	]) {
+		const value = active.getAttribute(attribute);
+		if (value) return {
+			attribute,
+			value
+		};
+	}
+	if ("labels" in active) {
+		const label = Array.from(active.labels ?? []).map((element) => element.textContent?.trim()).find(Boolean);
+		if (label) return {
+			attribute: "label",
+			value: label
+		};
+	}
+}
+function clearCapturedNavigationFocus() {
+	capturedActivationFocus = void 0;
+}
+function isPrimaryPointerActivation(event) {
+	if (event instanceof MouseEvent && (event.button !== 0 || event.metaKey || event.ctrlKey || event.shiftKey || event.altKey)) return false;
+	return true;
+}
+/** Stage entry-owned focus for the duration of one primary pointer activation. */
+function captureNavigationFocus(event) {
+	clearCapturedNavigationFocus();
+	if (!isPrimaryPointerActivation(event)) return;
+	capturedActivationFocus = readFocusDescriptor();
+}
+/** Release pointer activation state after its click has finished dispatching. */
+function releaseNavigationFocusCapture() {
+	clearCapturedNavigationFocus();
+}
+/** Preserve the active control before route content can be replaced. */
+function prepareNavigationFocus() {
+	pendingNavigationFocus = capturedActivationFocus ?? readFocusDescriptor();
+	clearCapturedNavigationFocus();
+}
+/** Mark the active element so restoration can avoid overwriting focus moved during route commit. */
+function beginHistoryFocusRestoration() {
+	focusAtHistoryNavigationStart = typeof document === "undefined" ? null : document.activeElement;
+}
 function getWindowHref() {
 	if (typeof window === "undefined") return "/";
 	return `${window.location.pathname}${window.location.search}${window.location.hash}`;
@@ -146,8 +202,10 @@ function writeHistoryScrollPosition(href, position) {
 	window.history.replaceState({
 		...state,
 		path: href,
-		scroll: position
+		scroll: position,
+		focus: pendingNavigationFocus ?? readFocusDescriptor()
 	}, "", href);
+	pendingNavigationFocus = void 0;
 }
 function saveScrollPosition(href) {
 	if (!scrollRestorationOptions.enabled || typeof window === "undefined") return;
@@ -194,6 +252,12 @@ function applyHistoryScroll(href, state) {
 		x: 0,
 		y: 0
 	});
+	const focus = state && typeof state === "object" && state.focus && typeof state.focus === "object" ? state.focus : void 0;
+	if (focus && (focus.attribute === "data-askr-focus-key" || focus.attribute === "id" || focus.attribute === "name" || focus.attribute === "aria-label" || focus.attribute === "label") && typeof focus.value === "string" && typeof document !== "undefined" && (document.activeElement === document.body || document.activeElement === document.documentElement || document.activeElement === focusAtHistoryNavigationStart)) {
+		const target = focus.attribute === "label" ? Array.from(document.querySelectorAll("input,select,textarea,button")).find((element) => "labels" in element && Array.from(element.labels ?? []).some((label) => label.textContent?.trim() === focus.value)) : Array.from(document.querySelectorAll(`[${focus.attribute}]`)).find((element) => element.getAttribute(focus.attribute) === focus.value);
+		if (target?.isConnected && !target.hasAttribute("disabled") && target.getAttribute("aria-hidden") !== "true" && target.getClientRects().length > 0) target.focus({ preventScroll: true });
+	}
+	focusAtHistoryNavigationStart = null;
 }
 function configureScrollRestoration(options) {
 	scrollRestorationOptions = normalizeScrollRestorationOptions(options);
@@ -362,6 +426,11 @@ function beginRouteRequest() {
 function isStaleRouteRequest(requestId) {
 	return requestId !== activeRouteRequestId;
 }
+/**
+* @internal Teardown-only cancellation. Prefer aborting through the signal
+* returned by `beginRouteRequest()`; this exists for registry teardown, where
+* no request owns the abort.
+*/
 function cancelRouteRequests() {
 	activeRouteRequestId += 1;
 	activeRouteRequestController?.abort();
@@ -419,29 +488,6 @@ function createDeniedResolvedRoute(status) {
 function bindResolvedRouteHandler(resolved) {
 	return () => resolved.handler(resolved.params);
 }
-function wrapRootRouteHandler(componentFn, cspNonce) {
-	const wrappedFn = (props, ctx) => {
-		const out = componentFn(props, ctx);
-		if (isPromiseLike(out)) throw new Error("Async components are not supported. Components must return synchronously.");
-		const portalVNode = {
-			$$typeof: ELEMENT_TYPE,
-			type: getDefaultPortalHost(),
-			props: { __askrAutoDefaultPortal: true },
-			key: "__default_portal"
-		};
-		const root = {
-			$$typeof: ELEMENT_TYPE,
-			type: Fragment,
-			props: { children: out === void 0 || out === null ? [portalVNode] : [out, portalVNode] }
-		};
-		return cspNonce === void 0 ? root : CspNonceScope({
-			value: cspNonce,
-			children: root
-		});
-	};
-	Object.defineProperty(wrappedFn, "name", { value: componentFn.name || "Component" });
-	return wrappedFn;
-}
 function flattenLifecycleErrors(error, result) {
 	if (error instanceof AggregateError) {
 		for (const nested of error.errors) flattenLifecycleErrors(nested, result);
@@ -456,255 +502,6 @@ function reportRouteCleanupErrors(errors) {
 		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) {
-		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();
-		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);
-		}
-		for (let child = node.lastChild; child; child = child.previousSibling) pending.push(child);
-	}
-	return instances;
-}
-function captureDeferredRouteCleanup(instance) {
-	return {
-		instance,
-		previousOwnershipGeneration: instance._ownershipGeneration,
-		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,
-		previousReaderEntries: Array.from(instance._lastReadSources ?? []).map((source) => ({
-			source,
-			reader: source._readers?.get(instance)
-		})),
-		previousAppRenderRuntime: instance._appRenderRuntime,
-		previousInstances: instance.target ? collectHostInstances(instance.target) : [],
-		previousDisposed: false
-	};
-}
-function restoreDeferredRouteInstance(deferred) {
-	const instance = deferred.instance;
-	const errors = [];
-	const activeGeneration = instance._ownershipGeneration;
-	const activeReadSources = instance._lastReadSources;
-	if (activeGeneration !== deferred.previousOwnershipGeneration) {
-		try {
-			cleanupReadableSubscriptionSources(instance, activeReadSources, activeGeneration);
-		} catch (error) {
-			errors.push(error);
-		}
-		instance._lastReadSources = void 0;
-		try {
-			cleanupComponent(instance);
-		} catch (error) {
-			errors.push(error);
-		}
-	}
-	errors.push(...restoreRouteDom(deferred.previousDom));
-	instance.fn = deferred.previousFn;
-	instance._ownershipGeneration = deferred.previousOwnershipGeneration;
-	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;
-	instance._appRenderRuntime = deferred.previousAppRenderRuntime;
-	const previousSources = new Set(deferred.previousReaderEntries.map(({ source }) => source));
-	for (const source of activeReadSources ?? []) {
-		if (previousSources.has(source)) continue;
-		if ((source._readers?.get(instance))?.generation === activeGeneration) {
-			if (source._readers?.delete(instance) && false);
-		}
-	}
-	for (const { source, reader } of deferred.previousReaderEntries) {
-		if (!reader) {
-			if (source._readers?.delete(instance) && false);
-			continue;
-		}
-		let readers = source._readers;
-		if (!readers) {
-			readers = /* @__PURE__ */ new Map();
-			source._readers = readers;
-		}
-		readers.has(instance);
-		readers.set(instance, reader);
-	}
-	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;
-	if (!deferred.previousDisposed) {
-		deferred.previousDisposed = true;
-		try {
-			cleanupComponentGeneration(instance, {
-				ownershipGeneration: deferred.previousOwnershipGeneration,
-				cleanupFns: deferred.previousCleanupFns,
-				ownedChildScopes: deferred.previousOwnedChildScopes,
-				abortController: deferred.previousAbortController,
-				readSources: deferred.previousLastReadSources
-			});
-		} catch (error) {
-			errors.push(error);
-		}
-	}
-	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, existingSnapshot) {
-	const deferredCleanup = existingSnapshot ?? captureDeferredRouteCleanup(instance);
-	clearRegisteredDefaultPortalForInstance(instance);
-	instance.fn = wrapRootRouteHandler(bindResolvedRouteHandler(resolved), instance._cspNonce);
-	instance.props = {};
-	instance._ownershipGeneration = {};
-	instance.stateValues = [];
-	instance.expectedStateIndices = [];
-	instance.firstRenderComplete = false;
-	instance.stateIndexCheck = -1;
-	instance.evaluationGeneration++;
-	instance.lifecycleGeneration++;
-	instance.notifyUpdate = null;
-	instance.mountOperations = [];
-	instance.commitOperations = [];
-	instance.lifecycleSlots = [];
-	instance.cleanupFns = [];
-	instance._ownedChildScopes = /* @__PURE__ */ new Set();
-	instance._placeholder = void 0;
-	instance.hasPendingUpdate = false;
-	instance._currentRenderToken = void 0;
-	instance.lastRenderToken = 0;
-	instance._pendingReadSources = void 0;
-	instance._lastReadSources = void 0;
-	instance.abortController = null;
-	executeComponent(instance);
-	setCurrentRouteLocation(pathname, href);
-	return deferredCleanup;
-}
-function rerenderResolvedRoute(instance, pathname, href) {
-	setCurrentRouteLocation(pathname, href);
-	instance._enqueueRun?.();
-	return true;
-}
 function resolveAppRouteRequest(app, pathname, href, signal) {
 	return resolveRouteRequest(href, {
 		registry: app.registry,
@@ -721,21 +518,15 @@ function getResolvedRouteHandler(resolved) {
 		params: resolved.params
 	};
 }
-function updateRouteRuntime(instance, resolved, href) {
-	const current = instance._appRenderRuntime;
-	const runtime = createAppRenderRuntime({
-		framework: withoutRouteHydrationMetadata(current?.framework),
-		dataRuntime: current?.dataRuntime,
-		routeRegistry: current?.routeRegistry,
-		routeAuth: current?.routeAuth,
-		route: resolved?.kind === "render" ? getRouteRenderData(resolved) : void 0,
-		hasRoute: resolved?.kind === "render" && hasRouteRenderData(resolved)
+function prepareNavigationRoot(target, href, replaceLifetime) {
+	const resolved = target.resolved;
+	return prepareRootUpdate(target.app.instance, {
+		handler: bindResolvedRouteHandler(getResolvedRouteHandler(resolved)),
+		href,
+		routeData: isRenderResult(resolved) ? getRouteRenderData(resolved) : void 0,
+		hasRouteData: isRenderResult(resolved) && hasRouteRenderData(resolved),
+		replaceLifetime
 	});
-	stageAppRenderRouteLocation(runtime, href);
-	instance._appRenderRuntime = runtime;
-}
-function clearStagedRouteLocations(targets) {
-	for (const target of targets) clearStagedAppRenderRouteLocation(target.app.instance._appRenderRuntime);
 }
 function resolveNavigationTargetsForApps(pathname, href, signal) {
 	const apps = getRegisteredAppsSnapshot();
@@ -790,94 +581,17 @@ function applyNavigationTargets(requestId, path, options, redirectState, pathnam
 		return;
 	}
 	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)) {
-			samePathTargets.push(target);
-			continue;
-		}
-		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;
-			}
-			updateRouteRuntime(target.app.instance, target.resolved, href);
-			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;
-			}
-			updateRouteRuntime(target.app.instance, target.resolved, href);
-			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)) return;
+	commitNavigationRoots(requestId, pathname, href, matchedTargets, () => {
 		saveScrollPosition(previousHref);
 		const historyMethod = getNavigationHistoryMode(options) === "replace" ? "replaceState" : "pushState";
-		window.history[historyMethod]({ path: href }, "", href);
-		setCurrentRouteLocation(pathname, href);
-		clearStagedRouteLocations(matchedTargets);
-		syncRegisteredRouteSnapshot();
-		reconcileNavigationMetadata(matchedTargets);
+		window.history[historyMethod]({
+			path: href,
+			askrHasState: Object.prototype.hasOwnProperty.call(options, "state"),
+			askrState: options.state
+		}, "", href);
+	}, () => {
 		if (pathname !== previousPathname || parseTargetUrl(href).hash) 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;
-	}
+	});
 }
 function applyPopStateNavigationTargets(requestId, previousHref, previousState, pathname, href, state, targets, navigate) {
 	if (isStaleRouteRequest(requestId)) return;
@@ -892,100 +606,86 @@ function applyPopStateNavigationTargets(requestId, previousHref, previousState,
 		navigate(resolved.to, { history: getRedirectHistoryMode(resolved.replace) });
 		return;
 	}
-	const samePathTargets = [];
-	const rootsToPrepare = [];
-	for (const target of matchedTargets) {
-		const resolved = target.resolved;
-		if (pathname === target.app.pathname && isRenderResult(resolved)) {
-			samePathTargets.push(target);
-			continue;
-		}
-		if (resolved.kind === "redirect") continue;
-		rootsToPrepare.push(target);
-	}
-	const previousPathname = getCurrentPathname();
 	saveScrollPosition(previousHref);
-	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;
+	commitNavigationRoots(requestId, pathname, href, matchedTargets, () => {}, () => applyHistoryScroll(href, state), () => {
+		window.history.replaceState(previousState, "", previousHref);
+		syncRegisteredRouteSnapshot();
+	});
+}
+/** Every root joins one transaction. History remains after lifecycle work,
+* so a navigation started by that work can supersede this destination. */
+function commitNavigationRoots(requestId, pathname, href, targets, updateHistory, updateScroll, restoreHistory) {
+	const previousPathname = getCurrentPathname();
+	const previousHref = getCurrentHref();
+	const roots = targets.map((target) => {
+		const replaceLifetime = pathname !== target.app.pathname || !isRenderResult(target.resolved);
+		return {
+			target,
+			replaceLifetime,
+			previousPathname: target.app.pathname,
+			previousHref: target.app.href,
+			prepared: prepareNavigationRoot(target, href, replaceLifetime)
+		};
+	});
+	const transaction = beginCommitTransaction();
+	let completionFailure;
+	registerCommitParticipant({
+		rollback() {
+			const errors = [];
+			for (let index = roots.length - 1; index >= 0; index--) errors.push(...roots[index].prepared.rollback());
+			for (const root of roots) {
+				root.target.app.pathname = root.previousPathname;
+				root.target.app.href = root.previousHref;
 			}
-			updateRouteRuntime(target.app.instance, target.resolved, href);
-			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;
+			setCurrentRouteLocation(previousPathname, previousHref);
+			try {
+				restoreHistory?.();
+			} catch (error) {
+				errors.push(error);
+			}
+			reportRouteCleanupErrors(errors);
+		},
+		settle() {
+			const errors = [];
+			for (const root of roots) errors.push(...root.prepared.retire());
+			reportRouteCleanupErrors(errors);
+		},
+		complete() {
+			if (isStaleRouteRequest(requestId)) return;
+			try {
+				updateHistory();
+				setCurrentRouteLocation(pathname, href);
+				syncRegisteredRouteSnapshot();
+				reconcileNavigationMetadata(targets);
+				updateScroll();
+			} catch (error) {
+				completionFailure = { error };
+				throw error;
+			} finally {
+				for (const root of roots) root.prepared.publish();
 			}
-			updateRouteRuntime(target.app.instance, target.resolved, href);
-			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);
-		clearStagedRouteLocations(matchedTargets);
-		syncRegisteredRouteSnapshot();
-		reconcileNavigationMetadata(matchedTargets);
-		applyHistoryScroll(href, state);
-		for (const deferredCleanup of deferredCleanups) cleanupErrors.push(...cleanupDeferredRouteInstance(deferredCleanup));
-		for (const error of cleanupErrors) reportRouteCleanupErrors([error]);
+	});
+	try {
+		for (const replaceLifetime of [true, false]) {
+			for (const root of roots) {
+				if (isStaleRouteRequest(requestId)) return;
+				if (root.replaceLifetime === replaceLifetime) root.prepared.apply();
+			}
+			if (isStaleRouteRequest(requestId)) return;
+			flushRuntimeScheduler();
+			if (isStaleRouteRequest(requestId)) return;
+		}
+		registerCommitParticipant({ publish() {
+			for (const root of roots) syncAppRegistrationLocation(root.target.app, pathname, href);
+		} });
+		commitTransaction(transaction);
+		if (completionFailure) throw completionFailure.error;
 	} catch (error) {
-		restoreOnExit();
-		try {
-			window.history.replaceState(previousState, "", previousHref);
-			syncRegisteredRouteSnapshot();
-		} catch (rollbackError) {
-			logger.error("[Askr] failed to restore URL after popstate failure:", rollbackError);
-		}
+		logger.error("[Askr] navigation failed:", error);
 		throw error;
+	} finally {
+		discardTransaction(transaction);
 	}
 }
 //#endregion
@@ -994,16 +694,38 @@ function applyPopStateNavigationTargets(requestId, previousHref, previousState,
 * Client-side navigation with History API
 */
 let navigationInitialized = false;
-configureNavigationRegistryHost({ cancelRouteRequests });
+let navigationRegistryHosted = false;
+/**
+* Publish request cancellation to the navigation registry.
+*
+* The registry cannot import this module (it is imported *by* it), so the
+* capability is injected. Doing that at module scope meant whether an app
+* could cancel its in-flight route requests depended on whether anything had
+* imported this module yet; every entry point that can navigate composes it.
+*/
+function ensureNavigationRegistryHost() {
+	if (navigationRegistryHosted) return;
+	navigationRegistryHosted = true;
+	configureNavigationRegistryHost({ cancelRouteRequests });
+}
 /** Navigate the client-side router to `path` using the History API. */
 function navigate(path, options = {}) {
+	ensureNavigationRegistryHost();
 	if (typeof window === "undefined") return;
+	prepareNavigationFocus();
 	const targetPath = addRouteBasePath(path, getActiveRouteBasePath());
 	const initialTarget = parseTargetUrl(targetPath);
-	navigateWithRedirectState(targetPath, options, {
+	const redirectState = {
 		redirects: 0,
 		visited: /* @__PURE__ */ new Set([`${initialTarget.pathname}${initialTarget.search}${initialTarget.hash}`])
-	});
+	};
+	if (isRuntimeSchedulerExecuting()) {
+		queueMicrotask(() => {
+			navigateWithRedirectState(targetPath, options, redirectState);
+		});
+		return;
+	}
+	navigateWithRedirectState(targetPath, options, redirectState);
 }
 function navigateWithRedirectState(path, options, redirectState) {
 	if (typeof window === "undefined") return;
@@ -1021,6 +743,7 @@ function navigateWithRedirectState(path, options, redirectState) {
 				logger.error("[Askr] navigation failed:", error);
 			}
 		}, (error) => {
+			if (isStaleRouteRequest(request.id)) return;
 			logger.error("[Askr] navigation failed:", error);
 		});
 		return;
@@ -1028,6 +751,7 @@ function navigateWithRedirectState(path, options, redirectState) {
 	applyNavigationTargets(request.id, path, options, redirectState, pathname, href, resolvedTargets, navigateWithRedirectState);
 }
 function handlePopState(event) {
+	beginHistoryFocusRestoration();
 	const request = beginRouteRequest();
 	const previousHref = getCurrentHref();
 	const pathname = window.location.pathname;
@@ -1045,6 +769,7 @@ function handlePopState(event) {
 		Promise.resolve(resolvedTargets).then((next) => {
 			applyResolved(next);
 		}, (error) => {
+			if (isStaleRouteRequest(request.id)) return;
 			logger.error("[Askr] popstate navigation failed:", error);
 		});
 		return;
@@ -1052,9 +777,12 @@ function handlePopState(event) {
 	applyResolved(resolvedTargets);
 }
 function initializeNavigation() {
+	ensureNavigationRegistryHost();
 	if (typeof window === "undefined" || navigationInitialized) return;
 	navigationInitialized = true;
 	window.addEventListener("popstate", handlePopState);
+	document.addEventListener("pointerdown", captureNavigationFocus, true);
+	document.addEventListener("click", releaseNavigationFocusCapture);
 }
 //#endregion
-export { serializeRouteMeta as a, getCurrentHref as c, parseTargetUrl as d, registerAppInstance as f, unregisterAppInstance as g, syncRegisteredRouteSnapshot as h, resolveRouteMeta as i, getRegisteredAppsSnapshot as l, syncAppRegistrationLocation as m, navigate as n, configureScrollRestoration as o, setCurrentRouteLocation as p, reconcileRouteMeta as r, saveScrollPosition as s, initializeNavigation as t, getWindowHref$1 as u };
+export { configureRootUpdateHost as _, serializeRouteMeta as a, getCurrentHref as c, parseTargetUrl as d, registerAppInstance as f, unregisterAppInstance as g, syncRegisteredRouteSnapshot as h, resolveRouteMeta as i, getRegisteredAppsSnapshot as l, syncAppRegistrationLocation as m, navigate as n, configureScrollRestoration as o, setCurrentRouteLocation as p, reconcileRouteMeta as r, saveScrollPosition as s, initializeNavigation as t, getWindowHref$1 as u };