@askrjs/askr 0.0.50 → 0.0.52

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

@@ -1,10 +1,10 @@
 import { __FOR_BOUNDARY__, _isDOMElement } from "../common/vnode.js";
 import "./types.js";
 import { getRuntimeEnv } from "../common/env.js";
-import { logger } from "../dev/logger.js";
+import { logger } from "../common/logger.js";
 import { Fragment, STATIC_CHILDREN } from "../common/jsx.js";
 import { getCurrentInstance } from "../runtime/component-scope.js";
-import "../runtime/component-contracts.js";
+import "../runtime/index.js";
 import "./env.js";
 import { isSkippedProp, parseEventName } from "./utils.js";
 import "../jsx-runtime.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

@@ -0,0 +1,149 @@
+import { _isDOMElement } from "../common/vnode.js";
+import "./types.js";
+import { getRuntimeEnv } from "../common/env.js";
+import { teardownNodeSubtree } from "./cleanup.js";
+import "./env.js";
+import { hasNonTrivialProps, logFastPathDebug, now, recordFastPathStats, tagNamesEqualIgnoreCase } from "./utils.js";
+import { keyedElements } from "./keyed.js";
+import { createDOMNode, updateElementFromVnode } from "./dom-internal.js";
+import "./dom.js";
+//#region src/renderer/children-fastpath.ts
+function upperCommonTagName(tag) {
+	switch (tag) {
+		case "div": return "DIV";
+		case "span": return "SPAN";
+		case "p": return "P";
+		case "a": return "A";
+		case "button": return "BUTTON";
+		case "input": return "INPUT";
+		case "ul": return "UL";
+		case "ol": return "OL";
+		case "li": return "LI";
+		default: return null;
+	}
+}
+function tagsEqualIgnoreCase(elementTagName, vnodeType) {
+	if (elementTagName === vnodeType) return true;
+	const upperCommon = upperCommonTagName(vnodeType);
+	if (upperCommon !== null && elementTagName === upperCommon) return true;
+	return tagNamesEqualIgnoreCase(elementTagName, vnodeType);
+}
+function performBulkPositionalKeyedTextUpdate(parent, keyedVnodes) {
+	const total = keyedVnodes.length;
+	let reused = 0;
+	let updatedKeys = 0;
+	const start = now();
+	const env = getRuntimeEnv();
+	const debugFastPath = env.ASKR_FASTPATH_DEBUG === "1" || env.ASKR_FASTPATH_DEBUG === "true";
+	for (let index = 0; index < total; index += 1) {
+		const { key, vnode } = keyedVnodes[index];
+		const child = parent.children[index];
+		if (child && _isDOMElement(vnode) && typeof vnode.type === "string") {
+			const vnodeType = vnode.type;
+			if (tagsEqualIgnoreCase(child.tagName, vnodeType)) {
+				const children = vnode.children || vnode.props?.children;
+				if (debugFastPath) logFastPathDebug("positional idx", index, {
+					chTag: child.tagName,
+					vnodeType,
+					chChildNodes: child.childNodes.length,
+					childrenType: Array.isArray(children) ? "array" : typeof children
+				});
+				updateTextContent(child, children, vnode);
+				setDataKey(child, key, () => updatedKeys += 1);
+				reused += 1;
+				continue;
+			}
+			if (debugFastPath) logFastPathDebug("positional tag mismatch", index, {
+				chTag: child.tagName,
+				vnodeType
+			});
+		} else if (debugFastPath) logFastPathDebug("positional missing or invalid", index, { ch: !!child });
+		replaceNodeAtPosition(parent, index, vnode);
+	}
+	const elapsed = now() - start;
+	updateKeyedElementsMap(parent, keyedVnodes);
+	const stats = {
+		n: total,
+		reused,
+		updatedKeys,
+		t: elapsed
+	};
+	recordFastPathStats(stats, "bulkKeyedPositionalHits");
+	return stats;
+}
+function updateTextContent(el, children, vnode) {
+	if (typeof children === "string" || typeof children === "number") {
+		setTextNodeData(el, String(children));
+		if (vnode.props && hasNonTrivialProps(vnode.props)) updateElementFromVnode(el, vnode, false);
+		return;
+	}
+	if (Array.isArray(children) && children.length === 1 && (typeof children[0] === "string" || typeof children[0] === "number")) {
+		setTextNodeData(el, String(children[0]));
+		if (vnode.props && hasNonTrivialProps(vnode.props)) updateElementFromVnode(el, vnode, false);
+		return;
+	}
+	if (!tryUpdateTwoChildTextPattern(el, vnode)) updateElementFromVnode(el, vnode);
+}
+function tryUpdateTwoChildTextPattern(parentEl, vnode) {
+	const vnodeChildren = vnode.props?.children ?? vnode.children;
+	if (!Array.isArray(vnodeChildren) || vnodeChildren.length !== 2) return false;
+	const firstChild = vnodeChildren[0];
+	const secondChild = vnodeChildren[1];
+	if (!_isDOMElement(firstChild) || !_isDOMElement(secondChild)) return false;
+	if (typeof firstChild.type !== "string" || typeof secondChild.type !== "string") return false;
+	const firstElement = parentEl.children[0];
+	const secondElement = parentEl.children[1];
+	if (!firstElement || !secondElement) return false;
+	if (parentEl.children.length !== 2 || parentEl.childNodes.length !== 2) return false;
+	if (!tagsEqualIgnoreCase(firstElement.tagName, firstChild.type)) return false;
+	if (!tagsEqualIgnoreCase(secondElement.tagName, secondChild.type)) return false;
+	const firstText = firstChild.children || firstChild.props?.children;
+	const secondText = secondChild.children || secondChild.props?.children;
+	if (typeof firstText === "string" || typeof firstText === "number") setTextNodeData(firstElement, String(firstText));
+	else if (Array.isArray(firstText) && firstText.length === 1 && (typeof firstText[0] === "string" || typeof firstText[0] === "number")) setTextNodeData(firstElement, String(firstText[0]));
+	else return false;
+	if (typeof secondText === "string" || typeof secondText === "number") setTextNodeData(secondElement, String(secondText));
+	else if (Array.isArray(secondText) && secondText.length === 1 && (typeof secondText[0] === "string" || typeof secondText[0] === "number")) setTextNodeData(secondElement, String(secondText[0]));
+	else return false;
+	return true;
+}
+function setTextNodeData(el, text) {
+	if (el.childNodes.length === 1 && el.firstChild?.nodeType === 3) {
+		const textNode = el.firstChild;
+		if (textNode.data !== text) textNode.data = text;
+	} else el.textContent = text;
+}
+function setDataKey(el, key, onSet) {
+	try {
+		const next = String(key);
+		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 {}
+}
+function replaceNodeAtPosition(parent, index, vnode) {
+	const dom = createDOMNode(vnode);
+	if (dom) {
+		const existing = parent.children[index];
+		if (existing) {
+			teardownNodeSubtree(existing);
+			parent.replaceChild(dom, existing);
+		} else parent.appendChild(dom);
+	}
+}
+function updateKeyedElementsMap(parent, keyedVnodes) {
+	try {
+		const existing = keyedElements.get(parent);
+		const newKeyMap = existing ? (existing.clear(), existing) : /* @__PURE__ */ new Map();
+		for (let index = 0; index < keyedVnodes.length; index += 1) {
+			const key = keyedVnodes[index].key;
+			const child = parent.children[index];
+			if (child) newKeyMap.set(key, child);
+		}
+		keyedElements.set(parent, newKeyMap);
+	} catch {}
+}
+//#endregion
+export { performBulkPositionalKeyedTextUpdate, tagsEqualIgnoreCase };

package/dist/renderer/children.js

@@ -1,149 +1,14 @@
-import { _isDOMElement } from "../common/vnode.js";
-import "./types.js";
 import { getRuntimeEnv } from "../common/env.js";
 import { incDevCounter, setDevValue } from "../runtime/dev-namespace.js";
+import "../runtime/index.js";
 import { teardownNodeSubtree } from "./cleanup.js";
 import "./env.js";
-import { hasNonTrivialProps, logFastPathDebug, now, recordDOMReplace, recordFastPathStats, tagNamesEqualIgnoreCase } from "./utils.js";
+import { now, recordDOMReplace } from "./utils.js";
 import { keyedElements } from "./keyed.js";
+import { performBulkPositionalKeyedTextUpdate, tagsEqualIgnoreCase } from "./children-fastpath.js";
 import { createDOMNode, updateElementFromVnode } from "./dom-internal.js";
 import "./dom.js";
 //#region src/renderer/children.ts
-function upperCommonTagName(tag) {
-	switch (tag) {
-		case "div": return "DIV";
-		case "span": return "SPAN";
-		case "p": return "P";
-		case "a": return "A";
-		case "button": return "BUTTON";
-		case "input": return "INPUT";
-		case "ul": return "UL";
-		case "ol": return "OL";
-		case "li": return "LI";
-		default: return null;
-	}
-}
-function tagsEqualIgnoreCase(elementTagName, vnodeType) {
-	if (elementTagName === vnodeType) return true;
-	const upperCommon = upperCommonTagName(vnodeType);
-	if (upperCommon !== null && elementTagName === upperCommon) return true;
-	return tagNamesEqualIgnoreCase(elementTagName, vnodeType);
-}
-function performBulkPositionalKeyedTextUpdate(parent, keyedVnodes) {
-	const total = keyedVnodes.length;
-	let reused = 0;
-	let updatedKeys = 0;
-	const start = now();
-	const env = getRuntimeEnv();
-	const debugFastPath = env.ASKR_FASTPATH_DEBUG === "1" || env.ASKR_FASTPATH_DEBUG === "true";
-	for (let index = 0; index < total; index += 1) {
-		const { key, vnode } = keyedVnodes[index];
-		const child = parent.children[index];
-		if (child && _isDOMElement(vnode) && typeof vnode.type === "string") {
-			const vnodeType = vnode.type;
-			if (tagsEqualIgnoreCase(child.tagName, vnodeType)) {
-				const children = vnode.children || vnode.props?.children;
-				if (debugFastPath) logFastPathDebug("positional idx", index, {
-					chTag: child.tagName,
-					vnodeType,
-					chChildNodes: child.childNodes.length,
-					childrenType: Array.isArray(children) ? "array" : typeof children
-				});
-				updateTextContent(child, children, vnode);
-				setDataKey(child, key, () => updatedKeys += 1);
-				reused += 1;
-				continue;
-			}
-			if (debugFastPath) logFastPathDebug("positional tag mismatch", index, {
-				chTag: child.tagName,
-				vnodeType
-			});
-		} else if (debugFastPath) logFastPathDebug("positional missing or invalid", index, { ch: !!child });
-		replaceNodeAtPosition(parent, index, vnode);
-	}
-	const elapsed = now() - start;
-	updateKeyedElementsMap(parent, keyedVnodes);
-	const stats = {
-		n: total,
-		reused,
-		updatedKeys,
-		t: elapsed
-	};
-	recordFastPathStats(stats, "bulkKeyedPositionalHits");
-	return stats;
-}
-function updateTextContent(el, children, vnode) {
-	if (typeof children === "string" || typeof children === "number") {
-		setTextNodeData(el, String(children));
-		if (vnode.props && hasNonTrivialProps(vnode.props)) updateElementFromVnode(el, vnode, false);
-		return;
-	}
-	if (Array.isArray(children) && children.length === 1 && (typeof children[0] === "string" || typeof children[0] === "number")) {
-		setTextNodeData(el, String(children[0]));
-		if (vnode.props && hasNonTrivialProps(vnode.props)) updateElementFromVnode(el, vnode, false);
-		return;
-	}
-	if (!tryUpdateTwoChildTextPattern(el, vnode)) updateElementFromVnode(el, vnode);
-}
-function tryUpdateTwoChildTextPattern(parentEl, vnode) {
-	const vnodeChildren = vnode.props?.children ?? vnode.children;
-	if (!Array.isArray(vnodeChildren) || vnodeChildren.length !== 2) return false;
-	const firstChild = vnodeChildren[0];
-	const secondChild = vnodeChildren[1];
-	if (!_isDOMElement(firstChild) || !_isDOMElement(secondChild)) return false;
-	if (typeof firstChild.type !== "string" || typeof secondChild.type !== "string") return false;
-	const firstElement = parentEl.children[0];
-	const secondElement = parentEl.children[1];
-	if (!firstElement || !secondElement) return false;
-	if (parentEl.children.length !== 2 || parentEl.childNodes.length !== 2) return false;
-	if (!tagsEqualIgnoreCase(firstElement.tagName, firstChild.type)) return false;
-	if (!tagsEqualIgnoreCase(secondElement.tagName, secondChild.type)) return false;
-	const firstText = firstChild.children || firstChild.props?.children;
-	const secondText = secondChild.children || secondChild.props?.children;
-	if (typeof firstText === "string" || typeof firstText === "number") setTextNodeData(firstElement, String(firstText));
-	else if (Array.isArray(firstText) && firstText.length === 1 && (typeof firstText[0] === "string" || typeof firstText[0] === "number")) setTextNodeData(firstElement, String(firstText[0]));
-	else return false;
-	if (typeof secondText === "string" || typeof secondText === "number") setTextNodeData(secondElement, String(secondText));
-	else if (Array.isArray(secondText) && secondText.length === 1 && (typeof secondText[0] === "string" || typeof secondText[0] === "number")) setTextNodeData(secondElement, String(secondText[0]));
-	else return false;
-	return true;
-}
-function setTextNodeData(el, text) {
-	if (el.childNodes.length === 1 && el.firstChild?.nodeType === 3) {
-		const textNode = el.firstChild;
-		if (textNode.data !== text) textNode.data = text;
-	} else el.textContent = text;
-}
-function setDataKey(el, key, onSet) {
-	try {
-		const next = String(key);
-		if (el.getAttribute("data-key") === next) return;
-		el.setAttribute("data-key", next);
-		onSet();
-	} catch {}
-}
-function replaceNodeAtPosition(parent, index, vnode) {
-	const dom = createDOMNode(vnode);
-	if (dom) {
-		const existing = parent.children[index];
-		if (existing) {
-			teardownNodeSubtree(existing);
-			parent.replaceChild(dom, existing);
-		} else parent.appendChild(dom);
-	}
-}
-function updateKeyedElementsMap(parent, keyedVnodes) {
-	try {
-		const existing = keyedElements.get(parent);
-		const newKeyMap = existing ? (existing.clear(), existing) : /* @__PURE__ */ new Map();
-		for (let index = 0; index < keyedVnodes.length; index += 1) {
-			const key = keyedVnodes[index].key;
-			const child = parent.children[index];
-			if (child) newKeyMap.set(key, child);
-		}
-		keyedElements.set(parent, newKeyMap);
-	} catch {}
-}
 function performBulkTextReplace(parent, newChildren) {
 	const start = now();
 	const existing = Array.from(parent.childNodes);
@@ -291,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 "../dev/logger.js";
+import { logger } from "../common/logger.js";
 import { incDevCounter } from "../runtime/dev-namespace.js";
 import { cleanupComponent } from "../runtime/component-cleanup.js";
-import "../runtime/component-contracts.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 };