@askrjs/askr 0.0.52 → 0.0.54

package/dist/for-internal-CSz8Unkq.js

@@ -0,0 +1,1563 @@
+import { r as _isDOMElement } from "./vnode-CGMJYPMB.js";
+import { b as isDevelopmentEnvironment, o as getRuntimeRenderer, v as logger } from "./access-Bg4RJNC8.js";
+import { f as notifyReadableReaders, l as markReactivePropsDirtySource, m as shouldCoalesceFineGrainedItemReads, p as recordReadableRead, u as markReadableDerivedSubscribersDirty } from "./fastlane-Dw8SOBr9.js";
+import { n as createComponentInstance, s as renderScopedComponent } from "./component-internal-D9PLuFUc.js";
+import { h as getCurrentStateIndex, i as claimHookIndex, o as clearRenderTracking, p as getCurrentInstance } from "./component-scope-CC3cojX9.js";
+import { _ as registerOwnedChildScope, c as finalizeInlineReadSubscriptions, f as registerLifecycleTransaction, h as cleanupComponent, v as unregisterOwnedChildScope } from "./component-lifecycle-C7lnU9Bt.js";
+//#region src/runtime/child-scope.ts
+const EMPTY_CHILD_SCOPE_PROPS = {};
+const childScopesByInstance = /* @__PURE__ */ new WeakMap();
+function executeChildScopeComponent() {
+	const instance = getCurrentInstance();
+	const scope = instance ? childScopesByInstance.get(instance) : void 0;
+	if (!scope?._renderFn) return null;
+	return scope._renderFn();
+}
+function ensureChildScopeFlushTask(scope) {
+	const instance = scope.componentInstance;
+	if (instance._pendingFlushTask) return;
+	instance._pendingFlushTask = () => {
+		instance.hasPendingUpdate = false;
+		if (instance.notifyUpdate === null || scope._disposed) return;
+		renderScope(scope);
+		scope._onDirty?.();
+	};
+}
+var ChildScopeImpl = class {
+	constructor(parent, key, onDirty, ownership) {
+		this.previousVnode = void 0;
+		this.vnode = void 0;
+		this.dom = void 0;
+		this.range = void 0;
+		this.needsDomUpdate = true;
+		this.hydrationPending = true;
+		this.blueprintOwner = void 0;
+		this._renderFn = void 0;
+		this._disposed = false;
+		this.key = key;
+		this._parent = parent;
+		this._onDirty = onDirty;
+		this._ownership = ownership;
+		this._startStateIndex = getCurrentStateIndex();
+		this.componentInstance = createComponentInstance("child-scope", executeChildScopeComponent, EMPTY_CHILD_SCOPE_PROPS, null);
+		childScopesByInstance.set(this.componentInstance, this);
+		if (parent) {
+			this.componentInstance.parentInstance = parent;
+			this.componentInstance.ownerFrame = parent.ownerFrame;
+			this.componentInstance.portalScope = parent.portalScope;
+			if (ownership) ownership.add(this);
+			else registerOwnedChildScope(parent, this);
+		}
+	}
+	markDirty() {
+		this.needsDomUpdate = true;
+	}
+	render(renderFn) {
+		this._renderFn = renderFn;
+		return renderScope(this);
+	}
+	dispose() {
+		if (this._disposed) return;
+		this._disposed = true;
+		if (this._parent) if (this._ownership) this._ownership.delete(this);
+		else unregisterOwnedChildScope(this._parent, this);
+		childScopesByInstance.delete(this.componentInstance);
+		cleanupComponent(this.componentInstance);
+		this._renderFn = void 0;
+		this.previousVnode = void 0;
+		this.vnode = void 0;
+		this.dom = void 0;
+		this.range = void 0;
+		this.needsDomUpdate = false;
+		this.hydrationPending = false;
+		this.blueprintOwner = void 0;
+		this.componentInstance.hasPendingUpdate = false;
+	}
+};
+function renderScope(scope) {
+	if (scope._disposed) {
+		if (isDevelopmentEnvironment()) throw new Error(`[askr] Attempted to render disposed child scope ${String(scope.key)}.`);
+		return scope.vnode;
+	}
+	if (!scope._renderFn) return scope.vnode;
+	const { componentInstance } = scope;
+	const previousVNode = scope.vnode;
+	try {
+		const nextVNode = renderScopedComponent(componentInstance, scope._startStateIndex, scope._renderFn);
+		if (previousVNode && nextVNode && _isDOMElement(previousVNode) && _isDOMElement(nextVNode) && typeof previousVNode.type === "function" && previousVNode.type === nextVNode.type && "__instance" in previousVNode && !("__instance" in nextVNode)) nextVNode.__instance = previousVNode.__instance;
+		scope.previousVnode = previousVNode;
+		scope.vnode = nextVNode;
+		scope.markDirty();
+		if ((componentInstance._pendingReadSources?.size ?? 0) > 0) ensureChildScopeFlushTask(scope);
+		finalizeInlineReadSubscriptions(componentInstance, componentInstance._currentRenderToken, componentInstance._pendingReadSources, componentInstance._pendingReadSourceVersions);
+		clearRenderTracking(componentInstance);
+		return scope.vnode;
+	} catch (error) {
+		componentInstance.hasPendingUpdate = false;
+		throw error;
+	}
+}
+function rerenderChildScope(scope) {
+	return renderScope(scope);
+}
+/** @internal */
+function captureChildScopeTransactionSnapshot(scope) {
+	const mutableScope = scope;
+	return {
+		previousVnode: scope.previousVnode,
+		vnode: scope.vnode,
+		dom: scope.dom,
+		range: scope.range,
+		domTextData: scope.dom?.nodeType === 3 ? scope.dom.data : void 0,
+		needsDomUpdate: scope.needsDomUpdate,
+		hydrationPending: scope.hydrationPending,
+		renderFn: mutableScope._renderFn
+	};
+}
+/** @internal */
+function restoreChildScopeTransactionSnapshot(scope, snapshot) {
+	const mutableScope = scope;
+	scope.previousVnode = snapshot.previousVnode;
+	scope.vnode = snapshot.vnode;
+	scope.dom = snapshot.dom;
+	scope.range = snapshot.range;
+	if (snapshot.domTextData !== void 0 && snapshot.dom?.nodeType === 3) snapshot.dom.data = snapshot.domTextData;
+	scope.needsDomUpdate = snapshot.needsDomUpdate;
+	scope.hydrationPending = snapshot.hydrationPending;
+	mutableScope._renderFn = snapshot.renderFn;
+}
+function disposeChildScope(scope) {
+	scope.dispose();
+}
+function createChildScope(parent, key, onDirty, ownership) {
+	return new ChildScopeImpl(parent, key, onDirty, ownership);
+}
+//#endregion
+//#region src/runtime/control.ts
+const SHOW_TRUTHY_KEY = "__show-truthy__";
+const SHOW_FALLBACK_KEY = "__show-fallback__";
+const CASE_FALLBACK_KEY = "__case-fallback__";
+function getBranchScopes(state) {
+	const scopes = [];
+	if (state.activeScope) scopes.push(state.activeScope);
+	if (state instanceof Object && "fallbackScope" in state) {
+		if (state.fallbackScope) scopes.push(state.fallbackScope);
+	}
+	if (state instanceof Object && "truthyScope" in state) {
+		if (state.truthyScope) scopes.push(state.truthyScope);
+	}
+	return scopes;
+}
+function beginControlTransaction(state) {
+	if (state._transaction) return state._transaction;
+	const scopeSnapshots = /* @__PURE__ */ new Map();
+	for (const scope of getBranchScopes(state)) scopeSnapshots.set(scope, captureChildScopeTransactionSnapshot(scope));
+	const transaction = {
+		state,
+		snapshot: {
+			activeKey: state.activeKey,
+			activeScope: state.activeScope,
+			activeVNodes: state.activeVNodes.slice(),
+			lastRemovedNodes: state.lastRemovedNodes.slice(),
+			lastRemovedRanges: state.lastRemovedRanges.slice(),
+			scopeSnapshots,
+			fallbackScope: "fallbackScope" in state ? state.fallbackScope : void 0,
+			truthyScope: "truthyScope" in state ? state.truthyScope : void 0
+		},
+		removedScopes: [],
+		shouldClearDomUpdateState: false,
+		registered: false
+	};
+	state._transaction = transaction;
+	transaction.registered = registerLifecycleTransaction(transaction, () => commitControlTransaction(state, transaction), () => rollbackControlTransaction(state, transaction));
+	return transaction;
+}
+function stageBranchRemoval(state, scope) {
+	if (!scope) return;
+	const transaction = state._transaction;
+	if (transaction && !transaction.removedScopes.includes(scope)) transaction.removedScopes.push(scope);
+	else if (!transaction) disposeChildScope(scope);
+	const removedDom = scope.dom;
+	if (removedDom) state.lastRemovedNodes.push(removedDom);
+	if (scope.range) state.lastRemovedRanges.push(scope.range);
+}
+function commitControlTransaction(state, transaction) {
+	if (state._transaction !== transaction) return;
+	const errors = [];
+	for (const scope of transaction.removedScopes) try {
+		disposeChildScope(scope);
+	} catch (error) {
+		errors.push(error);
+	}
+	if (transaction.shouldClearDomUpdateState) {
+		if ("truthyScope" in state && state.truthyScope) state.truthyScope.needsDomUpdate = false;
+		if ("fallbackScope" in state && state.fallbackScope) state.fallbackScope.needsDomUpdate = false;
+		if (state.activeScope) state.activeScope.needsDomUpdate = false;
+		state.lastRemovedNodes = [];
+		state.lastRemovedRanges = [];
+	}
+	state._transaction = null;
+	if (errors.length > 0) throw new AggregateError(errors, "Control branch cleanup failed");
+}
+function rollbackControlTransaction(state, transaction) {
+	if (state._transaction !== transaction) return;
+	const committedScopes = new Set(transaction.snapshot.scopeSnapshots.keys());
+	const currentScopes = getBranchScopes(state);
+	const errors = [];
+	for (const scope of currentScopes) {
+		if (committedScopes.has(scope)) continue;
+		try {
+			disposeChildScope(scope);
+		} catch (error) {
+			errors.push(error);
+		}
+	}
+	state.activeKey = transaction.snapshot.activeKey;
+	state.activeScope = transaction.snapshot.activeScope;
+	state.activeVNodes = transaction.snapshot.activeVNodes;
+	state.lastRemovedNodes = transaction.snapshot.lastRemovedNodes;
+	state.lastRemovedRanges = transaction.snapshot.lastRemovedRanges;
+	if ("truthyScope" in state) state.truthyScope = transaction.snapshot.truthyScope ?? null;
+	if ("fallbackScope" in state) state.fallbackScope = transaction.snapshot.fallbackScope ?? null;
+	for (const [scope, snapshot] of transaction.snapshot.scopeSnapshots) restoreChildScopeTransactionSnapshot(scope, snapshot);
+	state._transaction = null;
+	if (errors.length > 0) throw new AggregateError(errors, "Control branch rollback cleanup failed");
+}
+function finishImmediateControlTransaction(state, transaction) {
+	if (state._transaction === transaction && !transaction.registered) commitControlTransaction(state, transaction);
+}
+function createBranchScope(state, key) {
+	return createChildScope(state.parentInstance, key, () => {
+		if (state._enqueueBoundaryCommit) {
+			state._enqueueBoundaryCommit();
+			return;
+		}
+		state.parentInstance?._enqueueRun?.();
+	});
+}
+function createShowState(value, renderTruthy, renderFallback) {
+	return {
+		kind: "show",
+		activeKey: null,
+		activeScope: null,
+		activeVNodes: [],
+		fallbackScope: null,
+		lastRemovedNodes: [],
+		lastRemovedRanges: [],
+		parentInstance: getCurrentInstance(),
+		_enqueueBoundaryCommit: null,
+		_hasPendingBoundaryCommit: false,
+		_transaction: null,
+		renderFallback,
+		renderTruthy,
+		selectedValue: value,
+		truthyScope: null
+	};
+}
+function evaluateShowState(state) {
+	const transaction = beginControlTransaction(state);
+	state.lastRemovedNodes = [];
+	state.lastRemovedRanges = [];
+	try {
+		if (state.selectedValue) {
+			if (state.fallbackScope) {
+				stageBranchRemoval(state, state.fallbackScope);
+				state.fallbackScope = null;
+			}
+			const truthyScope = state.truthyScope ?? createBranchScope(state, SHOW_TRUTHY_KEY);
+			state.truthyScope = truthyScope;
+			state.activeScope = truthyScope;
+			state.activeKey = SHOW_TRUTHY_KEY;
+			const vnode = truthyScope.render(() => state.renderTruthy(state.selectedValue));
+			state.activeVNodes = vnode == null || vnode === false ? [] : [vnode];
+		} else {
+			if (state.truthyScope) {
+				stageBranchRemoval(state, state.truthyScope);
+				state.truthyScope = null;
+			}
+			if (!state.renderFallback) {
+				if (state.fallbackScope) {
+					stageBranchRemoval(state, state.fallbackScope);
+					state.fallbackScope = null;
+				}
+				state.activeKey = null;
+				state.activeScope = null;
+				state.activeVNodes = [];
+			} else {
+				const fallbackScope = state.fallbackScope ?? createBranchScope(state, SHOW_FALLBACK_KEY);
+				state.fallbackScope = fallbackScope;
+				state.activeScope = fallbackScope;
+				state.activeKey = SHOW_FALLBACK_KEY;
+				const vnode = fallbackScope.render(state.renderFallback);
+				state.activeVNodes = vnode == null || vnode === false ? [] : [vnode];
+			}
+		}
+		finishImmediateControlTransaction(state, transaction);
+		return state.activeVNodes;
+	} catch (error) {
+		rollbackControlTransaction(state, transaction);
+		throw error;
+	}
+}
+function clearShowDomUpdateState(state) {
+	if (state.truthyScope) state.truthyScope.needsDomUpdate = false;
+	if (state.fallbackScope) state.fallbackScope.needsDomUpdate = false;
+	if (state._transaction) {
+		state._transaction.shouldClearDomUpdateState = true;
+		return;
+	}
+	state.lastRemovedNodes = [];
+	state.lastRemovedRanges = [];
+}
+function createCaseState(matches, fallback) {
+	return {
+		kind: "case",
+		activeKey: null,
+		activeScope: null,
+		activeVNodes: [],
+		fallback,
+		lastRemovedNodes: [],
+		lastRemovedRanges: [],
+		matches,
+		parentInstance: getCurrentInstance(),
+		_enqueueBoundaryCommit: null,
+		_hasPendingBoundaryCommit: false,
+		_transaction: null
+	};
+}
+function evaluateCaseState(state) {
+	const transaction = beginControlTransaction(state);
+	state.lastRemovedNodes = [];
+	state.lastRemovedRanges = [];
+	try {
+		const selectedMatch = state.matches.find((candidate) => Boolean(candidate.when)) ?? null;
+		const nextKey = selectedMatch?.key ?? (state.fallback ? CASE_FALLBACK_KEY : null);
+		if (nextKey === null) {
+			if (state.activeScope) stageBranchRemoval(state, state.activeScope);
+			state.activeKey = null;
+			state.activeScope = null;
+			state.activeVNodes = [];
+		} else {
+			if (state.activeScope && state.activeKey !== nextKey) {
+				stageBranchRemoval(state, state.activeScope);
+				state.activeScope = null;
+			}
+			const activeScope = state.activeScope ?? createBranchScope(state, nextKey);
+			state.activeKey = nextKey;
+			state.activeScope = activeScope;
+			const renderBranch = selectedMatch?.render ?? state.fallback;
+			const vnode = renderBranch ? activeScope.render(renderBranch) : null;
+			state.activeVNodes = vnode == null || vnode === false ? [] : [vnode];
+		}
+		finishImmediateControlTransaction(state, transaction);
+		return state.activeVNodes;
+	} catch (error) {
+		rollbackControlTransaction(state, transaction);
+		throw error;
+	}
+}
+function clearCaseDomUpdateState(state) {
+	if (state.activeScope) state.activeScope.needsDomUpdate = false;
+	if (state._transaction) {
+		state._transaction.shouldClearDomUpdateState = true;
+		return;
+	}
+	state.lastRemovedNodes = [];
+	state.lastRemovedRanges = [];
+}
+//#endregion
+//#region src/runtime/for-signals.ts
+function peekForSignal() {
+	return this._value;
+}
+function setForValueSignal(newValue, notifyReaders = true) {
+	if (Object.is(this._value, newValue)) return;
+	this._value = newValue;
+	if (notifyReaders) notifyForSignalReaders(this);
+}
+function setForIndexValue(newValue, notifyReaders = true) {
+	const nextValue = typeof newValue === "function" ? newValue(this._value) : newValue;
+	if (nextValue === this._value) return;
+	this._value = nextValue;
+	if (notifyReaders) notifyForSignalReaders(this);
+}
+function notifyForSignalReaders(source, skipInstance, skipOwnedBy) {
+	markReadableDerivedSubscribersDirty(source);
+	markReactivePropsDirtySource(source);
+	notifyReadableReaders(source, skipInstance, skipOwnedBy);
+}
+function createForIndexSignal(initialIndex) {
+	function readIndexSignal() {
+		const signal = readIndexSignal;
+		signal._hasBeenRead = true;
+		recordReadableRead(signal);
+		return signal._value;
+	}
+	const indexSignal = readIndexSignal;
+	indexSignal._value = initialIndex;
+	indexSignal.peek = peekForSignal;
+	indexSignal.set = setForIndexValue;
+	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 createForItemSignal(initialItem) {
+	function readItemSignal() {
+		const signal = readItemSignal;
+		signal._hasBeenRead = true;
+		recordReadableRead(signal);
+		return signal._value;
+	}
+	const itemSignal = readItemSignal;
+	itemSignal._value = initialItem;
+	itemSignal.peek = peekForSignal;
+	itemSignal.set = setForValueSignal;
+	itemSignal._hasBeenRead = false;
+	return itemSignal;
+}
+function createForItemPropertySignal(initialValue) {
+	function readPropertySignal() {
+		const signal = readPropertySignal;
+		signal._hasBeenRead = true;
+		recordReadableRead(signal);
+		return signal._value;
+	}
+	const propertySignal = readPropertySignal;
+	propertySignal._value = initialValue;
+	propertySignal.peek = peekForSignal;
+	propertySignal.set = setForValueSignal;
+	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) {
+	const readers = source._readers;
+	if (!readers || readers.size === 0) return false;
+	for (const reader of readers.keys()) {
+		let current = reader;
+		while (current) {
+			if (current === scope.componentInstance) return true;
+			current = current.parentInstance;
+		}
+	}
+	return false;
+}
+function scopeDirectlyReadsSource(scope, source) {
+	return source._readers?.has(scope.componentInstance) ?? false;
+}
+function isForParentReader(parentInstance, reader) {
+	let current = parentInstance;
+	while (current) {
+		if (current === reader) return true;
+		current = current.parentInstance;
+	}
+	return false;
+}
+function removeForParentReaders(parentInstance, source) {
+	const readers = source._readers;
+	if (!readers || readers.size === 0) return;
+	for (const reader of readers.keys()) if (isForParentReader(parentInstance, reader)) {
+		if (readers.delete(reader) && false);
+	}
+}
+function getOrCreateForItemPropertySignal(state, prop) {
+	const item = state.currentItem;
+	const propertySignals = state.propertySignals ?? (state.propertySignals = /* @__PURE__ */ new Map());
+	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 === "function" || typeof item === "object" && item !== null && !Array.isArray(item);
+}
+function createReactiveForItem(item) {
+	const target = Object.create(null);
+	const state = {
+		currentItem: item,
+		itemSignal: null,
+		propertySignals: null,
+		coalescedProperties: null,
+		coalescedProperty2: null,
+		wholeItemRead: false,
+		proxy: void 0
+	};
+	target[REACTIVE_FOR_ITEM_STATE] = state;
+	state.proxy = new Proxy(target, REACTIVE_FOR_ITEM_PROXY_HANDLER);
+	return state;
+}
+const REACTIVE_FOR_ITEM_STATE = Symbol("askr.reactive-for-item-state");
+function getReactiveForItemState(target) {
+	return target[REACTIVE_FOR_ITEM_STATE];
+}
+function getWholeItemSignal(state) {
+	let signal = state.itemSignal;
+	if (!signal) {
+		signal = createForItemSignal(state.currentItem);
+		state.itemSignal = signal;
+	}
+	return signal;
+}
+const REACTIVE_FOR_ITEM_PROXY_HANDLER = {
+	get(target, prop, receiver) {
+		if (prop !== REACTIVE_FOR_ITEM_STATE && prop in target) return Reflect.get(target, prop, receiver);
+		const metadata = getReactiveForItemState(target);
+		const currentItem = metadata.currentItem;
+		if (typeof prop !== "symbol") {
+			if (shouldCoalesceFineGrainedItemReads()) {
+				const properties = metadata.coalescedProperties;
+				if (properties === null) metadata.coalescedProperties = prop;
+				else if (Array.isArray(properties)) {
+					if (!properties.includes(prop)) properties.push(prop);
+				} else if (properties !== prop && metadata.coalescedProperty2 !== prop) if (metadata.coalescedProperty2 === null) metadata.coalescedProperty2 = prop;
+				else {
+					metadata.coalescedProperties = [
+						properties,
+						metadata.coalescedProperty2,
+						prop
+					];
+					metadata.coalescedProperty2 = null;
+				}
+				let itemSignal = metadata.itemSignal;
+				if (!itemSignal) {
+					itemSignal = createForItemSignal(currentItem);
+					metadata.itemSignal = itemSignal;
+				}
+				itemSignal();
+				return readForItemProperty(currentItem, prop);
+			}
+			return getOrCreateForItemPropertySignal(metadata, prop)();
+		}
+		metadata.wholeItemRead = true;
+		recordReadableRead(getWholeItemSignal(metadata));
+		return Reflect.get(Object(currentItem), prop, receiver);
+	},
+	has(target, prop) {
+		if (prop === REACTIVE_FOR_ITEM_STATE) return false;
+		const metadata = getReactiveForItemState(target);
+		metadata.wholeItemRead = true;
+		recordReadableRead(getWholeItemSignal(metadata));
+		return prop in target || prop in Object(metadata.currentItem);
+	},
+	ownKeys(target) {
+		const metadata = getReactiveForItemState(target);
+		metadata.wholeItemRead = true;
+		recordReadableRead(getWholeItemSignal(metadata));
+		const keys = /* @__PURE__ */ new Set();
+		for (const key of Reflect.ownKeys(target)) if (key !== REACTIVE_FOR_ITEM_STATE) keys.add(key);
+		for (const key of Reflect.ownKeys(Object(metadata.currentItem))) keys.add(key);
+		return Array.from(keys);
+	},
+	getOwnPropertyDescriptor(target, prop) {
+		if (prop === REACTIVE_FOR_ITEM_STATE) return;
+		const metadata = getReactiveForItemState(target);
+		metadata.wholeItemRead = true;
+		recordReadableRead(getWholeItemSignal(metadata));
+		const ownDescriptor = Reflect.getOwnPropertyDescriptor(target, prop);
+		if (ownDescriptor) return ownDescriptor;
+		return Object.getOwnPropertyDescriptor(Object(metadata.currentItem), prop);
+	},
+	getPrototypeOf(target) {
+		const metadata = getReactiveForItemState(target);
+		metadata.wholeItemRead = true;
+		recordReadableRead(getWholeItemSignal(metadata));
+		return Object.getPrototypeOf(Object(metadata.currentItem));
+	}
+};
+const recordBenchEvent = (_event) => {};
+//#endregion
+//#region src/runtime/for-scopes.ts
+function recordRemovedBoundary(forState, dom, range) {
+	if (range && !range.single) forState.lastRemovedRanges.push(range);
+	else if (dom) forState.lastRemovedNodes.push(dom);
+}
+function captureRemovedScopeNodes(forState, dom, range) {
+	const transaction = forState._transaction;
+	if (!transaction) return;
+	const nodes = transaction.removedScopeNodes ??= [];
+	if (range && !range.single) for (let node = range.start.nextSibling; node && node !== range.end; node = node.nextSibling) nodes.push(node);
+	else if (dom) nodes.push(dom);
+}
+function enqueueForScopeUpdate(parent) {
+	parent?._enqueueRun?.();
+}
+const forStatesByScope = /* @__PURE__ */ new WeakMap();
+function enqueueForBoundaryScopeCommit() {
+	const forState = this.blueprintOwner ?? forStatesByScope.get(this);
+	if (!forState) return;
+	if (forState._enqueueBoundaryCommit) {
+		forState._enqueueBoundaryCommit();
+		return;
+	}
+	enqueueForScopeUpdate(forState.parentInstance);
+}
+function createForOwnedChildScope(forState, key) {
+	return createChildScope(forState.parentInstance, key, enqueueForBoundaryScopeCommit, forState._scopeOwnership);
+}
+function captureForItemTransactionSnapshot(forState, itemInstance) {
+	const transaction = forState._transaction;
+	if (!transaction || transaction.itemSnapshots?.has(itemInstance)) return;
+	if (transaction.collectionSnapshotMode === "reset-empty" || transaction.items.get(itemInstance.key) !== itemInstance) return;
+	const itemSnapshots = transaction.itemSnapshots ??= /* @__PURE__ */ new Map();
+	const propertySignals = itemInstance.reactiveItemState?.propertySignals ?? null;
+	const itemSignal = itemInstance.reactiveItemState?.itemSignal ?? null;
+	const propertySnapshots = propertySignals && propertySignals.size > 0 ? new Map(Array.from(propertySignals, ([property, signal]) => [property, {
+		signal,
+		value: signal.peek(),
+		hasBeenRead: signal._hasBeenRead === true
+	}])) : null;
+	itemSnapshots.set(itemInstance, {
+		item: itemInstance.item,
+		itemSignalExists: itemSignal !== null,
+		itemSignalValue: itemSignal?.peek(),
+		itemSignalHasBeenRead: itemSignal?._hasBeenRead === true,
+		indexValue: itemInstance.indexSignal.peek(),
+		indexHasBeenRead: itemInstance.indexSignal._hasBeenRead === true,
+		propertySignalStore: propertySignals,
+		propertySignals: propertySnapshots,
+		scope: captureChildScopeTransactionSnapshot(itemInstance.scope)
+	});
+}
+function captureForFallbackTransactionSnapshot(forState, fallbackScope = forState.fallbackScope) {
+	const transaction = forState._transaction;
+	if (!transaction || !fallbackScope || transaction.fallbackScope !== fallbackScope || transaction.fallbackScopeSnapshot) return;
+	transaction.fallbackScopeSnapshot = captureChildScopeTransactionSnapshot(fallbackScope);
+}
+function stageForSignalEffect(forState, source, notify, skipInstance = null, skipOwnedBy = null) {
+	const transaction = forState._transaction;
+	if (!transaction) return false;
+	const effects = transaction.signalEffects ??= /* @__PURE__ */ new Map();
+	const existing = effects.get(source);
+	if (existing) {
+		existing.notify ||= notify;
+		if (existing.skipInstance !== skipInstance) existing.skipInstance = null;
+		if (existing.skipOwnedBy !== skipOwnedBy) existing.skipOwnedBy = null;
+	} else effects.set(source, {
+		parentInstance: forState.parentInstance,
+		notify,
+		skipInstance,
+		skipOwnedBy
+	});
+	return true;
+}
+function syncForItemIndex(forState, itemInstance, nextIndex) {
+	const indexSignal = itemInstance.indexSignal;
+	const previousIndex = indexSignal.peek();
+	if (previousIndex === nextIndex) return false;
+	if (indexSignal._hasBeenRead !== true) {
+		const transaction = forState._transaction;
+		if (transaction) {
+			const snapshots = transaction.unreadIndexSnapshots ??= /* @__PURE__ */ new Map();
+			if (!snapshots.has(indexSignal)) snapshots.set(indexSignal, previousIndex);
+		}
+		indexSignal.set(nextIndex, false);
+		return false;
+	}
+	captureForItemTransactionSnapshot(forState, itemInstance);
+	const scopeReadsIndex = scopeReadsSource(itemInstance.scope, indexSignal);
+	const scopeDirectlyReadsIndex = scopeDirectlyReadsSource(itemInstance.scope, indexSignal);
+	if (forState._transaction) {
+		const shouldNotify = indexSignal._hasBeenRead === true;
+		indexSignal.set(nextIndex, false);
+		stageForSignalEffect(forState, indexSignal, shouldNotify, scopeReadsIndex ? itemInstance.scope.componentInstance : null);
+		if (!scopeReadsIndex) return false;
+		if (scopeDirectlyReadsIndex) rerenderItemInstance(forState, itemInstance, itemInstance.reactiveItem);
+		else itemInstance.scope.markDirty();
+		return true;
+	}
+	if (!scopeReadsIndex) {
+		syncForIndexSignal(indexSignal, nextIndex);
+		return false;
+	}
+	indexSignal.set(nextIndex, false);
+	notifyForSignalReaders(indexSignal, itemInstance.scope.componentInstance);
+	rerenderItemInstance(forState, itemInstance, itemInstance.reactiveItem);
+	return true;
+}
+function materializeItemVnode(forState, key, vnode) {
+	if (vnode && typeof vnode === "object" && "type" in vnode) {
+		const vn = vnode;
+		vn.key = key;
+		if (forState.parentInstance?.ssr && typeof vn.type === "string") {
+			if (!vn.props) vn.props = {};
+			if (vn.props["data-key"] === void 0) vn.props["data-key"] = String(key);
+			if (vn.props["data-askr-key-kind"] === void 0) vn.props["data-askr-key-kind"] = typeof key;
+		}
+	}
+}
+function renderItemScope(forState, scope, item, indexSignal, key) {
+	const vnode = scope.render(() => forState.renderFn(item, indexSignal));
+	materializeItemVnode(forState, key, vnode);
+	return vnode;
+}
+function disposeItemInstance(forState, itemInstance, domCleanup) {
+	const removedDom = itemInstance.scope.dom;
+	const removedRange = itemInstance.scope.range;
+	const transaction = forState._transaction;
+	if (transaction) {
+		(transaction.removedScopes ??= []).push(itemInstance.scope);
+		captureRemovedScopeNodes(forState, removedDom, removedRange);
+		recordRemovedBoundary(forState, removedDom, removedRange);
+		return;
+	}
+	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);
+	}
+	recordRemovedBoundary(forState, removedDom, removedRange);
+}
+function createItemInstance(key, item, index, forState) {
+	const indexSignal = createForIndexSignal(index);
+	const reactiveItemState = canProxyForItem(item) ? createReactiveForItem(item) : null;
+	const reactiveItem = reactiveItemState?.proxy ?? item;
+	const scope = createForOwnedChildScope(forState, key);
+	scope.blueprintOwner = forState;
+	try {
+		renderItemScope(forState, scope, reactiveItem, indexSignal, key);
+	} catch (error) {
+		disposeChildScope(scope);
+		throw error;
+	}
+	return {
+		key,
+		item,
+		reactiveItem,
+		reactiveItemState,
+		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;
+	captureForItemTransactionSnapshot(forState, itemInstance);
+	const previousItem = itemInstance.item;
+	itemInstance.item = item;
+	const scope = itemInstance.scope;
+	let scopeReadsChangedSignal = false;
+	const reactiveItemState = itemInstance.reactiveItemState;
+	if (!reactiveItemState) {
+		rerenderItemInstance(forState, itemInstance, item);
+		return true;
+	}
+	const itemSignal = reactiveItemState.itemSignal;
+	reactiveItemState.currentItem = item;
+	const propertySignals = reactiveItemState.propertySignals;
+	const changedPropertySignals = [];
+	if (propertySignals && propertySignals.size > 0) for (const [prop, propertySignal] of propertySignals) {
+		const previousValue = readForItemProperty(previousItem, prop);
+		const nextValue = readForItemProperty(item, prop);
+		if (Object.is(previousValue, nextValue)) continue;
+		if (scopeReadsSource(scope, propertySignal)) scopeReadsChangedSignal = true;
+		changedPropertySignals.push([propertySignal, nextValue]);
+	}
+	if (itemSignal && scopeReadsSource(scope, itemSignal)) scopeReadsChangedSignal = true;
+	let coalescedPropertyChanged = false;
+	const coalescedProperties = reactiveItemState.coalescedProperties;
+	if (coalescedProperties !== null) if (Array.isArray(coalescedProperties)) {
+		for (const property of coalescedProperties) if (!Object.is(readForItemProperty(previousItem, property), readForItemProperty(item, property))) {
+			coalescedPropertyChanged = true;
+			break;
+		}
+	} else {
+		coalescedPropertyChanged = !Object.is(readForItemProperty(previousItem, coalescedProperties), readForItemProperty(item, coalescedProperties));
+		const secondProperty = reactiveItemState.coalescedProperty2;
+		if (secondProperty !== null && !coalescedPropertyChanged) coalescedPropertyChanged = !Object.is(readForItemProperty(previousItem, secondProperty), readForItemProperty(item, secondProperty));
+	}
+	const wholeItemChanged = itemSignal?._hasBeenRead === true && (reactiveItemState.wholeItemRead || coalescedPropertyChanged);
+	const itemShapeChanged = !wholeItemChanged && changedPropertySignals.length === 0 && !haveSameOwnKeys(previousItem, item);
+	const notifyReaders = !scopeReadsChangedSignal && (changedPropertySignals.length > 0 || itemShapeChanged || wholeItemChanged);
+	const visibleChange = scopeReadsChangedSignal || changedPropertySignals.length > 0 || itemShapeChanged || wholeItemChanged;
+	for (const [propertySignal, nextValue] of changedPropertySignals) if (stageForSignalEffect(forState, propertySignal, notifyReaders, null, itemInstance.scope.componentInstance)) propertySignal.set(nextValue, false);
+	else {
+		removeForParentReaders(forState.parentInstance, propertySignal);
+		propertySignal.set(nextValue, notifyReaders);
+	}
+	if (itemSignal && stageForSignalEffect(forState, itemSignal, notifyReaders, null, itemInstance.scope.componentInstance)) itemSignal.set(item, false);
+	else if (itemSignal) {
+		removeForParentReaders(forState.parentInstance, itemSignal);
+		itemSignal.set(item, notifyReaders);
+	}
+	if (scopeReadsChangedSignal) if (itemSignal !== null && scopeDirectlyReadsSource(scope, itemSignal) || changedPropertySignals.some(([propertySignal]) => scopeDirectlyReadsSource(scope, propertySignal))) rerenderItemInstance(forState, itemInstance, itemInstance.reactiveItem);
+	else scope.markDirty();
+	return visibleChange;
+}
+const FOR_FALLBACK_SCOPE_KEY = "__for-fallback__";
+function disposeFallbackScope(forState, domCleanup) {
+	const fallbackScope = forState.fallbackScope;
+	if (!fallbackScope) return;
+	const removedDom = fallbackScope.dom;
+	const removedRange = fallbackScope.range;
+	const transaction = forState._transaction;
+	if (transaction) {
+		(transaction.removedScopes ??= []).push(fallbackScope);
+		captureRemovedScopeNodes(forState, removedDom, removedRange);
+	} else disposeChildScope(fallbackScope);
+	forState.fallbackScope = null;
+	if (!removedDom) return;
+	if (removedDom instanceof Element) {
+		if (domCleanup === "teardown") getRuntimeRenderer().teardownNodeSubtree(removedDom);
+	}
+	recordRemovedBoundary(forState, removedDom, removedRange);
+}
+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 ?? createForOwnedChildScope(forState, FOR_FALLBACK_SCOPE_KEY);
+	if (!forState.fallbackScope) forStatesByScope.set(fallbackScope, forState);
+	forState.fallbackScope = fallbackScope;
+	captureForFallbackTransactionSnapshot(forState, fallbackScope);
+	const fallbackVNode = forState.fallback;
+	const vnode = fallbackScope.render(() => fallbackVNode);
+	forState.orderedVNodes = vnode == null || vnode === false ? [] : [vnode];
+	forState.orderedItems = [];
+	return forState.orderedVNodes;
+}
+function disposeAllItems(forState, domCleanup) {
+	const { items, orderedKeys } = forState;
+	if (forState._transaction?.collectionSnapshotMode === "preserve-clear") {
+		const transaction = forState._transaction;
+		transaction.removeAllItems = true;
+		for (let index = 0; index < forState.orderedItems.length; index++) {
+			const scope = forState.orderedItems[index]?.scope;
+			const removedDom = scope?.dom;
+			const range = scope?.range;
+			if (scope) captureRemovedScopeNodes(forState, removedDom, range);
+			recordRemovedBoundary(forState, removedDom, range);
+		}
+		forState.items = /* @__PURE__ */ new Map();
+		forState.orderedKeys = [];
+		return;
+	}
+	for (let index = 0; index < orderedKeys.length; index += 1) {
+		const key = orderedKeys[index];
+		const itemInstance = items.get(key);
+		if (!itemInstance) continue;
+		disposeItemInstance(forState, itemInstance, domCleanup);
+		items.delete(key);
+	}
+	orderedKeys.length = 0;
+	forState.orderedKeys = orderedKeys;
+}
+//#endregion
+//#region src/runtime/for-reconcile.ts
+function failForValidation(message) {
+	throw new Error(message);
+}
+function validateForKeys(forState, newArray) {
+	if (!isDevelopmentEnvironment()) return;
+	const seen = /* @__PURE__ */ new Set();
+	const keyKinds = /* @__PURE__ */ new Map();
+	for (let i = 0; i < newArray.length; i++) {
+		const key = forState.byFn(newArray[i], i);
+		if (key === null || key === void 0) failForValidation("[askr] Invalid For key detected. Keys should be stable, non-null, and unique within a For list.");
+		if (seen.has(key)) failForValidation(`[askr] Duplicate For key detected: ${String(key)}. Keys should be stable, non-null, and unique within a For list.`);
+		seen.add(key);
+		const keyKind = typeof key;
+		const previousKeyKind = forState.devKeyKinds?.get(key);
+		if (previousKeyKind && previousKeyKind !== keyKind) failForValidation(`[askr] For key type changed for ${String(key)}. Keys must remain consistently typed across renders.`);
+		keyKinds.set(key, keyKind);
+	}
+	forState.devKeyKinds = keyKinds;
+}
+function reconcileForItems(forState, newArray) {
+	forState.currentItems = newArray;
+	validateForKeys(forState, newArray);
+	const { items, orderedKeys, byFn } = forState;
+	const oldLen = orderedKeys.length;
+	const newLen = newArray.length;
+	forState.lastRemovedNodes = [];
+	forState.lastRemovedRanges = [];
+	forState.pendingRemovedKey = null;
+	if (newLen === 0) {
+		if (oldLen > 0) disposeAllItems(forState, forState.fallback ? "teardown" : "none");
+		forState.lastCommitStrategy = "TRUNCATE";
+		forState.pendingDirtyIndices = null;
+		forState.pendingSwapIndices = null;
+		forState.pendingMoveOnly = false;
+		return renderFallbackScope(forState);
+	}
+	if (forState.fallbackScope) disposeFallbackScope(forState, "none");
+	if (newLen === oldLen + 1) {
+		let oldIndex = 0;
+		let insertedIndex = -1;
+		let insertedKey = null;
+		for (let newIndex = 0; newIndex < newLen; newIndex++) {
+			const item = newArray[newIndex];
+			const key = byFn(item, newIndex);
+			const expectedKey = orderedKeys[oldIndex];
+			if (oldIndex < oldLen && key === expectedKey) {
+				const existing = items.get(key);
+				if (!existing || existing.item !== item || existing.scope.needsDomUpdate || oldIndex !== newIndex && existing.indexSignal._hasBeenRead) {
+					insertedIndex = -2;
+					break;
+				}
+				oldIndex++;
+			} else if (insertedIndex === -1 && !items.has(key)) {
+				insertedIndex = newIndex;
+				insertedKey = key;
+			} else {
+				insertedIndex = -2;
+				break;
+			}
+		}
+		if (insertedIndex >= 0 && oldIndex === oldLen && insertedKey !== null) {
+			const insertedItem = createItemInstance(insertedKey, newArray[insertedIndex], insertedIndex, forState);
+			const resultVNodes = forState.orderedVNodes.slice();
+			const resultItems = forState.orderedItems.slice();
+			const resultKeys = orderedKeys.slice();
+			resultVNodes.splice(insertedIndex, 0, insertedItem.scope.vnode);
+			resultItems.splice(insertedIndex, 0, insertedItem);
+			resultKeys.splice(insertedIndex, 0, insertedKey);
+			items.set(insertedKey, insertedItem);
+			forState.lastCommitStrategy = "INSERT_ONE";
+			forState.orderedKeys = resultKeys;
+			forState.orderedItems = resultItems;
+			forState.orderedVNodes = resultVNodes;
+			forState.pendingDirtyIndices = null;
+			forState.pendingSwapIndices = null;
+			forState.pendingMoveOnly = false;
+			forState.pendingInsertedIndex = insertedIndex;
+			return resultVNodes;
+		}
+	}
+	if (oldLen < newLen) {
+		let canUseAppendPath = true;
+		let canSkipCommittedPrefix = true;
+		for (let i = 0; i < oldLen; i++) {
+			const key = byFn(newArray[i], i);
+			if (key !== orderedKeys[i]) {
+				canUseAppendPath = false;
+				break;
+			}
+			const existing = forState.orderedItems[i] ?? items.get(key);
+			if (!existing || existing.item !== newArray[i] || existing.scope.needsDomUpdate || existing.scope.hydrationPending) canSkipCommittedPrefix = false;
+		}
+		if (canUseAppendPath) {
+			forState.lastCommitStrategy = "APPEND";
+			const resultVNodes = forState.orderedVNodes;
+			const resultItems = forState.orderedItems;
+			resultVNodes.length = newLen;
+			resultItems.length = newLen;
+			if (!canSkipCommittedPrefix) for (let i = 0; i < oldLen; i++) {
+				const item = newArray[i];
+				const key = orderedKeys[i];
+				const existing = resultItems[i] ?? items.get(key);
+				updateItemInstance(forState, existing, item);
+				resultItems[i] = existing;
+				resultVNodes[i] = existing.scope.vnode;
+			}
+			for (let i = oldLen; i < newLen; i++) {
+				const item = newArray[i];
+				const key = byFn(item, i);
+				const itemInstance = createItemInstance(key, item, i, forState);
+				items.set(key, itemInstance);
+				resultItems[i] = itemInstance;
+				resultVNodes[i] = itemInstance.scope.vnode;
+				orderedKeys[i] = key;
+			}
+			forState.orderedVNodes = resultVNodes;
+			forState.pendingDirtyIndices = null;
+			forState.pendingSwapIndices = null;
+			forState.pendingMoveOnly = false;
+			forState.pendingAppendStart = canSkipCommittedPrefix ? oldLen : 0;
+			return resultVNodes;
+		}
+	}
+	if (newLen < oldLen) {
+		if (oldLen === newLen + 1) {
+			let removedIndex = -1;
+			for (let i = 0; i < newLen; i++) if (byFn(newArray[i], i) !== orderedKeys[i]) {
+				removedIndex = i;
+				break;
+			}
+			if (removedIndex !== -1) {
+				let canUseRemoveOnePath = true;
+				for (let i = removedIndex; i < newLen; i++) if (byFn(newArray[i], i) !== orderedKeys[i + 1]) {
+					canUseRemoveOnePath = false;
+					break;
+				}
+				if (canUseRemoveOnePath) {
+					forState.lastCommitStrategy = "REMOVE_ONE";
+					const resultVNodes = forState.orderedVNodes;
+					const resultItems = forState.orderedItems;
+					const removedKey = orderedKeys[removedIndex];
+					const removedItem = resultItems[removedIndex] ?? items.get(removedKey);
+					orderedKeys.copyWithin(removedIndex, removedIndex + 1);
+					resultItems.copyWithin(removedIndex, removedIndex + 1);
+					resultVNodes.copyWithin(removedIndex, removedIndex + 1);
+					orderedKeys.length = newLen;
+					resultItems.length = newLen;
+					resultVNodes.length = newLen;
+					const dirtyIndices = [];
+					for (let i = 0; i < newLen; i++) {
+						const item = newArray[i];
+						const existing = resultItems[i];
+						const scopeNeedsDomUpdate = existing.scope.needsDomUpdate;
+						const itemChanged = existing.item !== item;
+						const indexSignal = existing.indexSignal;
+						const indexChanged = i >= removedIndex && indexSignal.peek() !== i;
+						if (itemChanged) updateItemInstance(forState, existing, item);
+						const indexVisibleChange = indexChanged ? syncForItemIndex(forState, existing, i) : false;
+						if (itemChanged || indexVisibleChange || scopeNeedsDomUpdate) dirtyIndices.push(i);
+						resultVNodes[i] = existing.scope.vnode;
+					}
+					if (removedItem) {
+						disposeItemInstance(forState, removedItem, "teardown");
+						items.delete(removedKey);
+					}
+					forState.pendingRemovedKey = removedKey;
+					forState.pendingDirtyIndices = dirtyIndices;
+					forState.pendingSwapIndices = null;
+					forState.pendingMoveOnly = false;
+					return resultVNodes;
+				}
+			}
+		}
+		let canUseTruncatePath = true;
+		for (let i = 0; i < newLen; i++) if (byFn(newArray[i], i) !== orderedKeys[i]) {
+			canUseTruncatePath = false;
+			break;
+		}
+		if (canUseTruncatePath) {
+			forState.lastCommitStrategy = "TRUNCATE";
+			const resultVNodes = forState.orderedVNodes;
+			const resultItems = forState.orderedItems;
+			resultVNodes.length = newLen;
+			resultItems.length = newLen;
+			const isFullClear = newLen === 0;
+			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;
+			}
+			for (let i = newLen; i < oldLen; i++) {
+				const key = orderedKeys[i];
+				const itemInstance = items.get(key);
+				if (itemInstance) {
+					disposeItemInstance(forState, itemInstance, isFullClear ? "full-clear" : "teardown");
+					items.delete(key);
+				}
+			}
+			orderedKeys.length = newLen;
+			forState.orderedKeys = orderedKeys;
+			forState.orderedItems.length = newLen;
+			forState.orderedVNodes = resultVNodes;
+			forState.pendingDirtyIndices = 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) {
+			forState.lastCommitStrategy = "NO_REORDER";
+			const resultVNodes = forState.orderedVNodes;
+			const resultItems = forState.orderedItems;
+			resultVNodes.length = oldLen;
+			resultItems.length = oldLen;
+			const dirtyIndices = [];
+			for (let i = 0; i < oldLen; i++) {
+				const item = newArray[i];
+				const key = orderedKeys[i];
+				const existing = items.get(key);
+				if (existing.item !== item) updateItemInstance(forState, existing, item);
+				if (existing.scope.needsDomUpdate) dirtyIndices.push(i);
+				resultItems[i] = existing;
+				resultVNodes[i] = existing.scope.vnode;
+			}
+			forState.pendingDirtyIndices = dirtyIndices;
+			forState.pendingSwapIndices = null;
+			forState.pendingMoveOnly = false;
+			return resultVNodes;
+		}
+		let firstMismatch = -1;
+		let secondMismatch = -1;
+		let firstMismatchKey = null;
+		let secondMismatchKey = null;
+		let mismatchCount = 0;
+		let canUseSwapPath = true;
+		for (let i = 0; i < oldLen; i++) {
+			const item = newArray[i];
+			const key = byFn(newArray[i], i);
+			if (key === orderedKeys[i]) {
+				const existing = items.get(key);
+				if (existing && existing.item !== item) {
+					canUseSwapPath = false;
+					break;
+				}
+				continue;
+			}
+			mismatchCount++;
+			if (firstMismatch === -1) {
+				firstMismatch = i;
+				firstMismatchKey = key;
+				continue;
+			}
+			if (secondMismatch === -1) {
+				secondMismatch = i;
+				secondMismatchKey = key;
+				continue;
+			}
+			mismatchCount = 3;
+			break;
+		}
+		if (canUseSwapPath && mismatchCount === 2 && firstMismatch !== -1 && secondMismatch !== -1 && firstMismatchKey === orderedKeys[secondMismatch] && secondMismatchKey === orderedKeys[firstMismatch]) {
+			forState.lastCommitStrategy = "SWAP";
+			const nextOrderedKeys = orderedKeys.slice();
+			nextOrderedKeys[firstMismatch] = firstMismatchKey;
+			nextOrderedKeys[secondMismatch] = secondMismatchKey;
+			const resultVNodes = forState.orderedVNodes;
+			const firstExisting = items.get(firstMismatchKey);
+			const secondExisting = items.get(secondMismatchKey);
+			const firstItem = newArray[firstMismatch];
+			const secondItem = newArray[secondMismatch];
+			const nextOrderedItems = forState.orderedItems.slice();
+			nextOrderedItems[firstMismatch] = secondExisting;
+			nextOrderedItems[secondMismatch] = firstExisting;
+			if (firstExisting.item !== firstItem) updateItemInstance(forState, firstExisting, firstItem);
+			if (secondExisting.item !== secondItem) updateItemInstance(forState, secondExisting, secondItem);
+			syncForItemIndex(forState, firstExisting, firstMismatch);
+			syncForItemIndex(forState, secondExisting, secondMismatch);
+			resultVNodes[firstMismatch] = firstExisting.scope.vnode;
+			resultVNodes[secondMismatch] = secondExisting.scope.vnode;
+			forState.orderedKeys = nextOrderedKeys;
+			forState.orderedItems = nextOrderedItems;
+			forState.pendingDirtyIndices = null;
+			forState.pendingSwapIndices = [firstMismatch, secondMismatch];
+			forState.pendingMoveOnly = true;
+			return resultVNodes;
+		}
+		let canUseMoveOnlyPath = true;
+		const moveOnlyKeys = [];
+		const moveOnlyItems = [];
+		const moveOnlyVNodes = [];
+		for (let i = 0; i < oldLen; i++) {
+			const item = newArray[i];
+			const key = byFn(item, i);
+			const existing = items.get(key);
+			if (!existing || existing.item !== item || existing.indexSignal._hasBeenRead && existing.indexSignal.peek() !== i) {
+				canUseMoveOnlyPath = false;
+				break;
+			}
+			moveOnlyKeys[i] = key;
+			moveOnlyItems[i] = existing;
+			moveOnlyVNodes[i] = existing.scope.vnode;
+		}
+		if (canUseMoveOnlyPath) {
+			forState.lastCommitStrategy = "FULL_KEYED";
+			for (let i = 0; i < moveOnlyItems.length; i++) {
+				syncForItemIndex(forState, moveOnlyItems[i], i);
+				moveOnlyVNodes[i] = moveOnlyItems[i].scope.vnode;
+			}
+			forState.orderedKeys = moveOnlyKeys;
+			forState.orderedItems = moveOnlyItems;
+			forState.orderedVNodes = moveOnlyVNodes;
+			forState.pendingDirtyIndices = null;
+			forState.pendingSwapIndices = null;
+			forState.pendingMoveOnly = true;
+			return moveOnlyVNodes;
+		}
+	}
+	forState.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);
+		toRemove.delete(key);
+		newOrderedKeys.push(key);
+		const existing = items.get(key);
+		if (!existing) {
+			const itemInstance = createItemInstance(key, item, i, forState);
+			items.set(key, itemInstance);
+			newOrderedItems.push(itemInstance);
+			resultVNodes.push(itemInstance.scope.vnode);
+		} else {
+			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;
+	forState.orderedVNodes = resultVNodes;
+	forState.pendingDirtyIndices = null;
+	forState.pendingSwapIndices = null;
+	forState.pendingMoveOnly = moveOnly;
+	return resultVNodes;
+}
+//#endregion
+//#region src/runtime/for-internal.ts
+/**
+* For primitive runtime
+*
+* Manages For state storage, hook binding, source evaluation,
+* and DOM update state cleanup.
+*/
+const forStates = /* @__PURE__ */ new WeakMap();
+function getForStore(instance) {
+	const generation = instance._ownershipGeneration;
+	let store = forStates.get(generation);
+	if (!store) {
+		store = /* @__PURE__ */ new Map();
+		forStates.set(generation, store);
+	}
+	return store;
+}
+function createForState(eachSource, byFn, renderFn, fallback) {
+	const parentInstance = getCurrentInstance();
+	const ownedScopes = /* @__PURE__ */ new Set();
+	let bulkDisposing = false;
+	const scopeOwnership = {
+		add: (scope) => ownedScopes.add(scope),
+		delete: (scope) => bulkDisposing ? false : ownedScopes.delete(scope),
+		bulkDispose(run) {
+			bulkDisposing = true;
+			try {
+				run();
+			} finally {
+				bulkDisposing = false;
+				ownedScopes.clear();
+			}
+		}
+	};
+	if (parentInstance) registerOwnedChildScope(parentInstance, {
+		key: "for-boundary",
+		dispose() {
+			scopeOwnership.bulkDispose(() => {
+				const errors = [];
+				for (const scope of ownedScopes) try {
+					scope.dispose();
+				} catch (error) {
+					errors.push(error);
+				}
+				if (errors.length > 0) throw new AggregateError(errors, "For scope cleanup failed");
+			});
+		}
+	});
+	return {
+		kind: "for",
+		currentItems: [],
+		_committedItems: [],
+		eachSource,
+		fallback,
+		fallbackScope: null,
+		items: /* @__PURE__ */ new Map(),
+		orderedKeys: [],
+		orderedItems: [],
+		orderedVNodes: [],
+		byFn,
+		renderFn,
+		parentInstance,
+		lastCommitStrategy: "NO_REORDER",
+		lastRemovedNodes: [],
+		lastRemovedRanges: [],
+		pendingDirtyIndices: null,
+		pendingSwapIndices: null,
+		pendingMoveOnly: false,
+		pendingInsertedIndex: null,
+		pendingRemovedKey: null,
+		pendingAppendStart: null,
+		_hasResolvedItemDom: false,
+		_needsSourceReconcile: false,
+		_sourceEffect: null,
+		_suspendSourceCommit: false,
+		_enqueueBoundaryCommit: null,
+		_scopeOwnership: scopeOwnership,
+		_hasPendingBoundaryCommit: false,
+		_transaction: null
+	};
+}
+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 generation = instance._ownershipGeneration;
+	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);
+		if (store.size === 0 && forStates.get(generation) === store) forStates.delete(generation);
+	});
+	return created;
+}
+function evaluateForState(forState) {
+	if (!Array.isArray(forState.currentItems)) throw new Error("For source must evaluate to an array");
+	beginForStateTransaction(forState);
+	forState._needsSourceReconcile = false;
+	try {
+		return reconcileForItems(forState, forState.currentItems);
+	} catch (error) {
+		rollbackForStateTransaction(forState);
+		throw error;
+	}
+}
+/**
+* Reconciliation changes ownership before DOM work can fail. Keep a private
+* structural snapshot until the boundary has committed so failed work cannot
+* leave provisional child scopes in the parent owner graph.
+*/
+function beginForStateTransaction(forState, collectionMode = "auto") {
+	if (forState._transaction) return;
+	const hasEmptyCollections = forState.items.size === 0 && forState.orderedKeys.length === 0 && forState.orderedItems.length === 0 && forState.orderedVNodes.length === 0;
+	const isFullClear = forState.currentItems.length === 0 && forState.orderedKeys.length > 0;
+	const collectionSnapshotMode = collectionMode === "reuse" ? "reuse" : hasEmptyCollections ? "reset-empty" : isFullClear ? "preserve-clear" : "copy";
+	const transaction = {
+		collectionSnapshotMode,
+		currentItems: forState._committedItems,
+		items: collectionSnapshotMode === "copy" ? new Map(forState.items) : forState.items,
+		orderedKeys: collectionSnapshotMode === "copy" ? forState.orderedKeys.slice() : forState.orderedKeys,
+		orderedItems: collectionSnapshotMode === "copy" ? forState.orderedItems.slice() : forState.orderedItems,
+		orderedVNodes: collectionSnapshotMode === "copy" ? forState.orderedVNodes.slice() : forState.orderedVNodes,
+		fallbackScope: forState.fallbackScope,
+		lastCommitStrategy: forState.lastCommitStrategy,
+		lastRemovedNodes: forState.lastRemovedNodes,
+		lastRemovedRanges: forState.lastRemovedRanges,
+		pendingDirtyIndices: forState.pendingDirtyIndices,
+		pendingSwapIndices: forState.pendingSwapIndices,
+		pendingMoveOnly: forState.pendingMoveOnly,
+		pendingInsertedIndex: forState.pendingInsertedIndex,
+		pendingRemovedKey: forState.pendingRemovedKey,
+		pendingAppendStart: forState.pendingAppendStart,
+		hasResolvedItemDom: forState._hasResolvedItemDom,
+		needsSourceReconcile: forState._needsSourceReconcile,
+		devKeyKinds: forState.devKeyKinds,
+		itemSnapshots: null,
+		unreadIndexSnapshots: null,
+		fallbackScopeSnapshot: null,
+		removedScopes: null,
+		removedScopeNodes: null,
+		removeAllItems: false,
+		signalEffects: null,
+		shouldClearDomUpdateState: false
+	};
+	forState._transaction = transaction;
+	registerForStateTransaction(forState, transaction);
+}
+function registerForStateTransaction(forState, transaction = forState._transaction) {
+	if (!transaction || forState._transaction !== transaction) return false;
+	return registerLifecycleTransaction(transaction, () => commitForStateTransaction(forState, transaction), () => rollbackForStateTransaction(forState, transaction));
+}
+function finalizeForStateRemovals(forState, transaction) {
+	const removedScopes = transaction.removedScopes;
+	if (!transaction.removeAllItems && !removedScopes) return;
+	const cleanupErrors = [];
+	const finalizeScope = (scope) => {
+		const removedDom = scope.dom;
+		const removedRange = scope.range;
+		try {
+			disposeChildScope(scope);
+		} catch (error) {
+			cleanupErrors.push(error);
+		}
+		if (transaction.removedScopeNodes) return;
+		if (typeof Element !== "undefined" && removedDom instanceof Element) try {
+			getRuntimeRenderer().teardownNodeSubtree(removedDom);
+		} catch (error) {
+			cleanupErrors.push(error);
+		}
+		if (removedRange && !removedRange.single) for (let node = removedRange.start.nextSibling; node && node !== removedRange.end;) {
+			const next = node.nextSibling;
+			try {
+				getRuntimeRenderer().teardownNodeSubtree(node);
+			} catch (error) {
+				cleanupErrors.push(error);
+			}
+			node = next;
+		}
+	};
+	if (transaction.removeAllItems) forState._scopeOwnership.bulkDispose(() => {
+		for (let index = 0; index < transaction.orderedItems.length; index++) {
+			const item = transaction.orderedItems[index];
+			if (item) finalizeScope(item.scope);
+		}
+	});
+	for (const scope of removedScopes ?? []) finalizeScope(scope);
+	const removedScopeNodes = transaction.removedScopeNodes;
+	if (removedScopeNodes) for (const node of removedScopeNodes) try {
+		getRuntimeRenderer().teardownNodeSubtree(node);
+	} catch (error) {
+		cleanupErrors.push(error);
+	}
+	if (removedScopes) removedScopes.length = 0;
+	if (removedScopeNodes) removedScopeNodes.length = 0;
+	transaction.removeAllItems = false;
+	if (cleanupErrors.length > 0) logger.error("[Askr] For removal cleanup failed:", new AggregateError(cleanupErrors, "For removal cleanup failed"));
+}
+function finalizeForSignalEffects(transaction) {
+	if (!transaction.signalEffects) return;
+	for (const [source, effect] of transaction.signalEffects) {
+		removeForParentReaders(effect.parentInstance, source);
+		if (effect.notify) notifyForSignalReaders(source, effect.skipInstance, effect.skipOwnedBy);
+	}
+	transaction.signalEffects.clear();
+}
+function finalizeForDomUpdateFlags(forState) {
+	for (let index = 0; index < forState.orderedItems.length; index++) {
+		const item = forState.orderedItems[index];
+		if (item) item.scope.needsDomUpdate = false;
+	}
+	if (forState.fallbackScope) forState.fallbackScope.needsDomUpdate = false;
+}
+function commitForStateTransaction(forState, transaction = forState._transaction) {
+	if (!transaction || forState._transaction !== transaction) return;
+	try {
+		finalizeForStateRemovals(forState, transaction);
+		finalizeForSignalEffects(transaction);
+		if (transaction.shouldClearDomUpdateState) finalizeForDomUpdateFlags(forState);
+	} finally {
+		transaction.itemSnapshots?.clear();
+		transaction.unreadIndexSnapshots?.clear();
+		transaction.fallbackScopeSnapshot = null;
+		forState._committedItems = forState.currentItems;
+		forState._transaction = null;
+	}
+}
+function rollbackForStateTransaction(forState, transaction = forState._transaction) {
+	if (!transaction || forState._transaction !== transaction) return;
+	const rollbackCleanupErrors = [];
+	const scopesToDispose = /* @__PURE__ */ new Set();
+	const committedScopes = transaction.collectionSnapshotMode === "reset-empty" ? null : new Set(transaction.orderedItems.map((item) => item.scope));
+	if (transaction.fallbackScope) committedScopes?.add(transaction.fallbackScope);
+	if (transaction.collectionSnapshotMode === "reset-empty") for (const item of forState.items.values()) scopesToDispose.add(item.scope);
+	else for (const [key, item] of forState.items) if (transaction.items.get(key) !== item) scopesToDispose.add(item.scope);
+	for (const scope of transaction.removedScopes ?? []) if (scope !== transaction.fallbackScope && !committedScopes?.has(scope)) scopesToDispose.add(scope);
+	if (forState.fallbackScope && forState.fallbackScope !== transaction.fallbackScope) scopesToDispose.add(forState.fallbackScope);
+	for (const scope of scopesToDispose) try {
+		disposeChildScope(scope);
+	} catch (error) {
+		rollbackCleanupErrors.push(error);
+	}
+	if (transaction.collectionSnapshotMode === "reset-empty") {
+		forState.items.clear();
+		forState.orderedKeys.length = 0;
+		forState.orderedItems.length = 0;
+		forState.orderedVNodes.length = 0;
+	}
+	for (const [itemInstance, snapshot] of transaction.itemSnapshots ?? []) {
+		itemInstance.item = snapshot.item;
+		const reactiveItemState = itemInstance.reactiveItemState;
+		if (reactiveItemState) reactiveItemState.currentItem = snapshot.item;
+		const itemSignal = reactiveItemState?.itemSignal;
+		if (itemSignal && snapshot.itemSignalExists) {
+			itemSignal.set(snapshot.itemSignalValue, false);
+			itemSignal._hasBeenRead = snapshot.itemSignalHasBeenRead;
+		}
+		itemInstance.indexSignal.set(snapshot.indexValue, false);
+		itemInstance.indexSignal._hasBeenRead = snapshot.indexHasBeenRead;
+		const propertySignals = snapshot.propertySignalStore;
+		if (reactiveItemState) reactiveItemState.propertySignals = propertySignals;
+		if (propertySignals) {
+			propertySignals.clear();
+			for (const [property, propertySnapshot] of snapshot.propertySignals ?? []) {
+				propertySnapshot.signal.set(propertySnapshot.value, false);
+				propertySnapshot.signal._hasBeenRead = propertySnapshot.hasBeenRead;
+				propertySignals.set(property, propertySnapshot.signal);
+			}
+		}
+		restoreChildScopeTransactionSnapshot(itemInstance.scope, snapshot.scope);
+	}
+	for (const [indexSignal, index] of transaction.unreadIndexSnapshots ?? []) indexSignal.set(index, false);
+	if (transaction.fallbackScope && transaction.fallbackScopeSnapshot) restoreChildScopeTransactionSnapshot(transaction.fallbackScope, transaction.fallbackScopeSnapshot);
+	forState.currentItems = transaction.currentItems;
+	forState._committedItems = transaction.currentItems;
+	forState.items = transaction.items;
+	forState.orderedKeys = transaction.orderedKeys;
+	forState.orderedItems = transaction.orderedItems;
+	forState.orderedVNodes = transaction.orderedVNodes;
+	forState.fallbackScope = transaction.fallbackScope;
+	forState.lastCommitStrategy = transaction.lastCommitStrategy;
+	forState.lastRemovedNodes = transaction.lastRemovedNodes;
+	forState.lastRemovedRanges = transaction.lastRemovedRanges;
+	forState.pendingDirtyIndices = transaction.pendingDirtyIndices;
+	forState.pendingSwapIndices = transaction.pendingSwapIndices;
+	forState.pendingMoveOnly = transaction.pendingMoveOnly;
+	forState.pendingInsertedIndex = transaction.pendingInsertedIndex;
+	forState.pendingRemovedKey = transaction.pendingRemovedKey;
+	forState.pendingAppendStart = transaction.pendingAppendStart;
+	forState._hasResolvedItemDom = transaction.hasResolvedItemDom;
+	forState._needsSourceReconcile = transaction.needsSourceReconcile;
+	forState.devKeyKinds = transaction.devKeyKinds;
+	forState._transaction = null;
+	if (rollbackCleanupErrors.length > 0) logger.error("[Askr] transaction rollback cleanup failed:", new AggregateError(rollbackCleanupErrors, "Transaction rollback cleanup failed"));
+}
+function clearForDomUpdateState(forState) {
+	const transaction = forState._transaction;
+	if (transaction) transaction.shouldClearDomUpdateState = true;
+	if (transaction && !registerForStateTransaction(forState, transaction)) commitForStateTransaction(forState, transaction);
+	if (!transaction) finalizeForDomUpdateFlags(forState);
+	forState.lastRemovedNodes = [];
+	forState.lastRemovedRanges = [];
+	forState.pendingDirtyIndices = null;
+	forState.pendingSwapIndices = null;
+	forState.pendingMoveOnly = false;
+	forState.pendingInsertedIndex = null;
+	forState.pendingRemovedKey = null;
+	forState.pendingAppendStart = null;
+	forState._needsSourceReconcile = false;
+	forState._hasResolvedItemDom = forState.orderedKeys.length > 0;
+}
+//#endregion
+export { createChildScope as _, registerForStateTransaction as a, captureForFallbackTransactionSnapshot as c, clearCaseDomUpdateState as d, clearShowDomUpdateState as f, evaluateShowState as g, evaluateCaseState as h, evaluateForState as i, captureForItemTransactionSnapshot as l, createShowState as m, clearForDomUpdateState as n, rollbackForStateTransaction as o, createCaseState as p, commitForStateTransaction as r, useForState as s, beginForStateTransaction as t, recordBenchEvent as u, disposeChildScope as v, rerenderChildScope as y };