@askrjs/askr 0.0.51 → 0.0.52

package/dist/renderer/dom-range.js

@@ -0,0 +1,161 @@
+//#region src/renderer/dom-range.ts
+const RANGE_START_MARKER = "askr-range-start";
+const RANGE_END_MARKER = "askr-range-end";
+const rangesByOwner = /* @__PURE__ */ new WeakMap();
+const ownersByAnchor = /* @__PURE__ */ new WeakMap();
+function isRangeMarker(node) {
+	return node.nodeType === 8;
+}
+function normalizeNodes(node) {
+	if (!node) return [];
+	return node instanceof DocumentFragment ? Array.from(node.childNodes) : [node];
+}
+function getRangeNodes(range) {
+	if (range.single) return range.start.parentNode ? [range.start] : [];
+	const nodes = [];
+	let current = range.start.nextSibling;
+	while (current && current !== range.end) {
+		nodes.push(current);
+		current = current.nextSibling;
+	}
+	return nodes;
+}
+function createDetachedRange(nodes, owner) {
+	if (nodes && !(nodes instanceof DocumentFragment)) return {
+		range: createSingleNodeRange(nodes, owner),
+		fragment: null
+	};
+	const normalized = normalizeNodes(nodes);
+	const ownerDocument = normalized[0]?.ownerDocument ?? (typeof document !== "undefined" ? document : null);
+	if (!ownerDocument) throw new Error("[askr] Cannot create a DOM range without a document.");
+	if (normalized.length === 1) {
+		const single = normalized[0];
+		return {
+			range: createSingleNodeRange(single, owner),
+			fragment: null
+		};
+	}
+	const fragment = ownerDocument.createDocumentFragment();
+	const start = ownerDocument.createComment(RANGE_START_MARKER);
+	const end = ownerDocument.createComment(RANGE_END_MARKER);
+	fragment.appendChild(start);
+	for (const node of normalized) fragment.appendChild(node);
+	fragment.appendChild(end);
+	const range = {
+		start,
+		end,
+		single: false
+	};
+	registerRange(range, owner);
+	return {
+		range,
+		fragment
+	};
+}
+/** @internal Create the common singleton range without a result wrapper. */
+function createSingleNodeRange(node, owner) {
+	const range = {
+		start: node,
+		end: node,
+		single: true
+	};
+	registerRange(range, owner);
+	return range;
+}
+function createEmptyRange(ownerDocument = document, owner) {
+	return createDetachedRange(ownerDocument.createDocumentFragment(), owner);
+}
+function registerRange(range, owner) {
+	if (!owner) return;
+	rangesByOwner.set(owner, range);
+	ownersByAnchor.set(range.start, owner);
+	if (range.end !== range.start) ownersByAnchor.set(range.end, owner);
+}
+function getOwnedRange(owner) {
+	return rangesByOwner.get(owner);
+}
+function getRangeOwner(node) {
+	return ownersByAnchor.get(node);
+}
+function clearRangeOwner(range, owner) {
+	const startOwner = ownersByAnchor.get(range.start);
+	const endOwner = ownersByAnchor.get(range.end);
+	if (!owner || startOwner === owner) ownersByAnchor.delete(range.start);
+	if (!owner || endOwner === owner) ownersByAnchor.delete(range.end);
+	if (!owner || rangesByOwner.get(owner) === range) rangesByOwner.delete(owner ?? startOwner);
+}
+function appendRange(parent, range, before = null) {
+	if (range.single) {
+		parent.insertBefore(range.start, before);
+		return;
+	}
+	const nodes = [
+		range.start,
+		...getRangeNodes(range),
+		range.end
+	];
+	for (const node of nodes) parent.insertBefore(node, before);
+}
+function moveRange(parent, range, before = null) {
+	if (before && rangeContains(range, before)) return;
+	if (range.single) {
+		parent.insertBefore(range.start, before);
+		return;
+	}
+	const fragment = parent.ownerDocument.createDocumentFragment();
+	const nodes = [
+		range.start,
+		...getRangeNodes(range),
+		range.end
+	];
+	for (const node of nodes) fragment.appendChild(node);
+	parent.insertBefore(fragment, before);
+}
+function insertRangeBefore(parent, range, before = null) {
+	moveRange(parent, range, before);
+}
+function removeRange(range, removeNode = (node) => node.parentNode?.removeChild(node)) {
+	if (range.single) {
+		removeNode(range.start);
+		clearRangeOwner(range);
+		return;
+	}
+	const nodes = [
+		range.start,
+		...getRangeNodes(range),
+		range.end
+	];
+	for (const node of nodes) removeNode(node);
+	clearRangeOwner(range);
+}
+function rangeContains(range, node) {
+	if (range.single) return range.start === node;
+	if (range.start.parentNode !== node.parentNode) return false;
+	let current = range.start;
+	while (current) {
+		if (current === node) return true;
+		if (current === range.end) break;
+		current = current.nextSibling;
+	}
+	return false;
+}
+function isRangeStart(node) {
+	return isRangeMarker(node) && node.data === "askr-range-start";
+}
+function isRangeEnd(node) {
+	return isRangeMarker(node) && node.data === "askr-range-end";
+}
+function findRangeEnd(start) {
+	if (!isRangeStart(start)) return null;
+	let depth = 0;
+	for (let current = start; current; current = current.nextSibling) {
+		if (isRangeStart(current)) depth++;
+		if (isRangeEnd(current)) {
+			depth--;
+			if (depth === 0) return current;
+		}
+	}
+	return null;
+}
+//#endregion
+export { RANGE_END_MARKER, RANGE_START_MARKER, appendRange, clearRangeOwner, createDetachedRange, createEmptyRange, createSingleNodeRange, findRangeEnd, getOwnedRange, getRangeNodes, getRangeOwner, insertRangeBefore, isRangeEnd, isRangeStart, moveRange, rangeContains, registerRange, removeRange };

package/dist/renderer/dom.js

@@ -1,10 +1,11 @@
-import "./boundaries.js";
 import { performBulkPositionalKeyedTextUpdate } from "./children-fastpath.js";
 import { isBulkTextFastPathEligible, performBulkTextReplace } from "./children.js";
-import { syncComponentElement } from "./component-host.js";
 import { setStaticChildSlotsCacheEnabled } from "./static-reuse.js";
 import { updateElementChildren, updateUnkeyedChildren } from "./element-children.js";
 import { markReactivePropsDirtySource } from "./prop-bindings.js";
+import "./boundary-materialization.js";
+import "./boundaries.js";
+import { syncComponentElement } from "./component-host.js";
 import { tryPatchStableForDirtyItem } from "./stable-patch.js";
-import { IS_DOM_AVAILABLE, createDOMNode, updateElementFromVnode } from "./dom-internal.js";
-export { IS_DOM_AVAILABLE, createDOMNode, isBulkTextFastPathEligible, markReactivePropsDirtySource, performBulkPositionalKeyedTextUpdate, performBulkTextReplace, setStaticChildSlotsCacheEnabled, syncComponentElement, tryPatchStableForDirtyItem, updateElementChildren, updateElementFromVnode, updateUnkeyedChildren };
+import { IS_DOM_AVAILABLE, activateHydrationBoundary, createDOMNode, updateElementFromVnode } from "./dom-internal.js";
+export { IS_DOM_AVAILABLE, activateHydrationBoundary, createDOMNode, isBulkTextFastPathEligible, markReactivePropsDirtySource, performBulkPositionalKeyedTextUpdate, performBulkTextReplace, setStaticChildSlotsCacheEnabled, syncComponentElement, tryPatchStableForDirtyItem, updateElementChildren, updateElementFromVnode, updateUnkeyedChildren };

package/dist/renderer/element-children.js

@@ -1,16 +1,19 @@
-import { _isDOMElement } from "../common/vnode.js";
+import { __FOR_BOUNDARY__, _isDOMElement } from "../common/vnode.js";
 import "./types.js";
 import { teardownNodeSubtree } from "./cleanup.js";
-import { extractKey } from "./utils.js";
+import { extractKey, getMaterializedKey } from "./utils.js";
 import { keyedElements } from "./keyed.js";
+import { createDetachedRange, findRangeEnd, isRangeStart, moveRange, removeRange } from "./dom-range.js";
 import { getParentNamespace } from "./namespaces.js";
-import { clearControlBoundaryCommitOwner, commitForBoundaryChildren, evaluateControlBoundaryState, getControlBoundaryState, getDirectControlBoundaryVNode, registerControlBoundaryCommitOwner, trySyncControlBoundaryChild } from "./boundaries.js";
 import { isBulkTextFastPathEligible, performBulkTextReplace } from "./children.js";
-import { isFragmentVNode, normalizeComponentChildren } from "./child-shape.js";
 import { getRendererDOMHost } from "./dom-host.js";
-import { trySyncScalarChildSequenceInPlace } from "./reactive-children.js";
 import { reconcileKeyedChildren } from "./reconcile.js";
+import { isFragmentVNode, normalizeComponentChildren } from "./child-shape.js";
+import { trySyncScalarChildSequenceInPlace } from "./reactive-children.js";
 import { tagsEqualIgnoreCase } from "./static-reuse.js";
+import { syncControlBoundaryInMixedParent } from "./boundary-range-sync.js";
+import { evaluateControlBoundaryState, getControlBoundaryState, getDirectControlBoundaryVNode } from "./boundary-state.js";
+import { clearControlBoundaryCommitOwner, commitForBoundaryChildren, registerControlBoundaryCommitOwner, trySyncControlBoundaryChild } from "./boundaries.js";
 //#region src/renderer/element-children.ts
 const rendererReactiveChildDOMHost = {
 	createDOMNode: (node, parentNamespace) => getRendererDOMHost().createDOMNode(node, parentNamespace),
@@ -60,6 +63,14 @@ function updateElementChildren(el, children, forceUpdate = false) {
 			keyedElements.delete(el);
 			return;
 		}
+		if (normalizedChildren.some(isControlBoundaryVNode) && normalizedChildren.every((child) => {
+			if (!isControlBoundaryVNode(child)) return true;
+			return getControlBoundaryState(child)?.kind !== "for";
+		})) {
+			updateMixedControlChildren(el, normalizedChildren, forceUpdate);
+			keyedElements.delete(el);
+			return;
+		}
 		if (hasKeyedVNodeChildren(normalizedChildren)) {
 			const newKeyMap = reconcileKeyedChildren(el, normalizedChildren, getOrBuildDomKeyMap(el));
 			keyedElements.set(el, newKeyMap);
@@ -90,6 +101,88 @@ function hasKeyedVNodeChildren(children) {
 	for (let i = 0; i < children.length; i++) if (extractKey(children[i]) !== void 0) return true;
 	return false;
 }
+function isControlBoundaryVNode(child) {
+	return _isDOMElement(child) && child.type === __FOR_BOUNDARY__;
+}
+function removeRangeAtCursor(parent, cursor) {
+	if (!isRangeStart(cursor)) return cursor;
+	const end = findRangeEnd(cursor);
+	if (!end) return cursor;
+	const range = {
+		start: cursor,
+		end,
+		single: false
+	};
+	const next = end.nextSibling;
+	removeRange(range, (node) => {
+		if (node === range.start || node === range.end) {
+			node.parentNode?.removeChild(node);
+			return;
+		}
+		teardownNodeSubtree(node);
+		node.parentNode?.removeChild(node);
+	});
+	return next;
+}
+function updateMixedControlChildren(parent, children, forceUpdate) {
+	const parentNamespace = getParentNamespace(parent);
+	const domHost = getRendererDOMHost();
+	let cursor = parent.firstChild;
+	for (const child of children) {
+		if (isControlBoundaryVNode(child)) {
+			const controlState = getControlBoundaryState(child);
+			if (!controlState) throw new Error("[updateElementChildren] Control boundary missing internal state");
+			registerControlBoundaryCommitOwner(parent, controlState);
+			const ranges = syncControlBoundaryInMixedParent(parent, controlState, evaluateControlBoundaryState(controlState), cursor);
+			for (const range of ranges) if (range.start.parentNode !== parent) moveRange(parent, range, cursor?.parentNode === parent ? cursor : null);
+			else if (cursor?.parentNode === parent) moveRange(parent, range, cursor);
+			const last = ranges[ranges.length - 1];
+			if (last) {
+				const cursorWasReplaced = cursor && !ranges.some((range) => range.start === cursor);
+				if (!cursor?.parentNode) cursor = last.end.nextSibling;
+				else if (cursorWasReplaced && isRangeStart(cursor)) cursor = findRangeEnd(cursor)?.nextSibling ?? last.end.nextSibling;
+				else if (isRangeStart(cursor)) cursor = findRangeEnd(cursor)?.nextSibling ?? last.end.nextSibling;
+				else cursor = last.end.nextSibling;
+			}
+			continue;
+		}
+		if (cursor) cursor = removeRangeAtCursor(parent, cursor);
+		if (cursor && (typeof child === "string" || typeof child === "number") && cursor.nodeType === 3) {
+			cursor.data = String(child);
+			cursor = cursor.nextSibling;
+			continue;
+		}
+		if (cursor instanceof Element && _isDOMElement(child) && typeof child.type === "string" && tagsEqualIgnoreCase(cursor.tagName, child.type)) {
+			domHost.updateElementFromVnode(cursor, child, true, forceUpdate);
+			cursor = cursor.nextSibling;
+			continue;
+		}
+		if (cursor instanceof Element && _isDOMElement(child) && typeof child.type === "function") {
+			const synced = domHost.syncComponentElement(cursor, child, child.type, (child.props ?? {}) || {}, parentNamespace, forceUpdate);
+			if (synced) {
+				cursor = synced.nextSibling;
+				continue;
+			}
+		}
+		const created = domHost.createDOMNode(child, parentNamespace);
+		if (!created) {
+			cursor = cursor?.nextSibling ?? null;
+			continue;
+		}
+		const materialized = createDetachedRange(created);
+		const old = cursor;
+		moveRange(parent, materialized.range, old);
+		if (old) {
+			teardownNodeSubtree(old);
+			old.parentNode?.removeChild(old);
+		}
+		cursor = materialized.range.end.nextSibling;
+	}
+	while (cursor) {
+		const next = removeRangeAtCursor(parent, cursor);
+		cursor = next === cursor ? cursor.nextSibling : next;
+	}
+}
 function isEmptyChild(child) {
 	return child === null || child === void 0 || child === false;
 }
@@ -98,12 +191,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);
 	}
@@ -137,9 +226,7 @@ function updateUnkeyedChildren(parent, newChildren, forceUpdate = false) {
 			}
 			else if (_isDOMElement(next)) {
 				if (trySyncControlBoundaryChild(parent, current, next)) continue;
-				const synced = trySyncComponentChild(current, next);
-				if (synced && synced !== current) teardownNodeSubtree(current);
-				else if (!synced) {
+				if (!trySyncComponentChild(current, next)) {
 					const dom = domHost.createDOMNode(next, parentNamespace);
 					if (dom) {
 						teardownNodeSubtree(current);
@@ -192,9 +279,7 @@ function updateUnkeyedChildren(parent, newChildren, forceUpdate = false) {
 				}
 				else {
 					if (trySyncControlBoundaryChild(parent, currentNode, next)) continue;
-					const synced = trySyncComponentChild(currentEl, next);
-					if (synced && synced !== currentNode) teardownNodeSubtree(currentEl);
-					else if (!synced) {
+					if (!trySyncComponentChild(currentEl, next)) {
 						const dom = domHost.createDOMNode(next, parentNamespace);
 						if (dom) {
 							teardownNodeSubtree(currentEl);
@@ -245,26 +330,23 @@ function updateUnkeyedChildren(parent, newChildren, forceUpdate = false) {
 			const textNode = document.createTextNode(String(next));
 			teardownNodeSubtree(current);
 			parent.replaceChild(textNode, current);
-		} else if (_isDOMElement(next)) if (typeof next.type === "string") if (tagsEqualIgnoreCase(current.tagName, next.type)) domHost.updateElementFromVnode(current, next, true, forceUpdate);
-		else {
-			const dom = domHost.createDOMNode(next, parentNamespace);
-			if (dom) {
-				teardownNodeSubtree(current);
-				parent.replaceChild(dom, current);
+		} else if (_isDOMElement(next)) {
+			if (typeof next.type === "string") if (tagsEqualIgnoreCase(current.tagName, next.type)) domHost.updateElementFromVnode(current, next, true, forceUpdate);
+			else {
+				const dom = domHost.createDOMNode(next, parentNamespace);
+				if (dom) {
+					teardownNodeSubtree(current);
+					parent.replaceChild(dom, current);
+				}
 			}
-		}
-		else {
-			const synced = trySyncComponentChild(current, next);
-			if (synced && synced !== current) teardownNodeSubtree(current);
-			else if (!synced) {
+			else if (!trySyncComponentChild(current, next)) {
 				const dom = domHost.createDOMNode(next, parentNamespace);
 				if (dom) {
 					teardownNodeSubtree(current);
 					parent.replaceChild(dom, current);
 				}
 			}
-		}
-		else {
+		} else {
 			const dom = domHost.createDOMNode(next);
 			if (dom) {
 				teardownNodeSubtree(current);
@@ -275,5 +357,3 @@ function updateUnkeyedChildren(parent, newChildren, forceUpdate = false) {
 }
 //#endregion
 export { rendererReactiveChildDOMHost, updateElementChildren, updateUnkeyedChildren };
-
-//# sourceMappingURL=element-children.js.map

package/dist/renderer/error-boundary-dom.js

@@ -1,5 +1,6 @@
 import { isDevelopmentEnvironment } from "../common/env.js";
 import { logger } from "../common/logger.js";
+import { beginLifecycleCommitBatch, discardLifecycleCommitBatch, flushLifecycleCommitBatch } from "../runtime/lifecycle-batch.js";
 import { createBoundaryReset, reportBoundaryError } from "../runtime/error-boundary.js";
 import "../runtime/index.js";
 import { getRendererDOMHost } from "./dom-host.js";
@@ -51,28 +52,35 @@ function resolveErrorBoundaryFallback(fallback, error, reset) {
 	if (typeof fallback === "function") return fallback(error, reset);
 	return fallback ?? createDefaultFallbackNode(error, reset);
 }
+function runErrorBoundaryDOMAttempt(attempt) {
+	const lifecycleBatch = beginLifecycleCommitBatch();
+	try {
+		const result = attempt();
+		flushLifecycleCommitBatch(lifecycleBatch);
+		return result;
+	} catch (error) {
+		discardLifecycleCommitBatch(lifecycleBatch);
+		throw error;
+	}
+}
+function materializeErrorBoundaryValue(value, parentNamespace) {
+	if (value instanceof Node) return value;
+	return getRendererDOMHost().createDOMNode(value, parentNamespace) ?? document.createComment("");
+}
 function createErrorBoundaryElement(node, props, parentNamespace) {
 	const boundaryState = node.__instance?.errorBoundaryState ?? null;
 	const reset = node.__instance ? createBoundaryReset(node.__instance) : () => {};
 	const fallback = props.fallback;
 	const children = props.children;
 	const domHost = getRendererDOMHost();
-	if (boundaryState?.error != null) {
-		const fallbackValue = resolveErrorBoundaryFallback(fallback, boundaryState.error, reset);
-		if (fallbackValue instanceof Node) return fallbackValue;
-		return domHost.createDOMNode(fallbackValue, parentNamespace) ?? document.createComment("");
-	}
+	if (boundaryState?.error != null) return runErrorBoundaryDOMAttempt(() => materializeErrorBoundaryValue(resolveErrorBoundaryFallback(fallback, boundaryState.error, reset), parentNamespace));
 	try {
-		return domHost.createDOMNode(children, parentNamespace) ?? document.createComment("");
+		return runErrorBoundaryDOMAttempt(() => domHost.createDOMNode(children, parentNamespace) ?? document.createComment(""));
 	} catch (error) {
 		if (node.__instance) reportBoundaryError(node.__instance, error, props.onError);
 		else logger.error("[Askr] ErrorBoundary caught render error:", error);
-		const fallbackValue = resolveErrorBoundaryFallback(fallback, error, reset);
-		if (fallbackValue instanceof Node) return fallbackValue;
-		return domHost.createDOMNode(fallbackValue, parentNamespace) ?? document.createComment("");
+		return runErrorBoundaryDOMAttempt(() => materializeErrorBoundaryValue(resolveErrorBoundaryFallback(fallback, error, reset), parentNamespace));
 	}
 }
 //#endregion
 export { createErrorBoundaryElement };
-
-//# sourceMappingURL=error-boundary-dom.js.map

package/dist/renderer/evaluate-dom-range.js

@@ -1,6 +1,7 @@
 import { _isDOMElement } from "../common/vnode.js";
 import "./types.js";
 import { teardownNodeSubtree } from "./cleanup.js";
+import { RANGE_END_MARKER, RANGE_START_MARKER } from "./dom-range.js";
 import { getRendererDOMHost } from "./dom-host.js";
 import { smartUpdateElement, tagNamesEqualIgnoreCase } from "./evaluate-reconcile.js";
 //#region src/renderer/evaluate-dom-range.ts
@@ -9,8 +10,8 @@ function hasDOMRange(context) {
 	return domRanges.has(context);
 }
 function createDOMRange(target, context, node) {
-	const start = document.createComment("component-start");
-	const end = document.createComment("component-end");
+	const start = document.createComment(RANGE_START_MARKER);
+	const end = document.createComment(RANGE_END_MARKER);
 	target.appendChild(start);
 	target.appendChild(end);
 	domRanges.set(context, {
@@ -81,5 +82,3 @@ function updateDOMRangeForContext(target, context, children) {
 }
 //#endregion
 export { cleanupRangeNode, createDOMRange, hasDOMRange, updateDOMRangeForContext };
-
-//# sourceMappingURL=evaluate-dom-range.js.map

package/dist/renderer/evaluate-reconcile.js

@@ -7,18 +7,19 @@ import { incDevCounter, setDevValue } from "../runtime/dev-namespace.js";
 import { evaluateCaseState, evaluateShowState } from "../runtime/control.js";
 import { evaluateForState } from "../runtime/for-internal.js";
 import "../runtime/index.js";
-import { elementListeners } from "./cleanup.js";
+import { elementListeners, updateElementRef } from "./cleanup.js";
 import "./env.js";
-import { createWrappedHandler, extractKey, getEventListenerKey, getEventListenerOptions, parseEventProp, setRenderedAttribute, tagNamesEqualIgnoreCase as tagNamesEqualIgnoreCase$1, writeElementClassName } from "./utils.js";
+import { createWrappedHandler, extractKey, getEventListenerKey, getEventListenerOptions, getMaterializedKey, parseEventProp, setRenderedAttribute, tagNamesEqualIgnoreCase as tagNamesEqualIgnoreCase$1, writeElementClassName } from "./utils.js";
 import { keyedElements } from "./keyed.js";
 import { createElementForNamespace, getParentNamespace } from "./namespaces.js";
-import { commitForBoundaryChildren } from "./boundaries.js";
 import { performBulkPositionalKeyedTextUpdate } from "./children-fastpath.js";
 import { isBulkTextFastPathEligible, performBulkTextReplace } from "./children.js";
 import { getRendererDOMHost } from "./dom-host.js";
 import { reconcileKeyedChildren } from "./reconcile.js";
 import { updateUnkeyedChildren } from "./element-children.js";
 import { runRetainedElementUpdate } from "./retained-element-rollback.js";
+import { tryAdoptMatchingIntrinsicSubtree } from "./intrinsic-hydration-adoption.js";
+import { commitForBoundaryChildren } from "./boundaries.js";
 //#region src/renderer/evaluate-reconcile.ts
 function getRetainedHostOwnerChain(host, owner) {
 	const instances = host.__ASKR_INSTANCES ?? [];
@@ -60,12 +61,8 @@ function tryUpdateTextInPlace(element, text) {
 function buildKeyMapFromDOM(parent) {
 	const keyMap = /* @__PURE__ */ new Map();
 	for (let child = parent.firstElementChild; child; child = child.nextElementSibling) {
-		const k = child.getAttribute("data-key");
-		if (k !== null) {
-			keyMap.set(k, child);
-			const n = Number(k);
-			if (!Number.isNaN(n)) keyMap.set(n, child);
-		}
+		const key = getMaterializedKey(child);
+		if (key !== void 0) keyMap.set(key, child);
 	}
 	return keyMap;
 }
@@ -177,17 +174,11 @@ function updateElementChildren(element, vnodeChildren, cleanupRangeNode) {
 		updateForBoundaryChildren(element, vnodeChildren[0]);
 		return;
 	}
-	if (hasKeyedChildren(vnodeChildren)) {
-		const oldKeyMap = getOrBuildKeyMap(element);
-		try {
-			reconcileKeyed(element, vnodeChildren, oldKeyMap);
-		} catch {
-			const newKeyMap = reconcileKeyedChildren(element, vnodeChildren, oldKeyMap);
-			keyedElements.set(element, newKeyMap);
-		}
-	} else reconcileUnkeyed(element, vnodeChildren);
+	if (hasKeyedChildren(vnodeChildren)) reconcileKeyed(element, vnodeChildren, getOrBuildKeyMap(element));
+	else reconcileUnkeyed(element, vnodeChildren);
 }
 function smartUpdateElement(element, vnode, cleanupRangeNode) {
+	if (tryAdoptMatchingIntrinsicSubtree(element, vnode)) return;
 	const hadVNodeKey = Object.prototype.hasOwnProperty.call(vnode, "key");
 	const previousVNodeKey = vnode.key;
 	runRetainedElementUpdate(element, cleanupRangeNode, () => applySmartUpdateElement(element, vnode, cleanupRangeNode), () => {
@@ -198,11 +189,8 @@ function smartUpdateElement(element, vnode, cleanupRangeNode) {
 function applySmartUpdateElement(element, vnode, cleanupRangeNode) {
 	const domHost = getRendererDOMHost();
 	if (vnode.key == null && element.hasAttribute("data-key")) {
-		const existingKey = element.getAttribute("data-key");
-		if (existingKey !== null) {
-			const numericKey = Number(existingKey);
-			vnode.key = Number.isNaN(numericKey) ? existingKey : numericKey;
-		}
+		const existingKey = getMaterializedKey(element);
+		if (existingKey !== void 0) vnode.key = existingKey;
 	}
 	let vnodeChildren = vnode.props?.children ?? vnode.children;
 	if (vnodeChildren && _isDOMElement(vnodeChildren) && vnodeChildren.type === __FOR_BOUNDARY__) {
@@ -223,7 +211,7 @@ function applyPropsToElement(el, props) {
 		if (key === "children" || key === "key") continue;
 		if (value === void 0 || value === null || value === false) continue;
 		if (key === "ref") {
-			applyRef(el, value);
+			updateElementRef(el, value);
 			continue;
 		}
 		const eventProp = parseEventProp(key);
@@ -248,17 +236,6 @@ function applyPropsToElement(el, props) {
 		else setRenderedAttribute(el, key, String(value));
 	}
 }
-function applyRef(el, ref) {
-	const r = ref;
-	if (!r) return;
-	if (typeof r === "function") {
-		r(el);
-		return;
-	}
-	try {
-		r.current = el;
-	} catch {}
-}
 function tryFirstRenderKeyedChildren(target, vnode) {
 	const children = vnode.children;
 	if (!Array.isArray(children) || !hasKeyedChildren(children)) return false;
@@ -278,5 +255,3 @@ function getFragmentChildren(vnode) {
 }
 //#endregion
 export { getFragmentChildren, getRetainedHostOwnerChain, isFragment, processFragmentChildren, retainHostOwnerChain, smartUpdateElement, tagNamesEqualIgnoreCase, tryFirstRenderKeyedChildren, updateElementChildren, updateForBoundaryChildren };
-
-//# sourceMappingURL=evaluate-reconcile.js.map

package/dist/renderer/evaluate.js

@@ -1,12 +1,14 @@
 import { __FOR_BOUNDARY__, _isDOMElement } from "../common/vnode.js";
 import "./types.js";
 import { getRuntimeEnv } from "../common/env.js";
+import { beginLifecycleCommitBatch, discardLifecycleCommitBatch, flushLifecycleCommitBatch, getCurrentLifecycleCommitBatch } from "../runtime/lifecycle-batch.js";
+import "../runtime/index.js";
 import { removeAllListeners } from "./cleanup.js";
 import "./env.js";
+import { getFragmentChildren, getRetainedHostOwnerChain, isFragment, processFragmentChildren, retainHostOwnerChain, smartUpdateElement, tagNamesEqualIgnoreCase, tryFirstRenderKeyedChildren, updateElementChildren, updateForBoundaryChildren } from "./evaluate-reconcile.js";
 import { syncComponentElement } from "./component-host.js";
 import { createDOMNode } from "./dom-internal.js";
 import "./dom.js";
-import { getFragmentChildren, getRetainedHostOwnerChain, isFragment, processFragmentChildren, retainHostOwnerChain, smartUpdateElement, tagNamesEqualIgnoreCase, tryFirstRenderKeyedChildren, updateElementChildren, updateForBoundaryChildren } from "./evaluate-reconcile.js";
 import { cleanupRangeNode, createDOMRange, hasDOMRange, updateDOMRangeForContext } from "./evaluate-dom-range.js";
 function evaluate(node, target, context, retainedOwner) {
 	if (!target) return;
@@ -16,6 +18,17 @@ function evaluate(node, target, context, retainedOwner) {
 		} catch (e) {}
 		return;
 	}
+	const batch = !getCurrentLifecycleCommitBatch() ? beginLifecycleCommitBatch() : null;
+	try {
+		evaluateInLifecycleBatch(node, target, context, retainedOwner);
+		if (batch) flushLifecycleCommitBatch(batch);
+	} catch (error) {
+		if (batch) discardLifecycleCommitBatch(batch);
+		throw error;
+	}
+}
+function evaluateInLifecycleBatch(node, target, context, retainedOwner) {
+	if (!target) return;
 	if (context && hasDOMRange(context)) updateDOMRangeForContext(target, context, node === null || node === void 0 || node === false ? [] : isFragment(node) ? getFragmentChildren(node) : Array.isArray(node) ? node : [node]);
 	else if (context) createDOMRange(target, context, node);
 	else {
@@ -80,5 +93,3 @@ function evaluate(node, target, context, retainedOwner) {
 }
 //#endregion
 export { evaluate };
-
-//# sourceMappingURL=evaluate.js.map

package/dist/renderer/fastpath.js

@@ -7,7 +7,7 @@ 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 { createDOMNode, updateElementFromVnode } from "./dom-internal.js";
 import "./dom.js";
@@ -27,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;
@@ -47,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;
 				}
@@ -146,5 +140,3 @@ function applyRendererFastPath(parent, keyedVnodes, oldKeyMap) {
 }
 //#endregion
 export { applyRendererFastPath };
-
-//# sourceMappingURL=fastpath.js.map