@askrjs/askr 0.0.50 → 0.0.52

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

@@ -1,33 +1,27 @@
-import { logger } from "../dev/logger.js";
+import { logger } from "../common/logger.js";
+import { getCurrentLifecycleCommitBatch, registerLifecycleTransaction } from "../runtime/lifecycle-batch.js";
 import { addDelegatedListener, getDelegatedHandlersForElement, removeDelegatedListener, updateDelegatedListener } from "../runtime/events.js";
-import { elementListeners, elementReactivePropsCleanup, elementRefs } from "./cleanup.js";
+import "../runtime/index.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;
@@ -46,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) {
@@ -119,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;
@@ -143,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;
@@ -163,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);
@@ -227,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;
@@ -246,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

@@ -5,13 +5,13 @@ import { incDevCounter } from "../runtime/dev-namespace.js";
 import { getCurrentInstance } from "../runtime/component-scope.js";
 import { isPromiseLike } from "../common/promise.js";
 import { captureInlineRenderSnapshot, renderComponentInline, warnUnusedStateReads } from "../runtime/component-internal.js";
-import "../runtime/component-contracts.js";
-import { tagNamesEqualIgnoreCase } from "./utils.js";
 import { recordBenchEvent } from "../runtime/for-bench.js";
-import "../runtime/for.js";
+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 [];
@@ -50,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);
@@ -78,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

@@ -1,7 +1,8 @@
 import { getRuntimeEnv } from "../common/env.js";
-import { logger } from "../dev/logger.js";
+import { logger } from "../common/logger.js";
 import { runRuntimeHandlerScope } from "../runtime/access.js";
 import { incDevCounter, setDevValue } from "../runtime/dev-namespace.js";
+import "../runtime/index.js";
 import { getPublicAttributeName } from "../common/attr-names.js";
 import "./env.js";
 //#region src/renderer/utils.ts
@@ -14,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;
@@ -24,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;
@@ -206,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
 */
@@ -250,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/resources/index.js

@@ -1,6 +1,5 @@
 import { getSignal } from "../runtime/component-scope.js";
-import "../runtime/component.js";
 import { resource } from "../runtime/resource-operation.js";
 import { capture, documentVisible, on, routeActive, stream, task, timer, windowFocused } from "../runtime/lifecycle-operations.js";
-import "../runtime/operations.js";
+import "../runtime/index.js";
 export { capture, documentVisible, getSignal, on, resource, routeActive, stream, task, timer, windowFocused };

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

@@ -1,11 +1,12 @@
 import { markReactivePropsDirtySource, markReadableDerivedSubscribersDirty, notifyReadableReaders, recordReadableRead } from "../runtime/readable.js";
 import { getCurrentComponentInstance } from "../runtime/component-scope.js";
-import "../runtime/component.js";
 import { getActiveRenderContext } from "../common/render-context.js";
-import { getActiveRoutes } from "./store.js";
 import { syncRouteActivitySnapshot } from "../common/route-activity.js";
+import "../runtime/index.js";
+import { getActiveRoutes } from "./store.js";
 import { deepFreeze, makeQuery, parseLocation } from "./route-context.js";
-import { computeMatchesFromRoutes } from "./resolution.js";
+import { computeMatchesFromRoutes } from "./route-matching.js";
+import "./resolution.js";
 //#region src/router/activity.ts
 let currentRouteSnapshot = buildRouteSnapshot("/", "", "");
 const currentRouteSource = (() => currentRouteSnapshot);
@@ -39,28 +40,25 @@ function setCurrentRouteSnapshot(pathname, search, hash, activityMatches) {
 	markReactivePropsDirtySource(currentRouteSource);
 	notifyReadableReaders(currentRouteSource, instance);
 }
+function readCurrentRouteLocation() {
+	const renderContext = getActiveRenderContext();
+	if (renderContext?.url) return parseLocation(renderContext.url);
+	if (typeof window !== "undefined" && window.location) return {
+		pathname: window.location.pathname || "/",
+		search: window.location.search || "",
+		hash: window.location.hash || ""
+	};
+	if (serverLocation) return parseLocation(serverLocation);
+	return {
+		pathname: currentRouteSnapshot.path,
+		search: "",
+		hash: currentRouteSnapshot.hash ?? ""
+	};
+}
 function readCurrentRouteSnapshot() {
 	const instance = getCurrentComponentInstance();
 	if (!instance) throw new Error("currentRoute() can only be called during component render execution. Call currentRoute() from inside your component function.");
-	let pathname = "/";
-	let search = "";
-	let hash = "";
-	const renderContext = getActiveRenderContext();
-	if (instance.ssr && renderContext?.url) {
-		const parsed = parseLocation(renderContext.url);
-		pathname = parsed.pathname;
-		search = parsed.search;
-		hash = parsed.hash;
-	} else if (typeof window !== "undefined" && window.location) {
-		pathname = window.location.pathname || "/";
-		search = window.location.search || "";
-		hash = window.location.hash || "";
-	} else if (serverLocation) {
-		const parsed = parseLocation(serverLocation);
-		pathname = parsed.pathname;
-		search = parsed.search;
-		hash = parsed.hash;
-	}
+	const { pathname, search, hash } = readCurrentRouteLocation();
 	const query = makeQuery(search);
 	const matches = computeMatchesFromRoutes(pathname, getActiveRoutes());
 	const instanceParams = instance.props;
@@ -85,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

@@ -1,6 +1,6 @@
 import { getCurrentComponentInstance } from "../runtime/component-scope.js";
-import "../runtime/component.js";
 import { getExecutionModel } from "../runtime/execution-model.js";
+import "../runtime/index.js";
 import { computeRank, normalizeRouteSegmentName, parseSegments } from "./match.js";
 import { compileNodePolicies, nextAccessScopeState, validateAccessMetadata } from "./access.js";
 import { createRouteHandler } from "./rendering.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/index.d.ts

@@ -5,10 +5,10 @@ import { RouteQueryParamInput, RouteQueryParamValue, RouteQueryUpdater, RouteQue
 import { navigate } from "./navigate.js";
 import { fallback, group, index, page, registerRoutes, route } from "./authoring.js";
 import { currentRoute } from "./activity.js";
+import { allow, deny, forbidden, notFound, redirect, requireAuth, requirePermission, requireRole, unauthorized } from "./policy.js";
 import { clearRoutes, createRouteRegistry, getManifest } from "./manifest.js";
 import { getRoutes } from "./store.js";
 import { lazy } from "./lazy.js";
 import { Outlet } from "./rendering.js";
-import { allow, deny, forbidden, notFound, redirect, requireAuth, requirePermission, requireRole, unauthorized } from "./policy.js";
 import { Link, LinkProps } from "../components/link.js";
 export { type AccessDecision, type AccessDenyDecision, type AccessRedirectDecision, type GroupHelperOptions, type HistoryScrollBehavior, type LayoutScopeRecord, Link, type LinkProps, type NavigateOptions, type NavigationScrollBehavior, Outlet, type PageHelperOptions, type PageScopeRecord, type ParsedSegment, type RegisterRoutesOptions, type Route, type RouteAuthMode, type RouteAuthOptions, type RouteAuthResolver, type RouteAuthState, type RouteComponent, type RouteContext, type RouteDefinition, type RouteHandler, type RouteManifest, type RouteMatch, type RouteMode, type RouteOptions, type RouteParams, type RoutePathParams, type RoutePolicy, type RouteQuery, type RouteQueryParamInput, type RouteQueryParamValue, type RouteQueryUpdater, type RouteQueryUpdates, type RouteRecord, type RouteRegistry, type RouteRenderResult, type RouteRequestOptions, type RouteRequestResult, type RouteSnapshot, type ScrollRestorationOptions, type UpdateRouteQueryOptions, allow, clearRoutes, createRouteRegistry, currentRoute, deny, fallback, forbidden, getManifest, getRoutes, group, index, lazy, navigate, notFound, page, redirect, registerRoutes, requireAuth, requirePermission, requireRole, route, unauthorized, updateRouteQuery };