@askrjs/askr 0.0.48 → 0.0.50

package/dist/runtime/for.js

@@ -1,773 +1,5 @@
-import { isDevelopmentEnvironment } from "../common/env.js";
-import { markReactivePropsDirtySource, markReadableDerivedSubscribersDirty, notifyReadableReaders, recordReadableRead } from "./readable.js";
-import { claimHookIndex, getCurrentInstance } from "./component.js";
-import { teardownNodeSubtree } from "../renderer/cleanup.js";
-import { createChildScope, disposeChildScope } from "./child-scope.js";
-import { flushBenchMetrics, isBenchBuildEnabled, recordBenchEvent, recordBenchFastLane, recordBenchTiming, resetBenchMetrics } from "./for-bench.js";
-//#region src/runtime/for.ts
-/**
-* For primitive runtime
-*
-* Manages per-item component instances and array reconciliation
-* to eliminate over-invalidation in list rendering.
-*/
-const BENCH_BUILD_ENABLED = isBenchBuildEnabled();
-const forStates = /* @__PURE__ */ new WeakMap();
-function getForStore(instance) {
-	let store = forStates.get(instance);
-	if (!store) {
-		store = /* @__PURE__ */ new Map();
-		forStates.set(instance, store);
-	}
-	return store;
-}
-function createForState(eachSource, byFn, renderFn, fallback) {
-	const parentInstance = getCurrentInstance();
-	return {
-		kind: "for",
-		currentItems: [],
-		eachSource,
-		fallback,
-		fallbackScope: null,
-		items: /* @__PURE__ */ new Map(),
-		orderedKeys: [],
-		orderedItems: [],
-		orderedVNodes: [],
-		byFn,
-		renderFn,
-		parentInstance,
-		lastCommitStrategy: "NO_REORDER",
-		lastRemovedNodes: [],
-		pendingDirtyIndices: null,
-		pendingSwapIndices: null,
-		pendingMoveOnly: false,
-		_hasResolvedItemDom: false,
-		_needsSourceReconcile: false,
-		_sourceEffect: null,
-		_suspendSourceCommit: false,
-		_enqueueBoundaryCommit: null,
-		_hasPendingBoundaryCommit: false
-	};
-}
-function useForState(eachSource, byFn, renderFn, fallback) {
-	const instance = getCurrentInstance();
-	if (!instance) throw new Error("For can only be created during component render execution.");
-	const hookIndex = claimHookIndex(instance, "For");
-	const store = getForStore(instance);
-	const existing = store.get(hookIndex);
-	if (existing) {
-		existing.eachSource = eachSource;
-		existing.byFn = byFn;
-		existing.renderFn = renderFn;
-		existing.fallback = fallback;
-		return existing;
-	}
-	const created = createForState(eachSource, byFn, renderFn, fallback);
-	store.set(hookIndex, created);
-	(instance.cleanupFns ??= []).push(() => {
-		created._sourceEffect?.cleanup();
-		created._sourceEffect = null;
-		store.delete(hookIndex);
-	});
-	return created;
-}
-function createForIndexSignal(initialIndex) {
-	let indexValue = initialIndex;
-	const readers = /* @__PURE__ */ new Map();
-	const indexSignal = (() => {
-		indexSignal._hasBeenRead = true;
-		recordReadableRead(indexSignal);
-		return indexValue;
-	});
-	indexSignal._readers = readers;
-	indexSignal.peek = () => indexValue;
-	indexSignal.set = (newValue, notifyReaders = true) => {
-		const nextValue = typeof newValue === "function" ? newValue(indexValue) : newValue;
-		if (nextValue !== indexValue) {
-			indexValue = nextValue;
-			if (notifyReaders) {
-				markReadableDerivedSubscribersDirty(indexSignal);
-				markReactivePropsDirtySource(indexSignal);
-				notifyReadableReaders(indexSignal);
-			}
-		}
-	};
-	indexSignal._hasBeenRead = false;
-	return indexSignal;
-}
-function syncForIndexSignal(indexSignal, nextIndex) {
-	if (indexSignal.peek() === nextIndex) return false;
-	indexSignal.set(nextIndex, indexSignal._hasBeenRead);
-	return indexSignal._hasBeenRead === true;
-}
-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);
-	markReadableDerivedSubscribersDirty(indexSignal);
-	markReactivePropsDirtySource(indexSignal);
-	notifyReadableReaders(indexSignal, itemInstance.scope.componentInstance);
-	rerenderItemInstance(forState, itemInstance, itemInstance.reactiveItem);
-	return true;
-}
-function createForItemSignal(initialItem) {
-	let itemValue = initialItem;
-	const readers = /* @__PURE__ */ new Map();
-	const itemSignal = (() => {
-		itemSignal._hasBeenRead = true;
-		recordReadableRead(itemSignal);
-		return itemValue;
-	});
-	itemSignal._readers = readers;
-	itemSignal.peek = () => itemValue;
-	itemSignal.set = (newValue, notifyReaders = true) => {
-		if (Object.is(itemValue, newValue)) return;
-		itemValue = newValue;
-		if (notifyReaders) {
-			markReadableDerivedSubscribersDirty(itemSignal);
-			markReactivePropsDirtySource(itemSignal);
-			notifyReadableReaders(itemSignal);
-		}
-	};
-	itemSignal._hasBeenRead = false;
-	return itemSignal;
-}
-function createForItemPropertySignal(initialValue) {
-	let propertyValue = initialValue;
-	const readers = /* @__PURE__ */ new Map();
-	const propertySignal = (() => {
-		propertySignal._hasBeenRead = true;
-		recordReadableRead(propertySignal);
-		return propertyValue;
-	});
-	propertySignal._readers = readers;
-	propertySignal.peek = () => propertyValue;
-	propertySignal.set = (newValue, notifyReaders = true) => {
-		if (Object.is(propertyValue, newValue)) return;
-		propertyValue = newValue;
-		if (notifyReaders) {
-			markReadableDerivedSubscribersDirty(propertySignal);
-			markReactivePropsDirtySource(propertySignal);
-			notifyReadableReaders(propertySignal);
-		}
-	};
-	propertySignal._hasBeenRead = false;
-	return propertySignal;
-}
-function readForItemProperty(item, prop) {
-	return Reflect.get(Object(item), prop);
-}
-function haveSameOwnKeys(previousItem, nextItem) {
-	const previousKeys = Reflect.ownKeys(Object(previousItem));
-	const nextKeys = Reflect.ownKeys(Object(nextItem));
-	if (previousKeys.length !== nextKeys.length) return false;
-	for (let i = 0; i < previousKeys.length; i += 1) if (previousKeys[i] !== nextKeys[i]) return false;
-	return true;
-}
-function scopeReadsSource(scope, source) {
-	return source._readers?.has(scope.componentInstance) ?? false;
-}
-function isForParentReader(forState, reader) {
-	let current = forState.parentInstance;
-	while (current) {
-		if (current === reader) return true;
-		current = current.parentInstance;
-	}
-	return false;
-}
-function removeForParentReaders(forState, source) {
-	const readers = source._readers;
-	if (!readers || readers.size === 0) return;
-	for (const reader of readers.keys()) if (isForParentReader(forState, reader)) readers.delete(reader);
-}
-function getOrCreateForItemPropertySignal(item, propertySignals, prop) {
-	const existingSignal = propertySignals.get(prop);
-	if (existingSignal) return existingSignal;
-	const propertySignal = createForItemPropertySignal(readForItemProperty(item, prop));
-	propertySignals.set(prop, propertySignal);
-	return propertySignal;
-}
-function canProxyForItem(item) {
-	return typeof item === "object" && item !== null || typeof item === "function";
-}
-function createReactiveForItem(itemSignal, propertySignals) {
-	return new Proxy(Object.create(null), {
-		get(target, prop, receiver) {
-			if (Reflect.getOwnPropertyDescriptor(target, prop)) return Reflect.get(target, prop, receiver);
-			const currentItem = itemSignal.peek();
-			if (typeof prop !== "symbol") return getOrCreateForItemPropertySignal(currentItem, propertySignals, prop)();
-			recordReadableRead(itemSignal);
-			return Reflect.get(Object(currentItem), prop, receiver);
-		},
-		has(target, prop) {
-			recordReadableRead(itemSignal);
-			return prop in target || prop in Object(itemSignal.peek());
-		},
-		ownKeys(target) {
-			recordReadableRead(itemSignal);
-			const keys = new Set(Reflect.ownKeys(target));
-			for (const key of Reflect.ownKeys(Object(itemSignal.peek()))) keys.add(key);
-			return Array.from(keys);
-		},
-		getOwnPropertyDescriptor(target, prop) {
-			recordReadableRead(itemSignal);
-			const ownDescriptor = Reflect.getOwnPropertyDescriptor(target, prop);
-			if (ownDescriptor) return ownDescriptor;
-			return Object.getOwnPropertyDescriptor(Object(itemSignal.peek()), prop);
-		},
-		getPrototypeOf() {
-			recordReadableRead(itemSignal);
-			return Object.getPrototypeOf(Object(itemSignal.peek()));
-		}
-	});
-}
-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 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 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") 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;
-	let itemInstance = null;
-	const scope = createChildScope(forState.parentInstance, key, () => {
-		if (forState._enqueueBoundaryCommit) {
-			forState._enqueueBoundaryCommit();
-			return;
-		}
-		const parent = forState.parentInstance;
-		if (parent) parent._enqueueRun?.();
-	});
-	renderItemScope(forState, scope, reactiveItem, indexSignal, key);
-	itemInstance = {
-		key,
-		item,
-		reactiveItem,
-		itemSignal,
-		itemPropertySignals,
-		indexSignal,
-		scope
-	};
-	return itemInstance;
-}
-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, propertySignal);
-		propertySignal.set(nextValue, notifyReaders);
-	}
-	removeForParentReaders(forState, 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") 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;
-		}
-		forState.parentInstance?._enqueueRun?.();
-	});
-	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;
-}
-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;
-}
-function evaluateForState(forState) {
-	if (!Array.isArray(forState.currentItems)) throw new Error("For source must evaluate to an array");
-	forState._needsSourceReconcile = false;
-	return reconcileForItems(forState, forState.currentItems);
-}
-function clearForDomUpdateState(forState) {
-	const dirtyIndices = forState.pendingDirtyIndices;
-	if (dirtyIndices && dirtyIndices.length > 0) for (let i = 0; i < dirtyIndices.length; i++) {
-		const itemInstance = forState.orderedItems[dirtyIndices[i]];
-		if (itemInstance) itemInstance.scope.needsDomUpdate = false;
-	}
-	else for (let i = 0; i < forState.orderedKeys.length; i++) {
-		const key = forState.orderedKeys[i];
-		const itemInstance = forState.items.get(key);
-		if (itemInstance) itemInstance.scope.needsDomUpdate = false;
-	}
-	if (forState.fallbackScope) forState.fallbackScope.needsDomUpdate = false;
-	forState.lastRemovedNodes = [];
-	forState.pendingDirtyIndices = null;
-	forState.pendingSwapIndices = null;
-	forState.pendingMoveOnly = false;
-	forState._needsSourceReconcile = false;
-	forState._hasResolvedItemDom = forState.orderedKeys.length > 0;
-}
-//#endregion
-export { clearForDomUpdateState, evaluateForState, useForState };
-
-//# sourceMappingURL=for.js.map
+import { isBenchMetricScopeActive, recordBenchCounter, recordBenchEvent, recordBenchTiming, withBenchMetricScope } from "./for-bench.js";
+import "./for-scopes.js";
+import { reconcileForItems } from "./for-reconcile.js";
+import { clearForDomUpdateState, createForState, evaluateForState, useForState } from "./for-internal.js";
+export { clearForDomUpdateState, createForState, evaluateForState, isBenchMetricScopeActive, reconcileForItems, recordBenchCounter, recordBenchEvent, recordBenchTiming, useForState, withBenchMetricScope };