@askrjs/askr 0.0.51 → 0.0.52

package/dist/runtime/for-reconcile.js

@@ -15,11 +15,10 @@ function validateForKeys(forState, newArray) {
 		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 keyString = String(key);
 		const keyKind = typeof key;
-		const previousKeyKind = forState.devKeyKinds?.get(keyString);
-		if (previousKeyKind && previousKeyKind !== keyKind) failForValidation(`[askr] For key type changed for ${keyString}. Keys must remain consistently typed across renders.`);
-		keyKinds.set(keyString, keyKind);
+		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;
 }
@@ -32,6 +31,7 @@ function reconcileForItems(forState, newArray) {
 	const oldLen = orderedKeys.length;
 	const newLen = newArray.length;
 	forState.lastRemovedNodes = [];
+	forState.lastRemovedRanges = [];
 	if (newLen === 0) {
 		if (oldLen > 0) disposeAllItems(forState, forState.fallback ? "teardown" : "none");
 		recordBenchFastLane("TRUNCATE");
@@ -46,20 +46,75 @@ function reconcileForItems(forState, newArray) {
 		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);
+			recordBenchFastLane("INSERT_ONE");
+			recordBenchEvent("itemReused", oldLen);
+			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;
+			if (BENCH_BUILD_ENABLED) {
+				recordBenchTiming("reconcile", performance.now() - reconcileStartMs);
+				flushBenchMetrics();
+			}
+			return resultVNodes;
+		}
+	}
 	if (oldLen < newLen) {
 		let canUseAppendPath = true;
-		for (let i = 0; i < oldLen; i++) if (byFn(newArray[i], i) !== orderedKeys[i]) {
-			canUseAppendPath = false;
-			break;
+		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) {
-			recordBenchFastLane("APPEND");
+			if (BENCH_BUILD_ENABLED) recordBenchFastLane("APPEND");
 			forState.lastCommitStrategy = "APPEND";
 			const resultVNodes = forState.orderedVNodes;
 			const resultItems = forState.orderedItems;
 			resultVNodes.length = newLen;
 			resultItems.length = newLen;
-			for (let i = 0; i < oldLen; i++) {
+			if (!canSkipCommittedPrefix) for (let i = 0; i < oldLen; i++) {
 				const item = newArray[i];
 				const key = orderedKeys[i];
 				const existing = resultItems[i] ?? items.get(key);
@@ -67,7 +122,7 @@ function reconcileForItems(forState, newArray) {
 				resultItems[i] = existing;
 				resultVNodes[i] = existing.scope.vnode;
 			}
-			recordBenchEvent("itemReused", oldLen);
+			if (BENCH_BUILD_ENABLED) recordBenchEvent("itemReused", oldLen);
 			for (let i = oldLen; i < newLen; i++) {
 				const item = newArray[i];
 				const key = byFn(item, i);
@@ -85,6 +140,7 @@ function reconcileForItems(forState, newArray) {
 			forState.pendingDirtyIndices = null;
 			forState.pendingSwapIndices = null;
 			forState.pendingMoveOnly = false;
+			forState.pendingAppendStart = canSkipCommittedPrefix ? oldLen : 0;
 			return resultVNodes;
 		}
 	}
@@ -102,7 +158,7 @@ function reconcileForItems(forState, newArray) {
 					break;
 				}
 				if (canUseRemoveOnePath) {
-					recordBenchFastLane("REMOVE_ONE");
+					if (BENCH_BUILD_ENABLED) recordBenchFastLane("REMOVE_ONE");
 					forState.lastCommitStrategy = "NO_REORDER";
 					const previousOrderedItems = forState.orderedItems.slice();
 					const resultVNodes = forState.orderedVNodes;
@@ -123,7 +179,7 @@ function reconcileForItems(forState, newArray) {
 						resultItems[i] = existing;
 						resultVNodes[i] = existing.scope.vnode;
 					}
-					recordBenchEvent("itemReused", newLen);
+					if (BENCH_BUILD_ENABLED) recordBenchEvent("itemReused", newLen);
 					const removedKey = orderedKeys[removedIndex];
 					const removedItem = items.get(removedKey);
 					if (removedItem) {
@@ -211,9 +267,8 @@ function reconcileForItems(forState, newArray) {
 				const item = newArray[i];
 				const key = orderedKeys[i];
 				const existing = items.get(key);
-				const itemChanged = existing.item !== item;
-				if (itemChanged) updateItemInstance(forState, existing, item);
-				if (!itemChanged && existing.scope.needsDomUpdate) dirtyIndices.push(i);
+				if (existing.item !== item) updateItemInstance(forState, existing, item);
+				if (existing.scope.needsDomUpdate) dirtyIndices.push(i);
 				resultItems[i] = existing;
 				resultVNodes[i] = existing.scope.vnode;
 			}
@@ -274,7 +329,7 @@ function reconcileForItems(forState, newArray) {
 			const nextOrderedItems = forState.orderedItems.slice();
 			nextOrderedItems[firstMismatch] = secondExisting;
 			nextOrderedItems[secondMismatch] = firstExisting;
-			recordBenchEvent("itemReused");
+			if (BENCH_BUILD_ENABLED) recordBenchEvent("itemReused");
 			recordBenchEvent("itemReused");
 			if (firstExisting.item !== firstItem) updateItemInstance(forState, firstExisting, firstItem);
 			if (secondExisting.item !== secondItem) updateItemInstance(forState, secondExisting, secondItem);
@@ -311,7 +366,7 @@ function reconcileForItems(forState, newArray) {
 			recordBenchEvent("itemReused");
 		}
 		if (canUseMoveOnlyPath) {
-			recordBenchFastLane("FULL_KEYED");
+			if (BENCH_BUILD_ENABLED) recordBenchFastLane("FULL_KEYED");
 			forState.lastCommitStrategy = "FULL_KEYED";
 			for (let i = 0; i < moveOnlyItems.length; i++) {
 				syncForItemIndex(forState, moveOnlyItems[i], i);
@@ -330,7 +385,7 @@ function reconcileForItems(forState, newArray) {
 			return moveOnlyVNodes;
 		}
 	}
-	recordBenchFastLane("FULL_KEYED");
+	if (BENCH_BUILD_ENABLED) recordBenchFastLane("FULL_KEYED");
 	forState.lastCommitStrategy = "FULL_KEYED";
 	const toRemove = new Set(orderedKeys);
 	const newOrderedKeys = [];
@@ -340,18 +395,18 @@ function reconcileForItems(forState, newArray) {
 	for (let i = 0; i < newArray.length; i++) {
 		const item = newArray[i];
 		const key = byFn(item, i);
-		recordBenchEvent("keyLookup");
+		if (BENCH_BUILD_ENABLED) recordBenchEvent("keyLookup");
 		toRemove.delete(key);
 		newOrderedKeys.push(key);
 		const existing = items.get(key);
-		recordBenchEvent(existing ? "keyHit" : "keyMiss");
+		if (BENCH_BUILD_ENABLED) recordBenchEvent(existing ? "keyHit" : "keyMiss");
 		if (!existing) {
 			const itemInstance = createItemInstance(key, item, i, forState);
 			items.set(key, itemInstance);
 			newOrderedItems.push(itemInstance);
 			resultVNodes.push(itemInstance.scope.vnode);
 		} else {
-			recordBenchEvent("itemReused");
+			if (BENCH_BUILD_ENABLED) recordBenchEvent("itemReused");
 			const itemChanged = existing.item !== item;
 			const indexChanged = existing.indexSignal.peek() !== i;
 			if (itemChanged) {
@@ -385,5 +440,3 @@ function reconcileForItems(forState, newArray) {
 }
 //#endregion
 export { reconcileForItems };
-
-//# sourceMappingURL=for-reconcile.js.map

package/dist/runtime/for-scopes.d.ts

@@ -1,5 +1,5 @@
 import { ChildScope } from "./child-scope.js";
-import { ForIndexSignal, ForItemPropertySignal, ForItemSignal } from "./for-signals.js";
+import { ForIndexSignal, ReactiveForItemState } from "./for-signals.js";
 import { ForState } from "./for-internal.js";
 import { VNode } from "../common/vnode.js";
 
@@ -8,12 +8,13 @@ interface ForItemInstance<T> {
   key: string | number;
   item: T;
   reactiveItem: T;
-  itemSignal: ForItemSignal<T> | null;
-  itemPropertySignals: Map<PropertyKey, ForItemPropertySignal> | null;
+  reactiveItemState: ReactiveForItemState<T> | null;
   indexSignal: ForIndexSignal;
   scope: ChildScope;
 }
 type RemovedDomCleanupMode = 'none' | 'teardown' | 'full-clear';
+declare function captureForItemTransactionSnapshot<T>(forState: ForState<T>, itemInstance: ForItemInstance<T>): void;
+declare function captureForFallbackTransactionSnapshot<T>(forState: ForState<T>, fallbackScope?: ChildScope | null): void;
 declare function syncForItemIndex<T>(forState: ForState<T>, itemInstance: ForItemInstance<T>, nextIndex: number): boolean;
 declare function disposeItemInstance<T>(forState: ForState<T>, itemInstance: ForItemInstance<T>, domCleanup: RemovedDomCleanupMode): void;
 declare function createItemInstance<T>(key: string | number, item: T, index: number, forState: ForState<T>): ForItemInstance<T>;
@@ -22,5 +23,4 @@ declare function disposeFallbackScope<T>(forState: ForState<T>, domCleanup: Remo
 declare function renderFallbackScope<T>(forState: ForState<T>): VNode[];
 declare function disposeAllItems<T>(forState: ForState<T>, domCleanup: RemovedDomCleanupMode): void;
 //#endregion
-export { ForItemInstance, RemovedDomCleanupMode };
-//# sourceMappingURL=for-scopes.d.ts.map
+export { ForItemInstance, RemovedDomCleanupMode };

package/dist/runtime/for-scopes.js

@@ -1,16 +1,96 @@
 import { isDevelopmentEnvironment } from "../common/env.js";
 import { getRuntimeRenderer } from "./access.js";
-import { createChildScope, disposeChildScope } from "./child-scope.js";
-import { canProxyForItem, createForIndexSignal, createForItemSignal, createReactiveForItem, haveSameOwnKeys, notifyForSignalReaders, readForItemProperty, removeForParentReaders, scopeReadsSource, syncForIndexSignal } from "./for-signals.js";
-import { recordBenchEvent } from "./for-bench.js";
-//#region src/runtime/for-scopes.ts
+import { captureChildScopeTransactionSnapshot, createChildScope, disposeChildScope } from "./child-scope.js";
+import { canProxyForItem, createForIndexSignal, createReactiveForItem, haveSameOwnKeys, notifyForSignalReaders, readForItemProperty, removeForParentReaders, scopeDirectlyReadsSource, scopeReadsSource, syncForIndexSignal } from "./for-signals.js";
+import "./for-bench.js";
 function enqueueForScopeUpdate(parent) {
 	parent?._enqueueRun?.();
 }
+const forStatesByScope = /* @__PURE__ */ new WeakMap();
+function enqueueForBoundaryScopeCommit() {
+	const forState = this.blueprintOwner ?? forStatesByScope.get(this);
+	if (!forState) return;
+	if (forState._enqueueBoundaryCommit) {
+		forState._enqueueBoundaryCommit();
+		return;
+	}
+	enqueueForScopeUpdate(forState.parentInstance);
+}
+function createForOwnedChildScope(forState, key) {
+	return createChildScope(forState.parentInstance, key, enqueueForBoundaryScopeCommit);
+}
+function captureForItemTransactionSnapshot(forState, itemInstance) {
+	const transaction = forState._transaction;
+	if (!transaction || transaction.itemSnapshots?.has(itemInstance)) return;
+	if (transaction.collectionSnapshotMode === "reset-empty" || transaction.items.get(itemInstance.key) !== itemInstance) return;
+	const itemSnapshots = transaction.itemSnapshots ??= /* @__PURE__ */ new Map();
+	const propertySignals = itemInstance.reactiveItemState?.propertySignals ?? null;
+	const itemSignal = itemInstance.reactiveItemState?.itemSignal ?? null;
+	const propertySnapshots = propertySignals && propertySignals.size > 0 ? new Map(Array.from(propertySignals, ([property, signal]) => [property, {
+		signal,
+		value: signal.peek(),
+		hasBeenRead: signal._hasBeenRead === true
+	}])) : null;
+	itemSnapshots.set(itemInstance, {
+		item: itemInstance.item,
+		itemSignalExists: itemSignal !== null,
+		itemSignalValue: itemSignal?.peek(),
+		itemSignalHasBeenRead: itemSignal?._hasBeenRead === true,
+		indexValue: itemInstance.indexSignal.peek(),
+		indexHasBeenRead: itemInstance.indexSignal._hasBeenRead === true,
+		propertySignalStore: propertySignals,
+		propertySignals: propertySnapshots,
+		scope: captureChildScopeTransactionSnapshot(itemInstance.scope)
+	});
+}
+function captureForFallbackTransactionSnapshot(forState, fallbackScope = forState.fallbackScope) {
+	const transaction = forState._transaction;
+	if (!transaction || !fallbackScope || transaction.fallbackScope !== fallbackScope || transaction.fallbackScopeSnapshot) return;
+	transaction.fallbackScopeSnapshot = captureChildScopeTransactionSnapshot(fallbackScope);
+}
+function stageForSignalEffect(forState, source, notify, skipInstance = null, skipOwnedBy = null) {
+	const transaction = forState._transaction;
+	if (!transaction) return false;
+	const effects = transaction.signalEffects ??= /* @__PURE__ */ new Map();
+	const existing = effects.get(source);
+	if (existing) {
+		existing.notify ||= notify;
+		if (existing.skipInstance !== skipInstance) existing.skipInstance = null;
+		if (existing.skipOwnedBy !== skipOwnedBy) existing.skipOwnedBy = null;
+	} else effects.set(source, {
+		parentInstance: forState.parentInstance,
+		notify,
+		skipInstance,
+		skipOwnedBy
+	});
+	return true;
+}
 function syncForItemIndex(forState, itemInstance, nextIndex) {
 	const indexSignal = itemInstance.indexSignal;
-	if (indexSignal.peek() === nextIndex) return false;
-	if (!scopeReadsSource(itemInstance.scope, indexSignal)) {
+	const previousIndex = indexSignal.peek();
+	if (previousIndex === nextIndex) return false;
+	if (indexSignal._hasBeenRead !== true) {
+		const transaction = forState._transaction;
+		if (transaction) {
+			const snapshots = transaction.unreadIndexSnapshots ??= /* @__PURE__ */ new Map();
+			if (!snapshots.has(indexSignal)) snapshots.set(indexSignal, previousIndex);
+		}
+		indexSignal.set(nextIndex, false);
+		return false;
+	}
+	captureForItemTransactionSnapshot(forState, itemInstance);
+	const scopeReadsIndex = scopeReadsSource(itemInstance.scope, indexSignal);
+	const scopeDirectlyReadsIndex = scopeDirectlyReadsSource(itemInstance.scope, indexSignal);
+	if (forState._transaction) {
+		const shouldNotify = indexSignal._hasBeenRead === true;
+		indexSignal.set(nextIndex, false);
+		stageForSignalEffect(forState, indexSignal, shouldNotify, scopeReadsIndex ? itemInstance.scope.componentInstance : null);
+		if (!scopeReadsIndex) return false;
+		if (scopeDirectlyReadsIndex) rerenderItemInstance(forState, itemInstance, itemInstance.reactiveItem);
+		else itemInstance.scope.markDirty();
+		return true;
+	}
+	if (!scopeReadsIndex) {
 		syncForIndexSignal(indexSignal, nextIndex);
 		return false;
 	}
@@ -19,25 +99,32 @@ function syncForItemIndex(forState, itemInstance, nextIndex) {
 	rerenderItemInstance(forState, itemInstance, itemInstance.reactiveItem);
 	return true;
 }
-function materializeItemVnode(key, vnode) {
+function materializeItemVnode(forState, key, vnode) {
 	if (vnode && typeof vnode === "object" && "type" in vnode) {
 		const vn = vnode;
 		vn.key = key;
-		if (typeof vn.type === "string") {
+		if (forState.parentInstance?.ssr && typeof vn.type === "string") {
 			if (!vn.props) vn.props = {};
 			if (vn.props["data-key"] === void 0) vn.props["data-key"] = String(key);
+			if (vn.props["data-askr-key-kind"] === void 0) vn.props["data-askr-key-kind"] = typeof key;
 		}
 	}
 }
 function renderItemScope(forState, scope, item, indexSignal, key) {
-	recordBenchEvent("rowFactory");
 	const vnode = scope.render(() => forState.renderFn(item, indexSignal));
-	materializeItemVnode(key, vnode);
+	materializeItemVnode(forState, key, vnode);
 	return vnode;
 }
 function disposeItemInstance(forState, itemInstance, domCleanup) {
-	recordBenchEvent("itemRemoved");
 	const removedDom = itemInstance.scope.dom;
+	const removedRange = itemInstance.scope.range;
+	const transaction = forState._transaction;
+	if (transaction) {
+		(transaction.removedScopes ??= []).push(itemInstance.scope);
+		if (removedDom) forState.lastRemovedNodes.push(removedDom);
+		if (removedRange) forState.lastRemovedRanges.push(removedRange);
+		return;
+	}
 	try {
 		disposeChildScope(itemInstance.scope);
 	} catch (err) {
@@ -48,27 +135,25 @@ function disposeItemInstance(forState, itemInstance, domCleanup) {
 		if (domCleanup === "teardown") getRuntimeRenderer().teardownNodeSubtree(removedDom);
 	}
 	forState.lastRemovedNodes.push(removedDom);
+	if (removedRange) forState.lastRemovedRanges.push(removedRange);
 }
 function createItemInstance(key, item, index, forState) {
-	recordBenchEvent("itemCreated");
 	const indexSignal = createForIndexSignal(index);
-	const itemSignal = canProxyForItem(item) ? createForItemSignal(item) : null;
-	const itemPropertySignals = itemSignal ? /* @__PURE__ */ new Map() : null;
-	const reactiveItem = itemSignal && itemPropertySignals ? createReactiveForItem(itemSignal, itemPropertySignals) : item;
-	const scope = createChildScope(forState.parentInstance, key, () => {
-		if (forState._enqueueBoundaryCommit) {
-			forState._enqueueBoundaryCommit();
-			return;
-		}
-		enqueueForScopeUpdate(forState.parentInstance);
-	});
-	renderItemScope(forState, scope, reactiveItem, indexSignal, key);
+	const reactiveItemState = canProxyForItem(item) ? createReactiveForItem(item) : null;
+	const reactiveItem = reactiveItemState?.proxy ?? item;
+	const scope = createForOwnedChildScope(forState, key);
+	scope.blueprintOwner = forState;
+	try {
+		renderItemScope(forState, scope, reactiveItem, indexSignal, key);
+	} catch (error) {
+		disposeChildScope(scope);
+		throw error;
+	}
 	return {
 		key,
 		item,
 		reactiveItem,
-		itemSignal,
-		itemPropertySignals,
+		reactiveItemState,
 		indexSignal,
 		scope
 	};
@@ -78,16 +163,19 @@ function rerenderItemInstance(forState, itemInstance, item) {
 }
 function updateItemInstance(forState, itemInstance, item) {
 	if (itemInstance.item === item) return false;
+	captureForItemTransactionSnapshot(forState, itemInstance);
 	const previousItem = itemInstance.item;
 	itemInstance.item = item;
 	const scope = itemInstance.scope;
 	let scopeReadsChangedSignal = false;
-	const itemSignal = itemInstance.itemSignal;
-	if (!itemSignal) {
+	const reactiveItemState = itemInstance.reactiveItemState;
+	if (!reactiveItemState) {
 		rerenderItemInstance(forState, itemInstance, item);
 		return true;
 	}
-	const propertySignals = itemInstance.itemPropertySignals;
+	const itemSignal = reactiveItemState.itemSignal;
+	reactiveItemState.currentItem = item;
+	const propertySignals = reactiveItemState.propertySignals;
 	const changedPropertySignals = [];
 	if (propertySignals && propertySignals.size > 0) for (const [prop, propertySignal] of propertySignals) {
 		const previousValue = readForItemProperty(previousItem, prop);
@@ -96,17 +184,35 @@ function updateItemInstance(forState, itemInstance, item) {
 		if (scopeReadsSource(scope, propertySignal)) scopeReadsChangedSignal = true;
 		changedPropertySignals.push([propertySignal, nextValue]);
 	}
-	if (scopeReadsSource(scope, itemSignal)) scopeReadsChangedSignal = true;
-	const itemShapeChanged = changedPropertySignals.length === 0 && !haveSameOwnKeys(previousItem, item);
-	const notifyReaders = !scopeReadsChangedSignal && (changedPropertySignals.length > 0 || itemShapeChanged);
-	const visibleChange = scopeReadsChangedSignal || changedPropertySignals.length > 0 || itemShapeChanged;
-	for (const [propertySignal, nextValue] of changedPropertySignals) {
+	if (itemSignal && scopeReadsSource(scope, itemSignal)) scopeReadsChangedSignal = true;
+	let coalescedPropertyChanged = false;
+	const coalescedProperties = reactiveItemState.coalescedProperties;
+	if (coalescedProperties !== null) if (Array.isArray(coalescedProperties)) {
+		for (const property of coalescedProperties) if (!Object.is(readForItemProperty(previousItem, property), readForItemProperty(item, property))) {
+			coalescedPropertyChanged = true;
+			break;
+		}
+	} else {
+		coalescedPropertyChanged = !Object.is(readForItemProperty(previousItem, coalescedProperties), readForItemProperty(item, coalescedProperties));
+		const secondProperty = reactiveItemState.coalescedProperty2;
+		if (secondProperty !== null && !coalescedPropertyChanged) coalescedPropertyChanged = !Object.is(readForItemProperty(previousItem, secondProperty), readForItemProperty(item, secondProperty));
+	}
+	const wholeItemChanged = itemSignal?._hasBeenRead === true && (reactiveItemState.wholeItemRead || coalescedPropertyChanged);
+	const itemShapeChanged = !wholeItemChanged && changedPropertySignals.length === 0 && !haveSameOwnKeys(previousItem, item);
+	const notifyReaders = !scopeReadsChangedSignal && (changedPropertySignals.length > 0 || itemShapeChanged || wholeItemChanged);
+	const visibleChange = scopeReadsChangedSignal || changedPropertySignals.length > 0 || itemShapeChanged || wholeItemChanged;
+	for (const [propertySignal, nextValue] of changedPropertySignals) if (stageForSignalEffect(forState, propertySignal, notifyReaders, null, itemInstance.scope.componentInstance)) propertySignal.set(nextValue, false);
+	else {
 		removeForParentReaders(forState.parentInstance, propertySignal);
 		propertySignal.set(nextValue, notifyReaders);
 	}
-	removeForParentReaders(forState.parentInstance, itemSignal);
-	itemSignal.set(item, notifyReaders);
-	if (scopeReadsChangedSignal) rerenderItemInstance(forState, itemInstance, itemInstance.reactiveItem);
+	if (itemSignal && stageForSignalEffect(forState, itemSignal, notifyReaders, null, itemInstance.scope.componentInstance)) itemSignal.set(item, false);
+	else if (itemSignal) {
+		removeForParentReaders(forState.parentInstance, itemSignal);
+		itemSignal.set(item, notifyReaders);
+	}
+	if (scopeReadsChangedSignal) if (itemSignal !== null && scopeDirectlyReadsSource(scope, itemSignal) || changedPropertySignals.some(([propertySignal]) => scopeDirectlyReadsSource(scope, propertySignal))) rerenderItemInstance(forState, itemInstance, itemInstance.reactiveItem);
+	else scope.markDirty();
 	return visibleChange;
 }
 const FOR_FALLBACK_SCOPE_KEY = "__for-fallback__";
@@ -114,13 +220,19 @@ function disposeFallbackScope(forState, domCleanup) {
 	const fallbackScope = forState.fallbackScope;
 	if (!fallbackScope) return;
 	const removedDom = fallbackScope.dom;
-	disposeChildScope(fallbackScope);
+	const removedRange = fallbackScope.range;
+	const transaction = forState._transaction;
+	if (transaction) {
+		(transaction.removedScopes ??= []).push(fallbackScope);
+		if (removedRange) forState.lastRemovedRanges.push(removedRange);
+	} else disposeChildScope(fallbackScope);
 	forState.fallbackScope = null;
 	if (!removedDom) return;
 	if (removedDom instanceof Element) {
 		if (domCleanup === "teardown") getRuntimeRenderer().teardownNodeSubtree(removedDom);
 	}
 	forState.lastRemovedNodes.push(removedDom);
+	if (removedRange) forState.lastRemovedRanges.push(removedRange);
 }
 function renderFallbackScope(forState) {
 	if (forState.fallback == null || forState.fallback === false) {
@@ -129,21 +241,31 @@ function renderFallbackScope(forState) {
 		forState.orderedItems = [];
 		return [];
 	}
-	const fallbackScope = forState.fallbackScope ?? createChildScope(forState.parentInstance, FOR_FALLBACK_SCOPE_KEY, () => {
-		if (forState._enqueueBoundaryCommit) {
-			forState._enqueueBoundaryCommit();
-			return;
-		}
-		enqueueForScopeUpdate(forState.parentInstance);
-	});
+	const fallbackScope = forState.fallbackScope ?? createForOwnedChildScope(forState, FOR_FALLBACK_SCOPE_KEY);
+	if (!forState.fallbackScope) forStatesByScope.set(fallbackScope, forState);
 	forState.fallbackScope = fallbackScope;
-	const vnode = fallbackScope.render(() => forState.fallback);
+	captureForFallbackTransactionSnapshot(forState, fallbackScope);
+	const fallbackVNode = forState.fallback;
+	const vnode = fallbackScope.render(() => fallbackVNode);
 	forState.orderedVNodes = vnode == null || vnode === false ? [] : [vnode];
 	forState.orderedItems = [];
 	return forState.orderedVNodes;
 }
 function disposeAllItems(forState, domCleanup) {
 	const { items, orderedKeys } = forState;
+	if (forState._transaction?.collectionSnapshotMode === "preserve-clear") {
+		const transaction = forState._transaction;
+		transaction.removeAllItems = true;
+		for (let index = 0; index < forState.orderedItems.length; index++) {
+			const removedDom = forState.orderedItems[index]?.scope.dom;
+			if (removedDom) forState.lastRemovedNodes.push(removedDom);
+			const range = forState.orderedItems[index]?.scope.range;
+			if (range) forState.lastRemovedRanges.push(range);
+		}
+		forState.items = /* @__PURE__ */ new Map();
+		forState.orderedKeys = [];
+		return;
+	}
 	for (let index = 0; index < orderedKeys.length; index += 1) {
 		const key = orderedKeys[index];
 		const itemInstance = items.get(key);
@@ -155,6 +277,4 @@ function disposeAllItems(forState, domCleanup) {
 	forState.orderedKeys = orderedKeys;
 }
 //#endregion
-export { createItemInstance, disposeAllItems, disposeFallbackScope, disposeItemInstance, renderFallbackScope, syncForItemIndex, updateItemInstance };
-
-//# sourceMappingURL=for-scopes.js.map
+export { captureForFallbackTransactionSnapshot, captureForItemTransactionSnapshot, createItemInstance, disposeAllItems, disposeFallbackScope, disposeItemInstance, renderFallbackScope, syncForItemIndex, updateItemInstance };

package/dist/runtime/for-signals.d.ts

@@ -15,16 +15,25 @@ type ForIndexSignal = ReadableSource<number> & (() => number) & {
   peek(): number;
   set(newValue: number | ((prev: number) => number), notifyReaders?: boolean): void;
 };
-declare function notifyForSignalReaders(source: ReadableSource<unknown>, skipInstance?: ComponentInstance | null): void;
+declare function notifyForSignalReaders(source: ReadableSource<unknown>, skipInstance?: ComponentInstance | null, skipOwnedBy?: ComponentInstance | null): void;
 declare function createForIndexSignal(initialIndex: number): ForIndexSignal;
 declare function syncForIndexSignal(indexSignal: ForIndexSignal, nextIndex: number): boolean;
 declare function createForItemSignal<T>(initialItem: T): ForItemSignal<T>;
 declare function readForItemProperty(item: unknown, prop: PropertyKey): unknown;
 declare function haveSameOwnKeys(previousItem: unknown, nextItem: unknown): boolean;
 declare function scopeReadsSource(scope: ChildScope, source: ReadableSource<unknown>): boolean;
+declare function scopeDirectlyReadsSource(scope: ChildScope, source: ReadableSource<unknown>): boolean;
 declare function removeForParentReaders(parentInstance: ComponentInstance | null, source: ReadableSource<unknown>): void;
 declare function canProxyForItem(item: unknown): item is object;
-declare function createReactiveForItem<T>(itemSignal: ForItemSignal<T>, propertySignals: Map<PropertyKey, ForItemPropertySignal>): T;
+interface ReactiveForItemState<T> {
+  currentItem: T;
+  itemSignal: ForItemSignal<T> | null;
+  propertySignals: Map<PropertyKey, ForItemPropertySignal> | null;
+  coalescedProperties: PropertyKey | PropertyKey[] | null;
+  coalescedProperty2: PropertyKey | null;
+  wholeItemRead: boolean;
+  proxy: T;
+}
+declare function createReactiveForItem<T>(item: T): ReactiveForItemState<T>;
 //#endregion
-export { ForIndexSignal, ForItemPropertySignal, ForItemSignal };
-//# sourceMappingURL=for-signals.d.ts.map
+export { ForIndexSignal, ForItemPropertySignal, ForItemSignal, ReactiveForItemState };