@askrjs/askr 0.0.52 → 0.0.53

package/dist/runtime/fastlane.js

@@ -1,173 +0,0 @@
-import { isDevelopmentEnvironment } from "../common/env.js";
-import { getRuntimeRenderer, getRuntimeSchedulerState, runRuntimeWithSyncProgress, setRuntimeBulkCommitProbe } from "./access.js";
-import { Fragment } from "../common/jsx.js";
-import { finalizeReadableSubscriptions } from "./readable.js";
-import { getDevNamespace, getDevValue, setDevValue } from "./dev-namespace.js";
-//#region src/runtime/fastlane.ts
-let _bulkCommitActive = false;
-let _appliedParents = null;
-function enterBulkCommit() {
-	_bulkCommitActive = true;
-	_appliedParents = /* @__PURE__ */ new WeakSet();
-	setDevValue("__FASTLANE_CLEARED_TASKS", 0);
-}
-function exitBulkCommit() {
-	_bulkCommitActive = false;
-	_appliedParents = null;
-}
-function isBulkCommitActive() {
-	return _bulkCommitActive;
-}
-function markFastPathApplied(parent) {
-	if (!_appliedParents) return;
-	try {
-		_appliedParents.add(parent);
-	} catch (e) {}
-}
-function finalizeReadSubscriptions(instance) {
-	finalizeReadableSubscriptions(instance);
-}
-/**
-* Attempt to execute a runtime fast-lane for a single component's synchronous
-* render result. Returns true if the fast-lane was used and commit was done.
-*
-* Preconditions (checked conservatively):
-* - The render result is an intrinsic element root with keyed children
-* - The renderer's fast-path heuristics indicate to use the fast-path
-* - No mount operations are pending on the component instance
-* - No child vnodes are component functions (avoid async/component mounts)
-*/
-function unwrapFragmentForFastPath(vnode) {
-	if (!vnode || typeof vnode !== "object" || !("type" in vnode)) return vnode;
-	const v = vnode;
-	if (typeof v.type === "symbol" && (v.type === Fragment || String(v.type) === "Symbol(askr.fragment)")) {
-		const children = v.props?.children ?? v.children;
-		if (Array.isArray(children) && children.length > 0) {
-			for (const child of children) if (child && typeof child === "object" && "type" in child) {
-				if (typeof child.type === "string") return child;
-			}
-		}
-	}
-	return vnode;
-}
-function classifyUpdate(instance, result) {
-	const unwrappedResult = unwrapFragmentForFastPath(result);
-	if (!unwrappedResult || typeof unwrappedResult !== "object" || !("type" in unwrappedResult)) return {
-		useFastPath: false,
-		reason: "not-vnode"
-	};
-	const vnode = unwrappedResult;
-	if (vnode == null || typeof vnode.type !== "string") return {
-		useFastPath: false,
-		reason: "not-intrinsic"
-	};
-	const parent = instance.target;
-	if (!parent) return {
-		useFastPath: false,
-		reason: "no-root"
-	};
-	const firstChild = parent.children[0];
-	if (!firstChild) return {
-		useFastPath: false,
-		reason: "no-first-child"
-	};
-	if (firstChild.tagName.toLowerCase() !== String(vnode.type).toLowerCase()) return {
-		useFastPath: false,
-		reason: "root-tag-mismatch"
-	};
-	const children = vnode.props?.children ?? vnode.children;
-	if (!Array.isArray(children)) return {
-		useFastPath: false,
-		reason: "no-children-array"
-	};
-	for (const c of children) if (typeof c === "object" && c !== null && "type" in c && typeof c.type === "function") return {
-		useFastPath: false,
-		reason: "component-child-present"
-	};
-	if ((instance.mountOperations?.length ?? 0) > 0) return {
-		useFastPath: false,
-		reason: "pending-mounts"
-	};
-	if ((instance.commitOperations?.length ?? 0) > 0) return {
-		useFastPath: false,
-		reason: "pending-lifecycle-commits"
-	};
-	const renderer = getRuntimeRenderer();
-	try {
-		renderer.populateKeyMapForElement(firstChild);
-	} catch {}
-	const oldKeyMap = renderer.getKeyMapForElement(firstChild);
-	const decision = renderer.isKeyedReorderFastPathEligible(firstChild, children, oldKeyMap);
-	if (!decision.useFastPath || decision.totalKeyed < 128) return {
-		...decision,
-		useFastPath: false,
-		reason: "renderer-declined"
-	};
-	return {
-		...decision,
-		useFastPath: true
-	};
-}
-function commitReorderOnly(instance, result) {
-	const renderer = getRuntimeRenderer();
-	const schedBefore = isDevelopmentEnvironment() ? getRuntimeSchedulerState() : null;
-	enterBulkCommit();
-	try {
-		runRuntimeWithSyncProgress(() => {
-			renderer.evaluate(result, instance.target);
-			try {
-				finalizeReadSubscriptions(instance);
-			} catch (e) {
-				if (isDevelopmentEnvironment()) throw e;
-			}
-		});
-		setDevValue("__FASTLANE_CLEARED_AFTER", 0);
-		if (isDevelopmentEnvironment()) validateFastLaneInvariants(instance, schedBefore);
-		return true;
-	} finally {
-		exitBulkCommit();
-	}
-}
-/**
-* Validates fast-lane invariants in dev mode.
-* Extracted to reduce complexity in commitReorderOnly.
-*/
-function validateFastLaneInvariants(instance, schedBefore) {
-	const commitCount = getDevValue("__LAST_FASTPATH_COMMIT_COUNT") ?? 0;
-	const invariants = {
-		commitCount,
-		mountOps: instance.mountOperations?.length ?? 0,
-		commitOps: instance.commitOperations?.length ?? 0,
-		cleanupFns: instance.cleanupFns?.length ?? 0
-	};
-	setDevValue("__LAST_FASTLANE_INVARIANTS", invariants);
-	if (commitCount !== 1) {
-		console.error("[FASTLANE][INV] commitCount", commitCount, "diag", getDevNamespace());
-		throw new Error("Fast-lane invariant violated: expected exactly one DOM commit during reorder-only commit");
-	}
-	if (invariants.mountOps > 0) throw new Error("Fast-lane invariant violated: mount operations were registered during bulk commit");
-	if (invariants.commitOps > 0) throw new Error("Fast-lane invariant violated: lifecycle commit operations were registered during bulk commit");
-	if (invariants.cleanupFns > 0) throw new Error("Fast-lane invariant violated: cleanup functions were added during bulk commit");
-	const schedAfter = getRuntimeSchedulerState();
-	if (schedBefore && schedAfter && schedAfter.taskCount > schedBefore.taskCount) {
-		console.error("[FASTLANE] schedBefore, schedAfter", schedBefore, schedAfter);
-		console.error("[FASTLANE] enqueue logs", getDevValue("__ENQUEUE_LOGS"));
-		throw new Error("Fast-lane invariant violated: scheduler enqueued leftover work during bulk commit");
-	}
-}
-function tryRuntimeFastLaneSync(instance, result) {
-	if (!classifyUpdate(instance, result).useFastPath) {
-		setDevValue("__LAST_FASTPATH_STATS", void 0);
-		setDevValue("__LAST_FASTPATH_COMMIT_COUNT", 0);
-		return false;
-	}
-	try {
-		return commitReorderOnly(instance, result);
-	} catch (err) {
-		if (isDevelopmentEnvironment()) throw err;
-		return false;
-	}
-}
-setRuntimeBulkCommitProbe(isBulkCommitActive);
-//#endregion
-export { classifyUpdate, commitReorderOnly, enterBulkCommit, exitBulkCommit, isBulkCommitActive, markFastPathApplied, tryRuntimeFastLaneSync };

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

@@ -1,40 +0,0 @@
-//#region src/runtime/for-bench.d.ts
-interface BenchMetrics {
-  itemsCreated: number;
-  itemsReused: number;
-  itemsRemoved: number;
-  itemsMoved: number;
-  rowFactoryInvocations: number;
-  keyLookups: number;
-  keyHits: number;
-  keyMisses: number;
-  domInserts: number;
-  domRemoves: number;
-  domMoves: number;
-  domAttrSets: number;
-  domTextSets: number;
-  domNodesCreated: number;
-  listenerBindings: number;
-  reactivePropsMounted: number;
-  replaceChildrenCommits: number;
-  bulkClearCommits: number;
-  reconcilePhaseMs: number;
-  domCommitPhaseMs: number;
-  fastLaneName: string | null;
-}
-type BenchEvent = 'itemCreated' | 'itemReused' | 'itemRemoved' | 'itemMoved' | 'rowFactory' | 'keyLookup' | 'keyHit' | 'keyMiss' | 'domInsert' | 'domRemove' | 'domMove' | 'domAttrSet' | 'domTextSet';
-type BenchMetricScope = 'coldCreate' | 'fullClear';
-type BenchCounter = 'domNodesCreated' | 'listenerBindings' | 'reactivePropsMounted' | 'replaceChildrenCommits' | 'bulkClearCommits';
-declare function withBenchMetricScopeLive<T>(scope: BenchMetricScope, run: () => T): T;
-declare const resetBenchMetrics: () => void;
-declare const recordBenchEvent: (event: BenchEvent, delta?: number) => void;
-declare const recordBenchFastLane: (name: string) => void;
-declare const recordBenchTiming: (phase: "reconcile" | "domCommit", ms: number) => void;
-declare const recordBenchCounter: (counter: BenchCounter, delta?: number) => void;
-declare const withBenchMetricScope: typeof withBenchMetricScopeLive;
-declare const isBenchMetricScopeActive: (scope: BenchMetricScope) => boolean;
-declare const getBenchMetrics: () => BenchMetrics;
-declare const flushBenchMetrics: () => void;
-declare const isBenchBuildEnabled: () => boolean;
-//#endregion
-export { BenchEvent, BenchMetrics };

package/dist/runtime/for-bench.js

@@ -1,13 +0,0 @@
-//#region src/runtime/for-bench.ts
-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 };

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

@@ -1,106 +0,0 @@
-import { ComponentInstance } from "./component-internal.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";
-import { reconcileForItems } from "./for-reconcile.js";
-import { VNode } from "../common/vnode.js";
-
-//#region src/runtime/for-internal.d.ts
-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;
-  items: Map<string | number, ForItemInstance<T>>;
-  orderedKeys: Array<string | number>;
-  orderedItems: ForItemInstance<T>[];
-  orderedVNodes: VNode[];
-  byFn: ForKeySelector<T>;
-  renderFn: ForRenderItem<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, '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, ForItemTransactionSnapshot, ForState, ForTransaction, reconcileForItems };

package/dist/runtime/for-internal.js

@@ -1,285 +0,0 @@
-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
-/**
-* For primitive runtime
-*
-* Manages For state storage, hook binding, source evaluation,
-* and DOM update state cleanup.
-*/
-const forStates = /* @__PURE__ */ new WeakMap();
-function getForStore(instance) {
-	let store = forStates.get(instance);
-	if (!store) {
-		store = /* @__PURE__ */ new Map();
-		forStates.set(instance, store);
-	}
-	return store;
-}
-function createForState(eachSource, byFn, renderFn, fallback) {
-	const parentInstance = getCurrentInstance();
-	return {
-		kind: "for",
-		currentItems: [],
-		_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,
-		pendingAppendStart: null,
-		_hasResolvedItemDom: false,
-		_needsSourceReconcile: false,
-		_sourceEffect: null,
-		_suspendSourceCommit: false,
-		_enqueueBoundaryCommit: null,
-		_hasPendingBoundaryCommit: false,
-		_transaction: null
-	};
-}
-function useForState(eachSource, byFn, renderFn, fallback) {
-	const instance = getCurrentInstance();
-	if (!instance) throw new Error("For can only be created during component render execution.");
-	const hookIndex = claimHookIndex(instance, "For");
-	const store = getForStore(instance);
-	const existing = store.get(hookIndex);
-	if (existing) {
-		existing.eachSource = eachSource;
-		existing.byFn = byFn;
-		existing.renderFn = renderFn;
-		existing.fallback = fallback;
-		return existing;
-	}
-	const created = createForState(eachSource, byFn, renderFn, fallback);
-	store.set(hookIndex, created);
-	(instance.cleanupFns ??= []).push(() => {
-		created._sourceEffect?.cleanup();
-		created._sourceEffect = null;
-		store.delete(hookIndex);
-	});
-	return created;
-}
-function evaluateForState(forState) {
-	if (!Array.isArray(forState.currentItems)) throw new Error("For source must evaluate to an array");
-	beginForStateTransaction(forState);
-	forState._needsSourceReconcile = false;
-	try {
-		return reconcileForItems(forState, forState.currentItems);
-	} catch (error) {
-		rollbackForStateTransaction(forState);
-		throw error;
-	}
-}
-/**
-* Reconciliation changes ownership before DOM work can fail. Keep a private
-* structural snapshot until the boundary has committed so failed work cannot
-* leave provisional child scopes in the parent owner graph.
-*/
-function beginForStateTransaction(forState, collectionMode = "auto") {
-	if (forState._transaction) return;
-	const hasEmptyCollections = forState.items.size === 0 && forState.orderedKeys.length === 0 && forState.orderedItems.length === 0 && forState.orderedVNodes.length === 0;
-	const isFullClear = forState.currentItems.length === 0 && forState.orderedKeys.length > 0;
-	const collectionSnapshotMode = collectionMode === "reuse" ? "reuse" : hasEmptyCollections ? "reset-empty" : isFullClear ? "preserve-clear" : "copy";
-	const transaction = {
-		collectionSnapshotMode,
-		currentItems: forState._committedItems,
-		items: collectionSnapshotMode === "copy" ? new Map(forState.items) : forState.items,
-		orderedKeys: collectionSnapshotMode === "copy" ? forState.orderedKeys.slice() : forState.orderedKeys,
-		orderedItems: collectionSnapshotMode === "copy" ? forState.orderedItems.slice() : forState.orderedItems,
-		orderedVNodes: collectionSnapshotMode === "copy" ? forState.orderedVNodes.slice() : forState.orderedVNodes,
-		fallbackScope: forState.fallbackScope,
-		lastCommitStrategy: forState.lastCommitStrategy,
-		lastRemovedNodes: forState.lastRemovedNodes,
-		lastRemovedRanges: forState.lastRemovedRanges,
-		pendingDirtyIndices: forState.pendingDirtyIndices,
-		pendingSwapIndices: forState.pendingSwapIndices,
-		pendingMoveOnly: forState.pendingMoveOnly,
-		pendingInsertedIndex: forState.pendingInsertedIndex,
-		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);
-	}
-	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 { beginForStateTransaction, clearForDomUpdateState, commitForStateTransaction, createForState, evaluateForState, isBenchMetricScopeActive, reconcileForItems, recordBenchCounter, recordBenchEvent, recordBenchTiming, registerForStateTransaction, rollbackForStateTransaction, useForState, withBenchMetricScope };

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

@@ -1,7 +0,0 @@
-import { ForState } from "./for-internal.js";
-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 };