@askrjs/askr 0.3.0 → 0.4.0

package/dist/for-state-BDykeOJL.js

@@ -1,1753 +0,0 @@
-import { a as getRuntimeEvaluation, c as getRuntimeScopes, i as getRuntimeCleanup, v as logger, w as isDevelopmentEnvironment } from "./access-CEA2pOry.js";
-import { C as rebaseVNodeTreeWithContextFrame, I as DIRECT_RANGE_OWNER, O as registerOwnedChildScope, T as cleanupComponent, _ as haveEquivalentContextFrames, j as finalizeInlineReadSubscriptions, n as createComponentInstance, s as renderScopedComponent } from "./instance-VAFYVJOa.js";
-import { A as releaseOwnedChild, C as disposeOwnership, D as ownChild, O as ownCleanup, S as detachOwnedChildren, b as attachOwnership, f as getCurrentComponentInstance, i as claimHookIndex, k as registerScopedOwnership, m as getCurrentStateIndex, o as clearRenderTracking, y as OwnershipRecord } from "./scope-Cq_iYbTR.js";
-import { t as adoptComponentParent } from "./capabilities-Bbf0mlp9.js";
-import { i as commitTransaction, l as registerCommitParticipant, n as applyTransaction, o as discardTransaction, p as suspendTransaction, r as beginCommitTransaction, s as getCurrentCommitTransaction, t as notifyReadableSource, u as registerCommitRollback, v as recordReadableRead, y as shouldCoalesceFineGrainedItemReads } from "./notify-DxxuDPeY.js";
-import { n as _isDOMElement } from "./vnode-D24p6IW2.js";
-//#region src/runtime/ownership/child-scope.ts
-const EMPTY_CHILD_SCOPE_PROPS = {};
-const childScopesByInstance = /* @__PURE__ */ new WeakMap();
-function executeChildScopeComponent() {
-	const instance = getCurrentComponentInstance();
-	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 || instance.owner.disposed) return;
-		if (scope._preparedTransaction) discardTransaction(scope._preparedTransaction);
-		const transaction = beginCommitTransaction();
-		scope._preparedTransaction = transaction;
-		const snapshot = captureChildScopeTransactionSnapshot(scope);
-		registerCommitRollback(() => {
-			if (!instance.owner.disposed) restoreChildScopeTransactionSnapshot(scope, snapshot);
-		});
-		try {
-			renderScope(scope);
-			suspendTransaction(transaction);
-			if (scope._onDirty) scope._onDirty();
-			else {
-				scope._preparedTransaction = void 0;
-				commitTransaction(transaction);
-			}
-		} catch (error) {
-			discardTransaction(transaction);
-			scope._preparedTransaction = void 0;
-			throw error;
-		} finally {
-			suspendTransaction(transaction);
-		}
-	};
-}
-var ChildScopeImpl = class {
-	get [DIRECT_RANGE_OWNER]() {
-		return true;
-	}
-	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._renderedOwnerFrame = null;
-		this.key = key;
-		this._parentOwnership = parent?.owner ?? null;
-		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);
-		this.componentInstance.owner.finalizer = this;
-		registerScopedOwnership(this, this.componentInstance.owner);
-		if (parent) {
-			adoptComponentParent(this.componentInstance, 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() {
-		cleanupComponent(this.componentInstance);
-	}
-	release() {
-		try {
-			if (this._preparedTransaction) discardTransaction(this._preparedTransaction);
-			this._preparedTransaction = void 0;
-			if (this._ownership) this._ownership.delete(this);
-			else if (this._parentOwnership) releaseOwnedChild(this._parentOwnership, this);
-		} finally {
-			childScopesByInstance.delete(this.componentInstance);
-			this._renderFn = void 0;
-			this.previousVnode = void 0;
-			this.vnode = void 0;
-			getRuntimeScopes().clearChildScopeHost(this);
-			this.needsDomUpdate = false;
-			this.hydrationPending = false;
-			this.blueprintOwner = void 0;
-			this.componentInstance.hasPendingUpdate = false;
-			this._parentOwnership = null;
-			this._onDirty = void 0;
-			this._ownership = void 0;
-			this._renderedOwnerFrame = null;
-		}
-	}
-};
-function renderScope(scope) {
-	if (scope.componentInstance.owner.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;
-	joinChildScopePreparation(scope);
-	const { componentInstance } = scope;
-	const previousVNode = scope.vnode;
-	try {
-		const nextVNode = rebaseVNodeTreeWithContextFrame(renderScopedComponent(componentInstance, scope._startStateIndex, scope._renderFn), componentInstance.ownerFrame, scope._renderedOwnerFrame);
-		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._renderedOwnerFrame = componentInstance.ownerFrame;
-		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);
-}
-/** Join prepared reads and scope restoration to the transaction applying its output. */
-function joinChildScopePreparation(scope) {
-	const mutable = scope;
-	const transaction = mutable._preparedTransaction;
-	const current = getCurrentCommitTransaction();
-	if (!transaction || !current || transaction === current) return;
-	mutable._preparedTransaction = void 0;
-	applyTransaction(transaction, () => {});
-	commitTransaction(transaction);
-}
-/** @internal */
-function captureChildScopeTransactionSnapshot(scope) {
-	const mutableScope = scope;
-	return {
-		previousVnode: scope.previousVnode,
-		vnode: scope.vnode,
-		host: getRuntimeScopes().captureChildScopeHost(scope),
-		needsDomUpdate: scope.needsDomUpdate,
-		hydrationPending: scope.hydrationPending,
-		renderFn: mutableScope._renderFn,
-		renderedOwnerFrame: mutableScope._renderedOwnerFrame
-	};
-}
-/** @internal */
-function restoreChildScopeTransactionSnapshot(scope, snapshot) {
-	const mutableScope = scope;
-	scope.previousVnode = snapshot.previousVnode;
-	scope.vnode = snapshot.vnode;
-	snapshot.host?.restore(scope);
-	scope.needsDomUpdate = snapshot.needsDomUpdate;
-	scope.hydrationPending = snapshot.hydrationPending;
-	mutableScope._renderFn = snapshot.renderFn;
-	mutableScope._renderedOwnerFrame = snapshot.renderedOwnerFrame;
-}
-function disposeChildScope(scope) {
-	scope.dispose();
-}
-function createChildScope(parent, key, onDirty, ownership) {
-	return new ChildScopeImpl(parent, key, onDirty, ownership);
-}
-//#endregion
-//#region src/runtime/control/branches.ts
-function setScopeContextFrame(scope, frame) {
-	if (scope) scope.componentInstance.ownerFrame = frame;
-}
-function setControlBoundaryContextFrame(controlState, frame) {
-	const previousFrame = controlState._contextFrame;
-	controlState._contextFrame = frame;
-	if (controlState.kind === "for") {
-		controlState._contextFrameChanged ||= previousFrame !== null && !haveEquivalentContextFrames(previousFrame, frame);
-		setScopeContextFrame(controlState.fallbackScope, frame);
-		for (const item of controlState.items.values()) setScopeContextFrame(item.scope, frame);
-		return;
-	}
-	setScopeContextFrame(controlState.activeScope, frame);
-	if (controlState.kind === "show") {
-		setScopeContextFrame(controlState.truthyScope, frame);
-		setScopeContextFrame(controlState.fallbackScope, frame);
-	}
-}
-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 = registerCommitParticipant({
-		key: transaction,
-		collision: "keep-first",
-		publish: () => publishControlTransaction(state, transaction),
-		settle: () => commitControlTransaction(state, transaction),
-		rollback: () => 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 removedRange = getRuntimeEvaluation().resolveChildScopeRange?.(scope) ?? scope.range;
-	const removedDom = removedRange?.single ? removedRange.start : scope.dom;
-	if (removedDom) state.lastRemovedNodes.push(removedDom);
-	if (removedRange) state.lastRemovedRanges.push(removedRange);
-}
-function publishControlTransaction(state, transaction) {
-	if (state._transaction !== transaction) return;
-	if (transaction.shouldClearDomUpdateState) {
-		for (const scope of getBranchScopes(state)) scope.needsDomUpdate = false;
-		state.lastRemovedNodes = [];
-		state.lastRemovedRanges = [];
-	}
-	state._transaction = null;
-	transaction.published = true;
-}
-function commitControlTransaction(state, transaction) {
-	if (!transaction.published) publishControlTransaction(state, transaction);
-	if (!transaction.published) return;
-	transaction.published = false;
-	const errors = [];
-	for (const scope of transaction.removedScopes) try {
-		disposeChildScope(scope);
-	} catch (error) {
-		errors.push(error);
-	}
-	transaction.removedScopes.length = 0;
-	if (errors.length) throw new AggregateError(errors, "Control branch cleanup failed");
-}
-function rollbackControlTransaction(state, transaction) {
-	if (state._transaction !== transaction && !transaction.published) return;
-	transaction.published = false;
-	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) {
-	const scope = createChildScope(state.parentInstance, key, () => {
-		if (state._enqueueBoundaryCommit) {
-			state._enqueueBoundaryCommit();
-			return;
-		}
-		state.parentInstance?._enqueueRun?.();
-	});
-	if (state._contextFrame) scope.componentInstance.ownerFrame = state._contextFrame;
-	return scope;
-}
-function createShowState(value, renderTruthy, renderFallback) {
-	return {
-		kind: "show",
-		_contextFrame: null,
-		activeKey: null,
-		activeScope: null,
-		activeVNodes: [],
-		fallbackScope: null,
-		lastRemovedNodes: [],
-		lastRemovedRanges: [],
-		parentInstance: getCurrentComponentInstance(),
-		_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",
-		_contextFrame: null,
-		activeKey: null,
-		activeScope: null,
-		activeVNodes: [],
-		fallback,
-		lastRemovedNodes: [],
-		lastRemovedRanges: [],
-		matches,
-		parentInstance: getCurrentComponentInstance(),
-		_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 = [];
-}
-const recordBenchEvent = (_event) => {};
-//#endregion
-//#region src/runtime/control/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) {
-	notifyReadableSource(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;
-		const itemSignal = getWholeItemSignal(metadata);
-		recordReadableRead(itemSignal);
-		return prop in target || prop in Object(metadata.currentItem);
-	},
-	ownKeys(target) {
-		const metadata = getReactiveForItemState(target);
-		metadata.wholeItemRead = true;
-		const itemSignal = getWholeItemSignal(metadata);
-		recordReadableRead(itemSignal);
-		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;
-		const itemSignal = getWholeItemSignal(metadata);
-		recordReadableRead(itemSignal);
-		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;
-		const itemSignal = getWholeItemSignal(metadata);
-		recordReadableRead(itemSignal);
-		return Object.getPrototypeOf(Object(metadata.currentItem));
-	},
-	set(target, prop, value) {
-		if (!(prop in target) && typeof prop !== "symbol" && isDevelopmentEnvironment()) {
-			const metadata = getReactiveForItemState(target);
-			if (prop in Object(metadata.currentItem)) logger.warn(`[Askr] Assigning to "${String(prop)}" on a <For> item shadows a property from the source data - it will not update when the source item changes and does not trigger a re-render. Use a different property name for cached/derived per-row values, or a state() cell for values that should be reactive.`);
-		}
-		return Reflect.defineProperty(target, prop, {
-			value,
-			writable: true,
-			enumerable: true,
-			configurable: true
-		});
-	}
-};
-//#endregion
-//#region src/runtime/control/for-scopes.ts
-function recordRemovedBoundary(forState, dom, range) {
-	getRuntimeScopes().recordRemovedScopeBoundary(dom, range, forState.lastRemovedNodes, forState.lastRemovedRanges);
-}
-function prepareRemovedScope(forState, scope) {
-	const transaction = forState._transaction;
-	if (!transaction) return getRuntimeScopes().resolveScopeBoundary(scope);
-	return getRuntimeScopes().prepareScopeRemoval(scope, forState.lastRemovedNodes, forState.lastRemovedRanges, transaction.removedScopeNodes ??= []);
-}
-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) {
-	const scope = createChildScope(forState.parentInstance, key, enqueueForBoundaryScopeCommit, forState._scopeOwnership);
-	if (forState._contextFrame) scope.componentInstance.ownerFrame = forState._contextFrame;
-	return scope;
-}
-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 { dom: removedDom, range: removedRange } = prepareRemovedScope(forState, itemInstance.scope);
-	const transaction = forState._transaction;
-	if (transaction) {
-		(transaction.removedScopes ??= []).push(itemInstance.scope);
-		return;
-	}
-	try {
-		disposeChildScope(itemInstance.scope);
-	} catch (err) {
-		if (isDevelopmentEnvironment()) console.error("[For] Cleanup error:", err);
-	}
-	if (!removedDom && !removedRange) return;
-	if (domCleanup === "teardown") getRuntimeScopes().teardownScopeHost(removedDom, void 0);
-	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 refreshForContextScopes(forState) {
-	for (const itemInstance of forState.items.values()) {
-		captureForItemTransactionSnapshot(forState, itemInstance);
-		rerenderItemInstance(forState, itemInstance, itemInstance.reactiveItem);
-	}
-}
-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 { dom: removedDom, range: removedRange } = prepareRemovedScope(forState, fallbackScope);
-	const transaction = forState._transaction;
-	if (transaction) (transaction.removedScopes ??= []).push(fallbackScope);
-	else disposeChildScope(fallbackScope);
-	forState.fallbackScope = null;
-	if (!removedDom && !removedRange) return;
-	if (domCleanup === "teardown") getRuntimeScopes().teardownScopeHost(removedDom, void 0);
-	if (!transaction) 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;
-			if (scope) prepareRemovedScope(forState, scope);
-		}
-		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/control/for-paths/pending.ts
-/**
-* Publish the strategy a path chose, together with the three pending fields
-* every path owns.
-*
-* Every parameter is required, so a path cannot leave one of these behind by
-* omission — which is how they were previously written, one scattered
-* assignment at a time. The three remaining `pending*` fields belong to exactly
-* one path each (`pendingInsertedIndex`, `pendingAppendStart`,
-* `pendingRemovedKey`) and are assigned by that path directly; the others leave
-* them as reconciliation found them, since each commit clears them through
-* `clearForDomUpdateState`.
-*/
-function setForCommitPending(forState, strategy, pendingDirtyIndices, pendingSwapIndices, pendingMoveOnly) {
-	forState.lastCommitStrategy = strategy;
-	forState.pendingDirtyIndices = pendingDirtyIndices;
-	forState.pendingSwapIndices = pendingSwapIndices;
-	forState.pendingMoveOnly = pendingMoveOnly;
-}
-//#endregion
-//#region src/runtime/control/for-paths/append.ts
-/**
-* Rows added at the tail, every existing key still at its own index.
-*
-* When the retained prefix is also clean the commit can skip it entirely, which
-* `pendingAppendStart` reports; otherwise the prefix is updated in place and the
-* commit starts from zero.
-*
-* Guarded by `oldLen < newLen`.
-*/
-function tryAppendPath(forState, newArray, items, orderedKeys, byFn, 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) return null;
-	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;
-	setForCommitPending(forState, "APPEND", null, null, false);
-	forState.pendingAppendStart = canSkipCommittedPrefix ? oldLen : 0;
-	return resultVNodes;
-}
-//#endregion
-//#region src/runtime/control/for-paths/full-keyed.ts
-/**
-* A pure permutation: every new key resolves to an existing, unchanged item
-* whose index signal is either unread or already correct.
-*
-* Commits as FULL_KEYED, but flagged `pendingMoveOnly` so the commit can move
-* the existing nodes instead of rebuilding them.
-*
-* Guarded by `oldLen === newLen`, and runs only after NO_REORDER and SWAP
-* decline.
-*/
-function tryMoveOnlyKeyedPath(forState, newArray, items, byFn, oldLen) {
-	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) return null;
-		moveOnlyKeys[i] = key;
-		moveOnlyItems[i] = existing;
-		moveOnlyVNodes[i] = existing.scope.vnode;
-	}
-	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;
-	setForCommitPending(forState, "FULL_KEYED", null, null, true);
-	return moveOnlyVNodes;
-}
-/**
-* The general keyed reconciliation every other path declines to handle.
-*
-* One pass over the new array creates, reuses or reindexes each row while
-* tracking which old keys survive; whatever is left over is disposed. Always
-* succeeds, so it takes no guard and returns no `null`.
-*/
-function fullKeyedPath(forState, newArray, items, orderedKeys, byFn) {
-	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;
-	setForCommitPending(forState, "FULL_KEYED", null, null, moveOnly);
-	return resultVNodes;
-}
-//#endregion
-//#region src/runtime/control/for-paths/insert-one.ts
-/**
-* One row inserted, every existing DOM node retained.
-*
-* Requires that no shifted row has read its index signal and that no retained
-* row is already dirty: this path only syncs the inserted index, so a pending
-* update anywhere else would be silently dropped. Every other shape falls
-* through to the general keyed path.
-*
-* Guarded by `newLen === oldLen + 1`.
-*/
-function tryInsertOnePath(forState, newArray, items, orderedKeys, byFn, oldLen, newLen) {
-	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)) return 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.orderedKeys = resultKeys;
-	forState.orderedItems = resultItems;
-	forState.orderedVNodes = resultVNodes;
-	for (let index = insertedIndex; index < resultItems.length; index += 1) syncForItemIndex(forState, resultItems[index], index);
-	setForCommitPending(forState, "INSERT_ONE", null, null, false);
-	forState.pendingInsertedIndex = insertedIndex;
-	return resultVNodes;
-}
-//#endregion
-//#region src/runtime/control/for-paths/no-reorder.ts
-/**
-* Same length, same key at every index: an in-place update with no DOM moves.
-*
-* Dirtiness is read from the scope after `updateItemInstance`, so a row whose
-* item is unchanged but whose subtree was invalidated still commits.
-*
-* Guarded by `oldLen === newLen`.
-*/
-function tryNoReorderPath(forState, newArray, items, orderedKeys, byFn, oldLen) {
-	for (let i = 0; i < oldLen; i++) if (byFn(newArray[i], i) !== orderedKeys[i]) return null;
-	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;
-	}
-	setForCommitPending(forState, "NO_REORDER", dirtyIndices, null, false);
-	return resultVNodes;
-}
-//#endregion
-//#region src/runtime/control/for-paths/remove-one.ts
-/**
-* Exactly one row removed, the suffix shifted up by one.
-*
-* The shifted suffix keeps its instances; only rows whose item or index
-* actually changed land in the dirty list. `pendingRemovedKey` tells the commit
-* which keyed-map entry to drop, and the commit detaches that node before
-* applying the plan so dirty rows anchor on post-removal indices.
-*
-* Guarded by `oldLen === newLen + 1`.
-*/
-function tryRemoveOnePath(forState, newArray, items, orderedKeys, byFn, newLen) {
-	let removedIndex = -1;
-	for (let i = 0; i < newLen; i++) if (byFn(newArray[i], i) !== orderedKeys[i]) {
-		removedIndex = i;
-		break;
-	}
-	if (removedIndex === -1) return null;
-	for (let i = removedIndex; i < newLen; i++) if (byFn(newArray[i], i) !== orderedKeys[i + 1]) return null;
-	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);
-	}
-	setForCommitPending(forState, "REMOVE_ONE", dirtyIndices, null, false);
-	forState.pendingRemovedKey = removedKey;
-	return resultVNodes;
-}
-//#endregion
-//#region src/runtime/control/for-paths/swap.ts
-/**
-* Exactly two rows exchanged, everything else untouched.
-*
-* Bails when any key-matched row already carries a pending DOM update: SWAP
-* only ever syncs the two swapped indices, so such a row would silently lose
-* its update. This mirrors the INSERT_ONE guard.
-*
-* Guarded by `oldLen === newLen`, and runs only after NO_REORDER declines.
-*/
-function trySwapPath(forState, newArray, items, orderedKeys, byFn, oldLen) {
-	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 || existing.scope.needsDomUpdate)) {
-				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])) return null;
-	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] = firstExisting;
-	nextOrderedItems[secondMismatch] = secondExisting;
-	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;
-	setForCommitPending(forState, "SWAP", null, [firstMismatch, secondMismatch], true);
-	return resultVNodes;
-}
-//#endregion
-//#region src/runtime/control/for-paths/truncate.ts
-/**
-* The tail dropped, the surviving prefix keeping its keys and positions.
-*
-* Survivors are updated in place; the removed tail is disposed here, so the
-* commit only has to patch the dirty survivors and detach the orphaned nodes.
-* A survivor also counts as dirty when its component host was unmounted out
-* from under it.
-*
-* Guarded by `newLen < oldLen`.
-*/
-function tryTruncatePath(forState, newArray, items, orderedKeys, byFn, oldLen, newLen) {
-	for (let i = 0; i < newLen; i++) if (byFn(newArray[i], i) !== orderedKeys[i]) return null;
-	const resultVNodes = forState.orderedVNodes;
-	const resultItems = forState.orderedItems;
-	resultVNodes.length = newLen;
-	resultItems.length = newLen;
-	const isFullClear = newLen === 0;
-	const dirtyIndices = [];
-	for (let i = 0; i < newLen; i++) {
-		const item = newArray[i];
-		const key = orderedKeys[i];
-		const existing = items.get(key);
-		const itemChanged = existing.item !== item;
-		const scopeNeedsDomUpdate = existing.scope.needsDomUpdate || getRuntimeScopes().hasUnmountedComponentHost(existing.scope.dom);
-		if (itemChanged) updateItemInstance(forState, existing, item);
-		if (itemChanged || scopeNeedsDomUpdate) dirtyIndices.push(i);
-		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;
-	setForCommitPending(forState, "TRUNCATE", dirtyIndices, null, false);
-	return resultVNodes;
-}
-//#endregion
-//#region src/runtime/control/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");
-	/** Close out the pass. Each path has already published its own decision. */
-	const finish = (vnodes) => {
-		return vnodes;
-	};
-	if (newLen === oldLen + 1) {
-		const inserted = tryInsertOnePath(forState, newArray, items, orderedKeys, byFn, oldLen, newLen);
-		if (inserted) return finish(inserted);
-	}
-	if (oldLen < newLen) {
-		const appended = tryAppendPath(forState, newArray, items, orderedKeys, byFn, oldLen, newLen);
-		if (appended) return finish(appended);
-	}
-	if (newLen < oldLen) {
-		if (oldLen === newLen + 1) {
-			const removed = tryRemoveOnePath(forState, newArray, items, orderedKeys, byFn, newLen);
-			if (removed) return finish(removed);
-		}
-		const truncated = tryTruncatePath(forState, newArray, items, orderedKeys, byFn, oldLen, newLen);
-		if (truncated) return finish(truncated);
-	}
-	if (oldLen === newLen) {
-		const unmoved = tryNoReorderPath(forState, newArray, items, orderedKeys, byFn, oldLen);
-		if (unmoved) return finish(unmoved);
-		const swapped = trySwapPath(forState, newArray, items, orderedKeys, byFn, oldLen);
-		if (swapped) return finish(swapped);
-		const moved = tryMoveOnlyKeyedPath(forState, newArray, items, byFn, oldLen);
-		if (moved) return finish(moved);
-	}
-	return finish(fullKeyedPath(forState, newArray, items, orderedKeys, byFn));
-}
-//#endregion
-//#region src/runtime/control/for-state.ts
-const forStates = /* @__PURE__ */ new WeakMap();
-function getForStore(instance) {
-	const generation = instance.owner.identity;
-	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 = getCurrentComponentInstance();
-	const scopeOwner = new OwnershipRecord();
-	const scopeOwnership = {
-		add: (scope) => ownChild(scopeOwner, scope),
-		delete: (scope) => releaseOwnedChild(scopeOwner, scope),
-		bulkDispose(run) {
-			detachOwnedChildren(scopeOwner);
-			run();
-		}
-	};
-	if (parentInstance) {
-		registerScopedOwnership({
-			key: "for-boundary",
-			dispose() {
-				disposeOwnership(scopeOwner);
-			}
-		}, scopeOwner);
-		attachOwnership(scopeOwner, parentInstance.owner);
-	}
-	return {
-		kind: "for",
-		_contextFrame: null,
-		_contextFrameChanged: false,
-		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 = getCurrentComponentInstance();
-	if (!instance) throw new Error("For can only be created during component render execution.");
-	const hookIndex = claimHookIndex(instance, "For");
-	const generation = instance.owner.identity;
-	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);
-	ownCleanup(instance.owner, () => {
-		try {
-			created._sourceEffect?.cleanup();
-		} finally {
-			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 {
-		if (forState._contextFrameChanged) refreshForContextScopes(forState);
-		const result = reconcileForItems(forState, forState.currentItems);
-		forState._contextFrameChanged = false;
-		return result;
-	} 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 registerCommitParticipant({
-		key: transaction,
-		collision: "keep-first",
-		publish: () => publishForStateTransaction(forState, transaction),
-		settle: () => commitForStateTransaction(forState, transaction),
-		rollback: () => 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;
-		getRuntimeScopes().teardownScopeHost(removedDom, removedRange, (error) => cleanupErrors.push(error));
-	};
-	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 {
-		getRuntimeCleanup().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 publishForStateTransaction(forState, transaction) {
-	if (forState._transaction !== transaction) return;
-	if (transaction.shouldClearDomUpdateState) finalizeForDomUpdateFlags(forState);
-	forState._committedItems = forState.currentItems;
-	forState._transaction = null;
-	transaction.published = true;
-}
-function commitForStateTransaction(forState, transaction = forState._transaction) {
-	if (!transaction) return;
-	if (!transaction.published) publishForStateTransaction(forState, transaction);
-	if (!transaction.published) return;
-	transaction.published = false;
-	const errors = [];
-	try {
-		try {
-			finalizeForStateRemovals(forState, transaction);
-		} catch (error) {
-			errors.push(error);
-		}
-		try {
-			finalizeForSignalEffects(transaction);
-		} catch (error) {
-			errors.push(error);
-		}
-	} finally {
-		transaction.itemSnapshots?.clear();
-		transaction.unreadIndexSnapshots?.clear();
-		transaction.fallbackScopeSnapshot = null;
-	}
-	if (errors.length) throw new AggregateError(errors, "For settlement failed");
-}
-function rollbackForStateTransaction(forState, transaction = forState._transaction) {
-	if (!transaction || forState._transaction !== transaction && !transaction.published) return;
-	transaction.published = false;
-	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 { setControlBoundaryContextFrame as _, registerForStateTransaction as a, joinChildScopePreparation as b, 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, createChildScope as v, rerenderChildScope as x, disposeChildScope as y };