@askrjs/askr 0.0.51 → 0.0.52

package/dist/renderer/retained-element-rollback.js

@@ -1,34 +1,27 @@
 import { logger } from "../common/logger.js";
+import { getCurrentLifecycleCommitBatch, registerLifecycleTransaction } from "../runtime/lifecycle-batch.js";
 import { addDelegatedListener, getDelegatedHandlersForElement, removeDelegatedListener, updateDelegatedListener } from "../runtime/events.js";
 import "../runtime/index.js";
-import { elementListeners, elementReactivePropsCleanup, elementRefs } from "./cleanup.js";
+import { elementListeners, elementReactivePropsCleanup, elementRefs, getElementReactivePropsCleanupMap } from "./cleanup.js";
 import { keyedElements } from "./keyed.js";
 //#region src/renderer/retained-element-rollback.ts
-function collectElementSubtree(root) {
-	const elements = [root];
-	const descendants = root.querySelectorAll("*");
-	for (let index = 0; index < descendants.length; index += 1) elements.push(descendants[index]);
-	return elements;
-}
 function collectTextSnapshots(root) {
 	const snapshots = [];
-	const stack = Array.from(root.childNodes).reverse();
-	while (stack.length > 0) {
-		const node = stack.pop();
+	for (let index = 0; index < root.childNodes.length; index += 1) {
+		const node = root.childNodes[index];
 		if (node.nodeType === 3) {
+			const text = node;
 			snapshots.push({
-				node,
-				data: node.data
+				node: text,
+				data: text.data
 			});
-			continue;
 		}
-		for (let child = node.lastChild; child; child = child.previousSibling) stack.push(child);
 	}
 	return snapshots;
 }
 function getFormControlSnapshot(element) {
 	const control = element;
-	const snapshot = { element };
+	const snapshot = {};
 	if ("value" in control) snapshot.value = String(control.value ?? "");
 	if ("checked" in control) snapshot.checked = Boolean(control.checked);
 	return snapshot.value !== void 0 || snapshot.checked !== void 0 ? snapshot : null;
@@ -47,72 +40,38 @@ function cloneReactivePropEntry(entry) {
 	return {
 		cleanup: entry.cleanup,
 		fnRef: entry.fnRef,
+		groupedScalar: entry.groupedScalar,
 		restoreFn: entry.restoreFn,
 		updateFn: entry.updateFn
 	};
 }
-function snapshotRetainedElement(element) {
-	const elements = collectElementSubtree(element);
-	const attributes = [];
-	const childNodes = [];
-	const delegatedListeners = [];
-	const formControls = [];
-	const listeners = [];
-	const reactiveProps = [];
-	const refs = [];
-	for (const currentElement of elements) {
-		attributes.push({
-			element: currentElement,
-			attributes: Array.from(currentElement.attributes, (attribute) => [attribute.name, attribute.value])
-		});
-		childNodes.push({
-			element: currentElement,
-			childNodes: Array.from(currentElement.childNodes)
-		});
-		const formControl = getFormControlSnapshot(currentElement);
-		if (formControl) formControls.push(formControl);
-		const listenerMap = elementListeners.get(currentElement);
-		listeners.push({
-			element: currentElement,
-			entries: listenerMap ? Array.from(listenerMap, ([listenerKey, entry]) => ({
-				listenerKey,
-				entry: cloneListenerEntry(entry)
-			})) : []
-		});
-		const delegatedHandlerMap = getDelegatedHandlersForElement(currentElement);
-		delegatedListeners.push({
-			element: currentElement,
-			entries: delegatedHandlerMap ? Array.from(delegatedHandlerMap, ([eventName, entry]) => ({
-				eventName,
-				handler: entry.handler,
-				original: entry.original,
-				options: entry.options
-			})) : []
-		});
-		const reactivePropMap = elementReactivePropsCleanup.get(currentElement);
-		reactiveProps.push({
-			element: currentElement,
-			entries: reactivePropMap ? Array.from(reactivePropMap, ([propName, entry]) => ({
-				propName,
-				entry: cloneReactivePropEntry(entry)
-			})) : []
-		});
-		refs.push({
-			element: currentElement,
-			ref: elementRefs.get(currentElement)
-		});
-	}
+function snapshotRetainedElement(element, bindingsOnly = false) {
+	const listenerMap = elementListeners.get(element);
+	const delegatedHandlerMap = getDelegatedHandlersForElement(element);
+	const reactivePropMap = getElementReactivePropsCleanupMap(element);
 	const keyedMap = keyedElements.get(element);
 	return {
-		attributes,
-		childNodes,
-		delegatedListeners,
-		formControls,
+		attributes: bindingsOnly ? [] : Array.from(element.attributes, (attribute) => [attribute.name, attribute.value]),
+		childNodes: bindingsOnly ? [] : Array.from(element.childNodes),
+		delegatedListeners: delegatedHandlerMap ? Array.from(delegatedHandlerMap, ([eventName, entry]) => ({
+			eventName,
+			handler: entry.handler,
+			original: entry.original,
+			options: entry.options
+		})) : [],
+		domCaptured: !bindingsOnly,
+		formControl: bindingsOnly ? null : getFormControlSnapshot(element),
 		keyedMap: keyedMap ? new Map(keyedMap) : void 0,
-		listeners,
-		reactiveProps,
-		refs,
-		textNodes: collectTextSnapshots(element)
+		listeners: listenerMap ? Array.from(listenerMap, ([listenerKey, entry]) => ({
+			listenerKey,
+			entry: cloneListenerEntry(entry)
+		})) : [],
+		reactiveProps: reactivePropMap ? Array.from(reactivePropMap, ([propName, entry]) => ({
+			propName,
+			entry: cloneReactivePropEntry(entry)
+		})) : [],
+		ref: elementRefs.get(element),
+		textNodes: bindingsOnly ? [] : collectTextSnapshots(element)
 	};
 }
 function sameChildOrder(element, childNodes) {
@@ -120,19 +79,17 @@ function sameChildOrder(element, childNodes) {
 	for (let index = 0; index < childNodes.length; index += 1) if (element.childNodes[index] !== childNodes[index]) return false;
 	return true;
 }
-function restoreAttributes(snapshot) {
-	for (const { element, attributes } of snapshot.attributes) {
-		const expectedNames = new Set(attributes.map(([name]) => name));
-		for (const attribute of Array.from(element.attributes)) if (!expectedNames.has(attribute.name)) element.removeAttribute(attribute.name);
-		for (const [name, value] of attributes) if (element.getAttribute(name) !== value) element.setAttribute(name, value);
-	}
+function restoreAttributes(element, snapshot) {
+	const expectedNames = new Set(snapshot.attributes.map(([name]) => name));
+	for (const attribute of Array.from(element.attributes)) if (!expectedNames.has(attribute.name)) element.removeAttribute(attribute.name);
+	for (const [name, value] of snapshot.attributes) if (element.getAttribute(name) !== value) element.setAttribute(name, value);
 }
-function restoreFormControls(snapshot) {
-	for (const { element, value, checked } of snapshot.formControls) {
-		const control = element;
-		if (value !== void 0 && "value" in control) control.value = value;
-		if (checked !== void 0 && "checked" in control) control.checked = checked;
-	}
+function restoreFormControl(element, snapshot) {
+	if (!snapshot.formControl) return;
+	const { value, checked } = snapshot.formControl;
+	const control = element;
+	if (value !== void 0 && "value" in control) control.value = value;
+	if (checked !== void 0 && "checked" in control) control.checked = checked;
 }
 function applyRefValue(ref, value) {
 	if (!ref) return;
@@ -144,15 +101,13 @@ function applyRefValue(ref, value) {
 		if (Object.isExtensible(ref)) ref.current = value;
 	} catch {}
 }
-function restoreRefs(snapshot) {
-	for (const { element, ref } of snapshot.refs) {
-		const currentRef = elementRefs.get(element);
-		if (currentRef !== ref) applyRefValue(currentRef, null);
-		if (ref) {
-			applyRefValue(ref, element);
-			elementRefs.set(element, ref);
-		} else elementRefs.delete(element);
-	}
+function restoreRef(element, snapshot) {
+	const currentRef = elementRefs.get(element);
+	if (currentRef !== snapshot.ref) applyRefValue(currentRef, null);
+	if (snapshot.ref) {
+		applyRefValue(snapshot.ref, element);
+		elementRefs.set(element, snapshot.ref);
+	} else elementRefs.delete(element);
 }
 function removeDirectListener(element, entry) {
 	if (entry.isDelegated) return;
@@ -164,63 +119,86 @@ function addDirectListener(element, entry) {
 	if (entry.options !== void 0) element.addEventListener(entry.eventName, entry.handler, entry.options);
 	else element.addEventListener(entry.eventName, entry.handler);
 }
-function restoreListeners(snapshot) {
-	for (const { element, entries } of snapshot.listeners) {
-		const expectedKeys = new Set(entries.map(({ listenerKey }) => listenerKey));
-		let currentMap = elementListeners.get(element);
-		if (currentMap) {
-			for (const [listenerKey, entry] of Array.from(currentMap)) if (!expectedKeys.has(listenerKey)) {
+function restoreListeners(element, snapshot) {
+	const errors = [];
+	const expectedKeys = new Set(snapshot.listeners.map(({ listenerKey }) => listenerKey));
+	let currentMap = elementListeners.get(element);
+	if (currentMap) {
+		for (const [listenerKey, entry] of Array.from(currentMap)) if (!expectedKeys.has(listenerKey)) {
+			try {
 				removeDirectListener(element, entry);
-				currentMap.delete(listenerKey);
+			} catch (error) {
+				errors.push(error);
 			}
+			currentMap.delete(listenerKey);
 		}
-		if (entries.length === 0) {
-			if (currentMap?.size === 0) elementListeners.delete(element);
-			continue;
-		}
+	}
+	if (snapshot.listeners.length === 0) {
+		if (currentMap?.size === 0) elementListeners.delete(element);
+	} else {
 		if (!currentMap) {
 			currentMap = /* @__PURE__ */ new Map();
 			elementListeners.set(element, currentMap);
 		}
-		for (const { listenerKey, entry } of entries) {
+		for (const { listenerKey, entry } of snapshot.listeners) {
 			const currentEntry = currentMap.get(listenerKey);
 			entry.updateHandler?.(entry.original);
-			if (currentEntry && currentEntry.handler !== entry.handler) removeDirectListener(element, currentEntry);
-			if (!currentEntry || currentEntry.handler !== entry.handler) addDirectListener(element, entry);
+			if (currentEntry && currentEntry.handler !== entry.handler) try {
+				removeDirectListener(element, currentEntry);
+			} catch (error) {
+				errors.push(error);
+			}
+			if (!currentEntry || currentEntry.handler !== entry.handler) try {
+				addDirectListener(element, entry);
+			} catch (error) {
+				errors.push(error);
+			}
 			else currentEntry.updateHandler?.(entry.original);
 			currentMap.set(listenerKey, cloneListenerEntry(entry));
 		}
 	}
+	if (errors.length > 0) throw new AggregateError(errors, "Listener rollback failed");
 }
-function restoreDelegatedListeners(snapshot) {
-	for (const { element, entries } of snapshot.delegatedListeners) {
-		const expectedEventNames = new Set(entries.map(({ eventName }) => eventName));
-		const currentMap = getDelegatedHandlersForElement(element);
-		if (currentMap) {
-			for (const eventName of currentMap.keys()) if (!expectedEventNames.has(eventName)) removeDelegatedListener(element, eventName);
+function restoreDelegatedListeners(element, snapshot) {
+	const errors = [];
+	const expectedEventNames = new Set(snapshot.delegatedListeners.map(({ eventName }) => eventName));
+	const currentMap = getDelegatedHandlersForElement(element);
+	if (currentMap) {
+		for (const eventName of currentMap.keys()) if (!expectedEventNames.has(eventName)) try {
+			removeDelegatedListener(element, eventName);
+		} catch (error) {
+			errors.push(error);
 		}
-		for (const { eventName, handler, original, options } of entries) if (!updateDelegatedListener(element, eventName, handler, original, options)) addDelegatedListener(element, eventName, handler, original, options);
 	}
+	for (const { eventName, handler, original, options } of snapshot.delegatedListeners) try {
+		if (!updateDelegatedListener(element, eventName, handler, original, options)) addDelegatedListener(element, eventName, handler, original, options);
+	} catch (error) {
+		errors.push(error);
+	}
+	if (errors.length > 0) throw new AggregateError(errors, "Delegated listener rollback failed");
 }
-function restoreReactiveProps(snapshot) {
-	for (const { element, entries } of snapshot.reactiveProps) {
-		const expectedPropNames = new Set(entries.map(({ propName }) => propName));
-		let currentMap = elementReactivePropsCleanup.get(element);
-		if (currentMap) {
-			for (const [propName, entry] of Array.from(currentMap)) if (!expectedPropNames.has(propName)) {
+function restoreReactiveProps(element, snapshot) {
+	const errors = [];
+	const expectedPropNames = new Set(snapshot.reactiveProps.map(({ propName }) => propName));
+	let currentMap = getElementReactivePropsCleanupMap(element);
+	if (currentMap) {
+		for (const [propName, entry] of Array.from(currentMap)) if (!expectedPropNames.has(propName)) {
+			try {
 				entry.cleanup();
-				currentMap.delete(propName);
+			} catch (error) {
+				errors.push(error);
 			}
+			currentMap.delete(propName);
 		}
-		if (entries.length === 0) {
-			if (currentMap?.size === 0) elementReactivePropsCleanup.delete(element);
-			continue;
-		}
+	}
+	if (snapshot.reactiveProps.length === 0) {
+		if (currentMap?.size === 0) elementReactivePropsCleanup.delete(element);
+	} else {
 		if (!currentMap) {
 			currentMap = /* @__PURE__ */ new Map();
 			elementReactivePropsCleanup.set(element, currentMap);
 		}
-		for (const { propName, entry } of entries) {
+		for (const { propName, entry } of snapshot.reactiveProps) {
 			const currentEntry = currentMap.get(propName);
 			if (currentEntry) {
 				currentEntry.updateFn?.(entry.fnRef);
@@ -228,16 +206,28 @@ function restoreReactiveProps(snapshot) {
 				currentMap.set(propName, currentEntry);
 				continue;
 			}
-			currentMap.set(propName, entry.restoreFn?.(entry.fnRef) ?? cloneReactivePropEntry(entry));
+			currentMap.set(propName, (() => {
+				try {
+					return entry.restoreFn?.(entry.fnRef) ?? cloneReactivePropEntry(entry);
+				} catch (error) {
+					errors.push(error);
+					return cloneReactivePropEntry(entry);
+				}
+			})());
 		}
 	}
+	if (errors.length > 0) throw new AggregateError(errors, "Reactive property rollback failed");
 }
-function restoreChildNodes(snapshot, cleanupRangeNode) {
-	for (const { element, childNodes } of snapshot.childNodes) {
-		const expectedChildren = new Set(childNodes);
-		for (const child of Array.from(element.childNodes)) if (!expectedChildren.has(child)) cleanupRangeNode(child);
+function restoreChildNodes(element, snapshot, cleanupRangeNode) {
+	const errors = [];
+	const expectedChildren = new Set(snapshot.childNodes);
+	for (const child of Array.from(element.childNodes)) if (!expectedChildren.has(child)) try {
+		cleanupRangeNode(child);
+	} catch (error) {
+		errors.push(error);
 	}
-	for (const { element, childNodes } of snapshot.childNodes) if (!sameChildOrder(element, childNodes)) element.replaceChildren(...childNodes);
+	if (!sameChildOrder(element, snapshot.childNodes)) element.replaceChildren(...snapshot.childNodes);
+	if (errors.length > 0) throw new AggregateError(errors, "DOM range rollback cleanup failed");
 }
 function restoreTextNodes(snapshot) {
 	for (const { node, data } of snapshot.textNodes) if (node.data !== data) node.data = data;
@@ -247,31 +237,52 @@ function restoreKeyedMap(element, snapshot) {
 	else keyedElements.delete(element);
 }
 function restoreRetainedElement(element, snapshot, cleanupRangeNode) {
-	restoreChildNodes(snapshot, cleanupRangeNode);
-	restoreReactiveProps(snapshot);
-	restoreAttributes(snapshot);
-	restoreTextNodes(snapshot);
-	restoreFormControls(snapshot);
-	restoreRefs(snapshot);
-	restoreListeners(snapshot);
-	restoreDelegatedListeners(snapshot);
-	restoreKeyedMap(element, snapshot);
+	const errors = [];
+	const phases = [
+		...snapshot.domCaptured ? [
+			() => restoreChildNodes(element, snapshot, cleanupRangeNode),
+			() => restoreTextNodes(snapshot),
+			() => restoreFormControl(element, snapshot),
+			() => restoreAttributes(element, snapshot)
+		] : [],
+		() => restoreReactiveProps(element, snapshot),
+		() => restoreRef(element, snapshot),
+		() => restoreListeners(element, snapshot),
+		() => restoreDelegatedListeners(element, snapshot),
+		...snapshot.domCaptured ? [() => restoreKeyedMap(element, snapshot)] : []
+	];
+	for (const phase of phases) try {
+		phase();
+	} catch (error) {
+		errors.push(error);
+	}
+	if (errors.length > 0) throw new AggregateError(errors, "Retained element rollback failed");
 }
-function runRetainedElementUpdate(element, cleanupRangeNode, update, onError) {
-	const snapshot = snapshotRetainedElement(element);
+function runRetainedElementUpdate(element, cleanupRangeNode, update, onError, bindingsOnly = false) {
+	const batch = getCurrentLifecycleCommitBatch();
+	const existingSnapshot = batch?.retainedElementSnapshots.get(element);
+	const snapshot = existingSnapshot ?? snapshotRetainedElement(element, bindingsOnly);
+	let restored = false;
+	if (batch && !existingSnapshot) {
+		batch.retainedElementSnapshots.set(element, snapshot);
+		registerLifecycleTransaction(element, () => void 0, () => {
+			if (restored) return;
+			restored = true;
+			restoreRetainedElement(element, snapshot, cleanupRangeNode);
+		});
+	}
 	try {
 		update();
 	} catch (err) {
 		onError?.();
 		try {
+			restored = true;
 			restoreRetainedElement(element, snapshot, cleanupRangeNode);
 		} catch (rollbackError) {
-			logger.warn("[Askr] retained element rollback failed:", rollbackError);
+			logger.warn("[Askr] retained element rollback failed:", new AggregateError([err, rollbackError], "Render failed and retained rollback reported errors"));
 		}
 		throw err;
 	}
 }
 //#endregion
 export { restoreRetainedElement, runRetainedElementUpdate, snapshotRetainedElement };
-
-//# sourceMappingURL=retained-element-rollback.js.map

package/dist/renderer/stable-patch.js

@@ -10,7 +10,8 @@ import "../runtime/index.js";
 import { tagNamesEqualIgnoreCase } from "./utils.js";
 import { getRendererDOMHost } from "./dom-host.js";
 import { findHostInstanceByType, inheritComponentCleanupStrict, inheritComponentKey, isRouteRootComponentVNode } from "./component-host-instances.js";
-import { resolveNestedComponentResult } from "./component-host.js";
+import { resolveNestedComponentResult } from "./component-host-results.js";
+import "./component-host.js";
 //#region src/renderer/stable-patch.ts
 function normalizeStableIntrinsicChildren(children) {
 	if (children === null || children === void 0 || children === false) return [];
@@ -49,7 +50,7 @@ function resolveStableIntrinsicPatchVNode(dom, vnode) {
 	if (typeof vnode.type === "string") return tagNamesEqualIgnoreCase(dom.tagName, vnode.type) ? vnode : null;
 	if (typeof vnode.type !== "function") return null;
 	const host = dom;
-	const existingInstance = findHostInstanceByType(host, vnode.type);
+	const existingInstance = findHostInstanceByType(host, vnode.type, vnode, getCurrentInstance());
 	if (!existingInstance || existingInstance.fn !== vnode.type || host.__ASKR_WRAPPER_HOST) return null;
 	const snapshot = getVNodeContextFrame(vnode) || getCurrentContextFrame() || existingInstance.ownerFrame || null;
 	captureInlineRenderSnapshot(existingInstance);
@@ -77,5 +78,3 @@ function tryPatchStableForDirtyItem(scope) {
 }
 //#endregion
 export { tryPatchStableForDirtyItem };
-
-//# sourceMappingURL=stable-patch.js.map

package/dist/renderer/static-reuse.js

@@ -92,5 +92,3 @@ function canReuseStaticSubtree(el, vnode) {
 }
 //#endregion
 export { canReuseStaticSubtree, setStaticChildSlotsCacheEnabled, tagsEqualIgnoreCase };
-
-//# sourceMappingURL=static-reuse.js.map

package/dist/renderer/utils.js

@@ -15,6 +15,14 @@ const DIRECT_REPLACE_CHILDREN_SPREAD_LIMIT = 4096;
 function canUseDirectReplaceChildrenSpread(count) {
 	return count <= DIRECT_REPLACE_CHILDREN_SPREAD_LIMIT;
 }
+const CLICK_EVENT_PROP = {
+	eventName: "click",
+	capture: false
+};
+const CLICK_CAPTURE_EVENT_PROP = {
+	eventName: "click",
+	capture: true
+};
 const handlerCache = /* @__PURE__ */ new WeakMap();
 let cacheSize = 0;
 const MAX_CACHE_SIZE = 1e3;
@@ -25,6 +33,8 @@ function parseEventName(propName) {
 	return parseEventProp(propName)?.eventName ?? null;
 }
 function parseEventProp(propName) {
+	if (propName === "onClick") return CLICK_EVENT_PROP;
+	if (propName === "onClickCapture") return CLICK_CAPTURE_EVENT_PROP;
 	if (!propName.startsWith("on") || propName.length <= 2) return null;
 	const capture = propName.endsWith("Capture") && propName.length > 9;
 	const normalizedPropName = capture ? propName.slice(0, -7) : propName;
@@ -207,15 +217,16 @@ function extractKey(vnode) {
 function buildKeyMapFromChildren(parent) {
 	const map = /* @__PURE__ */ new Map();
 	for (let ch = parent.firstElementChild; ch; ch = ch.nextElementSibling) {
-		const k = ch.getAttribute("data-key");
-		if (k !== null) {
-			map.set(k, ch);
-			const n = Number(k);
-			if (!Number.isNaN(n)) map.set(n, ch);
-		}
+		const key = getMaterializedKey(ch);
+		if (key !== void 0) map.set(key, ch);
 	}
 	return map;
 }
+function getMaterializedKey(element) {
+	const value = element.getAttribute("data-key");
+	if (value === null) return void 0;
+	return element.getAttribute("data-askr-key-kind") === "number" ? Number(value) : value;
+}
 /**
 * Record DOM replace operation for diagnostics
 */
@@ -251,6 +262,4 @@ function now() {
 	return typeof performance !== "undefined" && performance.now ? performance.now() : Date.now();
 }
 //#endregion
-export { DIRECT_REPLACE_CHILDREN_SPREAD_LIMIT, buildKeyMapFromChildren, canUseDirectReplaceChildrenSpread, checkPropChanges, createMutableWrappedHandler, createWrappedHandler, extractKey, getEventListenerKey, getEventListenerOptions, getPassiveOptions, getRenderedAttributeName, hasNonTrivialProps, hasPropChanged, isIgnoredForPropChanges, isSVGDomElement, isSkippedProp, logFastPathDebug, now, parseEventName, parseEventProp, readElementClassName, recordDOMReplace, recordFastPathStats, removeRenderedAttribute, setRenderedAttribute, tagNamesEqualIgnoreCase, writeElementClassName };
-
-//# sourceMappingURL=utils.js.map
+export { DIRECT_REPLACE_CHILDREN_SPREAD_LIMIT, buildKeyMapFromChildren, canUseDirectReplaceChildrenSpread, checkPropChanges, createMutableWrappedHandler, createWrappedHandler, extractKey, getEventListenerKey, getEventListenerOptions, getMaterializedKey, getPassiveOptions, getRenderedAttributeName, hasNonTrivialProps, hasPropChanged, isIgnoredForPropChanges, isSVGDomElement, isSkippedProp, logFastPathDebug, now, parseEventName, parseEventProp, readElementClassName, recordDOMReplace, recordFastPathStats, removeRenderedAttribute, setRenderedAttribute, tagNamesEqualIgnoreCase, writeElementClassName };

package/dist/router/access.js

@@ -32,5 +32,3 @@ function compileNodePolicies(node) {
 }
 //#endregion
 export { compileNodePolicies, nextAccessScopeState, validateAccessMetadata };
-
-//# sourceMappingURL=access.js.map

package/dist/router/activity.d.ts

@@ -6,5 +6,4 @@ declare function isRoutePathActive(pathOrPaths: string | readonly string[]): boo
 declare function currentRoute<TParams extends RouteParams = RouteParams>(): RouteSnapshot<TParams>;
 declare function syncCurrentRouteSnapshot(pathname: string, search: string, hash: string, activityMatches?: readonly RouteMatch[]): void;
 //#endregion
-export { currentRoute };
-//# sourceMappingURL=activity.d.ts.map
+export { currentRoute };

package/dist/router/activity.js

@@ -83,5 +83,3 @@ function syncCurrentRouteSnapshot(pathname, search, hash, activityMatches) {
 }
 //#endregion
 export { currentRoute, setServerLocation, syncCurrentRouteSnapshot };
-
-//# sourceMappingURL=activity.js.map

package/dist/router/authoring.d.ts

@@ -18,5 +18,4 @@ declare function registerRoutes(definition: RouteDefinition, options?: RegisterR
 declare function route<const TPath extends string>(path: TPath, Component: RouteComponent<RoutePathParams<TPath>>, options?: RouteOptions<RoutePathParams<TPath>>): void;
 declare function route<const TPath extends string, TComponent extends AnyRouteComponent>(path: TPath, Component: CompatibleRouteComponent<TPath, TComponent>, options?: RouteOptionsForComponent<TPath, TComponent>): void;
 //#endregion
-export { fallback, group, index, page, registerRoutes, route };
-//# sourceMappingURL=authoring.d.ts.map
+export { fallback, group, index, page, registerRoutes, route };

package/dist/router/authoring.js

@@ -194,5 +194,3 @@ function route(path, Component, options) {
 }
 //#endregion
 export { fallback, group, index, page, registerRoutes, route };
-
-//# sourceMappingURL=authoring.js.map

package/dist/router/internal-types.d.ts

@@ -27,5 +27,4 @@ type RegistrationSession = {
   authConfigured: boolean;
 };
 //#endregion
-export { AccessScopeState, AnyRouteComponent, InternalRoute, InternalRouteRecord, RegistrationScope, RegistrationSession };
-//# sourceMappingURL=internal-types.d.ts.map
+export { AccessScopeState, AnyRouteComponent, InternalRoute, InternalRouteRecord, RegistrationScope, RegistrationSession };

package/dist/router/lazy.d.ts

@@ -15,5 +15,4 @@ declare function associateRouteSourceLazy(registry: RouteRegistry, manifest: Rou
 declare function clearPendingLazy(): void;
 declare function restorePendingLazy(lazyImports: readonly Promise<unknown>[]): void;
 //#endregion
-export { lazy };
-//# sourceMappingURL=lazy.d.ts.map
+export { lazy };

package/dist/router/lazy.js

@@ -48,5 +48,3 @@ function restorePendingLazy(lazyImports) {
 }
 //#endregion
 export { _drainLazy, _snapshotLazy, _snapshotRouteSourceLazy, associateRouteSourceLazy, clearPendingLazy, lazy, restorePendingLazy };
-
-//# sourceMappingURL=lazy.js.map

package/dist/router/manifest.d.ts

@@ -6,5 +6,4 @@ declare function _applyManifest(manifest: RouteManifest): void;
 declare function clearRoutes(): void;
 declare function createRouteRegistry(definition: RouteDefinition, options?: RegisterRoutesOptions): RouteRegistry;
 //#endregion
-export { clearRoutes, createRouteRegistry, getManifest };
-//# sourceMappingURL=manifest.d.ts.map
+export { clearRoutes, createRouteRegistry, getManifest };

package/dist/router/manifest.js

@@ -45,5 +45,3 @@ function createRouteRegistry(definition, options = {}) {
 }
 //#endregion
 export { _applyManifest, clearRoutes, createRouteRegistry, getManifest };
-
-//# sourceMappingURL=manifest.js.map

package/dist/router/match.js

@@ -118,5 +118,3 @@ function matchSegments(urlParts, segments) {
 }
 //#endregion
 export { computeRank, matchSegments, normalizeRouteSegmentName, parseSegments, splitPathSegments };
-
-//# sourceMappingURL=match.js.map

package/dist/router/navigate.d.ts

@@ -7,5 +7,4 @@ declare function navigate(path: string, options?: NavigateOptions): void;
 declare function initializeNavigation(): void;
 declare function cleanupNavigation(): void;
 //#endregion
-export { type HistoryScrollBehavior, type NavigateOptions, type NavigationScrollBehavior, type RouteQueryParamInput, type RouteQueryParamValue, type RouteQueryUpdater, type RouteQueryUpdates, type ScrollRestorationOptions, type UpdateRouteQueryOptions, navigate, updateRouteQuery };
-//# sourceMappingURL=navigate.d.ts.map
+export { type HistoryScrollBehavior, type NavigateOptions, type NavigationScrollBehavior, type RouteQueryParamInput, type RouteQueryParamValue, type RouteQueryUpdater, type RouteQueryUpdates, type ScrollRestorationOptions, type UpdateRouteQueryOptions, navigate, updateRouteQuery };

package/dist/router/navigate.js

@@ -1,7 +1,7 @@
 import { logger } from "../common/logger.js";
 import { isPromiseLike } from "../common/promise.js";
-import { configureScrollRestoration, saveScrollPosition } from "./navigation-scroll.js";
 import { configureNavigationRegistryHost, getCurrentHref, hasRegisteredApps, parseTargetUrl, registerAppInstance, unregisterAppInstance } from "./navigation-registry.js";
+import { configureScrollRestoration } from "./navigation-scroll.js";
 import { applyNavigationTargets, applyPopStateNavigationTargets, beginRouteRequest, cancelRouteRequests, isStaleRouteRequest, resolveNavigationTargetsForApps } from "./navigation-targets.js";
 import { updateRouteQuery } from "./route-query.js";
 //#region src/router/navigate.ts
@@ -29,7 +29,7 @@ function navigateWithRedirectState(path, options, redirectState) {
 		Promise.resolve(resolvedTargets).then((targets) => {
 			if (isStaleRouteRequest(request.id)) return;
 			try {
-				applyNavigationTargets(path, options, redirectState, pathname, href, targets, navigateWithRedirectState);
+				applyNavigationTargets(request.id, path, options, redirectState, pathname, href, targets, navigateWithRedirectState);
 			} catch (error) {
 				logger.error("[Askr] navigation failed:", error);
 			}
@@ -38,18 +38,17 @@ function navigateWithRedirectState(path, options, redirectState) {
 		});
 		return;
 	}
-	applyNavigationTargets(path, options, redirectState, pathname, href, resolvedTargets, navigateWithRedirectState);
+	applyNavigationTargets(request.id, path, options, redirectState, pathname, href, resolvedTargets, navigateWithRedirectState);
 }
 function handlePopState(event) {
 	const request = beginRouteRequest();
 	const previousHref = getCurrentHref();
 	const pathname = window.location.pathname;
 	const href = `${window.location.pathname}${window.location.search}${window.location.hash}`;
-	saveScrollPosition(previousHref);
 	if (!hasRegisteredApps()) return;
 	const applyResolved = (targets) => {
 		try {
-			applyPopStateNavigationTargets(request.id, pathname, href, event.state, targets, navigate);
+			applyPopStateNavigationTargets(request.id, previousHref, { path: previousHref }, pathname, href, event.state, targets, navigate);
 		} catch (error) {
 			logger.error("[Askr] popstate navigation failed:", error);
 		}
@@ -72,5 +71,3 @@ function initializeNavigation() {
 }
 //#endregion
 export { configureScrollRestoration, initializeNavigation, navigate, registerAppInstance, unregisterAppInstance, updateRouteQuery };
-
-//# sourceMappingURL=navigate.js.map

package/dist/router/navigation-registry.d.ts

@@ -28,5 +28,4 @@ declare function syncRegisteredRouteSnapshot(): void;
 declare function registerAppInstance(instance: ComponentInstance, path: string, source?: AppNavigationSource): void;
 declare function unregisterAppInstance(instance: ComponentInstance): void;
 //#endregion
-export { AppNavigationSource, AppRegistration };
-//# sourceMappingURL=navigation-registry.d.ts.map
+export { AppNavigationSource, AppRegistration };