@askrjs/askr 0.0.48 → 0.0.49

package/dist/runtime/for-reconcile.js

@@ -0,0 +1,389 @@
+import { isDevelopmentEnvironment } from "../common/env.js";
+import { flushBenchMetrics, isBenchBuildEnabled, recordBenchEvent, recordBenchFastLane, recordBenchTiming, resetBenchMetrics } from "./for-bench.js";
+import { createItemInstance, disposeAllItems, disposeFallbackScope, disposeItemInstance, renderFallbackScope, syncForItemIndex, updateItemInstance } from "./for-scopes.js";
+//#region src/runtime/for-reconcile.ts
+const BENCH_BUILD_ENABLED = isBenchBuildEnabled();
+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 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);
+	}
+	forState.devKeyKinds = keyKinds;
+}
+function reconcileForItems(forState, newArray) {
+	forState.currentItems = newArray;
+	validateForKeys(forState, newArray);
+	if (BENCH_BUILD_ENABLED) resetBenchMetrics();
+	const reconcileStartMs = BENCH_BUILD_ENABLED ? performance.now() : 0;
+	const { items, orderedKeys, byFn } = forState;
+	const oldLen = orderedKeys.length;
+	const newLen = newArray.length;
+	forState.lastRemovedNodes = [];
+	if (newLen === 0) {
+		if (oldLen > 0) disposeAllItems(forState, forState.fallback ? "teardown" : "none");
+		recordBenchFastLane("TRUNCATE");
+		forState.lastCommitStrategy = "TRUNCATE";
+		forState.pendingDirtyIndices = null;
+		forState.pendingSwapIndices = null;
+		forState.pendingMoveOnly = false;
+		if (BENCH_BUILD_ENABLED) {
+			recordBenchTiming("reconcile", performance.now() - reconcileStartMs);
+			flushBenchMetrics();
+		}
+		return renderFallbackScope(forState);
+	}
+	if (forState.fallbackScope) disposeFallbackScope(forState, "none");
+	if (oldLen < newLen) {
+		let canUseAppendPath = true;
+		for (let i = 0; i < oldLen; i++) if (byFn(newArray[i], i) !== orderedKeys[i]) {
+			canUseAppendPath = false;
+			break;
+		}
+		if (canUseAppendPath) {
+			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++) {
+				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;
+			}
+			recordBenchEvent("itemReused", oldLen);
+			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 (BENCH_BUILD_ENABLED) {
+				recordBenchTiming("reconcile", performance.now() - reconcileStartMs);
+				flushBenchMetrics();
+			}
+			forState.orderedVNodes = resultVNodes;
+			forState.pendingDirtyIndices = null;
+			forState.pendingSwapIndices = null;
+			forState.pendingMoveOnly = false;
+			return resultVNodes;
+		}
+	}
+	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) {
+					recordBenchFastLane("REMOVE_ONE");
+					forState.lastCommitStrategy = "NO_REORDER";
+					const previousOrderedItems = forState.orderedItems.slice();
+					const resultVNodes = forState.orderedVNodes;
+					const resultItems = forState.orderedItems;
+					resultVNodes.length = newLen;
+					resultItems.length = newLen;
+					const dirtyIndices = [];
+					for (let i = 0; i < newLen; i++) {
+						const item = newArray[i];
+						const key = i < removedIndex ? orderedKeys[i] : orderedKeys[i + 1];
+						const existing = items.get(key);
+						const scopeNeedsDomUpdate = existing.scope.needsDomUpdate;
+						const itemChanged = existing.item !== item;
+						const indexChanged = existing.indexSignal.peek() !== i;
+						if (itemChanged) updateItemInstance(forState, existing, item);
+						const indexVisibleChange = indexChanged ? syncForItemIndex(forState, existing, i) : false;
+						if (itemChanged || indexVisibleChange || scopeNeedsDomUpdate) dirtyIndices.push(i);
+						resultItems[i] = existing;
+						resultVNodes[i] = existing.scope.vnode;
+					}
+					recordBenchEvent("itemReused", newLen);
+					const removedKey = orderedKeys[removedIndex];
+					const removedItem = items.get(removedKey);
+					if (removedItem) {
+						disposeItemInstance(forState, removedItem, "teardown");
+						items.delete(removedKey);
+					}
+					const nextOrderedKeys = orderedKeys.slice(0, newLen);
+					const nextOrderedItems = previousOrderedItems.slice(0, newLen);
+					for (let i = removedIndex; i < newLen; i++) {
+						nextOrderedKeys[i] = orderedKeys[i + 1];
+						nextOrderedItems[i] = previousOrderedItems[i + 1];
+					}
+					forState.orderedKeys = nextOrderedKeys;
+					forState.orderedItems = nextOrderedItems;
+					if (BENCH_BUILD_ENABLED) {
+						recordBenchTiming("reconcile", performance.now() - reconcileStartMs);
+						flushBenchMetrics();
+					}
+					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) {
+			recordBenchFastLane("TRUNCATE");
+			forState.lastCommitStrategy = "TRUNCATE";
+			const resultVNodes = forState.orderedVNodes;
+			const resultItems = forState.orderedItems;
+			resultVNodes.length = newLen;
+			resultItems.length = newLen;
+			const isFullClear = newLen === 0;
+			for (let i = 0; i < newLen; i++) {
+				const item = newArray[i];
+				const key = orderedKeys[i];
+				const existing = items.get(key);
+				updateItemInstance(forState, existing, item);
+				resultItems[i] = existing;
+				resultVNodes[i] = existing.scope.vnode;
+			}
+			recordBenchEvent("itemReused", newLen);
+			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;
+			if (BENCH_BUILD_ENABLED) {
+				recordBenchTiming("reconcile", performance.now() - reconcileStartMs);
+				flushBenchMetrics();
+			}
+			forState.orderedVNodes = resultVNodes;
+			forState.pendingDirtyIndices = null;
+			forState.pendingSwapIndices = null;
+			forState.pendingMoveOnly = false;
+			return resultVNodes;
+		}
+	}
+	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) {
+			recordBenchFastLane("NO_REORDER");
+			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);
+				const itemChanged = existing.item !== item;
+				if (itemChanged) updateItemInstance(forState, existing, item);
+				if (!itemChanged && existing.scope.needsDomUpdate) dirtyIndices.push(i);
+				resultItems[i] = existing;
+				resultVNodes[i] = existing.scope.vnode;
+			}
+			recordBenchEvent("itemReused", oldLen);
+			if (BENCH_BUILD_ENABLED) {
+				recordBenchTiming("reconcile", performance.now() - reconcileStartMs);
+				flushBenchMetrics();
+			}
+			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) {
+					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]) {
+			recordBenchFastLane("SWAP");
+			recordBenchEvent("itemMoved");
+			recordBenchEvent("itemMoved");
+			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] = secondExisting;
+			nextOrderedItems[secondMismatch] = firstExisting;
+			recordBenchEvent("itemReused");
+			recordBenchEvent("itemReused");
+			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;
+			if (BENCH_BUILD_ENABLED) {
+				recordBenchTiming("reconcile", performance.now() - reconcileStartMs);
+				flushBenchMetrics();
+			}
+			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;
+			recordBenchEvent("itemReused");
+		}
+		if (canUseMoveOnlyPath) {
+			recordBenchFastLane("FULL_KEYED");
+			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;
+			if (BENCH_BUILD_ENABLED) {
+				recordBenchTiming("reconcile", performance.now() - reconcileStartMs);
+				flushBenchMetrics();
+			}
+			forState.pendingDirtyIndices = null;
+			forState.pendingSwapIndices = null;
+			forState.pendingMoveOnly = true;
+			return moveOnlyVNodes;
+		}
+	}
+	recordBenchFastLane("FULL_KEYED");
+	forState.lastCommitStrategy = "FULL_KEYED";
+	const toRemove = new Set(orderedKeys);
+	const newOrderedKeys = [];
+	const newOrderedItems = [];
+	const resultVNodes = [];
+	let moveOnly = toRemove.size === newArray.length;
+	for (let i = 0; i < newArray.length; i++) {
+		const item = newArray[i];
+		const key = byFn(item, i);
+		recordBenchEvent("keyLookup");
+		toRemove.delete(key);
+		newOrderedKeys.push(key);
+		const existing = items.get(key);
+		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");
+			const itemChanged = existing.item !== item;
+			const indexChanged = existing.indexSignal.peek() !== i;
+			if (itemChanged) {
+				moveOnly = false;
+				updateItemInstance(forState, existing, item);
+			}
+			if (indexChanged) syncForItemIndex(forState, existing, i);
+			newOrderedItems.push(existing);
+			resultVNodes.push(existing.scope.vnode);
+		}
+	}
+	for (const key of toRemove) {
+		moveOnly = false;
+		const itemInstance = items.get(key);
+		if (itemInstance) {
+			disposeItemInstance(forState, itemInstance, "none");
+			items.delete(key);
+		}
+	}
+	forState.orderedKeys = newOrderedKeys;
+	forState.orderedItems = newOrderedItems;
+	if (BENCH_BUILD_ENABLED) {
+		recordBenchTiming("reconcile", performance.now() - reconcileStartMs);
+		flushBenchMetrics();
+	}
+	forState.orderedVNodes = resultVNodes;
+	forState.pendingDirtyIndices = null;
+	forState.pendingSwapIndices = null;
+	forState.pendingMoveOnly = moveOnly;
+	return resultVNodes;
+}
+//#endregion
+export { reconcileForItems };
+
+//# sourceMappingURL=for-reconcile.js.map

package/dist/runtime/for-reconcile.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"for-reconcile.js","names":[],"sources":["../../src/runtime/for-reconcile.ts"],"sourcesContent":["/**\n * For key validation and reconciliation strategy ownership.\n */\n\nimport type { VNode } from '../common/vnode';\nimport { isDevelopmentEnvironment } from '../common/env';\nimport {\n  createItemInstance,\n  disposeAllItems,\n  disposeFallbackScope,\n  disposeItemInstance,\n  renderFallbackScope,\n  syncForItemIndex,\n  updateItemInstance,\n  type ForItemInstance,\n} from './for-scopes';\nimport {\n  flushBenchMetrics,\n  isBenchBuildEnabled,\n  recordBenchEvent,\n  recordBenchFastLane,\n  recordBenchTiming,\n  resetBenchMetrics,\n} from './for-bench';\nimport type { ForState } from './for-internal';\n\nconst BENCH_BUILD_ENABLED = isBenchBuildEnabled();\n\nfunction failForValidation(message: string): never {\n  throw new Error(message);\n}\n\nfunction validateForKeys<T>(forState: ForState<T>, newArray: T[]): void {\n  if (!isDevelopmentEnvironment()) {\n    return;\n  }\n\n  const seen = new Set<string | number>();\n  const keyKinds = new Map<string, 'number' | 'string'>();\n  for (let i = 0; i < newArray.length; i++) {\n    const key = forState.byFn(newArray[i], i);\n\n    if (key === null || key === undefined) {\n      failForValidation(\n        '[askr] Invalid For key detected. Keys should be stable, non-null, and unique within a For list.'\n      );\n    }\n\n    if (seen.has(key)) {\n      failForValidation(\n        `[askr] Duplicate For key detected: ${String(key)}. Keys should be stable, non-null, and unique within a For list.`\n      );\n    }\n\n    seen.add(key);\n\n    const keyString = String(key);\n    const keyKind = typeof key;\n    const previousKeyKind = forState.devKeyKinds?.get(keyString);\n    if (previousKeyKind && previousKeyKind !== keyKind) {\n      failForValidation(\n        `[askr] For key type changed for ${keyString}. Keys must remain consistently typed across renders.`\n      );\n    }\n    keyKinds.set(keyString, keyKind as 'number' | 'string');\n  }\n\n  forState.devKeyKinds = keyKinds;\n}\n\nexport function reconcileForItems<T>(\n  forState: ForState<T>,\n  newArray: T[]\n): VNode[] {\n  forState.currentItems = newArray;\n  validateForKeys(forState, newArray);\n\n  if (BENCH_BUILD_ENABLED) {\n    resetBenchMetrics();\n  }\n\n  const reconcileStartMs = BENCH_BUILD_ENABLED ? performance.now() : 0;\n\n  const { items, orderedKeys, byFn } = forState;\n  const oldLen = orderedKeys.length;\n  const newLen = newArray.length;\n  forState.lastRemovedNodes = [];\n\n  if (newLen === 0) {\n    if (oldLen > 0) {\n      disposeAllItems(forState, forState.fallback ? 'teardown' : 'none');\n    }\n    recordBenchFastLane('TRUNCATE');\n    forState.lastCommitStrategy = 'TRUNCATE';\n    forState.pendingDirtyIndices = null;\n    forState.pendingSwapIndices = null;\n    forState.pendingMoveOnly = false;\n\n    if (BENCH_BUILD_ENABLED) {\n      recordBenchTiming('reconcile', performance.now() - reconcileStartMs);\n      flushBenchMetrics();\n    }\n\n    return renderFallbackScope(forState);\n  }\n\n  if (forState.fallbackScope) {\n    disposeFallbackScope(forState, 'none');\n  }\n\n  // FAST PATH A: APPEND\n  // Guard: oldLen <= newLen && all old keys match new keys at same indices\n  if (oldLen < newLen) {\n    let canUseAppendPath = true;\n    for (let i = 0; i < oldLen; i++) {\n      const key = byFn(newArray[i], i);\n      if (key !== orderedKeys[i]) {\n        canUseAppendPath = false;\n        break;\n      }\n    }\n\n    if (canUseAppendPath) {\n      recordBenchFastLane('APPEND');\n      forState.lastCommitStrategy = 'APPEND';\n      const resultVNodes = forState.orderedVNodes;\n      const resultItems = forState.orderedItems;\n      resultVNodes.length = newLen;\n      resultItems.length = newLen;\n\n      // Update existing rows in-place\n      for (let i = 0; i < oldLen; i++) {\n        const item = newArray[i];\n        const key = orderedKeys[i];\n        const existing = resultItems[i] ?? items.get(key)!;\n\n        updateItemInstance(forState, existing, item);\n\n        resultItems[i] = existing;\n        resultVNodes[i] = existing.scope.vnode as VNode;\n      }\n\n      recordBenchEvent('itemReused', oldLen);\n\n      // Create and append new rows\n      for (let i = oldLen; i < newLen; i++) {\n        const item = newArray[i];\n        const key = byFn(item, i);\n        const itemInstance = createItemInstance(key, item, i, forState);\n        items.set(key, itemInstance);\n        resultItems[i] = itemInstance;\n        resultVNodes[i] = itemInstance.scope.vnode as VNode;\n        orderedKeys[i] = key;\n      }\n\n      if (BENCH_BUILD_ENABLED) {\n        recordBenchTiming('reconcile', performance.now() - reconcileStartMs);\n        flushBenchMetrics();\n      }\n\n      forState.orderedVNodes = resultVNodes;\n      forState.pendingDirtyIndices = null;\n      forState.pendingSwapIndices = null;\n      forState.pendingMoveOnly = false;\n\n      return resultVNodes;\n    }\n  }\n\n  // FAST PATH B: TRUNCATE\n  // Guard: newLen <= oldLen && all new keys match old keys at same indices\n  if (newLen < oldLen) {\n    if (oldLen === newLen + 1) {\n      let removedIndex = -1;\n\n      for (let i = 0; i < newLen; i++) {\n        const nextKey = byFn(newArray[i], i);\n        if (nextKey !== orderedKeys[i]) {\n          removedIndex = i;\n          break;\n        }\n      }\n\n      if (removedIndex !== -1) {\n        let canUseRemoveOnePath = true;\n        for (let i = removedIndex; i < newLen; i++) {\n          const nextKey = byFn(newArray[i], i);\n          if (nextKey !== orderedKeys[i + 1]) {\n            canUseRemoveOnePath = false;\n            break;\n          }\n        }\n\n        if (canUseRemoveOnePath) {\n          recordBenchFastLane('REMOVE_ONE');\n          forState.lastCommitStrategy = 'NO_REORDER';\n\n          const previousOrderedItems = forState.orderedItems.slice();\n          const resultVNodes = forState.orderedVNodes;\n          const resultItems = forState.orderedItems;\n          resultVNodes.length = newLen;\n          resultItems.length = newLen;\n          const dirtyIndices: number[] = [];\n\n          for (let i = 0; i < newLen; i++) {\n            const item = newArray[i];\n            const key = i < removedIndex ? orderedKeys[i] : orderedKeys[i + 1];\n            const existing = items.get(key)!;\n            const scopeNeedsDomUpdate = existing.scope.needsDomUpdate;\n\n            const itemChanged = existing.item !== item;\n            const indexSignal = existing.indexSignal;\n            const indexChanged = indexSignal.peek() !== i;\n\n            if (itemChanged) {\n              updateItemInstance(forState, existing, item);\n            }\n\n            const indexVisibleChange = indexChanged\n              ? syncForItemIndex(forState, existing, i)\n              : false;\n\n            if (itemChanged || indexVisibleChange || scopeNeedsDomUpdate) {\n              dirtyIndices.push(i);\n            }\n\n            resultItems[i] = existing;\n            resultVNodes[i] = existing.scope.vnode as VNode;\n          }\n\n          recordBenchEvent('itemReused', newLen);\n\n          const removedKey = orderedKeys[removedIndex];\n          const removedItem = items.get(removedKey);\n          if (removedItem) {\n            disposeItemInstance(forState, removedItem, 'teardown');\n            items.delete(removedKey);\n          }\n\n          const nextOrderedKeys = orderedKeys.slice(0, newLen);\n          const nextOrderedItems = previousOrderedItems.slice(0, newLen);\n          for (let i = removedIndex; i < newLen; i++) {\n            nextOrderedKeys[i] = orderedKeys[i + 1];\n            nextOrderedItems[i] = previousOrderedItems[i + 1];\n          }\n          forState.orderedKeys = nextOrderedKeys;\n          forState.orderedItems = nextOrderedItems;\n\n          if (BENCH_BUILD_ENABLED) {\n            recordBenchTiming(\n              'reconcile',\n              performance.now() - reconcileStartMs\n            );\n            flushBenchMetrics();\n          }\n\n          forState.pendingDirtyIndices = dirtyIndices;\n          forState.pendingSwapIndices = null;\n          forState.pendingMoveOnly = false;\n\n          return resultVNodes;\n        }\n      }\n    }\n\n    let canUseTruncatePath = true;\n    for (let i = 0; i < newLen; i++) {\n      const key = byFn(newArray[i], i);\n      if (key !== orderedKeys[i]) {\n        canUseTruncatePath = false;\n        break;\n      }\n    }\n\n    if (canUseTruncatePath) {\n      recordBenchFastLane('TRUNCATE');\n      forState.lastCommitStrategy = 'TRUNCATE';\n      const resultVNodes = forState.orderedVNodes;\n      const resultItems = forState.orderedItems;\n      resultVNodes.length = newLen;\n      resultItems.length = newLen;\n      const isFullClear = newLen === 0;\n\n      // Update existing rows in-place\n      for (let i = 0; i < newLen; i++) {\n        const item = newArray[i];\n        const key = orderedKeys[i];\n        const existing = items.get(key)!;\n\n        updateItemInstance(forState, existing, item);\n\n        resultItems[i] = existing;\n        resultVNodes[i] = existing.scope.vnode as VNode;\n      }\n\n      recordBenchEvent('itemReused', newLen);\n\n      // Remove tail rows\n      for (let i = newLen; i < oldLen; i++) {\n        const key = orderedKeys[i];\n        const itemInstance = items.get(key);\n        if (itemInstance) {\n          disposeItemInstance(\n            forState,\n            itemInstance,\n            isFullClear ? 'full-clear' : 'teardown'\n          );\n          items.delete(key);\n        }\n      }\n\n      orderedKeys.length = newLen;\n      forState.orderedKeys = orderedKeys;\n      forState.orderedItems.length = newLen;\n\n      if (BENCH_BUILD_ENABLED) {\n        recordBenchTiming('reconcile', performance.now() - reconcileStartMs);\n        flushBenchMetrics();\n      }\n\n      forState.orderedVNodes = resultVNodes;\n      forState.pendingDirtyIndices = null;\n      forState.pendingSwapIndices = null;\n      forState.pendingMoveOnly = false;\n\n      return resultVNodes;\n    }\n  }\n\n  // FAST PATH C: NO-REORDER (in-place update only)\n  // Guard: oldLen === newLen && keys match at all indices\n  if (oldLen === newLen) {\n    let canUseNoReorderPath = true;\n    for (let i = 0; i < oldLen; i++) {\n      const key = byFn(newArray[i], i);\n      if (key !== orderedKeys[i]) {\n        canUseNoReorderPath = false;\n        break;\n      }\n    }\n\n    if (canUseNoReorderPath) {\n      recordBenchFastLane('NO_REORDER');\n      forState.lastCommitStrategy = 'NO_REORDER';\n      const resultVNodes = forState.orderedVNodes;\n      const resultItems = forState.orderedItems;\n      resultVNodes.length = oldLen;\n      resultItems.length = oldLen;\n      const dirtyIndices: number[] = [];\n      // Update in-place only, no DOM moves needed\n      for (let i = 0; i < oldLen; i++) {\n        const item = newArray[i];\n        const key = orderedKeys[i];\n        const existing = items.get(key)!;\n        const itemChanged = existing.item !== item;\n\n        if (itemChanged) {\n          updateItemInstance(forState, existing, item);\n        }\n\n        if (!itemChanged && existing.scope.needsDomUpdate) {\n          dirtyIndices.push(i);\n        }\n\n        resultItems[i] = existing;\n        resultVNodes[i] = existing.scope.vnode as VNode;\n      }\n\n      recordBenchEvent('itemReused', oldLen);\n\n      if (BENCH_BUILD_ENABLED) {\n        recordBenchTiming('reconcile', performance.now() - reconcileStartMs);\n        flushBenchMetrics();\n      }\n\n      forState.pendingDirtyIndices = dirtyIndices;\n      forState.pendingSwapIndices = null;\n      forState.pendingMoveOnly = false;\n\n      return resultVNodes;\n    }\n\n    let firstMismatch = -1;\n    let secondMismatch = -1;\n    let firstMismatchKey: string | number | null = null;\n    let secondMismatchKey: string | number | null = null;\n    let mismatchCount = 0;\n    let canUseSwapPath = true;\n\n    for (let i = 0; i < oldLen; i++) {\n      const item = newArray[i];\n      const key = byFn(newArray[i], i);\n      if (key === orderedKeys[i]) {\n        const existing = items.get(key);\n        if (existing && existing.item !== item) {\n          canUseSwapPath = false;\n          break;\n        }\n        continue;\n      }\n\n      mismatchCount++;\n      if (firstMismatch === -1) {\n        firstMismatch = i;\n        firstMismatchKey = key;\n        continue;\n      }\n\n      if (secondMismatch === -1) {\n        secondMismatch = i;\n        secondMismatchKey = key;\n        continue;\n      }\n\n      mismatchCount = 3;\n      break;\n    }\n\n    if (\n      canUseSwapPath &&\n      mismatchCount === 2 &&\n      firstMismatch !== -1 &&\n      secondMismatch !== -1 &&\n      firstMismatchKey === orderedKeys[secondMismatch] &&\n      secondMismatchKey === orderedKeys[firstMismatch]\n    ) {\n      recordBenchFastLane('SWAP');\n      recordBenchEvent('itemMoved');\n      recordBenchEvent('itemMoved');\n\n      forState.lastCommitStrategy = 'SWAP';\n\n      const nextOrderedKeys = orderedKeys.slice();\n      nextOrderedKeys[firstMismatch] = firstMismatchKey;\n      nextOrderedKeys[secondMismatch] = secondMismatchKey;\n\n      const resultVNodes = forState.orderedVNodes;\n      const firstExisting = items.get(firstMismatchKey)!;\n      const secondExisting = items.get(secondMismatchKey)!;\n      const firstItem = newArray[firstMismatch];\n      const secondItem = newArray[secondMismatch];\n      const nextOrderedItems = forState.orderedItems.slice();\n      nextOrderedItems[firstMismatch] = secondExisting;\n      nextOrderedItems[secondMismatch] = firstExisting;\n\n      recordBenchEvent('itemReused');\n      recordBenchEvent('itemReused');\n\n      if (firstExisting.item !== firstItem) {\n        updateItemInstance(forState, firstExisting, firstItem);\n      }\n\n      if (secondExisting.item !== secondItem) {\n        updateItemInstance(forState, secondExisting, secondItem);\n      }\n\n      syncForItemIndex(forState, firstExisting, firstMismatch);\n\n      syncForItemIndex(forState, secondExisting, secondMismatch);\n\n      resultVNodes[firstMismatch] = firstExisting.scope.vnode as VNode;\n      resultVNodes[secondMismatch] = secondExisting.scope.vnode as VNode;\n\n      forState.orderedKeys = nextOrderedKeys;\n      forState.orderedItems = nextOrderedItems;\n\n      if (BENCH_BUILD_ENABLED) {\n        recordBenchTiming('reconcile', performance.now() - reconcileStartMs);\n        flushBenchMetrics();\n      }\n\n      forState.pendingDirtyIndices = null;\n      forState.pendingSwapIndices = [firstMismatch, secondMismatch];\n      forState.pendingMoveOnly = true;\n\n      return resultVNodes;\n    }\n\n    let canUseMoveOnlyPath = true;\n    const moveOnlyKeys: Array<string | number> = [];\n    const moveOnlyItems: ForItemInstance<T>[] = [];\n    const moveOnlyVNodes: VNode[] = [];\n\n    for (let i = 0; i < oldLen; i++) {\n      const item = newArray[i];\n      const key = byFn(item, i);\n      const existing = items.get(key);\n\n      if (\n        !existing ||\n        existing.item !== item ||\n        (existing.indexSignal._hasBeenRead && existing.indexSignal.peek() !== i)\n      ) {\n        canUseMoveOnlyPath = false;\n        break;\n      }\n\n      moveOnlyKeys[i] = key;\n      moveOnlyItems[i] = existing;\n      moveOnlyVNodes[i] = existing.scope.vnode as VNode;\n      recordBenchEvent('itemReused');\n    }\n\n    if (canUseMoveOnlyPath) {\n      recordBenchFastLane('FULL_KEYED');\n      forState.lastCommitStrategy = 'FULL_KEYED';\n\n      for (let i = 0; i < moveOnlyItems.length; i++) {\n        syncForItemIndex(forState, moveOnlyItems[i], i);\n        moveOnlyVNodes[i] = moveOnlyItems[i].scope.vnode as VNode;\n      }\n\n      forState.orderedKeys = moveOnlyKeys;\n      forState.orderedItems = moveOnlyItems;\n      forState.orderedVNodes = moveOnlyVNodes;\n\n      if (BENCH_BUILD_ENABLED) {\n        recordBenchTiming('reconcile', performance.now() - reconcileStartMs);\n        flushBenchMetrics();\n      }\n\n      forState.pendingDirtyIndices = null;\n      forState.pendingSwapIndices = null;\n      forState.pendingMoveOnly = true;\n\n      return moveOnlyVNodes;\n    }\n  }\n\n  // FULL KEYED RECONCILIATION (slow path for complex reorders)\n  // Avoid allocating newKeyMap: iterate directly and track removals\n  recordBenchFastLane('FULL_KEYED');\n  forState.lastCommitStrategy = 'FULL_KEYED';\n\n  const toRemove = new Set(orderedKeys);\n  const newOrderedKeys: Array<string | number> = [];\n  const newOrderedItems: ForItemInstance<T>[] = [];\n  const resultVNodes: VNode[] = [];\n  let moveOnly = toRemove.size === newArray.length;\n\n  // Single pass: iterate new array directly, no intermediate map\n  for (let i = 0; i < newArray.length; i++) {\n    const item = newArray[i];\n    const key = byFn(item, i);\n    recordBenchEvent('keyLookup');\n\n    toRemove.delete(key);\n    newOrderedKeys.push(key);\n\n    const existing = items.get(key);\n    recordBenchEvent(existing ? 'keyHit' : 'keyMiss');\n\n    if (!existing) {\n      // Added: create new item instance\n      const itemInstance = createItemInstance(key, item, i, forState);\n      items.set(key, itemInstance);\n      newOrderedItems.push(itemInstance);\n      resultVNodes.push(itemInstance.scope.vnode as VNode);\n    } else {\n      // Exists: check if item changed (by identity)\n      recordBenchEvent('itemReused');\n      const itemChanged = existing.item !== item;\n      const indexChanged = existing.indexSignal.peek() !== i;\n\n      if (itemChanged) {\n        moveOnly = false;\n        updateItemInstance(forState, existing, item);\n      }\n\n      if (indexChanged) {\n        // Index changed: update index signal (triggers re-render if index is used)\n        syncForItemIndex(forState, existing, i);\n      }\n\n      newOrderedItems.push(existing);\n      resultVNodes.push(existing.scope.vnode as VNode);\n    }\n  }\n\n  // Remove deleted items\n  for (const key of toRemove) {\n    moveOnly = false;\n    const itemInstance = items.get(key);\n    if (itemInstance) {\n      disposeItemInstance(forState, itemInstance, 'none');\n      items.delete(key);\n    }\n  }\n\n  forState.orderedKeys = newOrderedKeys;\n  forState.orderedItems = newOrderedItems;\n\n  // Record reconcile timing\n  if (BENCH_BUILD_ENABLED) {\n    recordBenchTiming('reconcile', performance.now() - reconcileStartMs);\n    flushBenchMetrics();\n  }\n\n  forState.orderedVNodes = resultVNodes;\n  forState.pendingDirtyIndices = null;\n  forState.pendingSwapIndices = null;\n  forState.pendingMoveOnly = moveOnly;\n\n  return resultVNodes;\n}\n"],"mappings":"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"}

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

@@ -0,0 +1,26 @@
+import { ChildScope } from "./child-scope.js";
+import { ForIndexSignal, ForItemPropertySignal, ForItemSignal } from "./for-signals.js";
+import { ForState } from "./for-internal.js";
+import { VNode } from "../common/vnode.js";
+
+//#region src/runtime/for-scopes.d.ts
+interface ForItemInstance<T> {
+  key: string | number;
+  item: T;
+  reactiveItem: T;
+  itemSignal: ForItemSignal<T> | null;
+  itemPropertySignals: Map<PropertyKey, ForItemPropertySignal> | null;
+  indexSignal: ForIndexSignal;
+  scope: ChildScope;
+}
+type RemovedDomCleanupMode = 'none' | 'teardown' | 'full-clear';
+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>;
+declare function updateItemInstance<T>(forState: ForState<T>, itemInstance: ForItemInstance<T>, item: T): boolean;
+declare function disposeFallbackScope<T>(forState: ForState<T>, domCleanup: RemovedDomCleanupMode): void;
+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

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

@@ -0,0 +1 @@
+{"version":3,"file":"for-scopes.d.ts","names":[],"sources":["../../src/runtime/for-scopes.ts"],"mappings":";;;;;;UA+BiB,eAAA;EACf,GAAA;EACA,IAAA,EAAM,CAAA;EACN,YAAA,EAAc,CAAA;EACd,UAAA,EAAY,aAAA,CAAc,CAAA;EAC1B,mBAAA,EAAqB,GAAA,CAAI,WAAA,EAAa,qBAAA;EACtC,WAAA,EAAa,cAAA;EACb,KAAA,EAAO,UAAA;AAAA;AAAA,KAGG,qBAAA;AAAA,iBAMI,gBAAA,IACd,QAAA,EAAU,QAAA,CAAS,CAAA,GACnB,YAAA,EAAc,eAAA,CAAgB,CAAA,GAC9B,SAAA;AAAA,iBAmDc,mBAAA,IACd,QAAA,EAAU,QAAA,CAAS,CAAA,GACnB,YAAA,EAAc,eAAA,CAAgB,CAAA,GAC9B,UAAA,EAAY,qBAAA;AAAA,iBA0BE,kBAAA,IACd,GAAA,mBACA,IAAA,EAAM,CAAA,EACN,KAAA,UACA,QAAA,EAAU,QAAA,CAAS,CAAA,IAClB,eAAA,CAAgB,CAAA;AAAA,iBAkDH,kBAAA,IACd,QAAA,EAAU,QAAA,CAAS,CAAA,GACnB,YAAA,EAAc,eAAA,CAAgB,CAAA,GAC9B,IAAA,EAAM,CAAA;AAAA,iBAgEQ,oBAAA,IACd,QAAA,EAAU,QAAA,CAAS,CAAA,GACnB,UAAA,EAAY,qBAAA;AAAA,iBAwBE,mBAAA,IAAuB,QAAA,EAAU,QAAA,CAAS,CAAA,IAAK,KAAA;AAAA,iBA4B/C,eAAA,IACd,QAAA,EAAU,QAAA,CAAS,CAAA,GACnB,UAAA,EAAY,qBAAA"}

package/dist/runtime/for-scopes.js

@@ -0,0 +1,160 @@
+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
+function enqueueForScopeUpdate(parent) {
+	parent?._enqueueRun?.();
+}
+function syncForItemIndex(forState, itemInstance, nextIndex) {
+	const indexSignal = itemInstance.indexSignal;
+	if (indexSignal.peek() === nextIndex) return false;
+	if (!scopeReadsSource(itemInstance.scope, indexSignal)) {
+		syncForIndexSignal(indexSignal, nextIndex);
+		return false;
+	}
+	indexSignal.set(nextIndex, false);
+	notifyForSignalReaders(indexSignal, itemInstance.scope.componentInstance);
+	rerenderItemInstance(forState, itemInstance, itemInstance.reactiveItem);
+	return true;
+}
+function materializeItemVnode(key, vnode) {
+	if (vnode && typeof vnode === "object" && "type" in vnode) {
+		const vn = vnode;
+		vn.key = key;
+		if (typeof vn.type === "string") {
+			if (!vn.props) vn.props = {};
+			if (vn.props["data-key"] === void 0) vn.props["data-key"] = String(key);
+		}
+	}
+}
+function renderItemScope(forState, scope, item, indexSignal, key) {
+	recordBenchEvent("rowFactory");
+	const vnode = scope.render(() => forState.renderFn(item, indexSignal));
+	materializeItemVnode(key, vnode);
+	return vnode;
+}
+function disposeItemInstance(forState, itemInstance, domCleanup) {
+	recordBenchEvent("itemRemoved");
+	const removedDom = itemInstance.scope.dom;
+	try {
+		disposeChildScope(itemInstance.scope);
+	} catch (err) {
+		if (isDevelopmentEnvironment()) console.error("[For] Cleanup error:", err);
+	}
+	if (!removedDom) return;
+	if (removedDom instanceof Element) {
+		if (domCleanup === "teardown") getRuntimeRenderer().teardownNodeSubtree(removedDom);
+	}
+	forState.lastRemovedNodes.push(removedDom);
+}
+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);
+	return {
+		key,
+		item,
+		reactiveItem,
+		itemSignal,
+		itemPropertySignals,
+		indexSignal,
+		scope
+	};
+}
+function rerenderItemInstance(forState, itemInstance, item) {
+	renderItemScope(forState, itemInstance.scope, item, itemInstance.indexSignal, itemInstance.key);
+}
+function updateItemInstance(forState, itemInstance, item) {
+	if (itemInstance.item === item) return false;
+	const previousItem = itemInstance.item;
+	itemInstance.item = item;
+	const scope = itemInstance.scope;
+	let scopeReadsChangedSignal = false;
+	const itemSignal = itemInstance.itemSignal;
+	if (!itemSignal) {
+		rerenderItemInstance(forState, itemInstance, item);
+		return true;
+	}
+	const propertySignals = itemInstance.itemPropertySignals;
+	const changedPropertySignals = [];
+	if (propertySignals && propertySignals.size > 0) for (const [prop, propertySignal] of propertySignals) {
+		const previousValue = readForItemProperty(previousItem, prop);
+		const nextValue = readForItemProperty(item, prop);
+		if (Object.is(previousValue, nextValue)) continue;
+		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) {
+		removeForParentReaders(forState.parentInstance, propertySignal);
+		propertySignal.set(nextValue, notifyReaders);
+	}
+	removeForParentReaders(forState.parentInstance, itemSignal);
+	itemSignal.set(item, notifyReaders);
+	if (scopeReadsChangedSignal) rerenderItemInstance(forState, itemInstance, itemInstance.reactiveItem);
+	return visibleChange;
+}
+const FOR_FALLBACK_SCOPE_KEY = "__for-fallback__";
+function disposeFallbackScope(forState, domCleanup) {
+	const fallbackScope = forState.fallbackScope;
+	if (!fallbackScope) return;
+	const removedDom = fallbackScope.dom;
+	disposeChildScope(fallbackScope);
+	forState.fallbackScope = null;
+	if (!removedDom) return;
+	if (removedDom instanceof Element) {
+		if (domCleanup === "teardown") getRuntimeRenderer().teardownNodeSubtree(removedDom);
+	}
+	forState.lastRemovedNodes.push(removedDom);
+}
+function renderFallbackScope(forState) {
+	if (forState.fallback == null || forState.fallback === false) {
+		if (forState.fallbackScope) disposeFallbackScope(forState, "none");
+		forState.orderedVNodes = [];
+		forState.orderedItems = [];
+		return [];
+	}
+	const fallbackScope = forState.fallbackScope ?? createChildScope(forState.parentInstance, FOR_FALLBACK_SCOPE_KEY, () => {
+		if (forState._enqueueBoundaryCommit) {
+			forState._enqueueBoundaryCommit();
+			return;
+		}
+		enqueueForScopeUpdate(forState.parentInstance);
+	});
+	forState.fallbackScope = fallbackScope;
+	const vnode = fallbackScope.render(() => forState.fallback);
+	forState.orderedVNodes = vnode == null || vnode === false ? [] : [vnode];
+	forState.orderedItems = [];
+	return forState.orderedVNodes;
+}
+function disposeAllItems(forState, domCleanup) {
+	const { items, orderedKeys } = forState;
+	for (let index = 0; index < orderedKeys.length; index += 1) {
+		const key = orderedKeys[index];
+		const itemInstance = items.get(key);
+		if (!itemInstance) continue;
+		disposeItemInstance(forState, itemInstance, domCleanup);
+		items.delete(key);
+	}
+	orderedKeys.length = 0;
+	forState.orderedKeys = orderedKeys;
+}
+//#endregion
+export { createItemInstance, disposeAllItems, disposeFallbackScope, disposeItemInstance, renderFallbackScope, syncForItemIndex, updateItemInstance };
+
+//# sourceMappingURL=for-scopes.js.map