@askrjs/askr 0.2.4 → 0.3.1

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

@@ -1,15 +1,19 @@
-import { S as isProductionEnvironment, r as flushRuntimeScheduler, s as isRuntimeSchedulerExecuting, x as isDevelopmentEnvironment, y as logger } from "./access-BucjYZcX.js";
-import { n as Fragment, t as ELEMENT_TYPE } from "./jsx-DRS-qjiN.js";
-import { r as executeComponent } from "./component-internal-C4hKKQBF.js";
-import { t as cleanupReadableSubscriptionSources } from "./readable-Di1fzSwm.js";
-import { n as cleanupComponentGeneration, t as cleanupComponent } from "./component-cleanup-jdbgjkT1.js";
-import { i as drainLifecycleCommitErrors, p as isPromiseLike, r as discardLifecycleCommitBatch, s as flushLifecycleCommitBatch, t as beginLifecycleCommitBatch } from "./lifecycle-batch-63aXFf2S.js";
-import { _ as teardownNodeSubtree } from "./cleanup-TXSsApEl.js";
-import { t as CspNonceScope } from "./csp-nonce-9NFUb7hJ.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-ClD-K7Lz.js";
-import { a as clearStagedAppRenderRouteLocation, i as syncCurrentRouteSnapshot, o as createAppRenderRuntime, s as stageAppRenderRouteLocation } from "./activity-FirwPXA_.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 = "/";
@@ -422,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();
@@ -479,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);
@@ -516,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,
@@ -781,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();
@@ -850,79 +581,7 @@ 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]({
@@ -930,18 +589,9 @@ function applyNavigationTargets(requestId, path, options, redirectState, pathnam
 			askrHasState: Object.prototype.hasOwnProperty.call(options, "state"),
 			askrState: options.state
 		}, "", href);
-		setCurrentRouteLocation(pathname, href);
-		clearStagedRouteLocations(matchedTargets);
-		syncRegisteredRouteSnapshot();
-		reconcileNavigationMetadata(matchedTargets);
+	}, () => {
 		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;
@@ -956,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
@@ -1058,9 +694,23 @@ 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());
@@ -1093,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;
@@ -1118,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;
@@ -1125,6 +777,7 @@ function handlePopState(event) {
 	applyResolved(resolvedTargets);
 }
 function initializeNavigation() {
+	ensureNavigationRegistryHost();
 	if (typeof window === "undefined" || navigationInitialized) return;
 	navigationInitialized = true;
 	window.addEventListener("popstate", handlePopState);
@@ -1132,4 +785,4 @@ function initializeNavigation() {
 	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 };