@askrjs/askr 0.0.50 → 0.0.52

package/dist/renderer/fastpath.js

@@ -1,13 +1,14 @@
 import { getRuntimeEnv } from "../common/env.js";
-import { logger } from "../dev/logger.js";
+import { logger } from "../common/logger.js";
 import { isRuntimeSchedulerExecuting } from "../runtime/access.js";
 import { incDevCounter, setDevValue } from "../runtime/dev-namespace.js";
 import { isBulkCommitActive, markFastPathApplied } from "../runtime/fastlane.js";
+import { recordBenchCounter, recordBenchEvent } from "../runtime/for-bench.js";
+import "../runtime/index.js";
 import { cleanupInstanceIfPresent, removeAllListeners } from "./cleanup.js";
 import "./env.js";
-import { canUseDirectReplaceChildrenSpread } from "./utils.js";
+import { canUseDirectReplaceChildrenSpread, getMaterializedKey } from "./utils.js";
 import { _reconcilerRecordedParents } from "./keyed.js";
-import { recordBenchCounter, recordBenchEvent } from "../runtime/for-bench.js";
 import { createDOMNode, updateElementFromVnode } from "./dom-internal.js";
 import "./dom.js";
 function applyRendererFastPath(parent, keyedVnodes, oldKeyMap) {
@@ -26,12 +27,8 @@ function applyRendererFastPath(parent, keyedVnodes, oldKeyMap) {
 		localOldKeyMap = /* @__PURE__ */ new Map();
 		try {
 			for (let ch = parent.firstElementChild; ch; ch = ch.nextElementSibling) {
-				const k = ch.getAttribute("data-key");
-				if (k !== null) {
-					localOldKeyMap.set(k, ch);
-					const n = Number(k);
-					if (!Number.isNaN(n)) localOldKeyMap.set(n, ch);
-				}
+				const key = getMaterializedKey(ch);
+				if (key !== void 0) localOldKeyMap.set(key, ch);
 			}
 		} catch (e) {
 			localOldKeyMap = void 0;
@@ -46,11 +43,9 @@ function applyRendererFastPath(parent, keyedVnodes, oldKeyMap) {
 		mapLookups++;
 		let el;
 		if (totalKeyed <= 20 && parentChildrenArr) {
-			const ks = String(key);
 			for (let j = 0; j < parentChildrenArr.length; j++) {
 				const ch = parentChildrenArr[j];
-				const k = ch.getAttribute("data-key");
-				if (k !== null && (k === ks || Number(k) === key)) {
+				if (getMaterializedKey(ch) === key) {
 					el = ch;
 					break;
 				}
@@ -145,5 +140,3 @@ function applyRendererFastPath(parent, keyedVnodes, oldKeyMap) {
 }
 //#endregion
 export { applyRendererFastPath };
-
-//# sourceMappingURL=fastpath.js.map

package/dist/renderer/for-commit-dom-map.js

@@ -1,3 +1,4 @@
+import { getMaterializedKey } from "./utils.js";
 import { keyedElements } from "./keyed.js";
 //#region src/renderer/for-commit-dom-map.ts
 function getOrBuildDomKeyMap(parent) {
@@ -5,12 +6,8 @@ function getOrBuildDomKeyMap(parent) {
 	if (!keyMap) {
 		keyMap = /* @__PURE__ */ new Map();
 		for (let child = parent.firstElementChild; child; child = child.nextElementSibling) {
-			const key = child.getAttribute("data-key");
-			if (key !== null) {
-				keyMap.set(key, child);
-				const numericKey = Number(key);
-				if (!Number.isNaN(numericKey)) keyMap.set(numericKey, child);
-			}
+			const key = getMaterializedKey(child);
+			if (key !== void 0) keyMap.set(key, child);
 		}
 		if (keyMap.size > 0) keyedElements.set(parent, keyMap);
 	}
@@ -22,7 +19,7 @@ function hydrateExistingForDomInOrder(parent, forState) {
 		const itemKey = forState.orderedKeys[i];
 		const itemInstance = forState.items.get(itemKey);
 		const currentDom = parent.children[i];
-		if (!itemInstance || currentDom.getAttribute("data-key") !== String(itemKey)) return false;
+		if (!itemInstance || getMaterializedKey(currentDom) !== itemKey) return false;
 		itemInstance.scope.dom = currentDom;
 		itemInstance.scope.needsDomUpdate = true;
 	}
@@ -30,13 +27,6 @@ function hydrateExistingForDomInOrder(parent, forState) {
 }
 function syncKeyedMapFromForState(parent, forState, strategy, removedNodes) {
 	const existing = keyedElements.get(parent);
-	const ensureMapEntry = (map, key, element) => {
-		map.set(key, element);
-		const keyString = String(key);
-		map.set(keyString, element);
-		const keyNumber = Number(keyString);
-		if (!Number.isNaN(keyNumber)) map.set(keyNumber, element);
-	};
 	if (strategy === "SWAP") {
 		if (existing) return;
 	}
@@ -60,7 +50,7 @@ function syncKeyedMapFromForState(parent, forState, strategy, removedNodes) {
 			const key = forState.orderedKeys[i];
 			if (key === null || existing.has(key)) continue;
 			const itemInstance = forState.items.get(key);
-			if (itemInstance?.scope.dom instanceof Element) ensureMapEntry(existing, key, itemInstance.scope.dom);
+			if (itemInstance?.scope.dom instanceof Element) existing.set(key, itemInstance.scope.dom);
 		}
 		if (existing.size > 0) keyedElements.set(parent, existing);
 		else keyedElements.delete(parent);
@@ -72,12 +62,10 @@ function syncKeyedMapFromForState(parent, forState, strategy, removedNodes) {
 		const key = forState.orderedKeys[i];
 		if (key === null) continue;
 		const itemInstance = forState.items.get(key);
-		if (itemInstance?.scope.dom instanceof Element) ensureMapEntry(nextMap, key, itemInstance.scope.dom);
+		if (itemInstance?.scope.dom instanceof Element) nextMap.set(key, itemInstance.scope.dom);
 	}
 	if (nextMap.size > 0) keyedElements.set(parent, nextMap);
 	else keyedElements.delete(parent);
 }
 //#endregion
 export { getOrBuildDomKeyMap, hydrateExistingForDomInOrder, syncKeyedMapFromForState };
-
-//# sourceMappingURL=for-commit-dom-map.js.map

package/dist/renderer/for-commit-removal.js

@@ -1,36 +1,27 @@
+import "../runtime/for-bench.js";
+import "../runtime/index.js";
 import { teardownNodeSubtree } from "./cleanup.js";
-import { recordBenchCounter, recordBenchEvent, withBenchMetricScope } from "../runtime/for-bench.js";
-import "../runtime/for.js";
-//#region src/renderer/for-commit-removal.ts
-function removeForBoundaryNodes(parent, removedNodes) {
+function removeForBoundaryNodes(parent, removedNodes, options = {}) {
+	const shouldTeardown = options.teardown !== false;
 	if (removedNodes.length > 0 && removedNodes.length === parent.childNodes.length) {
 		let canBulkClear = true;
-		for (let i = 0; i < removedNodes.length; i++) if (removedNodes[i].parentNode !== parent) {
+		for (let i = 0; i < removedNodes.length; i++) if (removedNodes[i] !== parent.childNodes[i]) {
 			canBulkClear = false;
 			break;
 		}
 		if (canBulkClear) {
-			for (let i = 0; i < removedNodes.length; i++) {
-				recordBenchEvent("domRemove");
-				teardownNodeSubtree(removedNodes[i]);
-			}
-			withBenchMetricScope("fullClear", () => {
-				recordBenchCounter("bulkClearCommits");
-				parent.textContent = "";
-			});
+			if (shouldTeardown) for (let i = 0; i < removedNodes.length; i++) teardownNodeSubtree(removedNodes[i]);
+			parent.textContent = "";
 			return;
 		}
 	}
 	for (let i = 0; i < removedNodes.length; i++) {
 		const node = removedNodes[i];
 		if (node.parentNode === parent) {
-			recordBenchEvent("domRemove");
-			teardownNodeSubtree(node);
+			if (shouldTeardown) teardownNodeSubtree(node);
 			parent.removeChild(node);
 		}
 	}
 }
 //#endregion
 export { removeForBoundaryNodes };
-
-//# sourceMappingURL=for-commit-removal.js.map

package/dist/renderer/for-commit-reorder.js

@@ -1,6 +1,6 @@
-import { canUseDirectReplaceChildrenSpread } from "./utils.js";
 import { recordBenchCounter, recordBenchEvent } from "../runtime/for-bench.js";
-import "../runtime/for.js";
+import "../runtime/index.js";
+import { canUseDirectReplaceChildrenSpread } from "./utils.js";
 //#region src/renderer/for-commit-reorder.ts
 const DENSE_MOVE_MINIMUM = 64;
 const DENSE_MOVE_RATIO = .75;
@@ -85,5 +85,3 @@ function commitMoveOnlyReorder(parent, nodes) {
 }
 //#endregion
 export { commitMoveOnlyReorder, replaceChildrenInOrder };
-
-//# sourceMappingURL=for-commit-reorder.js.map

package/dist/renderer/for-commit.js

@@ -1,16 +1,123 @@
+import { beginLifecycleCommitBatch, discardLifecycleCommitBatch, flushLifecycleCommitBatch } from "../runtime/lifecycle-batch.js";
+import { recordBenchEvent } from "../runtime/for-bench.js";
+import { captureForFallbackTransactionSnapshot, captureForItemTransactionSnapshot } from "../runtime/for-scopes.js";
+import { beginForStateTransaction, clearForDomUpdateState, registerForStateTransaction, rollbackForStateTransaction } from "../runtime/for-internal.js";
+import "../runtime/index.js";
 import { teardownNodeSubtree } from "./cleanup.js";
 import { canUseDirectReplaceChildrenSpread } from "./utils.js";
 import { keyedElements } from "./keyed.js";
-import { recordBenchCounter, recordBenchEvent, recordBenchTiming, withBenchMetricScope } from "../runtime/for-bench.js";
-import { clearForDomUpdateState } from "../runtime/for-internal.js";
-import "../runtime/for.js";
 import { getOrBuildDomKeyMap, hydrateExistingForDomInOrder, syncKeyedMapFromForState } from "./for-commit-dom-map.js";
 import { commitMoveOnlyReorder, replaceChildrenInOrder } from "./for-commit-reorder.js";
 import { removeForBoundaryNodes } from "./for-commit-removal.js";
-//#region src/renderer/for-commit.ts
+import { getRangeNodes, moveRange } from "./dom-range.js";
+import { isFragment } from "./evaluate-reconcile.js";
+function isExactRemovedBoundary(parent, removedNodes) {
+	if (removedNodes.length === 0 || removedNodes.length !== parent.childNodes.length) return false;
+	for (let index = 0; index < removedNodes.length; index++) if (removedNodes[index] !== parent.childNodes[index]) return false;
+	return true;
+}
+function isMultiNodeVNode(vnode) {
+	if (vnode === null || vnode === void 0 || vnode === false) return true;
+	return Array.isArray(vnode) || typeof vnode === "object" && vnode !== null && isFragment(vnode);
+}
+function getScopeRange(scope, node) {
+	if (scope.range) return scope.range;
+	if (!node) return null;
+	return {
+		start: node,
+		end: node,
+		single: true
+	};
+}
+function detachRange(range) {
+	const parent = range.start.parentNode;
+	if (!parent) return;
+	const fragment = parent.ownerDocument?.createDocumentFragment();
+	if (fragment) moveRange(fragment, range);
+}
+function detachRemovedForNodes(parent, forState) {
+	for (const range of forState.lastRemovedRanges) detachRange(range);
+	for (const node of forState.lastRemovedNodes) if (node.parentNode === parent) node.parentNode.removeChild(node);
+}
+function commitForStateBoundaryRanges(parent, forState, childrenVNodes, runtime) {
+	const desiredRanges = [];
+	if (forState.orderedKeys.length === 0) {
+		const fallbackScope = forState.fallbackScope;
+		const fallbackVNode = childrenVNodes[0];
+		if (fallbackScope && fallbackVNode !== void 0) {
+			const range = getScopeRange(fallbackScope, !fallbackScope.needsDomUpdate ? null : runtime.syncForItemDom(parent, fallbackScope, fallbackVNode));
+			if (range) desiredRanges.push(range);
+		}
+	} else for (let index = 0; index < forState.orderedItems.length; index += 1) {
+		const item = forState.orderedItems[index];
+		if (!item) continue;
+		captureItemBeforeRangeCommit(forState, item);
+		const node = !item.scope.needsDomUpdate ? null : runtime.syncForItemDom(parent, item.scope, childrenVNodes[index]);
+		const range = getScopeRange(item.scope, node);
+		if (range) desiredRanges.push(range);
+	}
+	const desiredNodes = /* @__PURE__ */ new Set();
+	for (const range of desiredRanges) {
+		desiredNodes.add(range.start);
+		for (const node of getRangeNodes(range)) desiredNodes.add(node);
+		if (!range.single) desiredNodes.add(range.end);
+	}
+	detachRemovedForNodes(parent, forState);
+	let anchor = null;
+	for (let index = desiredRanges.length - 1; index >= 0; index -= 1) {
+		const range = desiredRanges[index];
+		moveRange(parent, range, anchor);
+		anchor = range.start;
+	}
+	for (const node of Array.from(parent.childNodes)) {
+		if (desiredNodes.has(node)) continue;
+		node.parentNode?.removeChild(node);
+	}
+	forState._hasResolvedItemDom = true;
+	clearForDomUpdateState(forState);
+}
+function captureItemBeforeRangeCommit(forState, item) {
+	if (item.scope.needsDomUpdate || item.scope.hydrationPending) captureForItemTransactionSnapshot(forState, item);
+}
 function commitForStateBoundaryChildren(parent, forState, childrenVNodes, runtime) {
-	const domCommitStart = performance.now();
+	const previousChildren = Array.from(parent.childNodes);
+	const currentKeyedMap = keyedElements.get(parent);
+	const previousKeyedMap = currentKeyedMap ? new Map(currentKeyedMap) : void 0;
+	const lifecycleBatch = beginLifecycleCommitBatch();
+	beginForStateTransaction(forState, "reuse");
+	registerForStateTransaction(forState);
+	try {
+		commitForStateBoundaryChildrenImpl(parent, forState, childrenVNodes, runtime);
+		flushLifecycleCommitBatch(lifecycleBatch);
+	} catch (error) {
+		discardLifecycleCommitBatch(lifecycleBatch);
+		rollbackForStateTransaction(forState);
+		const previousChildrenSet = new Set(previousChildren);
+		for (const node of Array.from(parent.childNodes)) if (!previousChildrenSet.has(node)) teardownNodeSubtree(node);
+		parent.replaceChildren(...previousChildren);
+		if (previousKeyedMap) keyedElements.set(parent, new Map(previousKeyedMap));
+		else keyedElements.delete(parent);
+		throw error;
+	}
+}
+function commitForStateBoundaryChildrenImpl(parent, forState, childrenVNodes, runtime) {
+	if (childrenVNodes.some(isMultiNodeVNode) || forState.orderedItems.some((item) => item.scope.range && !item.scope.range.single) || Boolean(forState.fallbackScope?.range && !forState.fallbackScope.range.single)) {
+		commitForStateBoundaryRanges(parent, forState, childrenVNodes, runtime);
+		return;
+	}
+	let removedBoundaryConsumed = false;
+	const captureItemBeforeCommit = (item) => {
+		if (item.scope.needsDomUpdate || item.scope.hydrationPending) captureForItemTransactionSnapshot(forState, item);
+	};
+	const syncItemDom = (item, vnode) => {
+		captureItemBeforeCommit(item);
+		return runtime.syncForItemDom(parent, item.scope, vnode);
+	};
 	const hydrateExistingForDom = () => {
+		if (parent.children.length === forState.orderedKeys.length) for (let index = 0; index < forState.orderedItems.length; index++) {
+			const item = forState.orderedItems[index];
+			if (item) captureForItemTransactionSnapshot(forState, item);
+		}
 		if (hydrateExistingForDomInOrder(parent, forState)) return;
 		const domKeyMap = getOrBuildDomKeyMap(parent);
 		if (!domKeyMap) return;
@@ -20,21 +127,26 @@ function commitForStateBoundaryChildren(parent, forState, childrenVNodes, runtim
 			if (!itemInstance || itemInstance.scope.dom) continue;
 			const existingDom = domKeyMap.get(itemKey);
 			if (!existingDom) continue;
+			captureForItemTransactionSnapshot(forState, itemInstance);
 			itemInstance.scope.dom = existingDom;
 			itemInstance.scope.needsDomUpdate = true;
 		}
 	};
 	if (forState.orderedKeys.length === 0) {
-		removeForBoundaryNodes(parent, forState.lastRemovedNodes);
 		const fallbackScope = forState.fallbackScope;
 		const fallbackVNode = childrenVNodes[0];
+		if (fallbackScope && (fallbackScope.needsDomUpdate || fallbackScope.hydrationPending)) captureForFallbackTransactionSnapshot(forState, fallbackScope);
 		const nextDom = fallbackScope && fallbackVNode !== void 0 ? runtime.syncForItemDom(parent, fallbackScope, fallbackVNode) : null;
+		if (nextDom && isExactRemovedBoundary(parent, forState.lastRemovedNodes)) {
+			recordBenchEvent("domRemove", forState.lastRemovedNodes.length);
+			parent.replaceChildren(nextDom);
+			removedBoundaryConsumed = true;
+		} else removeForBoundaryNodes(parent, forState.lastRemovedNodes, { teardown: false });
 		if (nextDom) {
-			if (parent.childNodes.length !== 1 || parent.firstChild !== nextDom || forState.lastRemovedNodes.length > 0) parent.replaceChildren(nextDom);
+			if (parent.childNodes.length !== 1 || parent.firstChild !== nextDom || forState.lastRemovedNodes.length > 0 && !removedBoundaryConsumed) parent.replaceChildren(nextDom);
 		} else if (parent.firstChild) parent.textContent = "";
 		keyedElements.delete(parent);
 		forState._hasResolvedItemDom = false;
-		recordBenchTiming("domCommit", performance.now() - domCommitStart);
 		clearForDomUpdateState(forState);
 		return;
 	}
@@ -65,8 +177,9 @@ function commitForStateBoundaryChildren(parent, forState, childrenVNodes, runtim
 			const i = dirtyIndices[dirtyIndex];
 			const itemInstance = orderedItems[i];
 			if (!itemInstance) continue;
+			captureItemBeforeCommit(itemInstance);
 			if (runtime.tryPatchStableForDirtyItem(itemInstance.scope)) continue;
-			const dom = runtime.syncForItemDom(parent, itemInstance.scope, childrenVNodes[i]);
+			const dom = syncItemDom(itemInstance, childrenVNodes[i]);
 			if (!dom) continue;
 			const anchor = childNodes[i] ?? null;
 			if (dom.parentNode !== parent || dom !== anchor) {
@@ -80,7 +193,7 @@ function commitForStateBoundaryChildren(parent, forState, childrenVNodes, runtim
 		for (let i = 0; i < forState.orderedKeys.length; i++) {
 			const itemInstance = forState.orderedItems[i];
 			if (!itemInstance) continue;
-			const dom = runtime.syncForItemDom(parent, itemInstance.scope, childrenVNodes[i]);
+			const dom = syncItemDom(itemInstance, childrenVNodes[i]);
 			if (!dom) continue;
 			if (dom.parentNode !== parent) {
 				const anchor = parent.childNodes[i] ?? null;
@@ -101,7 +214,7 @@ function commitForStateBoundaryChildren(parent, forState, childrenVNodes, runtim
 					currentNode = currentNode?.nextSibling ?? null;
 					continue;
 				}
-				const dom = runtime.syncForItemDom(parent, itemInstance.scope, childrenVNodes[i]);
+				const dom = syncItemDom(itemInstance, childrenVNodes[i]);
 				if (!dom || dom.parentNode !== parent || dom !== currentNode) exactOrder = false;
 				currentNode = currentNode?.nextSibling ?? null;
 			}
@@ -110,23 +223,41 @@ function commitForStateBoundaryChildren(parent, forState, childrenVNodes, runtim
 				return;
 			}
 		}
-		withBenchMetricScope("coldCreate", () => {
-			const fragment = parent.ownerDocument.createDocumentFragment();
-			let hasPendingAppend = false;
-			for (let i = 0; i < forState.orderedKeys.length; i++) {
+		const appendColdRows = () => {
+			const pendingAppend = [];
+			const appendStart = forState.pendingAppendStart ?? 0;
+			const hasDetachedSuffix = forState.pendingAppendStart !== null && parent.childNodes.length === appendStart;
+			for (let i = appendStart; i < forState.orderedKeys.length; i++) {
 				const itemInstance = forState.orderedItems[i];
 				if (!itemInstance) continue;
-				if (itemInstance.scope.dom?.parentNode === parent && !itemInstance.scope.needsDomUpdate) continue;
-				const dom = runtime.syncForItemDom(parent, itemInstance.scope, childrenVNodes[i]);
+				if (!hasDetachedSuffix && itemInstance.scope.dom?.parentNode === parent && !itemInstance.scope.needsDomUpdate) continue;
+				const dom = syncItemDom(itemInstance, childrenVNodes[i]);
 				if (!dom) continue;
-				if (dom.parentNode !== parent) {
-					recordBenchEvent("domInsert");
-					fragment.appendChild(dom);
-					hasPendingAppend = true;
-				}
+				if (hasDetachedSuffix || dom.parentNode !== parent) pendingAppend.push(dom);
 			}
-			if (hasPendingAppend) parent.appendChild(fragment);
-		});
+			if (pendingAppend.length > 0) {
+				const fragment = parent.ownerDocument.createDocumentFragment();
+				if (canUseDirectReplaceChildrenSpread(pendingAppend.length)) fragment.append(...pendingAppend);
+				else for (const node of pendingAppend) fragment.appendChild(node);
+				parent.appendChild(fragment);
+			}
+		};
+		appendColdRows();
+		boundaryChildrenExact = true;
+	};
+	const commitInsertOne = () => {
+		const index = forState.pendingInsertedIndex;
+		const item = index === null ? void 0 : forState.orderedItems[index];
+		if (index === null || !item || parent.childNodes.length !== forState.orderedKeys.length - 1) {
+			commitReorder();
+			return;
+		}
+		const anchor = parent.childNodes[index] ?? null;
+		const dom = syncItemDom(item, childrenVNodes[index]);
+		if (dom && (dom.parentNode !== parent || dom !== anchor)) {
+			recordBenchEvent("domInsert");
+			parent.insertBefore(dom, anchor);
+		}
 		boundaryChildrenExact = true;
 	};
 	const commitSwap = () => {
@@ -143,8 +274,8 @@ function commitForStateBoundaryChildren(parent, forState, childrenVNodes, runtim
 			commitReorder();
 			return;
 		}
-		const firstDom = runtime.syncForItemDom(parent, firstItem.scope, childrenVNodes[firstIndex]);
-		const secondDom = runtime.syncForItemDom(parent, secondItem.scope, childrenVNodes[secondIndex]);
+		const firstDom = syncItemDom(firstItem, childrenVNodes[firstIndex]);
+		const secondDom = syncItemDom(secondItem, childrenVNodes[secondIndex]);
 		if (!firstDom || !secondDom) {
 			commitReorder();
 			return;
@@ -175,7 +306,7 @@ function commitForStateBoundaryChildren(parent, forState, childrenVNodes, runtim
 				const itemInstance = items[i];
 				if (!itemInstance) return;
 				const scope = itemInstance.scope;
-				const dom = scope.dom && !scope.needsDomUpdate ? scope.dom : runtime.syncForItemDom(parent, scope, childrenVNodes[i]);
+				const dom = scope.dom && !scope.needsDomUpdate ? scope.dom : syncItemDom(itemInstance, childrenVNodes[i]);
 				if (!dom) return;
 				if (dom.parentNode === parent) movedCount++;
 				else insertedCount++;
@@ -211,20 +342,19 @@ function commitForStateBoundaryChildren(parent, forState, childrenVNodes, runtim
 			break;
 		}
 		if (!hasExistingChild) {
-			withBenchMetricScope("coldCreate", () => {
+			const canConsumeRemovedBoundary = isExactRemovedBoundary(parent, forState.lastRemovedNodes);
+			const replaceColdRows = () => {
 				const nodes = [];
 				for (let i = 0; i < count; i++) {
 					const itemInstance = items[i];
 					if (!itemInstance) continue;
-					const dom = runtime.syncForItemDom(parent, itemInstance.scope, childrenVNodes[i]);
-					if (dom) {
-						recordBenchEvent("domInsert");
-						nodes.push(dom);
-					}
+					const dom = syncItemDom(itemInstance, childrenVNodes[i]);
+					if (dom) nodes.push(dom);
 				}
-				recordBenchCounter("replaceChildrenCommits");
-				replaceChildrenInOrder(parent, nodes, false);
-			});
+				replaceChildrenInOrder(parent, nodes, canConsumeRemovedBoundary);
+			};
+			replaceColdRows();
+			removedBoundaryConsumed = canConsumeRemovedBoundary;
 			boundaryChildrenExact = true;
 			return;
 		}
@@ -233,7 +363,7 @@ function commitForStateBoundaryChildren(parent, forState, childrenVNodes, runtim
 			for (let i = 0; i < count; i++) {
 				const itemInstance = items[i];
 				if (!itemInstance) continue;
-				const dom = runtime.syncForItemDom(parent, itemInstance.scope, childrenVNodes[i]);
+				const dom = syncItemDom(itemInstance, childrenVNodes[i]);
 				if (!dom) continue;
 				recordBenchEvent(dom.parentNode === parent ? "domMove" : "domInsert");
 				nodes.push(dom);
@@ -245,7 +375,7 @@ function commitForStateBoundaryChildren(parent, forState, childrenVNodes, runtim
 		for (let i = 0; i < count; i++) {
 			const itemInstance = items[i];
 			if (!itemInstance) continue;
-			const dom = runtime.syncForItemDom(parent, itemInstance.scope, childrenVNodes[i]);
+			const dom = syncItemDom(itemInstance, childrenVNodes[i]);
 			if (!dom) continue;
 			const anchor = parent.childNodes[i] ?? null;
 			if (dom !== anchor) {
@@ -258,7 +388,6 @@ function commitForStateBoundaryChildren(parent, forState, childrenVNodes, runtim
 	if (forState.lastCommitStrategy === "NO_REORDER" && dirtyIndices.length > 0 && forState.pendingDirtyIndices === null && forState.pendingSwapIndices === null && !forState.pendingMoveOnly && forState.lastRemovedNodes.length === 0 && parent.childNodes.length === forState.orderedKeys.length) {
 		commitDirtyNoReorder(dirtyIndices);
 		syncKeyedMapFromForState(parent, forState, "NO_REORDER", []);
-		recordBenchTiming("domCommit", performance.now() - domCommitStart);
 		clearForDomUpdateState(forState);
 		return;
 	}
@@ -272,6 +401,9 @@ function commitForStateBoundaryChildren(parent, forState, childrenVNodes, runtim
 		case "APPEND":
 			commitAppend();
 			break;
+		case "INSERT_ONE":
+			commitInsertOne();
+			break;
 		case "SWAP":
 			commitSwap();
 			break;
@@ -279,15 +411,14 @@ function commitForStateBoundaryChildren(parent, forState, childrenVNodes, runtim
 			commitReorder();
 			break;
 	}
-	removeForBoundaryNodes(parent, forState.lastRemovedNodes);
-	if (forState.lastRemovedNodes.length > 0) boundaryChildrenExact = false;
+	if (!removedBoundaryConsumed) removeForBoundaryNodes(parent, forState.lastRemovedNodes, { teardown: false });
 	syncKeyedMapFromForState(parent, forState, forState.lastCommitStrategy, forState.lastRemovedNodes);
 	const syncExactForBoundaryChildren = () => {
 		const expectedNodes = [];
 		for (let i = 0; i < forState.orderedKeys.length; i++) {
 			const itemInstance = forState.orderedItems[i];
 			if (!itemInstance) continue;
-			const dom = itemInstance.scope.dom && !itemInstance.scope.needsDomUpdate ? itemInstance.scope.dom : runtime.syncForItemDom(parent, itemInstance.scope, childrenVNodes[i]);
+			const dom = itemInstance.scope.dom && !itemInstance.scope.needsDomUpdate ? itemInstance.scope.dom : syncItemDom(itemInstance, childrenVNodes[i]);
 			if (dom) expectedNodes.push(dom);
 		}
 		const currentNodes = Array.from(parent.childNodes);
@@ -305,10 +436,7 @@ function commitForStateBoundaryChildren(parent, forState, childrenVNodes, runtim
 	};
 	if (!boundaryChildrenExact) syncExactForBoundaryChildren();
 	forState._hasResolvedItemDom = true;
-	recordBenchTiming("domCommit", performance.now() - domCommitStart);
 	clearForDomUpdateState(forState);
 }
 //#endregion
 export { commitForStateBoundaryChildren };
-
-//# sourceMappingURL=for-commit.js.map

package/dist/renderer/hydration-boundaries.js

@@ -0,0 +1,60 @@
+//#region src/renderer/hydration-boundaries.ts
+const recordsByElement = /* @__PURE__ */ new WeakMap();
+const recordsByRoot = /* @__PURE__ */ new WeakMap();
+function registerDeferredHydrationBoundary(root, element, range) {
+	const existing = recordsByElement.get(element);
+	if (existing) return existing;
+	const record = {
+		root,
+		element,
+		ownership: {
+			owner: null,
+			parent: null,
+			portalScope: null
+		},
+		context: null,
+		range,
+		vnode: void 0,
+		renderResult: void 0,
+		state: "deferred",
+		attempts: 0
+	};
+	recordsByElement.set(element, record);
+	const rootRecords = recordsByRoot.get(root) ?? /* @__PURE__ */ new Set();
+	rootRecords.add(record);
+	recordsByRoot.set(root, rootRecords);
+	return record;
+}
+function rememberDeferredHydrationVNode(element, vnode, owner, context) {
+	const record = recordsByElement.get(element);
+	if (!record) return;
+	record.vnode = vnode;
+	record.renderResult = vnode;
+	record.ownership.owner = owner;
+	record.ownership.parent = owner?.parentInstance ?? null;
+	record.ownership.portalScope = owner?.portalScope ?? null;
+	record.context = context;
+	return record;
+}
+function beginDeferredHydrationActivation(element) {
+	const record = recordsByElement.get(element);
+	if (!record || !record.vnode || record.state === "active" || record.state === "activating") return;
+	record.attempts += 1;
+	record.state = "activating";
+	return record;
+}
+function commitDeferredHydrationActivation(record) {
+	record.state = "active";
+}
+function rollbackDeferredHydrationActivation(record) {
+	record.state = "failed";
+}
+function clearDeferredHydrationBoundaries(root) {
+	const records = recordsByRoot.get(root);
+	if (!records) return;
+	for (const record of records) recordsByElement.delete(record.element);
+	records.clear();
+	recordsByRoot.delete(root);
+}
+//#endregion
+export { beginDeferredHydrationActivation, clearDeferredHydrationBoundaries, commitDeferredHydrationActivation, registerDeferredHydrationBoundary, rememberDeferredHydrationVNode, rollbackDeferredHydrationActivation };

package/dist/renderer/hydration-listener-transaction.js

@@ -0,0 +1,49 @@
+//#region src/renderer/hydration-listener-transaction.ts
+let currentTransaction = null;
+function beginHydrationListenerTransaction() {
+	const transaction = {
+		parent: currentTransaction,
+		stages: [],
+		active: true
+	};
+	currentTransaction = transaction;
+	return transaction;
+}
+function stageHydrationListener(stage) {
+	if (!currentTransaction?.active) return false;
+	currentTransaction.stages.push(stage);
+	return true;
+}
+function closeTransaction(transaction) {
+	if (!transaction.active) return false;
+	transaction.active = false;
+	currentTransaction = transaction.parent;
+	return true;
+}
+function commitHydrationListenerTransaction(transaction) {
+	if (!closeTransaction(transaction)) return;
+	const stages = [...transaction.stages].sort((left, right) => {
+		if (left.kind !== right.kind) return left.kind === "delegated" ? -1 : 1;
+		return left.eventName.localeCompare(right.eventName);
+	});
+	const published = [];
+	try {
+		for (const stage of stages) {
+			stage.publish();
+			published.push(stage);
+		}
+	} catch (error) {
+		for (let index = published.length - 1; index >= 0; index -= 1) try {
+			published[index].rollback();
+		} catch {}
+		throw error;
+	}
+}
+function discardHydrationListenerTransaction(transaction) {
+	if (!closeTransaction(transaction)) return;
+	for (let index = transaction.stages.length - 1; index >= 0; index -= 1) try {
+		transaction.stages[index].rollback();
+	} catch {}
+}
+//#endregion
+export { beginHydrationListenerTransaction, commitHydrationListenerTransaction, discardHydrationListenerTransaction, stageHydrationListener };