@askrjs/askr 0.0.28 → 0.0.30

package/dist/runtime/for.js

@@ -1 +1,668 @@
-import{getCurrentInstance as b,createComponentInstance as w,setCurrentComponentInstance as g,getCurrentStateIndex as T,finalizeReadSubscriptions as M,setStateIndex as F,cleanupComponent as B}from"./component.js";import{ELEMENT_TYPE as L}from"../common/jsx.js";import{teardownNodeSubtree as K}from"../renderer/cleanup.js";const y=globalThis,s={itemsCreated:0,itemsReused:0,itemsRemoved:0,itemsMoved:0,rowFactoryInvocations:0,keyLookups:0,keyHits:0,keyMisses:0,domInserts:0,domRemoves:0,domMoves:0,domAttrSets:0,domTextSets:0,reconcilePhaseMs:0,domCommitPhaseMs:0,fastLaneName:null};function P(){y.__ASKR_BENCH__&&(s.itemsCreated=0,s.itemsReused=0,s.itemsRemoved=0,s.itemsMoved=0,s.rowFactoryInvocations=0,s.keyLookups=0,s.keyHits=0,s.keyMisses=0,s.domInserts=0,s.domRemoves=0,s.domMoves=0,s.domAttrSets=0,s.domTextSets=0,s.reconcilePhaseMs=0,s.domCommitPhaseMs=0,s.fastLaneName=null)}function _(o){if(y.__ASKR_BENCH__)switch(o){case"itemCreated":s.itemsCreated++;break;case"itemReused":s.itemsReused++;break;case"itemRemoved":s.itemsRemoved++;break;case"itemMoved":s.itemsMoved++;break;case"rowFactory":s.rowFactoryInvocations++;break;case"keyLookup":s.keyLookups++;break;case"keyHit":s.keyHits++;break;case"keyMiss":s.keyMisses++;break;case"domInsert":s.domInserts++;break;case"domRemove":s.domRemoves++;break;case"domMove":s.domMoves++;break;case"domAttrSet":s.domAttrSets++;break;case"domTextSet":s.domTextSets++;break}}function S(o){y.__ASKR_BENCH__&&(s.fastLaneName=o)}function x(o,n){y.__ASKR_BENCH__&&(o==="reconcile"?s.reconcilePhaseMs=n:s.domCommitPhaseMs=n)}function $(){return{...s}}function E(o){if(o&&typeof o=="object"&&"$$typeof"in o&&o.$$typeof===L){const n=o;if(typeof n.type=="function"){const l=n.type,a=l(n.props||{});return E(a)}return n}return o}function O(o,n,l){const a=typeof o=="function"?null:o,f=b();return{sourceState:a,items:new Map,orderedKeys:[],byFn:n,renderFn:l,parentInstance:f,mounted:!1}}let N=1;function H(o,n,l,a){_("itemCreated");let f=l;const u=Object.assign(()=>f,{set(e){const t=typeof e=="function"?e(f):e;t!==f&&(f=t)}});u[Symbol.iterator]=function*(){yield u,yield u.set};const p=()=>null,c=w(`for-item-${o}`,p,{},null);a.parentInstance&&(c.ownerFrame=a.parentInstance.ownerFrame);const h=b();g(c);const R=T();c._currentRenderToken=N++,c._pendingReadSources=new Set,_("rowFactory");const k=E(a.renderFn(n,()=>u()));if(k&&typeof k=="object"&&"type"in k){const e=k;e.key=o,typeof e.type=="string"&&(e.props||(e.props={}),e.props["data-key"]===void 0&&(e.props["data-key"]=String(o)))}M(c),g(h);const m={key:o,item:n,indexSignal:u,componentInstance:c,vnode:k,_startStateIndex:R};return c._pendingFlushTask=()=>{const e=b();g(c),c.stateIndexCheck=-1;const t=c.stateValues;for(let d=0;d<t.length;d++){const i=t[d];i&&(i._hasBeenRead=!1)}F(R),c._currentRenderToken=N++,c._pendingReadSources=new Set;try{const d=E(a.renderFn(n,()=>u()));m.vnode=d,M(c)}finally{g(e)}const r=a.parentInstance;r&&r._enqueueRun?.()},m}function I(o,n,l){const a=n.componentInstance,f=b(),u=T();g(a),a.stateIndexCheck=-1;const p=a.stateValues;for(let c=0;c<p.length;c++){const h=p[c];h&&(h._hasBeenRead=!1)}F(n._startStateIndex),a._currentRenderToken=N++,a._pendingReadSources=new Set;try{_("rowFactory"),n.vnode=E(o.renderFn(l,()=>n.indexSignal()));try{n.vnode&&typeof n.vnode=="object"&&"type"in n.vnode&&(n.vnode.key=n.key)}catch(c){}M(a)}finally{F(u),g(f)}}function A(o,n){y.__ASKR_BENCH__&&P();const l=y.__ASKR_BENCH__?performance.now():0,{items:a,orderedKeys:f,byFn:u}=o,p=f.length,c=n.length;if(p<=c){let m=!0;for(let e=0;e<p;e++)if(u(n[e],e)!==f[e]){m=!1;break}if(m){S("APPEND");const e=[];for(let t=0;t<p;t++){const r=n[t],d=f[t],i=a.get(d);_("itemReused");const v=i.item!==r,C=i.indexSignal()!==t;v&&(i.item=r,I(o,i,r)),C&&i.indexSignal.set(t),e.push(i.vnode)}for(let t=p;t<c;t++){const r=n[t],d=u(r,t),i=H(d,r,t,o);a.set(d,i),e.push(i.vnode),f[t]=d}return y.__ASKR_BENCH__&&x("reconcile",performance.now()-l),e}}if(c<=p){let m=!0;for(let e=0;e<c;e++)if(u(n[e],e)!==f[e]){m=!1;break}if(m){S("TRUNCATE");const e=[];for(let t=0;t<c;t++){const r=n[t],d=f[t],i=a.get(d);_("itemReused");const v=i.item!==r,C=i.indexSignal()!==t;v&&(i.item=r,I(o,i,r)),C&&i.indexSignal.set(t),e.push(i.vnode)}for(let t=c;t<p;t++){const r=f[t],d=a.get(r);if(d){_("itemRemoved");const i=d.componentInstance;try{B(i)}catch{}d._dom instanceof Element&&K(d._dom),d.vnode=void 0,d._dom=void 0,a.delete(r)}}return f.length=c,o.orderedKeys=f,y.__ASKR_BENCH__&&x("reconcile",performance.now()-l),e}}if(p===c){let m=!0;for(let e=0;e<p;e++)if(u(n[e],e)!==f[e]){m=!1;break}if(m){S("NO_REORDER");const e=[];for(let t=0;t<p;t++){const r=n[t],d=f[t],i=a.get(d);_("itemReused");const v=i.item!==r,C=i.indexSignal()!==t;v&&(i.item=r,I(o,i,r)),C&&i.indexSignal.set(t),e.push(i.vnode)}return y.__ASKR_BENCH__&&x("reconcile",performance.now()-l),e}}S("FULL_KEYED");const h=new Set(f),R=[],k=[];for(let m=0;m<n.length;m++){const e=n[m],t=u(e,m);_("keyLookup"),h.delete(t),R.push(t);const r=a.get(t);if(_(r?"keyHit":"keyMiss"),r){_("itemReused");const d=r.item!==e,i=r.indexSignal()!==m;d&&(r.item=e,I(o,r,e)),i&&r.indexSignal.set(m),k.push(r.vnode)}else{const d=H(t,e,m,o);a.set(t,d),k.push(d.vnode)}}for(const m of h){const e=a.get(m);if(e){_("itemRemoved");const t=e.componentInstance;try{B(t)}catch{}e._dom instanceof Element&&K(e._dom),e.vnode=void 0,e._dom=void 0,a.delete(m)}}return o.orderedKeys=R,y.__ASKR_BENCH__&&x("reconcile",performance.now()-l),k}function D(o,n){const l=n();if(!Array.isArray(l))throw new Error("For source must evaluate to an array");return A(o,l)}export{O as createForState,H as createItemInstance,D as evaluateForState,$ as getBenchMetrics,A as reconcileForItems};
+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: [],
+		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) => {
+		const nextValue = typeof newValue === "function" ? newValue(indexValue) : newValue;
+		if (nextValue !== indexValue) {
+			indexValue = nextValue;
+			markReadableDerivedSubscribersDirty(indexSignal);
+			markReactivePropsDirtySource(indexSignal);
+			notifyReadableReaders(indexSignal);
+		}
+	};
+	indexSignal._hasBeenRead = false;
+	return indexSignal;
+}
+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;
+		markReadableDerivedSubscribersDirty(itemSignal);
+		markReactivePropsDirtySource(itemSignal);
+		if (notifyReaders) 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;
+		markReadableDerivedSubscribersDirty(propertySignal);
+		markReactivePropsDirtySource(propertySignal);
+		if (notifyReaders) notifyReadableReaders(propertySignal);
+	};
+	propertySignal._hasBeenRead = false;
+	return propertySignal;
+}
+function readForItemProperty(item, prop) {
+	return Reflect.get(Object(item), prop);
+}
+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)();
+			return Reflect.get(Object(currentItem), prop, receiver);
+		},
+		has(target, prop) {
+			return prop in target || prop in Object(itemSignal.peek());
+		},
+		ownKeys(target) {
+			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) {
+			const ownDescriptor = Reflect.getOwnPropertyDescriptor(target, prop);
+			if (ownDescriptor) return ownDescriptor;
+			return Object.getOwnPropertyDescriptor(Object(itemSignal.peek()), prop);
+		},
+		getPrototypeOf() {
+			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;
+	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);
+	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 itemSignal = itemInstance.itemSignal;
+	if (!itemSignal) {
+		rerenderItemInstance(forState, itemInstance, item);
+		return true;
+	}
+	let hasPropertyRenderReaders = false;
+	const propertySignals = itemInstance.itemPropertySignals;
+	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;
+		const propertyHasRenderReaders = (propertySignal._readers?.size ?? 0) > 0;
+		if (propertyHasRenderReaders) hasPropertyRenderReaders = true;
+		propertySignal.set(nextValue, !propertyHasRenderReaders);
+	}
+	const hasRenderReaders = (itemSignal._readers?.size ?? 0) > 0;
+	itemSignal.set(item, hasRenderReaders);
+	if (!hasRenderReaders && !hasPropertyRenderReaders) return false;
+	rerenderItemInstance(forState, itemInstance, itemInstance.reactiveItem);
+	return true;
+}
+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 = [];
+		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];
+	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;
+			resultVNodes.length = newLen;
+			for (let i = 0; i < oldLen; i++) {
+				const item = newArray[i];
+				const key = orderedKeys[i];
+				const existing = items.get(key);
+				recordBenchEvent("itemReused");
+				updateItemInstance(forState, existing, item);
+				resultVNodes[i] = existing.scope.vnode;
+			}
+			for (let i = oldLen; i < newLen; i++) {
+				const item = newArray[i];
+				const key = byFn(item, i);
+				const itemInstance = createItemInstance(key, item, i, forState);
+				items.set(key, itemInstance);
+				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 resultVNodes = forState.orderedVNodes;
+					resultVNodes.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);
+						recordBenchEvent("itemReused");
+						const itemChanged = existing.item !== item;
+						const needsDomUpdate = existing.scope.needsDomUpdate;
+						const indexChanged = existing.indexSignal.peek() !== i;
+						if (itemChanged) updateItemInstance(forState, existing, item);
+						if (indexChanged && existing.indexSignal._hasBeenRead) existing.indexSignal.set(i);
+						if (itemChanged || indexChanged || needsDomUpdate || existing.scope.needsDomUpdate) dirtyIndices.push(i);
+						resultVNodes[i] = existing.scope.vnode;
+					}
+					const removedKey = orderedKeys[removedIndex];
+					const removedItem = items.get(removedKey);
+					if (removedItem) {
+						disposeItemInstance(forState, removedItem, "teardown");
+						items.delete(removedKey);
+					}
+					const nextOrderedKeys = orderedKeys.slice(0, newLen);
+					for (let i = removedIndex; i < newLen; i++) nextOrderedKeys[i] = orderedKeys[i + 1];
+					forState.orderedKeys = nextOrderedKeys;
+					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;
+			resultVNodes.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);
+				recordBenchEvent("itemReused");
+				updateItemInstance(forState, existing, item);
+				resultVNodes[i] = existing.scope.vnode;
+			}
+			for (let i = newLen; i < oldLen; i++) {
+				const key = orderedKeys[i];
+				const itemInstance = items.get(key);
+				if (itemInstance) {
+					disposeItemInstance(forState, itemInstance, isFullClear ? "full-clear" : "teardown");
+					items.delete(key);
+				}
+			}
+			orderedKeys.length = newLen;
+			forState.orderedKeys = orderedKeys;
+			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;
+			resultVNodes.length = oldLen;
+			const dirtyIndices = [];
+			for (let i = 0; i < oldLen; i++) {
+				const item = newArray[i];
+				const key = orderedKeys[i];
+				const existing = items.get(key);
+				recordBenchEvent("itemReused");
+				const itemChanged = existing.item !== item;
+				const needsDomUpdate = existing.scope.needsDomUpdate;
+				let rerendered = false;
+				if (itemChanged) rerendered = updateItemInstance(forState, existing, item);
+				if (rerendered || needsDomUpdate || existing.scope.needsDomUpdate) dirtyIndices.push(i);
+				resultVNodes[i] = existing.scope.vnode;
+			}
+			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];
+			recordBenchEvent("itemReused");
+			recordBenchEvent("itemReused");
+			if (firstExisting.item !== firstItem) updateItemInstance(forState, firstExisting, firstItem);
+			if (secondExisting.item !== secondItem) updateItemInstance(forState, secondExisting, secondItem);
+			if (firstExisting.indexSignal._hasBeenRead && firstExisting.indexSignal.peek() !== firstMismatch) firstExisting.indexSignal.set(firstMismatch);
+			if (secondExisting.indexSignal._hasBeenRead && secondExisting.indexSignal.peek() !== secondMismatch) secondExisting.indexSignal.set(secondMismatch);
+			resultVNodes[firstMismatch] = firstExisting.scope.vnode;
+			resultVNodes[secondMismatch] = secondExisting.scope.vnode;
+			forState.orderedKeys = nextOrderedKeys;
+			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 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;
+			moveOnlyVNodes[i] = existing.scope.vnode;
+			recordBenchEvent("itemReused");
+		}
+		if (canUseMoveOnlyPath) {
+			recordBenchFastLane("FULL_KEYED");
+			forState.lastCommitStrategy = "FULL_KEYED";
+			forState.orderedKeys = moveOnlyKeys;
+			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 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);
+			resultVNodes.push(itemInstance.scope.vnode);
+		} else {
+			recordBenchEvent("itemReused");
+			const itemChanged = existing.item !== item;
+			const indexChanged = existing.indexSignal._hasBeenRead && existing.indexSignal.peek() !== i;
+			if (itemChanged) {
+				moveOnly = false;
+				updateItemInstance(forState, existing, item);
+			}
+			if (indexChanged) existing.indexSignal.set(i);
+			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;
+	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) {
+	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;
+}
+//#endregion
+export { clearForDomUpdateState, evaluateForState, useForState };
+
+//# sourceMappingURL=for.js.map