@askrjs/askr 0.0.51 → 0.0.52

package/dist/renderer/boundary-materialization.js

@@ -0,0 +1,72 @@
+import { getRuntimeEnv } from "../common/env.js";
+import { logger } from "../common/logger.js";
+import "./env.js";
+import { appendRange } from "./dom-range.js";
+import { assignScopeRange, checkVNodeShapeChanged, materializeChildScopeRange } from "./boundary-range-adoption.js";
+import { clearControlBoundaryDomUpdateState, evaluateControlBoundaryState, getControlBoundaryState } from "./boundary-state.js";
+//#region src/renderer/boundary-materialization.ts
+/**
+* Create DOM from For/Show/Case control boundaries.
+*
+* DOM order is reconstructed from the current vnode list on every render.
+* Reusing DOM nodes never implies preserving their position; appending an
+* existing node to the fragment expresses reordering per the DOM spec.
+*/
+function createForBoundary(node, props, parentNamespace) {
+	const controlState = getControlBoundaryState(node);
+	if (!controlState) {
+		if (getRuntimeEnv().NODE_ENV !== "production") logger.warn("[Askr] Control boundary missing state");
+		return document.createDocumentFragment();
+	}
+	const childrenVNodes = evaluateControlBoundaryState(controlState);
+	const fragment = document.createDocumentFragment();
+	if (controlState.kind !== "for") {
+		const activeScope = controlState.activeScope;
+		const vnode = childrenVNodes[0];
+		if (activeScope && vnode !== void 0) {
+			const range = materializeChildScopeRange(vnode, parentNamespace, activeScope);
+			assignScopeRange(activeScope, range);
+			activeScope.hydrationPending = false;
+			appendRange(fragment, range);
+		}
+		clearControlBoundaryDomUpdateState(controlState);
+		return fragment;
+	}
+	const forState = controlState;
+	if (forState.orderedKeys.length === 0) {
+		const fallbackScope = forState.fallbackScope;
+		const fallbackVNode = childrenVNodes[0];
+		if (fallbackScope && fallbackVNode !== void 0) {
+			const range = materializeChildScopeRange(fallbackVNode, parentNamespace, fallbackScope);
+			assignScopeRange(fallbackScope, range);
+			fallbackScope.hydrationPending = false;
+			appendRange(fragment, range);
+		}
+		clearControlBoundaryDomUpdateState(controlState);
+		return fragment;
+	}
+	for (let i = 0; i < childrenVNodes.length; i++) {
+		const childVNode = childrenVNodes[i];
+		const itemKey = forState.orderedKeys[i];
+		const itemInstance = itemKey != null ? forState.items.get(itemKey) : null;
+		let range = null;
+		if (itemInstance && itemInstance.scope.range) {
+			const cachedRange = itemInstance.scope.range;
+			const cachedDom = cachedRange.single ? cachedRange.start : null;
+			if (!cachedDom || !checkVNodeShapeChanged(cachedDom, childVNode)) range = cachedRange;
+		}
+		if (!range) {
+			const materializedRange = materializeChildScopeRange(childVNode, parentNamespace, itemInstance?.scope);
+			if (itemInstance) {
+				assignScopeRange(itemInstance.scope, materializedRange);
+				itemInstance.scope.hydrationPending = false;
+			}
+			range = materializedRange;
+		}
+		appendRange(fragment, range);
+	}
+	clearControlBoundaryDomUpdateState(controlState);
+	return fragment;
+}
+//#endregion
+export { createForBoundary };

package/dist/renderer/boundary-range-adoption.js

@@ -0,0 +1,76 @@
+import { _isDOMElement } from "../common/vnode.js";
+import "./types.js";
+import { Fragment } from "../common/jsx.js";
+import { enterDomCommitScope, restoreDomCommitScope } from "../runtime/component-scope.js";
+import "../runtime/index.js";
+import { createDetachedRange, createEmptyRange, createSingleNodeRange, findRangeEnd, getRangeNodes, isRangeStart } from "./dom-range.js";
+import { getParentNamespace } from "./namespaces.js";
+import "../jsx/index.js";
+//#region src/renderer/boundary-range-adoption.ts
+let boundaryRangeHost = null;
+function configureBoundaryRangeHost(host) {
+	boundaryRangeHost = host;
+}
+function getBoundaryRangeHost() {
+	if (!boundaryRangeHost) throw new Error("[askr] Control boundary DOM host is not configured.");
+	return boundaryRangeHost;
+}
+function assignScopeRange(scope, range) {
+	scope.range = range;
+	scope.dom = range.single ? range.start : void 0;
+}
+function checkVNodeShapeChanged(dom, vnode) {
+	if (!_isDOMElement(vnode) || !(dom instanceof Element)) return true;
+	if (typeof vnode.type !== "string") return true;
+	return dom.tagName.toLowerCase() !== vnode.type.toLowerCase();
+}
+function adoptHydratedRange(parent, scope, before, vnode) {
+	if (!scope.hydrationPending || !before || !isRangeStart(before)) return null;
+	const end = findRangeEnd(before);
+	if (!end || end.parentNode !== parent) return null;
+	const range = {
+		start: before,
+		end,
+		single: false
+	};
+	const contentNodes = getRangeNodes(range);
+	const expectedChildren = _isDOMElement(vnode) && vnode.type === Fragment ? vnode.props?.children ?? [] : [vnode];
+	if (contentNodes.length !== expectedChildren.length) return null;
+	for (let index = 0; index < expectedChildren.length; index += 1) {
+		const expected = expectedChildren[index];
+		const actual = contentNodes[index];
+		if (_isDOMElement(expected) && typeof expected.type === "string" && (!(actual instanceof Element) || actual.tagName.toLowerCase() !== expected.type.toLowerCase())) return null;
+	}
+	assignScopeRange(scope, range);
+	scope.hydrationPending = false;
+	return range;
+}
+function getScopeRange(scope) {
+	if (scope.range) return scope.range;
+	if (!scope.dom) return null;
+	const range = {
+		start: scope.dom,
+		end: scope.dom,
+		single: true
+	};
+	scope.range = range;
+	return range;
+}
+function materializeChildScopeRange(vnode, parentNamespace, scope, scopeAlreadyActive = false) {
+	const previousInstance = scope && !scopeAlreadyActive ? enterDomCommitScope(scope.componentInstance) : null;
+	let dom;
+	try {
+		const host = getBoundaryRangeHost();
+		dom = scope?.blueprintOwner && _isDOMElement(vnode) && typeof vnode.type === "string" ? host.createResultNodeWithBlueprint(scope.blueprintOwner, vnode, parentNamespace) : host.createDOMNode(vnode, parentNamespace);
+	} finally {
+		if (scope && !scopeAlreadyActive) restoreDomCommitScope(previousInstance);
+	}
+	if (!dom) return createEmptyRange(document, scope).range;
+	if (!(dom instanceof DocumentFragment)) return createSingleNodeRange(dom, scope);
+	return createDetachedRange(dom, scope).range;
+}
+function getBoundaryParentNamespace(parent) {
+	return getParentNamespace(parent);
+}
+//#endregion
+export { adoptHydratedRange, assignScopeRange, checkVNodeShapeChanged, configureBoundaryRangeHost, getBoundaryParentNamespace, getBoundaryRangeHost, getScopeRange, materializeChildScopeRange };

package/dist/renderer/boundary-range-sync.js

@@ -0,0 +1,101 @@
+import { _isDOMElement } from "../common/vnode.js";
+import "./types.js";
+import { enterDomCommitScope, restoreDomCommitScope } from "../runtime/component-scope.js";
+import { registerLifecycleTransaction } from "../runtime/lifecycle-batch.js";
+import { clearCaseDomUpdateState, clearShowDomUpdateState } from "../runtime/control.js";
+import { clearForDomUpdateState } from "../runtime/for-internal.js";
+import "../runtime/index.js";
+import { teardownNodeSubtree } from "./cleanup.js";
+import { tagNamesEqualIgnoreCase } from "./utils.js";
+import { insertRangeBefore, removeRange } from "./dom-range.js";
+import { adoptHydratedRange, assignScopeRange, getBoundaryParentNamespace, getBoundaryRangeHost, getScopeRange, materializeChildScopeRange } from "./boundary-range-adoption.js";
+//#region src/renderer/boundary-range-sync.ts
+function clearBoundaryState(controlState) {
+	if (controlState.kind === "for") clearForDomUpdateState(controlState);
+	else if (controlState.kind === "show") clearShowDomUpdateState(controlState);
+	else clearCaseDomUpdateState(controlState);
+}
+function syncControlBoundaryScopeDom(parent, scope, vnode, before = null, allowHydrationAdoption = true, insertDetached = true) {
+	const previousInstance = enterDomCommitScope(scope.componentInstance);
+	try {
+		const currentRange = getScopeRange(scope);
+		const dom = currentRange?.single ? currentRange.start : null;
+		const host = getBoundaryRangeHost();
+		const hydratedRange = currentRange || !allowHydrationAdoption ? null : adoptHydratedRange(parent, scope, before, vnode);
+		if (hydratedRange) return hydratedRange;
+		const resolvedRange = hydratedRange ?? currentRange;
+		if (resolvedRange && scope.hydrationPending && !resolvedRange.single) {
+			scope.hydrationPending = false;
+			return resolvedRange;
+		}
+		if (_isDOMElement(vnode) && typeof vnode.type === "function") {
+			const synced = host.syncComponentElement(dom, vnode, vnode.type, (vnode.props ?? {}) || {}, getBoundaryParentNamespace(parent));
+			if (synced) {
+				const nextRange = {
+					start: synced,
+					end: synced,
+					single: true
+				};
+				assignScopeRange(scope, nextRange);
+				return nextRange;
+			}
+		}
+		if (!resolvedRange) {
+			const nextRange = materializeChildScopeRange(vnode, getBoundaryParentNamespace(parent), scope, true);
+			assignScopeRange(scope, nextRange);
+			if (insertDetached) insertRangeBefore(parent, nextRange, before);
+			return nextRange;
+		}
+		if (resolvedRange.single && dom?.nodeType === 3 && (typeof vnode === "string" || typeof vnode === "number")) {
+			dom.data = String(vnode);
+			return currentRange;
+		}
+		if (resolvedRange.single && dom?.nodeType === 8 && (vnode === null || vnode === void 0 || vnode === false)) return currentRange;
+		if (resolvedRange.single && dom instanceof Element && _isDOMElement(vnode) && typeof vnode.type === "string" && tagNamesEqualIgnoreCase(dom.tagName, vnode.type)) {
+			host.updateElementFromVnode(dom, vnode, true);
+			return currentRange;
+		}
+		const nextRange = materializeChildScopeRange(vnode, getBoundaryParentNamespace(parent), scope);
+		const previousRange = resolvedRange;
+		const previousDom = scope.dom;
+		const previousParent = previousRange.start.parentNode;
+		const previousNextSibling = previousRange.end.nextSibling;
+		const registered = registerLifecycleTransaction({}, () => removeRange(previousRange, teardownBoundaryRangeNode), () => {
+			removeRange(nextRange, teardownBoundaryRangeNode);
+			if (previousParent && !previousRange.start.parentNode) previousParent.insertBefore(previousRange.start, previousNextSibling?.parentNode === previousParent ? previousNextSibling : null);
+			scope.range = previousRange;
+			scope.dom = previousDom;
+		});
+		if (previousRange.single && nextRange.single && previousRange.start.parentNode === parent) parent.replaceChild(nextRange.start, previousRange.start);
+		else insertRangeBefore(parent, nextRange, previousRange.start.parentNode === parent ? previousRange.start : null);
+		assignScopeRange(scope, nextRange);
+		if (!registered) removeRange(previousRange, teardownBoundaryRangeNode);
+		return nextRange;
+	} finally {
+		restoreDomCommitScope(previousInstance);
+	}
+}
+function teardownBoundaryRangeNode(node) {
+	if (node.nodeType === 8) {
+		node.parentNode?.removeChild(node);
+		return;
+	}
+	teardownNodeSubtree(node);
+	node.parentNode?.removeChild(node);
+}
+function syncControlBoundaryScopeNode(parent, scope, vnode) {
+	const range = syncControlBoundaryScopeDom(parent, scope, vnode, null, true, false);
+	return range?.single ? range.start : null;
+}
+function syncControlBoundaryInMixedParent(parent, controlState, childrenVNodes, before) {
+	if (controlState.kind === "for") throw new Error("[askr] For ranges require the keyed boundary commit path.");
+	const activeScope = controlState.activeScope;
+	const activeVNode = childrenVNodes[0];
+	const nextRange = activeScope && activeVNode !== void 0 ? syncControlBoundaryScopeDom(parent, activeScope, activeVNode, before, controlState.lastRemovedRanges.length === 0) : null;
+	for (const range of controlState.lastRemovedRanges) if (range !== nextRange) removeRange(range, teardownBoundaryRangeNode);
+	for (const node of controlState.lastRemovedNodes) if (node.parentNode === parent) teardownBoundaryRangeNode(node);
+	clearBoundaryState(controlState);
+	return nextRange ? [nextRange] : [];
+}
+//#endregion
+export { syncControlBoundaryInMixedParent, syncControlBoundaryScopeDom, syncControlBoundaryScopeNode };

package/dist/renderer/boundary-state.js

@@ -0,0 +1,50 @@
+import { __FOR_BOUNDARY__, _isDOMElement } from "../common/vnode.js";
+import "./types.js";
+import { clearCaseDomUpdateState, clearShowDomUpdateState, evaluateCaseState, evaluateShowState } from "../runtime/control.js";
+import { clearForDomUpdateState, evaluateForState } from "../runtime/for-internal.js";
+import "../runtime/index.js";
+//#region src/renderer/boundary-state.ts
+function evaluateControlBoundaryState(controlState) {
+	if (controlState.kind === "for") return evaluateForState(controlState);
+	if (controlState.kind === "show") return evaluateShowState(controlState);
+	return evaluateCaseState(controlState);
+}
+function clearControlBoundaryDomUpdateState(controlState) {
+	if (controlState.kind === "for") {
+		clearForDomUpdateState(controlState);
+		return;
+	}
+	if (controlState.kind === "show") {
+		clearShowDomUpdateState(controlState);
+		return;
+	}
+	clearCaseDomUpdateState(controlState);
+}
+function getControlBoundaryState(node) {
+	return node._controlState ?? node._forState ?? null;
+}
+function getDirectControlBoundaryVNode(children) {
+	if (!Array.isArray(children) && _isDOMElement(children) && children.type === __FOR_BOUNDARY__) return children;
+	if (Array.isArray(children) && children.length === 1 && _isDOMElement(children[0]) && children[0].type === __FOR_BOUNDARY__) return children[0];
+	return null;
+}
+function getControlBoundaryCommitChildren(controlState) {
+	if (controlState.kind === "for" && controlState._needsSourceReconcile) return evaluateForState(controlState);
+	if (controlState.kind !== "for") {
+		const activeVNode = controlState.activeScope?.vnode;
+		return activeVNode == null || activeVNode === false ? [] : [activeVNode];
+	}
+	if (controlState.orderedKeys.length === 0) {
+		const fallbackVNode = controlState.fallbackScope?.vnode;
+		return fallbackVNode == null || fallbackVNode === false ? [] : [fallbackVNode];
+	}
+	const childrenVNodes = [];
+	for (let index = 0; index < controlState.orderedKeys.length; index += 1) {
+		const itemKey = controlState.orderedKeys[index];
+		const itemInstance = controlState.items.get(itemKey);
+		childrenVNodes.push(itemInstance?.scope.vnode ?? null);
+	}
+	return childrenVNodes;
+}
+//#endregion
+export { clearControlBoundaryDomUpdateState, evaluateControlBoundaryState, getControlBoundaryCommitChildren, getControlBoundaryState, getDirectControlBoundaryVNode };

package/dist/renderer/child-shape.js

@@ -81,5 +81,3 @@ function tryGetStaticCreateFastPathShape(props, children) {
 }
 //#endregion
 export { isFragmentVNode, maybeWarnMissingKeys, normalizeComponentChildren, tryGetStaticCreateFastPathShape };
-
-//# sourceMappingURL=child-shape.js.map

package/dist/renderer/children-fastpath.js

@@ -116,8 +116,10 @@ function setTextNodeData(el, text) {
 function setDataKey(el, key, onSet) {
 	try {
 		const next = String(key);
-		if (el.getAttribute("data-key") === next) return;
+		const keyKind = typeof key;
+		if (el.getAttribute("data-key") === next && el.getAttribute("data-askr-key-kind") === keyKind) return;
 		el.setAttribute("data-key", next);
+		el.setAttribute("data-askr-key-kind", keyKind);
 		onSet();
 	} catch {}
 }
@@ -145,5 +147,3 @@ function updateKeyedElementsMap(parent, keyedVnodes) {
 }
 //#endregion
 export { performBulkPositionalKeyedTextUpdate, tagsEqualIgnoreCase };
-
-//# sourceMappingURL=children-fastpath.js.map

package/dist/renderer/children.js

@@ -156,5 +156,3 @@ function recordBulkDiag(data) {
 }
 //#endregion
 export { isBulkTextFastPathEligible, performBulkPositionalKeyedTextUpdate, performBulkTextReplace };
-
-//# sourceMappingURL=children.js.map

package/dist/renderer/cleanup.js

@@ -1,10 +1,12 @@
 import { logger } from "../common/logger.js";
 import { incDevCounter } from "../runtime/dev-namespace.js";
 import { cleanupComponent } from "../runtime/component-cleanup.js";
+import { registerLifecycleTransaction } from "../runtime/lifecycle-batch.js";
 import { clearDelegatedHandlersForElement, removeDelegatedListener } from "../runtime/events.js";
 import "../runtime/index.js";
 //#region src/renderer/cleanup.ts
 const elementRefs = /* @__PURE__ */ new WeakMap();
+const refOwners = /* @__PURE__ */ new Map();
 function applyRefValue(ref, value) {
 	const resolvedRef = ref;
 	if (!resolvedRef) return;
@@ -15,26 +17,47 @@ function applyRefValue(ref, value) {
 	if (Object.isExtensible(resolvedRef)) resolvedRef.current = value;
 }
 function updateElementRef(element, ref) {
+	if (registerLifecycleTransaction({}, () => updateElementRefImmediately(element, ref), () => void 0)) return;
+	updateElementRefImmediately(element, ref);
+}
+function updateElementRefImmediately(element, ref) {
 	const previousRef = elementRefs.get(element);
 	if (previousRef === ref) return;
 	if (previousRef) applyRefValue(previousRef, null);
 	if (ref) {
+		const previousOwner = refOwners.get(ref);
+		if (typeof ref === "function" && previousOwner && previousOwner !== element) {
+			elementRefs.set(element, ref);
+			refOwners.set(ref, element);
+			return;
+		}
 		applyRefValue(ref, element);
 		elementRefs.set(element, ref);
+		refOwners.set(ref, element);
 	} else elementRefs.delete(element);
 }
 function removeElementRef(element) {
 	const ref = elementRefs.get(element);
 	if (!ref) return;
+	if (typeof ref !== "function" && refOwners.get(ref) !== element) {
+		elementRefs.delete(element);
+		return;
+	}
 	applyRefValue(ref, null);
+	const nextOwner = refOwners.get(ref);
+	if (typeof ref === "function" && nextOwner && nextOwner !== element) applyRefValue(ref, nextOwner);
 	elementRefs.delete(element);
+	if (refOwners.get(ref) === element) refOwners.delete(ref);
 }
 function cleanupSingleInstance(node, errors, strict) {
+	const instanceList = node.__ASKR_INSTANCES;
+	const primaryInstance = node.__ASKR_INSTANCE;
+	if (!instanceList && !primaryInstance) return;
 	const instances = /* @__PURE__ */ new Set();
-	if (Array.isArray(node.__ASKR_INSTANCES)) {
-		for (const instance of node.__ASKR_INSTANCES) if (instance) instances.add(instance);
+	if (Array.isArray(instanceList)) {
+		for (const instance of instanceList) if (instance) instances.add(instance);
 	}
-	if (node.__ASKR_INSTANCE) instances.add(node.__ASKR_INSTANCE);
+	if (primaryInstance) instances.add(primaryInstance);
 	for (const instance of instances) try {
 		cleanupComponent(instance);
 	} catch (err) {
@@ -172,14 +195,50 @@ function teardownNodeSubtree(node, opts) {
 }
 const REACTIVE_CHILDREN_KEY = "__askr_reactive_children__";
 const elementReactivePropsCleanup = /* @__PURE__ */ new WeakMap();
+function getElementReactivePropsCleanupMap(element, create = false) {
+	const store = elementReactivePropsCleanup.get(element);
+	if (store instanceof Map) return store;
+	if (store) {
+		const map = /* @__PURE__ */ new Map([[store._bindingKey, store]]);
+		elementReactivePropsCleanup.set(element, map);
+		return map;
+	}
+	if (!create) return;
+	const map = /* @__PURE__ */ new Map();
+	elementReactivePropsCleanup.set(element, map);
+	return map;
+}
+function setDirectElementReactivePropCleanup(element, bindingKey, entry) {
+	if (!elementReactivePropsCleanup.get(element)) {
+		entry._bindingKey = bindingKey;
+		elementReactivePropsCleanup.set(element, entry);
+		return;
+	}
+	getElementReactivePropsCleanupMap(element, true).set(bindingKey, entry);
+}
+/** @internal Publish the first reactive binding on a newly created element. */
+function setFreshElementReactivePropCleanup(element, bindingKey, entry) {
+	entry._bindingKey = bindingKey;
+	elementReactivePropsCleanup.set(element, entry);
+}
+function getElementReactivePropCleanupSize(element) {
+	const store = elementReactivePropsCleanup.get(element);
+	return store instanceof Map ? store.size : store ? 1 : 0;
+}
+function forEachElementReactivePropCleanup(element, visit) {
+	const store = elementReactivePropsCleanup.get(element);
+	if (store instanceof Map) for (const entry of store.values()) visit(entry);
+	else if (store) visit(store);
+}
 function removeElementReactiveProps(element) {
-	const cleanupMap = elementReactivePropsCleanup.get(element);
-	if (cleanupMap) {
-		for (const entry of cleanupMap.values()) try {
-			entry.cleanup();
-		} catch (err) {
-			logger.warn("[Askr] reactive prop cleanup failed:", err);
-		}
+	if (elementReactivePropsCleanup.has(element)) {
+		forEachElementReactivePropCleanup(element, (entry) => {
+			try {
+				entry.cleanup();
+			} catch (err) {
+				logger.warn("[Askr] reactive prop cleanup failed:", err);
+			}
+		});
 		elementReactivePropsCleanup.delete(element);
 	}
 }
@@ -205,6 +264,4 @@ function removeAllListeners(root) {
 	});
 }
 //#endregion
-export { REACTIVE_CHILDREN_KEY, cleanupInstanceIfPresent, cleanupInstancesUnder, elementListeners, elementReactivePropsCleanup, elementRefs, removeAllListeners, removeElementListeners, removeElementReactiveProps, removeElementRef, teardownNodeSubtree, updateElementRef };
-
-//# sourceMappingURL=cleanup.js.map
+export { REACTIVE_CHILDREN_KEY, cleanupInstanceIfPresent, cleanupInstancesUnder, elementListeners, elementReactivePropsCleanup, elementRefs, forEachElementReactivePropCleanup, getElementReactivePropCleanupSize, getElementReactivePropsCleanupMap, removeAllListeners, removeElementListeners, removeElementReactiveProps, removeElementRef, setDirectElementReactivePropCleanup, setFreshElementReactivePropCleanup, teardownNodeSubtree, updateElementRef };

package/dist/renderer/component-host-cleanup.js

@@ -1,68 +1,143 @@
+import { incDevCounter } from "../runtime/dev-namespace.js";
 import { cleanupComponent } from "../runtime/component-cleanup.js";
+import { registerLifecycleTransaction } from "../runtime/lifecycle-batch.js";
+import { clearDelegatedHandlersForElement, removeDelegatedListener } from "../runtime/events.js";
 import "../runtime/index.js";
-import { removeElementListeners, removeElementReactiveProps } from "./cleanup.js";
+import { elementListeners, elementReactivePropsCleanup, elementRefs, forEachElementReactivePropCleanup, removeElementRef } from "./cleanup.js";
 //#region src/renderer/component-host-cleanup.ts
 function cleanupDetachedComponentHost(host, retainedInstance) {
-	removeElementListeners(host);
-	removeElementReactiveProps(host);
-	const hostInstances = host.__ASKR_INSTANCES;
-	if (hostInstances && hostInstances.length > 0) for (const instance of hostInstances) {
-		if (instance === retainedInstance) continue;
-		cleanupComponent(instance);
+	const retainedInstances = retainedInstance instanceof Object && typeof retainedInstance[Symbol.iterator] === "function" ? new Set(retainedInstance) : /* @__PURE__ */ new Set([retainedInstance]);
+	const cleanupErrors = [];
+	const cleanedInstances = /* @__PURE__ */ new Set();
+	const elements = [host];
+	try {
+		const descendants = host.querySelectorAll("*");
+		for (let index = 0; index < descendants.length; index += 1) elements.push(descendants[index]);
+	} catch (error) {
+		cleanupErrors.push(error);
+	}
+	for (const element of elements) {
+		cleanupElementListeners(element, cleanupErrors);
+		cleanupElementReactiveProps(element, cleanupErrors);
+		cleanupElementRef(element, cleanupErrors);
+		cleanupElementInstances(element, retainedInstances, cleanedInstances, cleanupErrors);
+		clearHostMetadata(element, cleanupErrors);
 	}
-	else if (host.__ASKR_INSTANCE && host.__ASKR_INSTANCE !== retainedInstance) cleanupComponent(host.__ASKR_INSTANCE);
-	const descendants = host.querySelectorAll("*");
-	for (let index = 0; index < descendants.length; index += 1) {
-		const descendant = descendants[index];
-		removeElementListeners(descendant);
-		removeElementReactiveProps(descendant);
-		if (descendant.__ASKR_INSTANCES?.length) {
-			for (const instance of descendant.__ASKR_INSTANCES) {
-				if (instance === retainedInstance) continue;
-				cleanupComponent(instance);
-			}
-			try {
-				delete descendant.__ASKR_INSTANCES;
-			} catch {}
-		} else if (descendant.__ASKR_INSTANCE && descendant.__ASKR_INSTANCE !== retainedInstance) {
-			cleanupComponent(descendant.__ASKR_INSTANCE);
-			try {
-				delete descendant.__ASKR_INSTANCE;
-			} catch {}
+	if (cleanupErrors.length > 0) throw new AggregateError(cleanupErrors, "Detached component host cleanup failed");
+}
+function cleanupElementListeners(element, cleanupErrors) {
+	const listenerMap = elementListeners.get(element);
+	if (listenerMap) {
+		elementListeners.delete(element);
+		for (const entry of listenerMap.values()) try {
+			incDevCounter("listenerRemoves");
+			if (entry.isDelegated) removeDelegatedListener(element, entry.eventName);
+			else if (entry.options !== void 0) element.removeEventListener(entry.eventName, entry.handler, entry.options);
+			else element.removeEventListener(entry.eventName, entry.handler);
+		} catch (error) {
+			cleanupErrors.push(error);
 		}
 	}
 	try {
-		delete host.__ASKR_INSTANCE;
-		delete host.__ASKR_INSTANCES;
-		delete host.__ASKR_WRAPPER_HOST;
-	} catch {}
+		clearDelegatedHandlersForElement(element);
+	} catch (error) {
+		cleanupErrors.push(error);
+	}
 }
-function pruneComponentHostInstances(host, retainedInstances) {
-	const retained = new Set(retainedInstances);
-	const nextInstances = [];
-	const staleInstances = /* @__PURE__ */ new Set();
-	const retainOrMarkStale = (instance) => {
-		if (!instance) return;
-		if (retained.has(instance)) {
-			if (!nextInstances.includes(instance)) nextInstances.push(instance);
-			return;
+function cleanupElementReactiveProps(element, cleanupErrors) {
+	if (!elementReactivePropsCleanup.has(element)) return;
+	const entries = [];
+	forEachElementReactivePropCleanup(element, (entry) => entries.push(entry));
+	elementReactivePropsCleanup.delete(element);
+	for (const entry of entries) try {
+		entry.cleanup();
+	} catch (error) {
+		cleanupErrors.push(error);
+	}
+}
+function cleanupElementRef(element, cleanupErrors) {
+	try {
+		removeElementRef(element);
+	} catch (error) {
+		elementRefs.delete(element);
+		cleanupErrors.push(error);
+	}
+}
+function cleanupElementInstances(element, retainedInstances, cleanedInstances, cleanupErrors) {
+	const instances = new Set(element.__ASKR_INSTANCES ?? []);
+	if (element.__ASKR_INSTANCE) instances.add(element.__ASKR_INSTANCE);
+	for (const instance of instances) {
+		if (retainedInstances.has(instance) || cleanedInstances.has(instance)) continue;
+		cleanedInstances.add(instance);
+		try {
+			cleanupComponent(instance);
+		} catch (error) {
+			cleanupErrors.push(error);
 		}
-		staleInstances.add(instance);
+	}
+}
+function clearHostMetadata(element, cleanupErrors) {
+	for (const property of [
+		"__ASKR_INSTANCE",
+		"__ASKR_INSTANCES",
+		"__ASKR_WRAPPER_HOST"
+	]) try {
+		delete element[property];
+	} catch (error) {
+		cleanupErrors.push(error);
+	}
+}
+function pruneComponentHostInstances(host, retainedInstances) {
+	const hadInstanceList = Object.prototype.hasOwnProperty.call(host, "__ASKR_INSTANCES");
+	const hadPrimaryInstance = Object.prototype.hasOwnProperty.call(host, "__ASKR_INSTANCE");
+	const previousInstanceList = host.__ASKR_INSTANCES?.slice();
+	const previousPrimaryInstance = host.__ASKR_INSTANCE;
+	const previousInstances = collectHostInstances(host);
+	const commit = () => {
+		const retained = new Set(retainedInstances);
+		const currentInstances = collectHostInstances(host);
+		const nextInstances = Array.from(currentInstances).filter((instance) => retained.has(instance));
+		for (const instance of retained) if (instance.target === host && !nextInstances.includes(instance)) nextInstances.push(instance);
+		writeHostInstances(host, nextInstances);
+		cleanupHostInstances(Array.from(currentInstances).filter((instance) => !retained.has(instance)), "Component host pruning failed");
+	};
+	const rollback = () => {
+		const currentInstances = collectHostInstances(host);
+		try {
+			if (hadInstanceList) host.__ASKR_INSTANCES = previousInstanceList;
+			else delete host.__ASKR_INSTANCES;
+			if (hadPrimaryInstance) host.__ASKR_INSTANCE = previousPrimaryInstance;
+			else delete host.__ASKR_INSTANCE;
+		} catch {}
+		cleanupHostInstances(Array.from(currentInstances).filter((instance) => !previousInstances.has(instance)), "Provisional component host cleanup failed");
 	};
-	for (const instance of host.__ASKR_INSTANCES ?? []) retainOrMarkStale(instance);
-	retainOrMarkStale(host.__ASKR_INSTANCE);
-	for (const instance of staleInstances) cleanupComponent(instance);
+	if (!registerLifecycleTransaction({}, commit, rollback)) commit();
+}
+function collectHostInstances(host) {
+	const instances = /* @__PURE__ */ new Set();
+	for (const instance of host.__ASKR_INSTANCES ?? []) instances.add(instance);
+	if (host.__ASKR_INSTANCE) instances.add(host.__ASKR_INSTANCE);
+	return instances;
+}
+function writeHostInstances(host, instances) {
 	try {
-		if (nextInstances.length > 0) {
-			host.__ASKR_INSTANCES = nextInstances;
-			host.__ASKR_INSTANCE = nextInstances[0];
+		if (instances.length > 0) {
+			host.__ASKR_INSTANCES = instances;
+			host.__ASKR_INSTANCE = instances[0];
 		} else {
 			delete host.__ASKR_INSTANCES;
 			delete host.__ASKR_INSTANCE;
 		}
 	} catch {}
 }
+function cleanupHostInstances(instances, message) {
+	const cleanupErrors = [];
+	for (const instance of instances) try {
+		cleanupComponent(instance);
+	} catch (error) {
+		cleanupErrors.push(error);
+	}
+	if (cleanupErrors.length > 0) throw new AggregateError(cleanupErrors, message);
+}
 //#endregion
 export { cleanupDetachedComponentHost, pruneComponentHostInstances };
-
-//# sourceMappingURL=component-host-cleanup.js.map