@askrjs/askr 0.2.4 → 0.3.1

package/dist/{for-internal-DyBHfKJA.js → for-state-BDykeOJL.js}

@@ -1,15 +1,14 @@
+import { a as getRuntimeEvaluation, c as getRuntimeScopes, i as getRuntimeCleanup, v as logger, w as isDevelopmentEnvironment } from "./access-CEA2pOry.js";
+import { C as rebaseVNodeTreeWithContextFrame, I as DIRECT_RANGE_OWNER, O as registerOwnedChildScope, T as cleanupComponent, _ as haveEquivalentContextFrames, j as finalizeInlineReadSubscriptions, n as createComponentInstance, s as renderScopedComponent } from "./instance-VAFYVJOa.js";
+import { A as releaseOwnedChild, C as disposeOwnership, D as ownChild, O as ownCleanup, S as detachOwnedChildren, b as attachOwnership, f as getCurrentComponentInstance, i as claimHookIndex, k as registerScopedOwnership, m as getCurrentStateIndex, o as clearRenderTracking, y as OwnershipRecord } from "./scope-Cq_iYbTR.js";
+import { t as adoptComponentParent } from "./capabilities-Bbf0mlp9.js";
+import { i as commitTransaction, l as registerCommitParticipant, n as applyTransaction, o as discardTransaction, p as suspendTransaction, r as beginCommitTransaction, s as getCurrentCommitTransaction, t as notifyReadableSource, u as registerCommitRollback, v as recordReadableRead, y as shouldCoalesceFineGrainedItemReads } from "./notify-DxxuDPeY.js";
 import { n as _isDOMElement } from "./vnode-D24p6IW2.js";
-import { o as getRuntimeRenderer, x as isDevelopmentEnvironment, y as logger } from "./access-BucjYZcX.js";
-import { h as getCurrentStateIndex, i as claimHookIndex, o as clearRenderTracking, p as getCurrentInstance } from "./component-scope-4I3yEMkb.js";
-import { n as createComponentInstance, s as renderScopedComponent, v as haveEquivalentContextFrames, x as rebaseVNodeTreeWithContextFrame } from "./component-internal-C4hKKQBF.js";
-import { d as shouldCoalesceFineGrainedItemReads, l as notifyReadableReaders, o as markReactivePropsDirtySource, s as markReadableDerivedSubscribersDirty, u as recordReadableRead } from "./readable-Di1fzSwm.js";
-import { i as unregisterOwnedChildScope, r as registerOwnedChildScope, t as cleanupComponent } from "./component-cleanup-jdbgjkT1.js";
-import { o as finalizeInlineReadSubscriptions, u as registerLifecycleTransaction } from "./lifecycle-batch-63aXFf2S.js";
-//#region src/runtime/child-scope.ts
+//#region src/runtime/ownership/child-scope.ts
 const EMPTY_CHILD_SCOPE_PROPS = {};
 const childScopesByInstance = /* @__PURE__ */ new WeakMap();
 function executeChildScopeComponent() {
-	const instance = getCurrentInstance();
+	const instance = getCurrentComponentInstance();
 	const scope = instance ? childScopesByInstance.get(instance) : void 0;
 	if (!scope?._renderFn) return null;
 	return scope._renderFn();
@@ -19,12 +18,35 @@ function ensureChildScopeFlushTask(scope) {
 	if (instance._pendingFlushTask) return;
 	instance._pendingFlushTask = () => {
 		instance.hasPendingUpdate = false;
-		if (instance.notifyUpdate === null || scope._disposed) return;
-		renderScope(scope);
-		scope._onDirty?.();
+		if (instance.notifyUpdate === null || instance.owner.disposed) return;
+		if (scope._preparedTransaction) discardTransaction(scope._preparedTransaction);
+		const transaction = beginCommitTransaction();
+		scope._preparedTransaction = transaction;
+		const snapshot = captureChildScopeTransactionSnapshot(scope);
+		registerCommitRollback(() => {
+			if (!instance.owner.disposed) restoreChildScopeTransactionSnapshot(scope, snapshot);
+		});
+		try {
+			renderScope(scope);
+			suspendTransaction(transaction);
+			if (scope._onDirty) scope._onDirty();
+			else {
+				scope._preparedTransaction = void 0;
+				commitTransaction(transaction);
+			}
+		} catch (error) {
+			discardTransaction(transaction);
+			scope._preparedTransaction = void 0;
+			throw error;
+		} finally {
+			suspendTransaction(transaction);
+		}
 	};
 }
 var ChildScopeImpl = class {
+	get [DIRECT_RANGE_OWNER]() {
+		return true;
+	}
 	constructor(parent, key, onDirty, ownership) {
 		this.previousVnode = void 0;
 		this.vnode = void 0;
@@ -34,17 +56,18 @@ var ChildScopeImpl = class {
 		this.hydrationPending = true;
 		this.blueprintOwner = void 0;
 		this._renderFn = void 0;
-		this._disposed = false;
 		this._renderedOwnerFrame = null;
 		this.key = key;
-		this._parent = parent;
+		this._parentOwnership = parent?.owner ?? null;
 		this._onDirty = onDirty;
 		this._ownership = ownership;
 		this._startStateIndex = getCurrentStateIndex();
 		this.componentInstance = createComponentInstance("child-scope", executeChildScopeComponent, EMPTY_CHILD_SCOPE_PROPS, null);
 		childScopesByInstance.set(this.componentInstance, this);
+		this.componentInstance.owner.finalizer = this;
+		registerScopedOwnership(this, this.componentInstance.owner);
 		if (parent) {
-			this.componentInstance.parentInstance = parent;
+			adoptComponentParent(this.componentInstance, parent);
 			this.componentInstance.ownerFrame = parent.ownerFrame;
 			this.componentInstance.portalScope = parent.portalScope;
 			if (ownership) ownership.add(this);
@@ -59,31 +82,38 @@ var ChildScopeImpl = class {
 		return renderScope(this);
 	}
 	dispose() {
-		if (this._disposed) return;
-		this._disposed = true;
-		if (this._parent) {
+		cleanupComponent(this.componentInstance);
+	}
+	release() {
+		try {
+			if (this._preparedTransaction) discardTransaction(this._preparedTransaction);
+			this._preparedTransaction = void 0;
 			if (this._ownership) this._ownership.delete(this);
-			else unregisterOwnedChildScope(this._parent, this);
+			else if (this._parentOwnership) releaseOwnedChild(this._parentOwnership, this);
+		} finally {
+			childScopesByInstance.delete(this.componentInstance);
+			this._renderFn = void 0;
+			this.previousVnode = void 0;
+			this.vnode = void 0;
+			getRuntimeScopes().clearChildScopeHost(this);
+			this.needsDomUpdate = false;
+			this.hydrationPending = false;
+			this.blueprintOwner = void 0;
+			this.componentInstance.hasPendingUpdate = false;
+			this._parentOwnership = null;
+			this._onDirty = void 0;
+			this._ownership = void 0;
+			this._renderedOwnerFrame = null;
 		}
-		childScopesByInstance.delete(this.componentInstance);
-		cleanupComponent(this.componentInstance);
-		this._renderFn = void 0;
-		this.previousVnode = void 0;
-		this.vnode = void 0;
-		this.dom = void 0;
-		this.range = void 0;
-		this.needsDomUpdate = false;
-		this.hydrationPending = false;
-		this.blueprintOwner = void 0;
-		this.componentInstance.hasPendingUpdate = false;
 	}
 };
 function renderScope(scope) {
-	if (scope._disposed) {
+	if (scope.componentInstance.owner.disposed) {
 		if (isDevelopmentEnvironment()) throw new Error(`[askr] Attempted to render disposed child scope ${String(scope.key)}.`);
 		return scope.vnode;
 	}
 	if (!scope._renderFn) return scope.vnode;
+	joinChildScopePreparation(scope);
 	const { componentInstance } = scope;
 	const previousVNode = scope.vnode;
 	try {
@@ -105,15 +135,23 @@ function renderScope(scope) {
 function rerenderChildScope(scope) {
 	return renderScope(scope);
 }
+/** Join prepared reads and scope restoration to the transaction applying its output. */
+function joinChildScopePreparation(scope) {
+	const mutable = scope;
+	const transaction = mutable._preparedTransaction;
+	const current = getCurrentCommitTransaction();
+	if (!transaction || !current || transaction === current) return;
+	mutable._preparedTransaction = void 0;
+	applyTransaction(transaction, () => {});
+	commitTransaction(transaction);
+}
 /** @internal */
 function captureChildScopeTransactionSnapshot(scope) {
 	const mutableScope = scope;
 	return {
 		previousVnode: scope.previousVnode,
 		vnode: scope.vnode,
-		dom: scope.dom,
-		range: scope.range,
-		domTextData: scope.dom?.nodeType === 3 ? scope.dom.data : void 0,
+		host: getRuntimeScopes().captureChildScopeHost(scope),
 		needsDomUpdate: scope.needsDomUpdate,
 		hydrationPending: scope.hydrationPending,
 		renderFn: mutableScope._renderFn,
@@ -125,9 +163,7 @@ function restoreChildScopeTransactionSnapshot(scope, snapshot) {
 	const mutableScope = scope;
 	scope.previousVnode = snapshot.previousVnode;
 	scope.vnode = snapshot.vnode;
-	scope.dom = snapshot.dom;
-	scope.range = snapshot.range;
-	if (snapshot.domTextData !== void 0 && snapshot.dom?.nodeType === 3) snapshot.dom.data = snapshot.domTextData;
+	snapshot.host?.restore(scope);
 	scope.needsDomUpdate = snapshot.needsDomUpdate;
 	scope.hydrationPending = snapshot.hydrationPending;
 	mutableScope._renderFn = snapshot.renderFn;
@@ -140,7 +176,7 @@ function createChildScope(parent, key, onDirty, ownership) {
 	return new ChildScopeImpl(parent, key, onDirty, ownership);
 }
 //#endregion
-//#region src/runtime/control.ts
+//#region src/runtime/control/branches.ts
 function setScopeContextFrame(scope, frame) {
 	if (scope) scope.componentInstance.ownerFrame = frame;
 }
@@ -194,7 +230,13 @@ function beginControlTransaction(state) {
 		registered: false
 	};
 	state._transaction = transaction;
-	transaction.registered = registerLifecycleTransaction(transaction, () => commitControlTransaction(state, transaction), () => rollbackControlTransaction(state, transaction));
+	transaction.registered = registerCommitParticipant({
+		key: transaction,
+		collision: "keep-first",
+		publish: () => publishControlTransaction(state, transaction),
+		settle: () => commitControlTransaction(state, transaction),
+		rollback: () => rollbackControlTransaction(state, transaction)
+	});
 	return transaction;
 }
 function stageBranchRemoval(state, scope) {
@@ -202,31 +244,37 @@ function stageBranchRemoval(state, scope) {
 	const transaction = state._transaction;
 	if (transaction && !transaction.removedScopes.includes(scope)) transaction.removedScopes.push(scope);
 	else if (!transaction) disposeChildScope(scope);
-	const removedRange = getRuntimeRenderer().resolveChildScopeRange?.(scope) ?? scope.range;
+	const removedRange = getRuntimeEvaluation().resolveChildScopeRange?.(scope) ?? scope.range;
 	const removedDom = removedRange?.single ? removedRange.start : scope.dom;
 	if (removedDom) state.lastRemovedNodes.push(removedDom);
 	if (removedRange) state.lastRemovedRanges.push(removedRange);
 }
-function commitControlTransaction(state, transaction) {
+function publishControlTransaction(state, transaction) {
 	if (state._transaction !== transaction) return;
+	if (transaction.shouldClearDomUpdateState) {
+		for (const scope of getBranchScopes(state)) scope.needsDomUpdate = false;
+		state.lastRemovedNodes = [];
+		state.lastRemovedRanges = [];
+	}
+	state._transaction = null;
+	transaction.published = true;
+}
+function commitControlTransaction(state, transaction) {
+	if (!transaction.published) publishControlTransaction(state, transaction);
+	if (!transaction.published) return;
+	transaction.published = false;
 	const errors = [];
 	for (const scope of transaction.removedScopes) try {
 		disposeChildScope(scope);
 	} catch (error) {
 		errors.push(error);
 	}
-	if (transaction.shouldClearDomUpdateState) {
-		if ("truthyScope" in state && state.truthyScope) state.truthyScope.needsDomUpdate = false;
-		if ("fallbackScope" in state && state.fallbackScope) state.fallbackScope.needsDomUpdate = false;
-		if (state.activeScope) state.activeScope.needsDomUpdate = false;
-		state.lastRemovedNodes = [];
-		state.lastRemovedRanges = [];
-	}
-	state._transaction = null;
-	if (errors.length > 0) throw new AggregateError(errors, "Control branch cleanup failed");
+	transaction.removedScopes.length = 0;
+	if (errors.length) throw new AggregateError(errors, "Control branch cleanup failed");
 }
 function rollbackControlTransaction(state, transaction) {
-	if (state._transaction !== transaction) return;
+	if (state._transaction !== transaction && !transaction.published) return;
+	transaction.published = false;
 	const committedScopes = new Set(transaction.snapshot.scopeSnapshots.keys());
 	const currentScopes = getBranchScopes(state);
 	const errors = [];
@@ -273,7 +321,7 @@ function createShowState(value, renderTruthy, renderFallback) {
 		fallbackScope: null,
 		lastRemovedNodes: [],
 		lastRemovedRanges: [],
-		parentInstance: getCurrentInstance(),
+		parentInstance: getCurrentComponentInstance(),
 		_enqueueBoundaryCommit: null,
 		_hasPendingBoundaryCommit: false,
 		_transaction: null,
@@ -349,7 +397,7 @@ function createCaseState(matches, fallback) {
 		lastRemovedNodes: [],
 		lastRemovedRanges: [],
 		matches,
-		parentInstance: getCurrentInstance(),
+		parentInstance: getCurrentComponentInstance(),
 		_enqueueBoundaryCommit: null,
 		_hasPendingBoundaryCommit: false,
 		_transaction: null
@@ -395,8 +443,9 @@ function clearCaseDomUpdateState(state) {
 	state.lastRemovedNodes = [];
 	state.lastRemovedRanges = [];
 }
+const recordBenchEvent = (_event) => {};
 //#endregion
-//#region src/runtime/for-signals.ts
+//#region src/runtime/control/for-signals.ts
 function peekForSignal() {
 	return this._value;
 }
@@ -412,9 +461,10 @@ function setForIndexValue(newValue, notifyReaders = true) {
 	if (notifyReaders) notifyForSignalReaders(this);
 }
 function notifyForSignalReaders(source, skipInstance, skipOwnedBy) {
-	markReadableDerivedSubscribersDirty(source);
-	markReactivePropsDirtySource(source);
-	notifyReadableReaders(source, skipInstance, skipOwnedBy);
+	notifyReadableSource(source, {
+		skipInstance,
+		skipOwnedBy
+	});
 }
 function createForIndexSignal(initialIndex) {
 	function readIndexSignal() {
@@ -626,29 +676,15 @@ const REACTIVE_FOR_ITEM_PROXY_HANDLER = {
 		});
 	}
 };
-const recordBenchEvent = (_event) => {};
 //#endregion
-//#region src/runtime/for-scopes.ts
-function resolveScopeBoundary(scope) {
-	const range = getRuntimeRenderer().resolveChildScopeRange?.(scope) ?? scope.range;
-	return {
-		dom: range?.single ? range.start : scope.dom,
-		range
-	};
-}
+//#region src/runtime/control/for-scopes.ts
 function recordRemovedBoundary(forState, dom, range) {
-	if (range && !range.single) forState.lastRemovedRanges.push(range);
-	else if (dom) forState.lastRemovedNodes.push(dom);
+	getRuntimeScopes().recordRemovedScopeBoundary(dom, range, forState.lastRemovedNodes, forState.lastRemovedRanges);
 }
-function captureRemovedScopeNodes(forState, dom, range) {
+function prepareRemovedScope(forState, scope) {
 	const transaction = forState._transaction;
-	if (!transaction) return;
-	const nodes = transaction.removedScopeNodes ??= [];
-	if (range && !range.single) {
-		nodes.push(range.start);
-		for (let node = range.start.nextSibling; node && node !== range.end; node = node.nextSibling) nodes.push(node);
-		nodes.push(range.end);
-	} else if (dom) nodes.push(dom);
+	if (!transaction) return getRuntimeScopes().resolveScopeBoundary(scope);
+	return getRuntimeScopes().prepareScopeRemoval(scope, forState.lastRemovedNodes, forState.lastRemovedRanges, transaction.removedScopeNodes ??= []);
 }
 function enqueueForScopeUpdate(parent) {
 	parent?._enqueueRun?.();
@@ -765,12 +801,10 @@ function renderItemScope(forState, scope, item, indexSignal, key) {
 	return vnode;
 }
 function disposeItemInstance(forState, itemInstance, domCleanup) {
-	const { dom: removedDom, range: removedRange } = resolveScopeBoundary(itemInstance.scope);
+	const { dom: removedDom, range: removedRange } = prepareRemovedScope(forState, itemInstance.scope);
 	const transaction = forState._transaction;
 	if (transaction) {
 		(transaction.removedScopes ??= []).push(itemInstance.scope);
-		captureRemovedScopeNodes(forState, removedDom, removedRange);
-		recordRemovedBoundary(forState, removedDom, removedRange);
 		return;
 	}
 	try {
@@ -779,9 +813,7 @@ function disposeItemInstance(forState, itemInstance, domCleanup) {
 		if (isDevelopmentEnvironment()) console.error("[For] Cleanup error:", err);
 	}
 	if (!removedDom && !removedRange) return;
-	if (removedDom instanceof Element) {
-		if (domCleanup === "teardown") getRuntimeRenderer().teardownNodeSubtree(removedDom);
-	}
+	if (domCleanup === "teardown") getRuntimeScopes().teardownScopeHost(removedDom, void 0);
 	recordRemovedBoundary(forState, removedDom, removedRange);
 }
 function createItemInstance(key, item, index, forState) {
@@ -876,18 +908,14 @@ const FOR_FALLBACK_SCOPE_KEY = "__for-fallback__";
 function disposeFallbackScope(forState, domCleanup) {
 	const fallbackScope = forState.fallbackScope;
 	if (!fallbackScope) return;
-	const { dom: removedDom, range: removedRange } = resolveScopeBoundary(fallbackScope);
+	const { dom: removedDom, range: removedRange } = prepareRemovedScope(forState, fallbackScope);
 	const transaction = forState._transaction;
-	if (transaction) {
-		(transaction.removedScopes ??= []).push(fallbackScope);
-		captureRemovedScopeNodes(forState, removedDom, removedRange);
-	} else disposeChildScope(fallbackScope);
+	if (transaction) (transaction.removedScopes ??= []).push(fallbackScope);
+	else disposeChildScope(fallbackScope);
 	forState.fallbackScope = null;
 	if (!removedDom && !removedRange) return;
-	if (removedDom instanceof Element) {
-		if (domCleanup === "teardown") getRuntimeRenderer().teardownNodeSubtree(removedDom);
-	}
-	recordRemovedBoundary(forState, removedDom, removedRange);
+	if (domCleanup === "teardown") getRuntimeScopes().teardownScopeHost(removedDom, void 0);
+	if (!transaction) recordRemovedBoundary(forState, removedDom, removedRange);
 }
 function renderFallbackScope(forState) {
 	if (forState.fallback == null || forState.fallback === false) {
@@ -913,12 +941,7 @@ function disposeAllItems(forState, domCleanup) {
 		transaction.removeAllItems = true;
 		for (let index = 0; index < forState.orderedItems.length; index++) {
 			const scope = forState.orderedItems[index]?.scope;
-			const { dom: removedDom, range } = scope ? resolveScopeBoundary(scope) : {
-				dom: void 0,
-				range: void 0
-			};
-			if (scope) captureRemovedScopeNodes(forState, removedDom, range);
-			recordRemovedBoundary(forState, removedDom, range);
+			if (scope) prepareRemovedScope(forState, scope);
 		}
 		forState.items = /* @__PURE__ */ new Map();
 		forState.orderedKeys = [];
@@ -935,345 +958,118 @@ function disposeAllItems(forState, domCleanup) {
 	forState.orderedKeys = orderedKeys;
 }
 //#endregion
-//#region src/runtime/for-reconcile.ts
-function hasUnmountedComponentHost(node) {
-	if (!node) return false;
-	const host = node;
-	if (host.__ASKR_INSTANCE?.mounted === false) return true;
-	return host.__ASKR_INSTANCES?.some((instance) => !instance.mounted) ?? false;
-}
-function failForValidation(message) {
-	throw new Error(message);
-}
-function validateForKeys(forState, newArray) {
-	if (!isDevelopmentEnvironment()) return;
-	const seen = /* @__PURE__ */ new Set();
-	const keyKinds = /* @__PURE__ */ new Map();
-	for (let i = 0; i < newArray.length; i++) {
-		const key = forState.byFn(newArray[i], i);
-		if (key === null || key === void 0) failForValidation("[askr] Invalid For key detected. Keys should be stable, non-null, and unique within a For list.");
-		if (seen.has(key)) failForValidation(`[askr] Duplicate For key detected: ${String(key)}. Keys should be stable, non-null, and unique within a For list.`);
-		seen.add(key);
-		const keyKind = typeof key;
-		const previousKeyKind = forState.devKeyKinds?.get(key);
-		if (previousKeyKind && previousKeyKind !== keyKind) failForValidation(`[askr] For key type changed for ${String(key)}. Keys must remain consistently typed across renders.`);
-		keyKinds.set(key, keyKind);
-	}
-	forState.devKeyKinds = keyKinds;
+//#region src/runtime/control/for-paths/pending.ts
+/**
+* Publish the strategy a path chose, together with the three pending fields
+* every path owns.
+*
+* Every parameter is required, so a path cannot leave one of these behind by
+* omission — which is how they were previously written, one scattered
+* assignment at a time. The three remaining `pending*` fields belong to exactly
+* one path each (`pendingInsertedIndex`, `pendingAppendStart`,
+* `pendingRemovedKey`) and are assigned by that path directly; the others leave
+* them as reconciliation found them, since each commit clears them through
+* `clearForDomUpdateState`.
+*/
+function setForCommitPending(forState, strategy, pendingDirtyIndices, pendingSwapIndices, pendingMoveOnly) {
+	forState.lastCommitStrategy = strategy;
+	forState.pendingDirtyIndices = pendingDirtyIndices;
+	forState.pendingSwapIndices = pendingSwapIndices;
+	forState.pendingMoveOnly = pendingMoveOnly;
 }
-function reconcileForItems(forState, newArray) {
-	forState.currentItems = newArray;
-	validateForKeys(forState, newArray);
-	const { items, orderedKeys, byFn } = forState;
-	const oldLen = orderedKeys.length;
-	const newLen = newArray.length;
-	forState.lastRemovedNodes = [];
-	forState.lastRemovedRanges = [];
-	forState.pendingRemovedKey = null;
-	if (newLen === 0) {
-		if (oldLen > 0) disposeAllItems(forState, forState.fallback ? "teardown" : "none");
-		forState.lastCommitStrategy = "TRUNCATE";
-		forState.pendingDirtyIndices = null;
-		forState.pendingSwapIndices = null;
-		forState.pendingMoveOnly = false;
-		return renderFallbackScope(forState);
-	}
-	if (forState.fallbackScope) disposeFallbackScope(forState, "none");
-	if (newLen === oldLen + 1) {
-		let oldIndex = 0;
-		let insertedIndex = -1;
-		let insertedKey = null;
-		for (let newIndex = 0; newIndex < newLen; newIndex++) {
-			const item = newArray[newIndex];
-			const key = byFn(item, newIndex);
-			const expectedKey = orderedKeys[oldIndex];
-			if (oldIndex < oldLen && key === expectedKey) {
-				const existing = items.get(key);
-				if (!existing || existing.item !== item || existing.scope.needsDomUpdate || oldIndex !== newIndex && existing.indexSignal._hasBeenRead) {
-					insertedIndex = -2;
-					break;
-				}
-				oldIndex++;
-			} else if (insertedIndex === -1 && !items.has(key)) {
-				insertedIndex = newIndex;
-				insertedKey = key;
-			} else {
-				insertedIndex = -2;
-				break;
-			}
-		}
-		if (insertedIndex >= 0 && oldIndex === oldLen && insertedKey !== null) {
-			const insertedItem = createItemInstance(insertedKey, newArray[insertedIndex], insertedIndex, forState);
-			const resultVNodes = forState.orderedVNodes.slice();
-			const resultItems = forState.orderedItems.slice();
-			const resultKeys = orderedKeys.slice();
-			resultVNodes.splice(insertedIndex, 0, insertedItem.scope.vnode);
-			resultItems.splice(insertedIndex, 0, insertedItem);
-			resultKeys.splice(insertedIndex, 0, insertedKey);
-			items.set(insertedKey, insertedItem);
-			forState.lastCommitStrategy = "INSERT_ONE";
-			forState.orderedKeys = resultKeys;
-			forState.orderedItems = resultItems;
-			forState.orderedVNodes = resultVNodes;
-			forState.pendingDirtyIndices = null;
-			forState.pendingSwapIndices = null;
-			forState.pendingMoveOnly = false;
-			forState.pendingInsertedIndex = insertedIndex;
-			for (let index = insertedIndex; index < resultItems.length; index += 1) syncForItemIndex(forState, resultItems[index], index);
-			return resultVNodes;
+//#endregion
+//#region src/runtime/control/for-paths/append.ts
+/**
+* Rows added at the tail, every existing key still at its own index.
+*
+* When the retained prefix is also clean the commit can skip it entirely, which
+* `pendingAppendStart` reports; otherwise the prefix is updated in place and the
+* commit starts from zero.
+*
+* Guarded by `oldLen < newLen`.
+*/
+function tryAppendPath(forState, newArray, items, orderedKeys, byFn, oldLen, newLen) {
+	let canUseAppendPath = true;
+	let canSkipCommittedPrefix = true;
+	for (let i = 0; i < oldLen; i++) {
+		const key = byFn(newArray[i], i);
+		if (key !== orderedKeys[i]) {
+			canUseAppendPath = false;
+			break;
 		}
+		const existing = forState.orderedItems[i] ?? items.get(key);
+		if (!existing || existing.item !== newArray[i] || existing.scope.needsDomUpdate || existing.scope.hydrationPending) canSkipCommittedPrefix = false;
 	}
-	if (oldLen < newLen) {
-		let canUseAppendPath = true;
-		let canSkipCommittedPrefix = true;
-		for (let i = 0; i < oldLen; i++) {
-			const key = byFn(newArray[i], i);
-			if (key !== orderedKeys[i]) {
-				canUseAppendPath = false;
-				break;
-			}
-			const existing = forState.orderedItems[i] ?? items.get(key);
-			if (!existing || existing.item !== newArray[i] || existing.scope.needsDomUpdate || existing.scope.hydrationPending) canSkipCommittedPrefix = false;
-		}
-		if (canUseAppendPath) {
-			forState.lastCommitStrategy = "APPEND";
-			const resultVNodes = forState.orderedVNodes;
-			const resultItems = forState.orderedItems;
-			resultVNodes.length = newLen;
-			resultItems.length = newLen;
-			if (!canSkipCommittedPrefix) for (let i = 0; i < oldLen; i++) {
-				const item = newArray[i];
-				const key = orderedKeys[i];
-				const existing = resultItems[i] ?? items.get(key);
-				updateItemInstance(forState, existing, item);
-				resultItems[i] = existing;
-				resultVNodes[i] = existing.scope.vnode;
-			}
-			for (let i = oldLen; i < newLen; i++) {
-				const item = newArray[i];
-				const key = byFn(item, i);
-				const itemInstance = createItemInstance(key, item, i, forState);
-				items.set(key, itemInstance);
-				resultItems[i] = itemInstance;
-				resultVNodes[i] = itemInstance.scope.vnode;
-				orderedKeys[i] = key;
-			}
-			forState.orderedVNodes = resultVNodes;
-			forState.pendingDirtyIndices = null;
-			forState.pendingSwapIndices = null;
-			forState.pendingMoveOnly = false;
-			forState.pendingAppendStart = canSkipCommittedPrefix ? oldLen : 0;
-			return resultVNodes;
-		}
+	if (!canUseAppendPath) return null;
+	const resultVNodes = forState.orderedVNodes;
+	const resultItems = forState.orderedItems;
+	resultVNodes.length = newLen;
+	resultItems.length = newLen;
+	if (!canSkipCommittedPrefix) for (let i = 0; i < oldLen; i++) {
+		const item = newArray[i];
+		const key = orderedKeys[i];
+		const existing = resultItems[i] ?? items.get(key);
+		updateItemInstance(forState, existing, item);
+		resultItems[i] = existing;
+		resultVNodes[i] = existing.scope.vnode;
 	}
-	if (newLen < oldLen) {
-		if (oldLen === newLen + 1) {
-			let removedIndex = -1;
-			for (let i = 0; i < newLen; i++) if (byFn(newArray[i], i) !== orderedKeys[i]) {
-				removedIndex = i;
-				break;
-			}
-			if (removedIndex !== -1) {
-				let canUseRemoveOnePath = true;
-				for (let i = removedIndex; i < newLen; i++) if (byFn(newArray[i], i) !== orderedKeys[i + 1]) {
-					canUseRemoveOnePath = false;
-					break;
-				}
-				if (canUseRemoveOnePath) {
-					forState.lastCommitStrategy = "REMOVE_ONE";
-					const resultVNodes = forState.orderedVNodes;
-					const resultItems = forState.orderedItems;
-					const removedKey = orderedKeys[removedIndex];
-					const removedItem = resultItems[removedIndex] ?? items.get(removedKey);
-					orderedKeys.copyWithin(removedIndex, removedIndex + 1);
-					resultItems.copyWithin(removedIndex, removedIndex + 1);
-					resultVNodes.copyWithin(removedIndex, removedIndex + 1);
-					orderedKeys.length = newLen;
-					resultItems.length = newLen;
-					resultVNodes.length = newLen;
-					const dirtyIndices = [];
-					for (let i = 0; i < newLen; i++) {
-						const item = newArray[i];
-						const existing = resultItems[i];
-						const scopeNeedsDomUpdate = existing.scope.needsDomUpdate;
-						const itemChanged = existing.item !== item;
-						const indexSignal = existing.indexSignal;
-						const indexChanged = i >= removedIndex && indexSignal.peek() !== i;
-						if (itemChanged) updateItemInstance(forState, existing, item);
-						const indexVisibleChange = indexChanged ? syncForItemIndex(forState, existing, i) : false;
-						if (itemChanged || indexVisibleChange || scopeNeedsDomUpdate) dirtyIndices.push(i);
-						resultVNodes[i] = existing.scope.vnode;
-					}
-					if (removedItem) {
-						disposeItemInstance(forState, removedItem, "teardown");
-						items.delete(removedKey);
-					}
-					forState.pendingRemovedKey = removedKey;
-					forState.pendingDirtyIndices = dirtyIndices;
-					forState.pendingSwapIndices = null;
-					forState.pendingMoveOnly = false;
-					return resultVNodes;
-				}
-			}
-		}
-		let canUseTruncatePath = true;
-		for (let i = 0; i < newLen; i++) if (byFn(newArray[i], i) !== orderedKeys[i]) {
-			canUseTruncatePath = false;
-			break;
-		}
-		if (canUseTruncatePath) {
-			forState.lastCommitStrategy = "TRUNCATE";
-			const resultVNodes = forState.orderedVNodes;
-			const resultItems = forState.orderedItems;
-			resultVNodes.length = newLen;
-			resultItems.length = newLen;
-			const isFullClear = newLen === 0;
-			const dirtyIndices = [];
-			for (let i = 0; i < newLen; i++) {
-				const item = newArray[i];
-				const key = orderedKeys[i];
-				const existing = items.get(key);
-				const itemChanged = existing.item !== item;
-				const scopeNeedsDomUpdate = existing.scope.needsDomUpdate || hasUnmountedComponentHost(existing.scope.dom);
-				if (itemChanged) updateItemInstance(forState, existing, item);
-				if (itemChanged || scopeNeedsDomUpdate) dirtyIndices.push(i);
-				resultItems[i] = existing;
-				resultVNodes[i] = existing.scope.vnode;
-			}
-			for (let i = newLen; i < oldLen; i++) {
-				const key = orderedKeys[i];
-				const itemInstance = items.get(key);
-				if (itemInstance) {
-					disposeItemInstance(forState, itemInstance, isFullClear ? "full-clear" : "teardown");
-					items.delete(key);
-				}
-			}
-			orderedKeys.length = newLen;
-			forState.orderedKeys = orderedKeys;
-			forState.orderedItems.length = newLen;
-			forState.orderedVNodes = resultVNodes;
-			forState.pendingDirtyIndices = dirtyIndices;
-			forState.pendingSwapIndices = null;
-			forState.pendingMoveOnly = false;
-			return resultVNodes;
-		}
+	for (let i = oldLen; i < newLen; i++) {
+		const item = newArray[i];
+		const key = byFn(item, i);
+		const itemInstance = createItemInstance(key, item, i, forState);
+		items.set(key, itemInstance);
+		resultItems[i] = itemInstance;
+		resultVNodes[i] = itemInstance.scope.vnode;
+		orderedKeys[i] = key;
 	}
-	if (oldLen === newLen) {
-		let canUseNoReorderPath = true;
-		for (let i = 0; i < oldLen; i++) if (byFn(newArray[i], i) !== orderedKeys[i]) {
-			canUseNoReorderPath = false;
-			break;
-		}
-		if (canUseNoReorderPath) {
-			forState.lastCommitStrategy = "NO_REORDER";
-			const resultVNodes = forState.orderedVNodes;
-			const resultItems = forState.orderedItems;
-			resultVNodes.length = oldLen;
-			resultItems.length = oldLen;
-			const dirtyIndices = [];
-			for (let i = 0; i < oldLen; i++) {
-				const item = newArray[i];
-				const key = orderedKeys[i];
-				const existing = items.get(key);
-				if (existing.item !== item) updateItemInstance(forState, existing, item);
-				if (existing.scope.needsDomUpdate) dirtyIndices.push(i);
-				resultItems[i] = existing;
-				resultVNodes[i] = existing.scope.vnode;
-			}
-			forState.pendingDirtyIndices = dirtyIndices;
-			forState.pendingSwapIndices = null;
-			forState.pendingMoveOnly = false;
-			return resultVNodes;
-		}
-		let firstMismatch = -1;
-		let secondMismatch = -1;
-		let firstMismatchKey = null;
-		let secondMismatchKey = null;
-		let mismatchCount = 0;
-		let canUseSwapPath = true;
-		for (let i = 0; i < oldLen; i++) {
-			const item = newArray[i];
-			const key = byFn(newArray[i], i);
-			if (key === orderedKeys[i]) {
-				const existing = items.get(key);
-				if (existing && (existing.item !== item || existing.scope.needsDomUpdate)) {
-					canUseSwapPath = false;
-					break;
-				}
-				continue;
-			}
-			mismatchCount++;
-			if (firstMismatch === -1) {
-				firstMismatch = i;
-				firstMismatchKey = key;
-				continue;
-			}
-			if (secondMismatch === -1) {
-				secondMismatch = i;
-				secondMismatchKey = key;
-				continue;
-			}
-			mismatchCount = 3;
-			break;
-		}
-		if (canUseSwapPath && mismatchCount === 2 && firstMismatch !== -1 && secondMismatch !== -1 && firstMismatchKey === orderedKeys[secondMismatch] && secondMismatchKey === orderedKeys[firstMismatch]) {
-			forState.lastCommitStrategy = "SWAP";
-			const nextOrderedKeys = orderedKeys.slice();
-			nextOrderedKeys[firstMismatch] = firstMismatchKey;
-			nextOrderedKeys[secondMismatch] = secondMismatchKey;
-			const resultVNodes = forState.orderedVNodes;
-			const firstExisting = items.get(firstMismatchKey);
-			const secondExisting = items.get(secondMismatchKey);
-			const firstItem = newArray[firstMismatch];
-			const secondItem = newArray[secondMismatch];
-			const nextOrderedItems = forState.orderedItems.slice();
-			nextOrderedItems[firstMismatch] = firstExisting;
-			nextOrderedItems[secondMismatch] = secondExisting;
-			if (firstExisting.item !== firstItem) updateItemInstance(forState, firstExisting, firstItem);
-			if (secondExisting.item !== secondItem) updateItemInstance(forState, secondExisting, secondItem);
-			syncForItemIndex(forState, firstExisting, firstMismatch);
-			syncForItemIndex(forState, secondExisting, secondMismatch);
-			resultVNodes[firstMismatch] = firstExisting.scope.vnode;
-			resultVNodes[secondMismatch] = secondExisting.scope.vnode;
-			forState.orderedKeys = nextOrderedKeys;
-			forState.orderedItems = nextOrderedItems;
-			forState.pendingDirtyIndices = null;
-			forState.pendingSwapIndices = [firstMismatch, secondMismatch];
-			forState.pendingMoveOnly = true;
-			return resultVNodes;
-		}
-		let canUseMoveOnlyPath = true;
-		const moveOnlyKeys = [];
-		const moveOnlyItems = [];
-		const moveOnlyVNodes = [];
-		for (let i = 0; i < oldLen; i++) {
-			const item = newArray[i];
-			const key = byFn(item, i);
-			const existing = items.get(key);
-			if (!existing || existing.item !== item || existing.indexSignal._hasBeenRead && existing.indexSignal.peek() !== i) {
-				canUseMoveOnlyPath = false;
-				break;
-			}
-			moveOnlyKeys[i] = key;
-			moveOnlyItems[i] = existing;
-			moveOnlyVNodes[i] = existing.scope.vnode;
-		}
-		if (canUseMoveOnlyPath) {
-			forState.lastCommitStrategy = "FULL_KEYED";
-			for (let i = 0; i < moveOnlyItems.length; i++) {
-				syncForItemIndex(forState, moveOnlyItems[i], i);
-				moveOnlyVNodes[i] = moveOnlyItems[i].scope.vnode;
-			}
-			forState.orderedKeys = moveOnlyKeys;
-			forState.orderedItems = moveOnlyItems;
-			forState.orderedVNodes = moveOnlyVNodes;
-			forState.pendingDirtyIndices = null;
-			forState.pendingSwapIndices = null;
-			forState.pendingMoveOnly = true;
-			return moveOnlyVNodes;
-		}
+	forState.orderedVNodes = resultVNodes;
+	setForCommitPending(forState, "APPEND", null, null, false);
+	forState.pendingAppendStart = canSkipCommittedPrefix ? oldLen : 0;
+	return resultVNodes;
+}
+//#endregion
+//#region src/runtime/control/for-paths/full-keyed.ts
+/**
+* A pure permutation: every new key resolves to an existing, unchanged item
+* whose index signal is either unread or already correct.
+*
+* Commits as FULL_KEYED, but flagged `pendingMoveOnly` so the commit can move
+* the existing nodes instead of rebuilding them.
+*
+* Guarded by `oldLen === newLen`, and runs only after NO_REORDER and SWAP
+* decline.
+*/
+function tryMoveOnlyKeyedPath(forState, newArray, items, byFn, oldLen) {
+	const moveOnlyKeys = [];
+	const moveOnlyItems = [];
+	const moveOnlyVNodes = [];
+	for (let i = 0; i < oldLen; i++) {
+		const item = newArray[i];
+		const key = byFn(item, i);
+		const existing = items.get(key);
+		if (!existing || existing.item !== item || existing.indexSignal._hasBeenRead && existing.indexSignal.peek() !== i) return null;
+		moveOnlyKeys[i] = key;
+		moveOnlyItems[i] = existing;
+		moveOnlyVNodes[i] = existing.scope.vnode;
 	}
-	forState.lastCommitStrategy = "FULL_KEYED";
+	for (let i = 0; i < moveOnlyItems.length; i++) {
+		syncForItemIndex(forState, moveOnlyItems[i], i);
+		moveOnlyVNodes[i] = moveOnlyItems[i].scope.vnode;
+	}
+	forState.orderedKeys = moveOnlyKeys;
+	forState.orderedItems = moveOnlyItems;
+	forState.orderedVNodes = moveOnlyVNodes;
+	setForCommitPending(forState, "FULL_KEYED", null, null, true);
+	return moveOnlyVNodes;
+}
+/**
+* The general keyed reconciliation every other path declines to handle.
+*
+* One pass over the new array creates, reuses or reindexes each row while
+* tracking which old keys survive; whatever is left over is disposed. Always
+* succeeds, so it takes no guard and returns no `null`.
+*/
+function fullKeyedPath(forState, newArray, items, orderedKeys, byFn) {
 	const toRemove = new Set(orderedKeys);
 	const newOrderedKeys = [];
 	const newOrderedItems = [];
@@ -1313,22 +1109,327 @@ function reconcileForItems(forState, newArray) {
 	forState.orderedKeys = newOrderedKeys;
 	forState.orderedItems = newOrderedItems;
 	forState.orderedVNodes = resultVNodes;
-	forState.pendingDirtyIndices = null;
-	forState.pendingSwapIndices = null;
-	forState.pendingMoveOnly = moveOnly;
+	setForCommitPending(forState, "FULL_KEYED", null, null, moveOnly);
+	return resultVNodes;
+}
+//#endregion
+//#region src/runtime/control/for-paths/insert-one.ts
+/**
+* One row inserted, every existing DOM node retained.
+*
+* Requires that no shifted row has read its index signal and that no retained
+* row is already dirty: this path only syncs the inserted index, so a pending
+* update anywhere else would be silently dropped. Every other shape falls
+* through to the general keyed path.
+*
+* Guarded by `newLen === oldLen + 1`.
+*/
+function tryInsertOnePath(forState, newArray, items, orderedKeys, byFn, oldLen, newLen) {
+	let oldIndex = 0;
+	let insertedIndex = -1;
+	let insertedKey = null;
+	for (let newIndex = 0; newIndex < newLen; newIndex++) {
+		const item = newArray[newIndex];
+		const key = byFn(item, newIndex);
+		const expectedKey = orderedKeys[oldIndex];
+		if (oldIndex < oldLen && key === expectedKey) {
+			const existing = items.get(key);
+			if (!existing || existing.item !== item || existing.scope.needsDomUpdate || oldIndex !== newIndex && existing.indexSignal._hasBeenRead) {
+				insertedIndex = -2;
+				break;
+			}
+			oldIndex++;
+		} else if (insertedIndex === -1 && !items.has(key)) {
+			insertedIndex = newIndex;
+			insertedKey = key;
+		} else {
+			insertedIndex = -2;
+			break;
+		}
+	}
+	if (!(insertedIndex >= 0 && oldIndex === oldLen && insertedKey !== null)) return null;
+	const insertedItem = createItemInstance(insertedKey, newArray[insertedIndex], insertedIndex, forState);
+	const resultVNodes = forState.orderedVNodes.slice();
+	const resultItems = forState.orderedItems.slice();
+	const resultKeys = orderedKeys.slice();
+	resultVNodes.splice(insertedIndex, 0, insertedItem.scope.vnode);
+	resultItems.splice(insertedIndex, 0, insertedItem);
+	resultKeys.splice(insertedIndex, 0, insertedKey);
+	items.set(insertedKey, insertedItem);
+	forState.orderedKeys = resultKeys;
+	forState.orderedItems = resultItems;
+	forState.orderedVNodes = resultVNodes;
+	for (let index = insertedIndex; index < resultItems.length; index += 1) syncForItemIndex(forState, resultItems[index], index);
+	setForCommitPending(forState, "INSERT_ONE", null, null, false);
+	forState.pendingInsertedIndex = insertedIndex;
+	return resultVNodes;
+}
+//#endregion
+//#region src/runtime/control/for-paths/no-reorder.ts
+/**
+* Same length, same key at every index: an in-place update with no DOM moves.
+*
+* Dirtiness is read from the scope after `updateItemInstance`, so a row whose
+* item is unchanged but whose subtree was invalidated still commits.
+*
+* Guarded by `oldLen === newLen`.
+*/
+function tryNoReorderPath(forState, newArray, items, orderedKeys, byFn, oldLen) {
+	for (let i = 0; i < oldLen; i++) if (byFn(newArray[i], i) !== orderedKeys[i]) return null;
+	const resultVNodes = forState.orderedVNodes;
+	const resultItems = forState.orderedItems;
+	resultVNodes.length = oldLen;
+	resultItems.length = oldLen;
+	const dirtyIndices = [];
+	for (let i = 0; i < oldLen; i++) {
+		const item = newArray[i];
+		const key = orderedKeys[i];
+		const existing = items.get(key);
+		if (existing.item !== item) updateItemInstance(forState, existing, item);
+		if (existing.scope.needsDomUpdate) dirtyIndices.push(i);
+		resultItems[i] = existing;
+		resultVNodes[i] = existing.scope.vnode;
+	}
+	setForCommitPending(forState, "NO_REORDER", dirtyIndices, null, false);
+	return resultVNodes;
+}
+//#endregion
+//#region src/runtime/control/for-paths/remove-one.ts
+/**
+* Exactly one row removed, the suffix shifted up by one.
+*
+* The shifted suffix keeps its instances; only rows whose item or index
+* actually changed land in the dirty list. `pendingRemovedKey` tells the commit
+* which keyed-map entry to drop, and the commit detaches that node before
+* applying the plan so dirty rows anchor on post-removal indices.
+*
+* Guarded by `oldLen === newLen + 1`.
+*/
+function tryRemoveOnePath(forState, newArray, items, orderedKeys, byFn, newLen) {
+	let removedIndex = -1;
+	for (let i = 0; i < newLen; i++) if (byFn(newArray[i], i) !== orderedKeys[i]) {
+		removedIndex = i;
+		break;
+	}
+	if (removedIndex === -1) return null;
+	for (let i = removedIndex; i < newLen; i++) if (byFn(newArray[i], i) !== orderedKeys[i + 1]) return null;
+	const resultVNodes = forState.orderedVNodes;
+	const resultItems = forState.orderedItems;
+	const removedKey = orderedKeys[removedIndex];
+	const removedItem = resultItems[removedIndex] ?? items.get(removedKey);
+	orderedKeys.copyWithin(removedIndex, removedIndex + 1);
+	resultItems.copyWithin(removedIndex, removedIndex + 1);
+	resultVNodes.copyWithin(removedIndex, removedIndex + 1);
+	orderedKeys.length = newLen;
+	resultItems.length = newLen;
+	resultVNodes.length = newLen;
+	const dirtyIndices = [];
+	for (let i = 0; i < newLen; i++) {
+		const item = newArray[i];
+		const existing = resultItems[i];
+		const scopeNeedsDomUpdate = existing.scope.needsDomUpdate;
+		const itemChanged = existing.item !== item;
+		const indexSignal = existing.indexSignal;
+		const indexChanged = i >= removedIndex && indexSignal.peek() !== i;
+		if (itemChanged) updateItemInstance(forState, existing, item);
+		const indexVisibleChange = indexChanged ? syncForItemIndex(forState, existing, i) : false;
+		if (itemChanged || indexVisibleChange || scopeNeedsDomUpdate) dirtyIndices.push(i);
+		resultVNodes[i] = existing.scope.vnode;
+	}
+	if (removedItem) {
+		disposeItemInstance(forState, removedItem, "teardown");
+		items.delete(removedKey);
+	}
+	setForCommitPending(forState, "REMOVE_ONE", dirtyIndices, null, false);
+	forState.pendingRemovedKey = removedKey;
+	return resultVNodes;
+}
+//#endregion
+//#region src/runtime/control/for-paths/swap.ts
+/**
+* Exactly two rows exchanged, everything else untouched.
+*
+* Bails when any key-matched row already carries a pending DOM update: SWAP
+* only ever syncs the two swapped indices, so such a row would silently lose
+* its update. This mirrors the INSERT_ONE guard.
+*
+* Guarded by `oldLen === newLen`, and runs only after NO_REORDER declines.
+*/
+function trySwapPath(forState, newArray, items, orderedKeys, byFn, oldLen) {
+	let firstMismatch = -1;
+	let secondMismatch = -1;
+	let firstMismatchKey = null;
+	let secondMismatchKey = null;
+	let mismatchCount = 0;
+	let canUseSwapPath = true;
+	for (let i = 0; i < oldLen; i++) {
+		const item = newArray[i];
+		const key = byFn(newArray[i], i);
+		if (key === orderedKeys[i]) {
+			const existing = items.get(key);
+			if (existing && (existing.item !== item || existing.scope.needsDomUpdate)) {
+				canUseSwapPath = false;
+				break;
+			}
+			continue;
+		}
+		mismatchCount++;
+		if (firstMismatch === -1) {
+			firstMismatch = i;
+			firstMismatchKey = key;
+			continue;
+		}
+		if (secondMismatch === -1) {
+			secondMismatch = i;
+			secondMismatchKey = key;
+			continue;
+		}
+		mismatchCount = 3;
+		break;
+	}
+	if (!(canUseSwapPath && mismatchCount === 2 && firstMismatch !== -1 && secondMismatch !== -1 && firstMismatchKey === orderedKeys[secondMismatch] && secondMismatchKey === orderedKeys[firstMismatch])) return null;
+	const nextOrderedKeys = orderedKeys.slice();
+	nextOrderedKeys[firstMismatch] = firstMismatchKey;
+	nextOrderedKeys[secondMismatch] = secondMismatchKey;
+	const resultVNodes = forState.orderedVNodes;
+	const firstExisting = items.get(firstMismatchKey);
+	const secondExisting = items.get(secondMismatchKey);
+	const firstItem = newArray[firstMismatch];
+	const secondItem = newArray[secondMismatch];
+	const nextOrderedItems = forState.orderedItems.slice();
+	nextOrderedItems[firstMismatch] = firstExisting;
+	nextOrderedItems[secondMismatch] = secondExisting;
+	if (firstExisting.item !== firstItem) updateItemInstance(forState, firstExisting, firstItem);
+	if (secondExisting.item !== secondItem) updateItemInstance(forState, secondExisting, secondItem);
+	syncForItemIndex(forState, firstExisting, firstMismatch);
+	syncForItemIndex(forState, secondExisting, secondMismatch);
+	resultVNodes[firstMismatch] = firstExisting.scope.vnode;
+	resultVNodes[secondMismatch] = secondExisting.scope.vnode;
+	forState.orderedKeys = nextOrderedKeys;
+	forState.orderedItems = nextOrderedItems;
+	setForCommitPending(forState, "SWAP", null, [firstMismatch, secondMismatch], true);
 	return resultVNodes;
 }
 //#endregion
-//#region src/runtime/for-internal.ts
+//#region src/runtime/control/for-paths/truncate.ts
 /**
-* For primitive runtime
+* The tail dropped, the surviving prefix keeping its keys and positions.
 *
-* Manages For state storage, hook binding, source evaluation,
-* and DOM update state cleanup.
+* Survivors are updated in place; the removed tail is disposed here, so the
+* commit only has to patch the dirty survivors and detach the orphaned nodes.
+* A survivor also counts as dirty when its component host was unmounted out
+* from under it.
+*
+* Guarded by `newLen < oldLen`.
 */
+function tryTruncatePath(forState, newArray, items, orderedKeys, byFn, oldLen, newLen) {
+	for (let i = 0; i < newLen; i++) if (byFn(newArray[i], i) !== orderedKeys[i]) return null;
+	const resultVNodes = forState.orderedVNodes;
+	const resultItems = forState.orderedItems;
+	resultVNodes.length = newLen;
+	resultItems.length = newLen;
+	const isFullClear = newLen === 0;
+	const dirtyIndices = [];
+	for (let i = 0; i < newLen; i++) {
+		const item = newArray[i];
+		const key = orderedKeys[i];
+		const existing = items.get(key);
+		const itemChanged = existing.item !== item;
+		const scopeNeedsDomUpdate = existing.scope.needsDomUpdate || getRuntimeScopes().hasUnmountedComponentHost(existing.scope.dom);
+		if (itemChanged) updateItemInstance(forState, existing, item);
+		if (itemChanged || scopeNeedsDomUpdate) dirtyIndices.push(i);
+		resultItems[i] = existing;
+		resultVNodes[i] = existing.scope.vnode;
+	}
+	for (let i = newLen; i < oldLen; i++) {
+		const key = orderedKeys[i];
+		const itemInstance = items.get(key);
+		if (itemInstance) {
+			disposeItemInstance(forState, itemInstance, isFullClear ? "full-clear" : "teardown");
+			items.delete(key);
+		}
+	}
+	orderedKeys.length = newLen;
+	forState.orderedKeys = orderedKeys;
+	forState.orderedItems.length = newLen;
+	forState.orderedVNodes = resultVNodes;
+	setForCommitPending(forState, "TRUNCATE", dirtyIndices, null, false);
+	return resultVNodes;
+}
+//#endregion
+//#region src/runtime/control/for-reconcile.ts
+function failForValidation(message) {
+	throw new Error(message);
+}
+function validateForKeys(forState, newArray) {
+	if (!isDevelopmentEnvironment()) return;
+	const seen = /* @__PURE__ */ new Set();
+	const keyKinds = /* @__PURE__ */ new Map();
+	for (let i = 0; i < newArray.length; i++) {
+		const key = forState.byFn(newArray[i], i);
+		if (key === null || key === void 0) failForValidation("[askr] Invalid For key detected. Keys should be stable, non-null, and unique within a For list.");
+		if (seen.has(key)) failForValidation(`[askr] Duplicate For key detected: ${String(key)}. Keys should be stable, non-null, and unique within a For list.`);
+		seen.add(key);
+		const keyKind = typeof key;
+		const previousKeyKind = forState.devKeyKinds?.get(key);
+		if (previousKeyKind && previousKeyKind !== keyKind) failForValidation(`[askr] For key type changed for ${String(key)}. Keys must remain consistently typed across renders.`);
+		keyKinds.set(key, keyKind);
+	}
+	forState.devKeyKinds = keyKinds;
+}
+function reconcileForItems(forState, newArray) {
+	forState.currentItems = newArray;
+	validateForKeys(forState, newArray);
+	const { items, orderedKeys, byFn } = forState;
+	const oldLen = orderedKeys.length;
+	const newLen = newArray.length;
+	forState.lastRemovedNodes = [];
+	forState.lastRemovedRanges = [];
+	forState.pendingRemovedKey = null;
+	if (newLen === 0) {
+		if (oldLen > 0) disposeAllItems(forState, forState.fallback ? "teardown" : "none");
+		forState.lastCommitStrategy = "TRUNCATE";
+		forState.pendingDirtyIndices = null;
+		forState.pendingSwapIndices = null;
+		forState.pendingMoveOnly = false;
+		return renderFallbackScope(forState);
+	}
+	if (forState.fallbackScope) disposeFallbackScope(forState, "none");
+	/** Close out the pass. Each path has already published its own decision. */
+	const finish = (vnodes) => {
+		return vnodes;
+	};
+	if (newLen === oldLen + 1) {
+		const inserted = tryInsertOnePath(forState, newArray, items, orderedKeys, byFn, oldLen, newLen);
+		if (inserted) return finish(inserted);
+	}
+	if (oldLen < newLen) {
+		const appended = tryAppendPath(forState, newArray, items, orderedKeys, byFn, oldLen, newLen);
+		if (appended) return finish(appended);
+	}
+	if (newLen < oldLen) {
+		if (oldLen === newLen + 1) {
+			const removed = tryRemoveOnePath(forState, newArray, items, orderedKeys, byFn, newLen);
+			if (removed) return finish(removed);
+		}
+		const truncated = tryTruncatePath(forState, newArray, items, orderedKeys, byFn, oldLen, newLen);
+		if (truncated) return finish(truncated);
+	}
+	if (oldLen === newLen) {
+		const unmoved = tryNoReorderPath(forState, newArray, items, orderedKeys, byFn, oldLen);
+		if (unmoved) return finish(unmoved);
+		const swapped = trySwapPath(forState, newArray, items, orderedKeys, byFn, oldLen);
+		if (swapped) return finish(swapped);
+		const moved = tryMoveOnlyKeyedPath(forState, newArray, items, byFn, oldLen);
+		if (moved) return finish(moved);
+	}
+	return finish(fullKeyedPath(forState, newArray, items, orderedKeys, byFn));
+}
+//#endregion
+//#region src/runtime/control/for-state.ts
 const forStates = /* @__PURE__ */ new WeakMap();
 function getForStore(instance) {
-	const generation = instance._ownershipGeneration;
+	const generation = instance.owner.identity;
 	let store = forStates.get(generation);
 	if (!store) {
 		store = /* @__PURE__ */ new Map();
@@ -1337,36 +1438,25 @@ function getForStore(instance) {
 	return store;
 }
 function createForState(eachSource, byFn, renderFn, fallback) {
-	const parentInstance = getCurrentInstance();
-	const ownedScopes = /* @__PURE__ */ new Set();
-	let bulkDisposing = false;
+	const parentInstance = getCurrentComponentInstance();
+	const scopeOwner = new OwnershipRecord();
 	const scopeOwnership = {
-		add: (scope) => ownedScopes.add(scope),
-		delete: (scope) => bulkDisposing ? false : ownedScopes.delete(scope),
+		add: (scope) => ownChild(scopeOwner, scope),
+		delete: (scope) => releaseOwnedChild(scopeOwner, scope),
 		bulkDispose(run) {
-			bulkDisposing = true;
-			try {
-				run();
-			} finally {
-				bulkDisposing = false;
-				ownedScopes.clear();
-			}
+			detachOwnedChildren(scopeOwner);
+			run();
 		}
 	};
-	if (parentInstance) registerOwnedChildScope(parentInstance, {
-		key: "for-boundary",
-		dispose() {
-			scopeOwnership.bulkDispose(() => {
-				const errors = [];
-				for (const scope of ownedScopes) try {
-					scope.dispose();
-				} catch (error) {
-					errors.push(error);
-				}
-				if (errors.length > 0) throw new AggregateError(errors, "For scope cleanup failed");
-			});
-		}
-	});
+	if (parentInstance) {
+		registerScopedOwnership({
+			key: "for-boundary",
+			dispose() {
+				disposeOwnership(scopeOwner);
+			}
+		}, scopeOwner);
+		attachOwnership(scopeOwner, parentInstance.owner);
+	}
 	return {
 		kind: "for",
 		_contextFrame: null,
@@ -1403,10 +1493,10 @@ function createForState(eachSource, byFn, renderFn, fallback) {
 	};
 }
 function useForState(eachSource, byFn, renderFn, fallback) {
-	const instance = getCurrentInstance();
+	const instance = getCurrentComponentInstance();
 	if (!instance) throw new Error("For can only be created during component render execution.");
 	const hookIndex = claimHookIndex(instance, "For");
-	const generation = instance._ownershipGeneration;
+	const generation = instance.owner.identity;
 	const store = getForStore(instance);
 	const existing = store.get(hookIndex);
 	if (existing) {
@@ -1418,11 +1508,14 @@ function useForState(eachSource, byFn, renderFn, fallback) {
 	}
 	const created = createForState(eachSource, byFn, renderFn, fallback);
 	store.set(hookIndex, created);
-	(instance.cleanupFns ??= []).push(() => {
-		created._sourceEffect?.cleanup();
-		created._sourceEffect = null;
-		store.delete(hookIndex);
-		if (store.size === 0 && forStates.get(generation) === store) forStates.delete(generation);
+	ownCleanup(instance.owner, () => {
+		try {
+			created._sourceEffect?.cleanup();
+		} finally {
+			created._sourceEffect = null;
+			store.delete(hookIndex);
+			if (store.size === 0 && forStates.get(generation) === store) forStates.delete(generation);
+		}
 	});
 	return created;
 }
@@ -1484,7 +1577,13 @@ function beginForStateTransaction(forState, collectionMode = "auto") {
 }
 function registerForStateTransaction(forState, transaction = forState._transaction) {
 	if (!transaction || forState._transaction !== transaction) return false;
-	return registerLifecycleTransaction(transaction, () => commitForStateTransaction(forState, transaction), () => rollbackForStateTransaction(forState, transaction));
+	return registerCommitParticipant({
+		key: transaction,
+		collision: "keep-first",
+		publish: () => publishForStateTransaction(forState, transaction),
+		settle: () => commitForStateTransaction(forState, transaction),
+		rollback: () => rollbackForStateTransaction(forState, transaction)
+	});
 }
 function finalizeForStateRemovals(forState, transaction) {
 	const removedScopes = transaction.removedScopes;
@@ -1499,20 +1598,7 @@ function finalizeForStateRemovals(forState, transaction) {
 			cleanupErrors.push(error);
 		}
 		if (transaction.removedScopeNodes) return;
-		if (typeof Element !== "undefined" && removedDom instanceof Element) try {
-			getRuntimeRenderer().teardownNodeSubtree(removedDom);
-		} catch (error) {
-			cleanupErrors.push(error);
-		}
-		if (removedRange && !removedRange.single) for (let node = removedRange.start.nextSibling; node && node !== removedRange.end;) {
-			const next = node.nextSibling;
-			try {
-				getRuntimeRenderer().teardownNodeSubtree(node);
-			} catch (error) {
-				cleanupErrors.push(error);
-			}
-			node = next;
-		}
+		getRuntimeScopes().teardownScopeHost(removedDom, removedRange, (error) => cleanupErrors.push(error));
 	};
 	if (transaction.removeAllItems) forState._scopeOwnership.bulkDispose(() => {
 		for (let index = 0; index < transaction.orderedItems.length; index++) {
@@ -1523,7 +1609,7 @@ function finalizeForStateRemovals(forState, transaction) {
 	for (const scope of removedScopes ?? []) finalizeScope(scope);
 	const removedScopeNodes = transaction.removedScopeNodes;
 	if (removedScopeNodes) for (const node of removedScopeNodes) try {
-		getRuntimeRenderer().teardownNodeSubtree(node);
+		getRuntimeCleanup().teardownNodeSubtree(node);
 	} catch (error) {
 		cleanupErrors.push(error);
 	}
@@ -1547,22 +1633,40 @@ function finalizeForDomUpdateFlags(forState) {
 	}
 	if (forState.fallbackScope) forState.fallbackScope.needsDomUpdate = false;
 }
+function publishForStateTransaction(forState, transaction) {
+	if (forState._transaction !== transaction) return;
+	if (transaction.shouldClearDomUpdateState) finalizeForDomUpdateFlags(forState);
+	forState._committedItems = forState.currentItems;
+	forState._transaction = null;
+	transaction.published = true;
+}
 function commitForStateTransaction(forState, transaction = forState._transaction) {
-	if (!transaction || forState._transaction !== transaction) return;
+	if (!transaction) return;
+	if (!transaction.published) publishForStateTransaction(forState, transaction);
+	if (!transaction.published) return;
+	transaction.published = false;
+	const errors = [];
 	try {
-		finalizeForStateRemovals(forState, transaction);
-		finalizeForSignalEffects(transaction);
-		if (transaction.shouldClearDomUpdateState) finalizeForDomUpdateFlags(forState);
+		try {
+			finalizeForStateRemovals(forState, transaction);
+		} catch (error) {
+			errors.push(error);
+		}
+		try {
+			finalizeForSignalEffects(transaction);
+		} catch (error) {
+			errors.push(error);
+		}
 	} finally {
 		transaction.itemSnapshots?.clear();
 		transaction.unreadIndexSnapshots?.clear();
 		transaction.fallbackScopeSnapshot = null;
-		forState._committedItems = forState.currentItems;
-		forState._transaction = null;
 	}
+	if (errors.length) throw new AggregateError(errors, "For settlement failed");
 }
 function rollbackForStateTransaction(forState, transaction = forState._transaction) {
-	if (!transaction || forState._transaction !== transaction) return;
+	if (!transaction || forState._transaction !== transaction && !transaction.published) return;
+	transaction.published = false;
 	const rollbackCleanupErrors = [];
 	const scopesToDispose = /* @__PURE__ */ new Set();
 	const committedScopes = transaction.collectionSnapshotMode === "reset-empty" ? null : new Set(transaction.orderedItems.map((item) => item.scope));
@@ -1646,4 +1750,4 @@ function clearForDomUpdateState(forState) {
 	forState._hasResolvedItemDom = forState.orderedKeys.length > 0;
 }
 //#endregion
-export { setControlBoundaryContextFrame as _, registerForStateTransaction as a, rerenderChildScope as b, captureForFallbackTransactionSnapshot as c, clearCaseDomUpdateState as d, clearShowDomUpdateState as f, evaluateShowState as g, evaluateCaseState as h, evaluateForState as i, captureForItemTransactionSnapshot as l, createShowState as m, clearForDomUpdateState as n, rollbackForStateTransaction as o, createCaseState as p, commitForStateTransaction as r, useForState as s, beginForStateTransaction as t, recordBenchEvent as u, createChildScope as v, disposeChildScope as y };
+export { setControlBoundaryContextFrame as _, registerForStateTransaction as a, joinChildScopePreparation as b, captureForFallbackTransactionSnapshot as c, clearCaseDomUpdateState as d, clearShowDomUpdateState as f, evaluateShowState as g, evaluateCaseState as h, evaluateForState as i, captureForItemTransactionSnapshot as l, createShowState as m, clearForDomUpdateState as n, rollbackForStateTransaction as o, createCaseState as p, commitForStateTransaction as r, useForState as s, beginForStateTransaction as t, recordBenchEvent as u, createChildScope as v, rerenderChildScope as x, disposeChildScope as y };