@askrjs/askr 0.0.51 → 0.0.52

package/dist/runtime/for-bench.js

@@ -1,171 +1,13 @@
-import { isRuntimeEnvFlagEnabled } from "../common/env.js";
 //#region src/runtime/for-bench.ts
-const BENCH_BUILD_ENABLED = isRuntimeEnvFlagEnabled("ASKR_BENCH");
-function createInitialBenchMetrics() {
-	return {
-		itemsCreated: 0,
-		itemsReused: 0,
-		itemsRemoved: 0,
-		itemsMoved: 0,
-		rowFactoryInvocations: 0,
-		keyLookups: 0,
-		keyHits: 0,
-		keyMisses: 0,
-		domInserts: 0,
-		domRemoves: 0,
-		domMoves: 0,
-		domAttrSets: 0,
-		domTextSets: 0,
-		domNodesCreated: 0,
-		listenerBindings: 0,
-		reactivePropsMounted: 0,
-		replaceChildrenCommits: 0,
-		bulkClearCommits: 0,
-		reconcilePhaseMs: 0,
-		domCommitPhaseMs: 0,
-		fastLaneName: null
-	};
-}
-let activeBenchMetricScope = null;
-function isBenchRuntimeEnabled() {
-	if (!BENCH_BUILD_ENABLED) return false;
-	try {
-		return !!globalThis.__ASKR_BENCH__;
-	} catch {
-		return false;
-	}
-}
-function publishBenchMetrics(metrics) {
-	if (!isBenchRuntimeEnabled()) return;
-	globalThis.__ASKR_FOR_BENCH__ = { ...metrics };
-}
-const flushBenchMetricsLive = () => {
-	if (!benchMetrics) return;
-	publishBenchMetrics(benchMetrics);
-};
-function resetBenchMetricsLive(metrics) {
-	metrics.itemsCreated = 0;
-	metrics.itemsReused = 0;
-	metrics.itemsRemoved = 0;
-	metrics.itemsMoved = 0;
-	metrics.rowFactoryInvocations = 0;
-	metrics.keyLookups = 0;
-	metrics.keyHits = 0;
-	metrics.keyMisses = 0;
-	metrics.domInserts = 0;
-	metrics.domRemoves = 0;
-	metrics.domMoves = 0;
-	metrics.domAttrSets = 0;
-	metrics.domTextSets = 0;
-	metrics.domNodesCreated = 0;
-	metrics.listenerBindings = 0;
-	metrics.reactivePropsMounted = 0;
-	metrics.replaceChildrenCommits = 0;
-	metrics.bulkClearCommits = 0;
-	metrics.reconcilePhaseMs = 0;
-	metrics.domCommitPhaseMs = 0;
-	metrics.fastLaneName = null;
-	publishBenchMetrics(metrics);
-}
-const benchMetrics = BENCH_BUILD_ENABLED ? createInitialBenchMetrics() : null;
-const recordBenchEventLive = (event, delta = 1) => {
-	if (!isBenchRuntimeEnabled() || !benchMetrics) return;
-	if (delta === 0) return;
-	switch (event) {
-		case "itemCreated":
-			benchMetrics.itemsCreated += delta;
-			break;
-		case "itemReused":
-			benchMetrics.itemsReused += delta;
-			break;
-		case "itemRemoved":
-			benchMetrics.itemsRemoved += delta;
-			break;
-		case "itemMoved":
-			benchMetrics.itemsMoved += delta;
-			break;
-		case "rowFactory":
-			benchMetrics.rowFactoryInvocations += delta;
-			break;
-		case "keyLookup":
-			benchMetrics.keyLookups += delta;
-			break;
-		case "keyHit":
-			benchMetrics.keyHits += delta;
-			break;
-		case "keyMiss":
-			benchMetrics.keyMisses += delta;
-			break;
-		case "domInsert":
-			benchMetrics.domInserts += delta;
-			break;
-		case "domRemove":
-			benchMetrics.domRemoves += delta;
-			break;
-		case "domMove":
-			benchMetrics.domMoves += delta;
-			break;
-		case "domAttrSet":
-			benchMetrics.domAttrSets += delta;
-			break;
-		case "domTextSet":
-			benchMetrics.domTextSets += delta;
-			break;
-	}
-};
-const recordBenchFastLaneLive = (name) => {
-	if (!isBenchRuntimeEnabled() || !benchMetrics) return;
-	benchMetrics.fastLaneName = name;
-};
-const recordBenchCounterLive = (counter, delta = 1) => {
-	if (!isBenchRuntimeEnabled() || !benchMetrics || delta === 0) return;
-	switch (counter) {
-		case "domNodesCreated":
-			benchMetrics.domNodesCreated += delta;
-			break;
-		case "listenerBindings":
-			benchMetrics.listenerBindings += delta;
-			break;
-		case "reactivePropsMounted":
-			benchMetrics.reactivePropsMounted += delta;
-			break;
-		case "replaceChildrenCommits":
-			benchMetrics.replaceChildrenCommits += delta;
-			break;
-		case "bulkClearCommits":
-			benchMetrics.bulkClearCommits += delta;
-			break;
-	}
-};
-function withBenchMetricScopeLive(scope, run) {
-	if (!isBenchRuntimeEnabled()) return run();
-	const previousScope = activeBenchMetricScope;
-	activeBenchMetricScope = scope;
-	try {
-		return run();
-	} finally {
-		activeBenchMetricScope = previousScope;
-	}
-}
-const isBenchMetricScopeActiveLive = (scope) => isBenchRuntimeEnabled() && activeBenchMetricScope === scope;
-const recordBenchTimingLive = (phase, ms) => {
-	if (!isBenchRuntimeEnabled() || !benchMetrics) return;
-	if (phase === "reconcile") benchMetrics.reconcilePhaseMs = ms;
-	else benchMetrics.domCommitPhaseMs = ms;
-};
-const resetBenchMetrics = BENCH_BUILD_ENABLED ? () => {
-	if (!isBenchRuntimeEnabled() || !benchMetrics) return;
-	resetBenchMetricsLive(benchMetrics);
-} : () => {};
-const recordBenchEvent = BENCH_BUILD_ENABLED ? recordBenchEventLive : (_event) => {};
-const recordBenchFastLane = BENCH_BUILD_ENABLED ? recordBenchFastLaneLive : (_name) => {};
-const recordBenchTiming = BENCH_BUILD_ENABLED ? recordBenchTimingLive : (_phase, _ms) => {};
-const recordBenchCounter = BENCH_BUILD_ENABLED ? recordBenchCounterLive : (_counter, _delta = 1) => {};
-const withBenchMetricScope = BENCH_BUILD_ENABLED ? withBenchMetricScopeLive : (_scope, run) => run();
-const isBenchMetricScopeActive = BENCH_BUILD_ENABLED ? isBenchMetricScopeActiveLive : (_scope) => false;
-const flushBenchMetrics = BENCH_BUILD_ENABLED ? flushBenchMetricsLive : () => {};
+const BENCH_BUILD_ENABLED = false;
+const resetBenchMetrics = () => {};
+const recordBenchEvent = (_event) => {};
+const recordBenchFastLane = (_name) => {};
+const recordBenchTiming = (_phase, _ms) => {};
+const recordBenchCounter = (_counter, _delta = 1) => {};
+const withBenchMetricScope = (_scope, run) => run();
+const isBenchMetricScopeActive = (_scope) => false;
+const flushBenchMetrics = () => {};
 const isBenchBuildEnabled = () => BENCH_BUILD_ENABLED;
 //#endregion
 export { flushBenchMetrics, isBenchBuildEnabled, isBenchMetricScopeActive, recordBenchCounter, recordBenchEvent, recordBenchFastLane, recordBenchTiming, resetBenchMetrics, withBenchMetricScope };
-
-//# sourceMappingURL=for-bench.js.map

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

@@ -1,5 +1,8 @@
 import { ComponentInstance } from "./component-internal.js";
-import { ChildScope } from "./child-scope.js";
+import { ReadableSource } from "./readable.js";
+import { DOMRange } from "../common/dom-range.js";
+import { ChildScope, ChildScopeTransactionSnapshot } from "./child-scope.js";
+import { ForIndexSignal, ForItemPropertySignal } from "./for-signals.js";
 import { ForItemInstance } from "./for-scopes.js";
 import { FineGrainedEffectHandle } from "./effect.js";
 import { ForEachSource, ForKeySelector, ForRenderItem } from "./for-types.js";
@@ -7,10 +10,11 @@ import { reconcileForItems } from "./for-reconcile.js";
 import { VNode } from "../common/vnode.js";
 
 //#region src/runtime/for-internal.d.ts
-type ForCommitStrategy = 'APPEND' | 'TRUNCATE' | 'NO_REORDER' | 'SWAP' | 'FULL_KEYED';
+type ForCommitStrategy = 'APPEND' | 'INSERT_ONE' | 'TRUNCATE' | 'NO_REORDER' | 'SWAP' | 'FULL_KEYED';
 interface ForState<T> {
   kind: 'for';
   currentItems: T[];
+  _committedItems: T[];
   eachSource: ForEachSource<T>;
   fallback: VNode | null;
   fallbackScope: ChildScope | null;
@@ -23,21 +27,80 @@ interface ForState<T> {
   parentInstance: ComponentInstance | null;
   lastCommitStrategy: ForCommitStrategy;
   lastRemovedNodes: Node[];
+  lastRemovedRanges: DOMRange[];
   pendingDirtyIndices: number[] | null;
   pendingSwapIndices: [number, number] | null;
   pendingMoveOnly: boolean;
+  pendingInsertedIndex: number | null;
+  pendingAppendStart: number | null;
   _hasResolvedItemDom: boolean;
   _needsSourceReconcile: boolean;
   _sourceEffect: FineGrainedEffectHandle<T[]> | null;
   _suspendSourceCommit: boolean;
   _enqueueBoundaryCommit?: (() => void) | null;
   _hasPendingBoundaryCommit?: boolean;
-  devKeyKinds?: Map<string, 'number' | 'string'>;
+  devKeyKinds?: Map<string | number, 'number' | 'string'>;
+  _transaction?: ForTransaction<T> | null;
+}
+interface ForItemTransactionSnapshot<T> {
+  item: T;
+  itemSignalExists: boolean;
+  itemSignalValue: T | undefined;
+  itemSignalHasBeenRead: boolean;
+  indexValue: number;
+  indexHasBeenRead: boolean;
+  propertySignalStore: Map<PropertyKey, ForItemPropertySignal> | null;
+  propertySignals: Map<PropertyKey, {
+    signal: ForItemPropertySignal;
+    value: unknown;
+    hasBeenRead: boolean;
+  }> | null;
+  scope: ChildScopeTransactionSnapshot;
+}
+interface ForTransaction<T> {
+  collectionSnapshotMode: 'copy' | 'reset-empty' | 'preserve-clear' | 'reuse';
+  currentItems: T[];
+  items: Map<string | number, ForItemInstance<T>>;
+  orderedKeys: Array<string | number>;
+  orderedItems: ForItemInstance<T>[];
+  orderedVNodes: VNode[];
+  fallbackScope: ChildScope | null;
+  lastCommitStrategy: ForCommitStrategy;
+  lastRemovedNodes: Node[];
+  lastRemovedRanges: DOMRange[];
+  pendingDirtyIndices: number[] | null;
+  pendingSwapIndices: [number, number] | null;
+  pendingMoveOnly: boolean;
+  pendingInsertedIndex: number | null;
+  pendingAppendStart: number | null;
+  hasResolvedItemDom: boolean;
+  needsSourceReconcile: boolean;
+  devKeyKinds?: Map<string | number, 'number' | 'string'>;
+  itemSnapshots: Map<ForItemInstance<T>, ForItemTransactionSnapshot<T>> | null;
+  unreadIndexSnapshots: Map<ForIndexSignal, number> | null;
+  fallbackScopeSnapshot: ChildScopeTransactionSnapshot | null;
+  removedScopes: ChildScope[] | null;
+  removeAllItems: boolean;
+  signalEffects: Map<ReadableSource<unknown>, {
+    parentInstance: ComponentInstance | null;
+    notify: boolean;
+    skipInstance: ComponentInstance | null;
+    skipOwnedBy: ComponentInstance | null;
+  }> | null;
+  shouldClearDomUpdateState: boolean;
 }
 declare function createForState<T>(eachSource: ForEachSource<T>, byFn: ForState<T>['byFn'], renderFn: ForRenderItem<T>, fallback: VNode | null): ForState<T>;
 declare function useForState<T>(eachSource: ForEachSource<T>, byFn: ForState<T>['byFn'], renderFn: ForRenderItem<T>, fallback: VNode | null): ForState<T>;
 declare function evaluateForState<T>(forState: ForState<T>): VNode[];
+/**
+ * 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.
+ */
+declare function beginForStateTransaction<T>(forState: ForState<T>, collectionMode?: 'auto' | 'reuse'): void;
+declare function registerForStateTransaction<T>(forState: ForState<T>, transaction?: ForTransaction<T> | null | undefined): boolean;
+declare function commitForStateTransaction<T>(forState: ForState<T>, transaction?: ForTransaction<T> | null | undefined): void;
+declare function rollbackForStateTransaction<T>(forState: ForState<T>, transaction?: ForTransaction<T> | null | undefined): void;
 declare function clearForDomUpdateState<T>(forState: ForState<T>): void;
 //#endregion
-export { ForCommitStrategy, ForState, reconcileForItems };
-//# sourceMappingURL=for-internal.d.ts.map
+export { ForCommitStrategy, ForItemTransactionSnapshot, ForState, ForTransaction, reconcileForItems };

package/dist/runtime/for-internal.js

@@ -1,5 +1,11 @@
+import { logger } from "../common/logger.js";
+import { getRuntimeRenderer } from "./access.js";
 import { claimHookIndex, getCurrentInstance } from "./component-scope.js";
+import { registerLifecycleTransaction } from "./lifecycle-batch.js";
+import "./component-lifecycle.js";
 import "./component.js";
+import { disposeChildScope, restoreChildScopeTransactionSnapshot } from "./child-scope.js";
+import { notifyForSignalReaders, removeForParentReaders } from "./for-signals.js";
 import { isBenchMetricScopeActive, recordBenchCounter, recordBenchEvent, recordBenchTiming, withBenchMetricScope } from "./for-bench.js";
 import { reconcileForItems } from "./for-reconcile.js";
 //#region src/runtime/for-internal.ts
@@ -23,6 +29,7 @@ function createForState(eachSource, byFn, renderFn, fallback) {
 	return {
 		kind: "for",
 		currentItems: [],
+		_committedItems: [],
 		eachSource,
 		fallback,
 		fallbackScope: null,
@@ -35,15 +42,19 @@ function createForState(eachSource, byFn, renderFn, fallback) {
 		parentInstance,
 		lastCommitStrategy: "NO_REORDER",
 		lastRemovedNodes: [],
+		lastRemovedRanges: [],
 		pendingDirtyIndices: null,
 		pendingSwapIndices: null,
 		pendingMoveOnly: false,
+		pendingInsertedIndex: null,
+		pendingAppendStart: null,
 		_hasResolvedItemDom: false,
 		_needsSourceReconcile: false,
 		_sourceEffect: null,
 		_suspendSourceCommit: false,
 		_enqueueBoundaryCommit: null,
-		_hasPendingBoundaryCommit: false
+		_hasPendingBoundaryCommit: false,
+		_transaction: null
 	};
 }
 function useForState(eachSource, byFn, renderFn, fallback) {
@@ -70,29 +81,205 @@ function useForState(eachSource, byFn, renderFn, fallback) {
 }
 function evaluateForState(forState) {
 	if (!Array.isArray(forState.currentItems)) throw new Error("For source must evaluate to an array");
+	beginForStateTransaction(forState);
 	forState._needsSourceReconcile = false;
-	return reconcileForItems(forState, forState.currentItems);
+	try {
+		return reconcileForItems(forState, forState.currentItems);
+	} catch (error) {
+		rollbackForStateTransaction(forState);
+		throw error;
+	}
 }
-function clearForDomUpdateState(forState) {
-	const dirtyIndices = forState.pendingDirtyIndices;
-	if (dirtyIndices && dirtyIndices.length > 0) for (let i = 0; i < dirtyIndices.length; i++) {
-		const itemInstance = forState.orderedItems[dirtyIndices[i]];
-		if (itemInstance) itemInstance.scope.needsDomUpdate = false;
+/**
+* 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,
+		pendingAppendStart: forState.pendingAppendStart,
+		hasResolvedItemDom: forState._hasResolvedItemDom,
+		needsSourceReconcile: forState._needsSourceReconcile,
+		devKeyKinds: forState.devKeyKinds,
+		itemSnapshots: null,
+		unreadIndexSnapshots: null,
+		fallbackScopeSnapshot: null,
+		removedScopes: 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(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 (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;
+			if (typeof Element !== "undefined" && node instanceof Element) try {
+				getRuntimeRenderer().teardownNodeSubtree(node);
+			} catch (error) {
+				cleanupErrors.push(error);
+			}
+			node = next;
+		}
+	};
+	if (transaction.removeAllItems) for (let index = 0; index < transaction.orderedItems.length; index++) {
+		const item = transaction.orderedItems[index];
+		if (item) finalizeScope(item.scope);
 	}
-	else for (let i = 0; i < forState.orderedKeys.length; i++) {
-		const key = forState.orderedKeys[i];
-		const itemInstance = forState.items.get(key);
-		if (itemInstance) itemInstance.scope.needsDomUpdate = false;
+	for (const scope of removedScopes ?? []) finalizeScope(scope);
+	if (removedScopes) removedScopes.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(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.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.pendingAppendStart = null;
 	forState._needsSourceReconcile = false;
 	forState._hasResolvedItemDom = forState.orderedKeys.length > 0;
 }
 //#endregion
-export { clearForDomUpdateState, createForState, evaluateForState, isBenchMetricScopeActive, reconcileForItems, recordBenchCounter, recordBenchEvent, recordBenchTiming, useForState, withBenchMetricScope };
-
-//# sourceMappingURL=for-internal.js.map
+export { beginForStateTransaction, clearForDomUpdateState, commitForStateTransaction, createForState, evaluateForState, isBenchMetricScopeActive, reconcileForItems, recordBenchCounter, recordBenchEvent, recordBenchTiming, registerForStateTransaction, rollbackForStateTransaction, useForState, withBenchMetricScope };

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

@@ -4,5 +4,4 @@ import { VNode } from "../common/vnode.js";
 //#region src/runtime/for-reconcile.d.ts
 declare function reconcileForItems<T>(forState: ForState<T>, newArray: T[]): VNode[];
 //#endregion
-export { reconcileForItems };
-//# sourceMappingURL=for-reconcile.d.ts.map
+export { reconcileForItems };