@askrjs/askr 0.3.1 → 0.4.1

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

@@ -1,9 +1,40 @@
-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";
+import { I as logger, L as isDevelopmentEnvironment, R as isProductionEnvironment, x as isFlushing, y as flushSync } from "./instance-DL-YKrj6.js";
+import { b as reportUncaughtErrorLater, c as onCommit, i as currentComponent, n as createSource, o as hookSlot, r as currentAppRuntime, s as notify, u as readSource } from "./hooks-kjLigwDJ.js";
+import { n as getActiveRenderContext } from "./render-context-DGHnEveC.js";
+import { n as isPromiseLike } from "./promise-Dz8iIHAm.js";
+import { C as removeRouteBasePath, E as parseLocation, M as getActiveRouteBasePath, N as getActiveRoutes, T as makeQuery, Y as lockRouteRegistration, a as resolveRouteRequest, b as addLogicalRouteBasePath, g as computeRouteActivityMatches, h as computeMatchesFromRoutes, i as hasRouteRenderData, n as getRouteRenderContext, r as getRouteRenderData, w as deepFreeze } from "./resolution-CF1BqHLm.js";
+import { n as syncRouteActivitySnapshot } from "./route-activity-CNJfpwx-.js";
+import { c as resolveNavigationUrl } from "./url-C9xMpMMv.js";
+//#region src/common/app-render-runtime.ts
+const stagedRouteLocations = /* @__PURE__ */ new WeakMap();
+function createAppRenderRuntime(input = {}) {
+	return {
+		hydrationResources: input.hydrationResources,
+		framework: Object.freeze({ ...input.framework }),
+		route: input.route,
+		hasRoute: input.hasRoute ?? false,
+		dataRuntime: input.dataRuntime,
+		routeRegistry: input.routeRegistry,
+		routeAuth: input.routeAuth,
+		lifetime: input.lifetime
+	};
+}
+function stageAppRenderRouteLocation(runtime, href, state) {
+	stagedRouteLocations.set(runtime, {
+		href,
+		state
+	});
+}
+function getStagedAppRenderRouteLocation(runtime) {
+	return runtime ? stagedRouteLocations.get(runtime)?.href : void 0;
+}
+function getStagedAppRenderRouteState(runtime) {
+	return runtime ? stagedRouteLocations.get(runtime)?.state : void 0;
+}
+function clearStagedAppRenderRouteLocation(runtime) {
+	if (runtime) stagedRouteLocations.delete(runtime);
+}
+//#endregion
 //#region src/common/root-update.ts
 let rootUpdateHost;
 function configureRootUpdateHost(host) {
@@ -14,6 +45,169 @@ function prepareRootUpdate(root, input) {
 	return rootUpdateHost.prepare(root, input);
 }
 //#endregion
+//#region src/router/activity.ts
+function routeSignature(route) {
+	return `${route.path}\u0000${JSON.stringify(route.query.toJSON())}\u0000${route.hash ?? ""}`;
+}
+let currentRouteSnapshot = buildRouteSnapshot("/", "", "");
+const currentRouteSource = createSource();
+/** Register a callback to run whenever the active route changes, with optional cleanup. */
+function onRouteChange(fn, options = {}) {
+	const instance = currentComponent();
+	if (!instance) return;
+	const route = currentRoute();
+	const slot = hookSlot(instance, "onRouteChange", () => ({
+		kind: "route-change",
+		previous: null,
+		cleanup: null,
+		cleanupRegistered: false
+	}));
+	const immediate = options.immediate === true;
+	if (!slot.cleanupRegistered) {
+		instance.onCleanup(() => {
+			slot.cleanup?.();
+			slot.cleanup = null;
+		});
+		slot.cleanupRegistered = true;
+	}
+	onCommit(instance, () => {
+		const previous = slot.previous;
+		if (!previous) {
+			if (immediate) slot.cleanup = fn(route, null) ?? null;
+			slot.previous = route;
+			return;
+		}
+		if (routeSignature(previous) === routeSignature(route)) return;
+		slot.cleanup?.();
+		slot.cleanup = fn(route, previous) ?? null;
+		slot.previous = route;
+	});
+}
+let serverLocation = null;
+function readLocationState() {
+	if (getActiveRenderContext()?.mode === "ssr") return {
+		hasState: false,
+		state: void 0
+	};
+	const staged = getStagedAppRenderRouteState(currentAppRuntime());
+	if (staged) return staged;
+	const historyState = typeof window !== "undefined" && window.history?.state ? window.history.state : null;
+	const hasState = historyState?.askrHasState === true;
+	return {
+		hasState,
+		state: hasState ? historyState.askrState : void 0
+	};
+}
+function logicalRoutePathname(pathname) {
+	const logical = removeRouteBasePath(pathname, getActiveRouteBasePath());
+	return logical === void 0 ? void 0 : parseLocation(logical).pathname;
+}
+function routePathname(pathname) {
+	const logical = logicalRoutePathname(pathname);
+	return logical === void 0 ? {
+		pathname: parseLocation(pathname).pathname,
+		withinBasePath: false
+	} : {
+		pathname: logical,
+		withinBasePath: true
+	};
+}
+function setServerLocation(url) {
+	serverLocation = url;
+	if (url) {
+		const location = routePathname(parseLocation(url).pathname);
+		syncRouteActivitySnapshot(location.pathname, location.withinBasePath ? computeMatchesFromRoutes(location.pathname, getActiveRoutes()) : []);
+		return;
+	}
+	syncRouteActivitySnapshot(currentRouteSnapshot.path, currentRouteSnapshot.matches);
+}
+function buildRouteSnapshot(pathname, search, hash) {
+	const location = routePathname(pathname);
+	pathname = location.pathname;
+	const query = makeQuery(search);
+	const matches = location.withinBasePath ? computeMatchesFromRoutes(pathname, getActiveRoutes()) : [];
+	const locationState = readLocationState();
+	return Object.freeze({
+		path: pathname,
+		params: deepFreeze({ ...matches[0]?.params }),
+		query,
+		hash: hash || null,
+		...locationState,
+		matches: Object.freeze(matches)
+	});
+}
+function setCurrentRouteSnapshot(pathname, search, hash, activityMatches) {
+	currentRouteSnapshot = buildRouteSnapshot(pathname, search, hash);
+	syncRouteActivitySnapshot(currentRouteSnapshot.path, activityMatches ?? currentRouteSnapshot.matches);
+	notify(currentRouteSource);
+}
+function readCurrentRouteLocation() {
+	const renderContext = getActiveRenderContext();
+	if (renderContext?.url) {
+		const parsed = parseLocation(renderContext.url);
+		const location = routePathname(parsed.pathname);
+		return {
+			...parsed,
+			...location
+		};
+	}
+	const stagedRouteLocation = getStagedAppRenderRouteLocation(currentAppRuntime());
+	if (stagedRouteLocation) {
+		const parsed = parseLocation(stagedRouteLocation);
+		const location = routePathname(parsed.pathname);
+		return {
+			...parsed,
+			...location
+		};
+	}
+	if (typeof window !== "undefined" && window.location) return {
+		...routePathname(window.location.pathname || "/"),
+		search: window.location.search || "",
+		hash: window.location.hash || ""
+	};
+	if (serverLocation) {
+		const parsed = parseLocation(serverLocation);
+		const location = routePathname(parsed.pathname);
+		return {
+			...parsed,
+			...location
+		};
+	}
+	return {
+		...routePathname(currentRouteSnapshot.path),
+		search: "",
+		hash: currentRouteSnapshot.hash ?? ""
+	};
+}
+function readCurrentRouteSnapshot() {
+	if (!currentComponent()) throw new Error("currentRoute() can only be called during component render execution. Call currentRoute() from inside your component function.");
+	const { pathname, search, hash, withinBasePath } = readCurrentRouteLocation();
+	const query = makeQuery(search);
+	const matches = withinBasePath ? computeMatchesFromRoutes(pathname, getActiveRoutes()) : [];
+	const routeParams = (withinBasePath ? getActiveRenderContext()?.params : void 0) ?? matches[0]?.params ?? {};
+	const params = deepFreeze({ ...routeParams });
+	const locationState = readLocationState();
+	return Object.freeze({
+		path: pathname,
+		params,
+		query,
+		hash: hash || null,
+		...locationState,
+		matches: Object.freeze(matches)
+	});
+}
+/** Read the currently active route's {@link RouteSnapshot}; reactive during component render. */
+function currentRoute() {
+	const instance = currentComponent();
+	if (!instance) throw new Error("currentRoute() can only be called during component render execution. Call currentRoute() from inside your component function.");
+	if (typeof window === "undefined" || instance.server) return readCurrentRouteSnapshot();
+	readSource(currentRouteSource);
+	return readCurrentRouteSnapshot();
+}
+function syncCurrentRouteSnapshot(pathname, search, hash, activityMatches) {
+	setCurrentRouteSnapshot(pathname, search, hash, activityMatches);
+}
+//#endregion
 //#region src/router/navigation-registry.ts
 let currentInstance = null;
 let currentPathname = "/";
@@ -45,6 +239,29 @@ function parseTargetUrl(path) {
 	const base = href && href !== "about:blank" && !href.startsWith("about:") && !href.startsWith("data:") ? href : `http://localhost${pathname}${search}${hash}`;
 	return new URL(path, base);
 }
+/** Whether a parsed target shares the origin of the current document. */
+function isCurrentOrigin(target) {
+	return target.origin === parseTargetUrl("/").origin;
+}
+/**
+* The absolute URL of a root-relative href on the current origin. Browsers
+* read a root-relative `//host/x` as another host, so history writes and
+* document loads never receive the root-relative form.
+*/
+function toDocumentUrl(href) {
+	const origin = typeof window === "undefined" ? void 0 : window.location.origin;
+	return origin && origin !== "null" ? `${origin}${href}` : href;
+}
+/**
+* Parse a navigation or redirect target. Only a target written with an
+* explicit `http:`/`https:` scheme may leave the current origin: a path-like
+* string that the URL parser resolves elsewhere (`/\\evil.example`,
+* `//evil.example`, `/.//evil.example`) would otherwise turn an app path into
+* an open redirect.
+*/
+function parseNavigationTarget(path) {
+	return resolveNavigationUrl(path, parseTargetUrl("").href);
+}
 function getRegisteredAppsSnapshot() {
 	return [...registeredApps];
 }
@@ -217,13 +434,29 @@ function scrollToPosition(position) {
 	if (typeof window === "undefined" || typeof window.scrollTo !== "function") return;
 	window.scrollTo(position.x, position.y);
 }
+/**
+* Find the element a URL fragment indicates. Like the browser, try the raw
+* fragment first, then its percent-decoded form. A fragment that is not valid
+* percent-encoding (`#%E0`) has no decoded form, so only the raw id applies.
+*/
+function findFragmentTarget(fragment) {
+	const raw = document.getElementById(fragment);
+	if (raw) return raw;
+	let decoded;
+	try {
+		decoded = decodeURIComponent(fragment);
+	} catch (error) {
+		if (error instanceof URIError) return null;
+		throw error;
+	}
+	return decoded === fragment ? null : document.getElementById(decoded);
+}
 function applyNavigationScroll(behavior) {
 	const nextBehavior = behavior ?? scrollRestorationOptions.navigation;
 	if (!scrollRestorationOptions.enabled || nextBehavior === "preserve") return;
 	const hash = typeof window !== "undefined" ? window.location.hash : "";
 	if (hash && typeof document !== "undefined") {
-		const id = decodeURIComponent(hash.slice(1));
-		const target = document.getElementById(id);
+		const target = findFragmentTarget(hash.slice(1));
 		if (target && typeof target.scrollIntoView === "function") {
 			target.scrollIntoView({ behavior: "auto" });
 			return;
@@ -410,6 +643,118 @@ function serializeRouteMeta(meta) {
 	return output.join("");
 }
 //#endregion
+//#region src/router/document-navigation.ts
+/**
+* Hand a location no registered app can render to the browser as a document
+* load, keeping the requested history mode.
+*/
+function loadDocument(href, history) {
+	if (history === "replace") window.location.replace(href);
+	else window.location.assign(href);
+}
+/** Reload the document at the current history entry. */
+function reloadDocument() {
+	window.location.reload();
+}
+//#endregion
+//#region src/router/history-index.ts
+/**
+* Positions in this document's session history.
+*
+* Askr stamps an index into every entry it writes. A failed back/forward
+* traversal then returns with `history.go()` to the entry whose page is still
+* rendered, instead of rewriting the entry the browser landed on. A position
+* is `undefined` once it cannot be known, for example after other code pushed
+* an entry; rollback then reloads rather than guess.
+*/
+let landedIndex;
+let renderedIndex;
+let pendingReturnIndex;
+let historyIndexInitialized = false;
+function readHistoryIndex(state) {
+	if (!state || typeof state !== "object") return void 0;
+	const index = state.askrIndex;
+	return typeof index === "number" ? index : void 0;
+}
+function stampActiveEntry(state, index) {
+	window.history.replaceState({
+		...state && typeof state === "object" ? state : {},
+		askrIndex: index
+	}, "", window.location.href);
+}
+/**
+* The index an entry written with `mode` occupies. The active entry must still
+* carry the index Askr last tracked; otherwise other code wrote an entry and
+* positions are unknown from here on.
+*/
+function nextHistoryIndex(mode) {
+	if (readHistoryIndex(window.history.state) !== landedIndex) landedIndex = renderedIndex = void 0;
+	if (landedIndex === void 0) return void 0;
+	return mode === "push" ? landedIndex + 1 : landedIndex;
+}
+/** Record that the entry at `index` is active and its page rendered. */
+function commitHistoryIndex(index) {
+	landedIndex = renderedIndex = index;
+}
+/**
+* Record the entry a popstate landed on, before its page renders. An entry
+* without an index was added by a fragment navigation from the entry the user
+* was on, so it is stamped as the next position.
+*/
+function landOnHistoryEntry(state) {
+	let index = readHistoryIndex(state);
+	if (index === void 0 && landedIndex !== void 0) {
+		index = landedIndex + 1;
+		stampActiveEntry(state, index);
+	}
+	landedIndex = index;
+	return index;
+}
+/**
+* Adopt the active entry's index. Only the document's first entry is stamped
+* as index 0: stamping later would guess a position the user may not be at.
+*/
+function initializeHistoryIndex() {
+	const state = window.history?.state;
+	const index = readHistoryIndex(state);
+	if (index !== void 0) {
+		historyIndexInitialized = true;
+		commitHistoryIndex(index);
+		return;
+	}
+	if (historyIndexInitialized || typeof window.history?.replaceState !== "function") return;
+	historyIndexInitialized = true;
+	commitHistoryIndex(0);
+	stampActiveEntry(state, 0);
+}
+/**
+* Traverse back to the entry whose page is rendered. Returns false when the
+* positions are unknown, leaving history untouched.
+*/
+function returnToRenderedHistoryEntry() {
+	if (landedIndex === void 0 || renderedIndex === void 0) return false;
+	const delta = renderedIndex - landedIndex;
+	if (delta === 0) return false;
+	pendingReturnIndex = renderedIndex;
+	window.history.go(delta);
+	return true;
+}
+/** A newer navigation owns history, so a pending return must not skip it. */
+function cancelHistoryReturn() {
+	pendingReturnIndex = void 0;
+}
+/**
+* Whether this popstate completes a {@link returnToRenderedHistoryEntry}
+* traversal, whose destination is already rendered.
+*/
+function consumeHistoryReturn(state) {
+	const expected = pendingReturnIndex;
+	pendingReturnIndex = void 0;
+	if (expected === void 0 || readHistoryIndex(state) !== expected) return false;
+	commitHistoryIndex(expected);
+	return true;
+}
+//#endregion
 //#region src/router/navigation-targets.ts
 const MAX_NAVIGATION_REDIRECTS = 20;
 let activeRouteRequestId = 0;
@@ -506,7 +851,8 @@ function resolveAppRouteRequest(app, pathname, href, signal) {
 	return resolveRouteRequest(href, {
 		registry: app.registry,
 		auth: app.auth,
-		signal
+		signal,
+		dataRuntime: app.instance.appRuntime?.dataRuntime
 	});
 }
 function getResolvedRouteHandler(resolved) {
@@ -518,11 +864,12 @@ function getResolvedRouteHandler(resolved) {
 		params: resolved.params
 	};
 }
-function prepareNavigationRoot(target, href, replaceLifetime) {
+function prepareNavigationRoot(target, href, replaceLifetime, locationState) {
 	const resolved = target.resolved;
 	return prepareRootUpdate(target.app.instance, {
 		handler: bindResolvedRouteHandler(getResolvedRouteHandler(resolved)),
 		href,
+		locationState,
 		routeData: isRenderResult(resolved) ? getRouteRenderData(resolved) : void 0,
 		hasRouteData: isRenderResult(resolved) && hasRouteRenderData(resolved),
 		replaceLifetime
@@ -562,8 +909,8 @@ function applyNavigationTargets(requestId, path, options, redirectState, pathnam
 	for (const target of targets) {
 		const resolved = target.resolved;
 		if (!resolved || resolved.kind !== "redirect") continue;
-		const redirectTarget = parseTargetUrl(resolved.to);
-		const redirectHref = `${redirectTarget.pathname}${redirectTarget.search}${redirectTarget.hash}`;
+		const redirectTarget = parseNavigationTarget(resolved.to);
+		const redirectHref = isCurrentOrigin(redirectTarget) ? `${redirectTarget.pathname}${redirectTarget.search}${redirectTarget.hash}` : redirectTarget.href;
 		if (redirectHref === href) {
 			if (isDevelopmentEnvironment()) logger.warn(`Navigation guard redirected to the same path: ${redirectHref}`);
 			return;
@@ -578,26 +925,40 @@ function applyNavigationTargets(requestId, path, options, redirectState, pathnam
 	const matchedTargets = targets.filter((target) => target.resolved !== null);
 	if (matchedTargets.length === 0) {
 		if (isDevelopmentEnvironment()) logger.warn(`No route found for path: ${path}`);
+		if (href !== getWindowHref$1()) loadDocument(toDocumentUrl(href), getNavigationHistoryMode(options));
 		return;
 	}
 	if (isStaleRouteRequest(requestId)) return;
-	commitNavigationRoots(requestId, pathname, href, matchedTargets, () => {
+	const hasState = Object.prototype.hasOwnProperty.call(options, "state");
+	const locationState = {
+		hasState,
+		state: hasState ? options.state : void 0
+	};
+	commitNavigationRoots(requestId, pathname, href, matchedTargets, locationState, () => {
 		saveScrollPosition(previousHref);
-		const historyMethod = getNavigationHistoryMode(options) === "replace" ? "replaceState" : "pushState";
-		window.history[historyMethod]({
+		const historyMode = getNavigationHistoryMode(options);
+		const historyIndex = nextHistoryIndex(historyMode);
+		window.history[historyMode === "replace" ? "replaceState" : "pushState"]({
 			path: href,
-			askrHasState: Object.prototype.hasOwnProperty.call(options, "state"),
-			askrState: options.state
-		}, "", href);
+			askrHasState: locationState.hasState,
+			askrState: locationState.state,
+			askrIndex: historyIndex
+		}, "", toDocumentUrl(href));
+		commitHistoryIndex(historyIndex);
 	}, () => {
 		if (pathname !== previousPathname || parseTargetUrl(href).hash) applyNavigationScroll(options.scroll);
 	});
 }
-function applyPopStateNavigationTargets(requestId, previousHref, previousState, pathname, href, state, targets, navigate) {
+function applyPopStateNavigationTargets(requestId, previousHref, historyIndex, pathname, href, state, targets, navigate) {
 	if (isStaleRouteRequest(requestId)) return;
 	const matchedTargets = targets.filter((target) => target.resolved !== null);
 	if (matchedTargets.length === 0) {
+		if (href.split("#")[0] === previousHref.split("#")[0]) {
+			commitHistoryIndex(historyIndex);
+			return;
+		}
 		if (isDevelopmentEnvironment()) logger.warn(`No route found for path: ${pathname}`);
+		reloadDocument();
 		return;
 	}
 	for (const target of matchedTargets) {
@@ -607,14 +968,22 @@ function applyPopStateNavigationTargets(requestId, previousHref, previousState,
 		return;
 	}
 	saveScrollPosition(previousHref);
-	commitNavigationRoots(requestId, pathname, href, matchedTargets, () => {}, () => applyHistoryScroll(href, state), () => {
-		window.history.replaceState(previousState, "", previousHref);
-		syncRegisteredRouteSnapshot();
+	const historyState = state;
+	const hasState = historyState?.askrHasState === true;
+	commitNavigationRoots(requestId, pathname, href, matchedTargets, {
+		hasState,
+		state: hasState ? historyState?.askrState : void 0
+	}, () => commitHistoryIndex(historyIndex), () => applyHistoryScroll(href, state), () => {
+		if (isStaleRouteRequest(requestId)) return;
+		if (!returnToRenderedHistoryEntry()) reloadDocument();
 	});
 }
-/** 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) {
+/**
+* Render every destination root, then commit all of them or none. Lifecycle
+* work of the committed destination runs before history is updated, so a
+* navigation it starts supersedes this one.
+*/
+function commitNavigationRoots(requestId, pathname, href, targets, locationState, updateHistory, updateScroll, restoreHistory) {
 	const previousPathname = getCurrentPathname();
 	const previousHref = getCurrentHref();
 	const roots = targets.map((target) => {
@@ -622,21 +991,13 @@ function commitNavigationRoots(requestId, pathname, href, targets, updateHistory
 		return {
 			target,
 			replaceLifetime,
-			previousPathname: target.app.pathname,
-			previousHref: target.app.href,
-			prepared: prepareNavigationRoot(target, href, replaceLifetime)
+			prepared: prepareNavigationRoot(target, href, replaceLifetime, locationState)
 		};
 	});
-	const transaction = beginCommitTransaction();
-	let completionFailure;
-	registerCommitParticipant({
-		rollback() {
+	try {
+		const 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;
-			}
 			setCurrentRouteLocation(previousPathname, previousHref);
 			try {
 				restoreHistory?.();
@@ -644,48 +1005,48 @@ function commitNavigationRoots(requestId, pathname, href, targets, updateHistory
 				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();
-			}
+		};
+		try {
+			for (const replaceLifetime of [true, false]) for (const root of roots) if (root.replaceLifetime === replaceLifetime) root.prepared.apply();
+		} catch (error) {
+			rollback();
+			logger.error("[Askr] navigation failed:", error);
+			throw 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)) {
+			rollback();
+			return;
+		}
+		const committedFailures = [];
+		for (const root of roots) {
+			const result = root.prepared.publish();
+			if (result.aborted) {
+				rollback();
+				const failure = result.errors[0];
+				logger.error("[Askr] navigation failed:", failure);
+				throw failure;
 			}
-			if (isStaleRouteRequest(requestId)) return;
-			flushRuntimeScheduler();
-			if (isStaleRouteRequest(requestId)) return;
+			committedFailures.push(...result.errors);
+			syncAppRegistrationLocation(root.target.app, pathname, href);
+		}
+		for (const failure of committedFailures) reportUncaughtErrorLater(failure);
+		const retired = [];
+		for (const root of roots) retired.push(...root.prepared.retire());
+		if (retired.length) reportUncaughtErrorLater(retired.length === 1 ? retired[0] : new AggregateError(retired, "Route cleanup failed"));
+		flushSync();
+		if (isStaleRouteRequest(requestId)) return;
+		try {
+			updateHistory();
+			setCurrentRouteLocation(pathname, href);
+			syncRegisteredRouteSnapshot();
+			reconcileNavigationMetadata(targets);
+			updateScroll();
+		} catch (error) {
+			logger.error("[Askr] navigation failed:", error);
+			throw error;
 		}
-		registerCommitParticipant({ publish() {
-			for (const root of roots) syncAppRegistrationLocation(root.target.app, pathname, href);
-		} });
-		commitTransaction(transaction);
-		if (completionFailure) throw completionFailure.error;
-	} catch (error) {
-		logger.error("[Askr] navigation failed:", error);
-		throw error;
 	} finally {
-		discardTransaction(transaction);
+		for (const root of roots) root.prepared.complete();
 	}
 }
 //#endregion
@@ -708,29 +1069,43 @@ function ensureNavigationRegistryHost() {
 	navigationRegistryHosted = true;
 	configureNavigationRegistryHost({ cancelRouteRequests });
 }
-/** Navigate the client-side router to `path` using the History API. */
-function navigate(path, options = {}) {
+/**
+* Navigate the client-side router using the History API.
+*
+* A string is a logical path: a root-relative path gains the registry
+* `basePath`. A typed destination from `to()` already carries its public href.
+* A target on another origin is handed to the browser.
+*/
+function navigate(target, options = {}) {
+	navigateToPublicHref(typeof target === "string" ? addLogicalRouteBasePath(target, getActiveRouteBasePath()) : target.href, options);
+}
+/** Navigate to a public (already mounted) href without adding the `basePath`. */
+function navigateToPublicHref(href, options = {}) {
 	ensureNavigationRegistryHost();
 	if (typeof window === "undefined") return;
 	prepareNavigationFocus();
-	const targetPath = addRouteBasePath(path, getActiveRouteBasePath());
-	const initialTarget = parseTargetUrl(targetPath);
+	cancelHistoryReturn();
+	const initialTarget = parseTargetUrl(href);
 	const redirectState = {
 		redirects: 0,
 		visited: /* @__PURE__ */ new Set([`${initialTarget.pathname}${initialTarget.search}${initialTarget.hash}`])
 	};
-	if (isRuntimeSchedulerExecuting()) {
+	if (isFlushing()) {
 		queueMicrotask(() => {
-			navigateWithRedirectState(targetPath, options, redirectState);
+			navigateWithRedirectState(href, options, redirectState);
 		});
 		return;
 	}
-	navigateWithRedirectState(targetPath, options, redirectState);
+	navigateWithRedirectState(href, options, redirectState);
 }
 function navigateWithRedirectState(path, options, redirectState) {
 	if (typeof window === "undefined") return;
 	const request = beginRouteRequest();
-	const target = parseTargetUrl(path);
+	const target = parseNavigationTarget(path);
+	if (!isCurrentOrigin(target)) {
+		loadDocument(target.href, getNavigationHistoryMode(options));
+		return;
+	}
 	const pathname = target.pathname;
 	const href = `${target.pathname}${target.search}${target.hash}`;
 	const resolvedTargets = resolveNavigationTargetsForApps(pathname, href, request.signal);
@@ -751,15 +1126,20 @@ function navigateWithRedirectState(path, options, redirectState) {
 	applyNavigationTargets(request.id, path, options, redirectState, pathname, href, resolvedTargets, navigateWithRedirectState);
 }
 function handlePopState(event) {
+	if (consumeHistoryReturn(event.state)) {
+		syncRegisteredRouteSnapshot();
+		return;
+	}
 	beginHistoryFocusRestoration();
 	const request = beginRouteRequest();
 	const previousHref = getCurrentHref();
+	const historyIndex = landOnHistoryEntry(event.state);
 	const pathname = window.location.pathname;
 	const href = `${window.location.pathname}${window.location.search}${window.location.hash}`;
 	if (!hasRegisteredApps()) return;
 	const applyResolved = (targets) => {
 		try {
-			applyPopStateNavigationTargets(request.id, previousHref, { path: previousHref }, pathname, href, event.state, targets, navigate);
+			applyPopStateNavigationTargets(request.id, previousHref, historyIndex, pathname, href, event.state, targets, navigateToPublicHref);
 		} catch (error) {
 			logger.error("[Askr] popstate navigation failed:", error);
 		}
@@ -771,6 +1151,7 @@ function handlePopState(event) {
 		}, (error) => {
 			if (isStaleRouteRequest(request.id)) return;
 			logger.error("[Askr] popstate navigation failed:", error);
+			if (!returnToRenderedHistoryEntry()) reloadDocument();
 		});
 		return;
 	}
@@ -778,11 +1159,13 @@ function handlePopState(event) {
 }
 function initializeNavigation() {
 	ensureNavigationRegistryHost();
-	if (typeof window === "undefined" || navigationInitialized) return;
+	if (typeof window === "undefined") return;
+	if (getRegisteredAppsSnapshot().length <= 1) initializeHistoryIndex();
+	if (navigationInitialized) return;
 	navigationInitialized = true;
 	window.addEventListener("popstate", handlePopState);
 	document.addEventListener("pointerdown", captureNavigationFocus, true);
 	document.addEventListener("click", releaseNavigationFocusCapture);
 }
 //#endregion
-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 };
+export { currentRoute as C, clearStagedAppRenderRouteLocation as D, configureRootUpdateHost as E, createAppRenderRuntime as O, unregisterAppInstance as S, setServerLocation as T, registerAppInstance as _, nextHistoryIndex as a, syncRegisteredRouteSnapshot as b, reconcileRouteMeta as c, configureScrollRestoration as d, saveScrollPosition as f, parseTargetUrl as g, getWindowHref$1 as h, commitHistoryIndex as i, stageAppRenderRouteLocation as k, resolveRouteMeta as l, getRegisteredAppsSnapshot as m, navigate as n, readHistoryIndex as o, getCurrentHref as p, navigateToPublicHref as r, loadDocument as s, initializeNavigation as t, serializeRouteMeta as u, setCurrentRouteLocation as v, onRouteChange as w, toDocumentUrl as x, syncAppRegistrationLocation as y };