@askrjs/askr 0.0.51 → 0.0.52

package/dist/runtime/component-lifecycle.d.ts

@@ -1,49 +1,10 @@
-import { Props } from "../common/props.js";
-import { ContextFrame } from "./context.js";
+import { LifecycleCommitBatch, LifecycleOperation, LifecycleTransaction } from "./lifecycle-batch.js";
 import { ComponentInstance } from "./component-internal.js";
-import { ReadableSource } from "./readable.js";
 
 //#region src/runtime/component-lifecycle.d.ts
-type LifecycleOperation = () => void | (() => void) | PromiseLike<void | (() => void)>;
-type LifecycleCommitBatchEntry = {
-  instance: ComponentInstance;
-  wasFirstMount: boolean;
-};
-type ReadSubscriptionCommit = {
-  instance: ComponentInstance;
-  token: number;
-  pendingReadSources: Set<ReadableSource<unknown>> | undefined;
-  pendingReadSourceVersions: Map<ReadableSource<unknown>, number> | undefined;
-};
-type InlineRenderSnapshot = {
-  instance: ComponentInstance;
-  props: Props;
-  ownerFrame: ContextFrame | null;
-  portalScope: object | null;
-  parentInstance: ComponentInstance | null;
-  isRoot: boolean | undefined;
-};
-type LifecycleCommitBatch = {
-  parent: LifecycleCommitBatch | null;
-  entries: LifecycleCommitBatchEntry[];
-  entriesByInstance: Map<ComponentInstance, LifecycleCommitBatchEntry>;
-  readCommits: ReadSubscriptionCommit[];
-  readCommitsByInstance: Map<ComponentInstance, ReadSubscriptionCommit>;
-  renderSnapshots: InlineRenderSnapshot[];
-  renderSnapshotsByInstance: Map<ComponentInstance, InlineRenderSnapshot>;
-  active: boolean;
-};
-declare function beginLifecycleCommitBatch(): LifecycleCommitBatch;
-declare function captureInlineRenderSnapshot(instance: ComponentInstance): void;
-declare function finalizeInlineReadSubscriptions(instance: ComponentInstance, token: number, pendingReadSources: Set<ReadableSource<unknown>> | undefined, pendingReadSourceVersions: Map<ReadableSource<unknown>, number> | undefined): void;
-declare function flushLifecycleCommitBatch(batch: LifecycleCommitBatch): void;
-declare function discardLifecycleCommitBatch(batch: LifecycleCommitBatch): void;
 declare function registerMountOperationForInstance(instance: ComponentInstance | null, operation: LifecycleOperation): void;
 declare function registerCommitOperationForInstance(instance: ComponentInstance | null, operation: LifecycleOperation): void;
-declare function discardCommitOperations(instance: ComponentInstance): void;
-declare function executeCommittedLifecycleOperations(instance: ComponentInstance, wasFirstMount: boolean): void;
 declare function commitLifecycleForInstance(instance: ComponentInstance, wasFirstMount: boolean): void;
 declare function commitRenderedComponent(instance: ComponentInstance): void;
 //#endregion
-export { LifecycleCommitBatch, LifecycleOperation };
-//# sourceMappingURL=component-lifecycle.d.ts.map
+export type { LifecycleOperation };

package/dist/runtime/component-lifecycle.js

@@ -1,108 +1,8 @@
 import { isDevelopmentEnvironment } from "../common/env.js";
-import { logger } from "../common/logger.js";
-import { finalizeReadableSubscriptionsFromSnapshot } from "./readable.js";
-import { isPromiseLike } from "../common/promise.js";
 import { isBulkCommitActive } from "./fastlane.js";
+import { discardCommitOperations, executeCommittedLifecycleOperations } from "./lifecycle-operation-settlement.js";
+import { beginLifecycleCommitBatch, captureInlineRenderSnapshot, discardLifecycleCommitBatch, drainLifecycleCommitErrors, enqueueLifecycleCommitForInstance, finalizeInlineReadSubscriptions, flushLifecycleCommitBatch, getCurrentLifecycleCommitBatch, registerLifecycleRollback, registerLifecycleTransaction } from "./lifecycle-batch.js";
 //#region src/runtime/component-lifecycle.ts
-let currentLifecycleCommitBatch = null;
-function beginLifecycleCommitBatch() {
-	const batch = {
-		parent: currentLifecycleCommitBatch,
-		entries: [],
-		entriesByInstance: /* @__PURE__ */ new Map(),
-		readCommits: [],
-		readCommitsByInstance: /* @__PURE__ */ new Map(),
-		renderSnapshots: [],
-		renderSnapshotsByInstance: /* @__PURE__ */ new Map(),
-		active: true
-	};
-	currentLifecycleCommitBatch = batch;
-	return batch;
-}
-function closeLifecycleCommitBatch(batch) {
-	if (!batch.active) return false;
-	batch.active = false;
-	currentLifecycleCommitBatch = batch.parent;
-	return true;
-}
-function enqueueLifecycleCommit(batch, instance, wasFirstMount) {
-	const existing = batch.entriesByInstance.get(instance);
-	if (existing) {
-		existing.wasFirstMount = existing.wasFirstMount || wasFirstMount;
-		return;
-	}
-	const entry = {
-		instance,
-		wasFirstMount
-	};
-	batch.entriesByInstance.set(instance, entry);
-	batch.entries.push(entry);
-}
-function enqueueReadSubscriptionCommit(batch, instance, token, pendingReadSources, pendingReadSourceVersions) {
-	const existing = batch.readCommitsByInstance.get(instance);
-	const commit = existing ?? {
-		instance,
-		token,
-		pendingReadSources,
-		pendingReadSourceVersions
-	};
-	commit.token = token;
-	commit.pendingReadSources = pendingReadSources ? new Set(pendingReadSources) : void 0;
-	commit.pendingReadSourceVersions = pendingReadSourceVersions ? new Map(pendingReadSourceVersions) : void 0;
-	if (!existing) {
-		batch.readCommitsByInstance.set(instance, commit);
-		batch.readCommits.push(commit);
-	}
-}
-function enqueueInlineRenderSnapshot(batch, snapshot) {
-	if (batch.renderSnapshotsByInstance.has(snapshot.instance)) return;
-	batch.renderSnapshotsByInstance.set(snapshot.instance, snapshot);
-	batch.renderSnapshots.push(snapshot);
-}
-function captureInlineRenderSnapshot(instance) {
-	if (!currentLifecycleCommitBatch?.active) return;
-	enqueueInlineRenderSnapshot(currentLifecycleCommitBatch, {
-		instance,
-		props: instance.props,
-		ownerFrame: instance.ownerFrame,
-		portalScope: instance.portalScope,
-		parentInstance: instance.parentInstance,
-		isRoot: instance.isRoot
-	});
-}
-function finalizeInlineReadSubscriptions(instance, token, pendingReadSources, pendingReadSourceVersions) {
-	if (currentLifecycleCommitBatch?.active) {
-		enqueueReadSubscriptionCommit(currentLifecycleCommitBatch, instance, token, pendingReadSources, pendingReadSourceVersions);
-		return;
-	}
-	finalizeReadableSubscriptionsFromSnapshot(instance, token, pendingReadSources, pendingReadSourceVersions);
-}
-function flushLifecycleCommitBatch(batch) {
-	if (!closeLifecycleCommitBatch(batch)) return;
-	if (batch.parent?.active) {
-		for (const snapshot of batch.renderSnapshots) enqueueInlineRenderSnapshot(batch.parent, snapshot);
-		for (const commit of batch.readCommits) enqueueReadSubscriptionCommit(batch.parent, commit.instance, commit.token, commit.pendingReadSources, commit.pendingReadSourceVersions);
-		for (const entry of batch.entries) enqueueLifecycleCommit(batch.parent, entry.instance, entry.wasFirstMount);
-		return;
-	}
-	for (const commit of batch.readCommits) finalizeReadableSubscriptionsFromSnapshot(commit.instance, commit.token, commit.pendingReadSources, commit.pendingReadSourceVersions);
-	for (const entry of batch.entries) executeCommittedLifecycleOperations(entry.instance, entry.wasFirstMount);
-}
-function discardLifecycleCommitBatch(batch) {
-	if (!closeLifecycleCommitBatch(batch)) return;
-	for (let index = batch.renderSnapshots.length - 1; index >= 0; index -= 1) {
-		const snapshot = batch.renderSnapshots[index];
-		snapshot.instance.props = snapshot.props;
-		snapshot.instance.ownerFrame = snapshot.ownerFrame;
-		snapshot.instance.portalScope = snapshot.portalScope;
-		snapshot.instance.parentInstance = snapshot.parentInstance;
-		snapshot.instance.isRoot = snapshot.isRoot;
-	}
-	for (const entry of batch.entries) {
-		if (entry.wasFirstMount) entry.instance.mountOperations = [];
-		discardCommitOperations(entry.instance);
-	}
-}
 function registerMountOperationForInstance(instance, operation) {
 	if (instance) {
 		if (isBulkCommitActive()) {
@@ -121,56 +21,13 @@ function registerCommitOperationForInstance(instance, operation) {
 		instance.commitOperations.push(operation);
 	}
 }
-function settleLifecycleOperationResult(instance, lifecycleGeneration, result) {
-	if (isPromiseLike(result)) Promise.resolve(result).then((cleanup) => {
-		if (typeof cleanup === "function") {
-			if (instance.lifecycleGeneration === lifecycleGeneration && instance.mounted) {
-				instance.cleanupFns.push(cleanup);
-				return;
-			}
-			try {
-				cleanup();
-			} catch (err) {
-				logger.error("[Askr] async mount cleanup failed:", err);
-			}
-		}
-	}, (err) => {
-		logger.error("[Askr] async mount operation failed:", err);
-	});
-	else if (typeof result === "function") instance.cleanupFns.push(result);
-}
-function executeMountOperations(instance) {
-	const mountOperations = instance.mountOperations;
-	if (mountOperations.length === 0) return;
-	const lifecycleGeneration = instance.lifecycleGeneration;
-	for (const operation of mountOperations) settleLifecycleOperationResult(instance, lifecycleGeneration, operation());
-	instance.mountOperations = [];
-}
-function executeCommitOperations(instance) {
-	const commitOperations = instance.commitOperations;
-	if (commitOperations.length === 0) return;
-	instance.commitOperations = [];
-	const lifecycleGeneration = instance.lifecycleGeneration;
-	for (const operation of commitOperations) settleLifecycleOperationResult(instance, lifecycleGeneration, operation());
-}
-function discardCommitOperations(instance) {
-	instance.commitOperations = [];
-}
-function executeCommittedLifecycleOperations(instance, wasFirstMount) {
-	if (wasFirstMount && instance.mountOperations.length > 0) executeMountOperations(instance);
-	if (instance.commitOperations.length > 0) executeCommitOperations(instance);
-}
 function commitLifecycleForInstance(instance, wasFirstMount) {
-	if (currentLifecycleCommitBatch) {
-		enqueueLifecycleCommit(currentLifecycleCommitBatch, instance, wasFirstMount);
-		return;
-	}
+	if ((instance.mountOperations?.length ?? 0) === 0 && (instance.commitOperations?.length ?? 0) === 0) return;
+	if (enqueueLifecycleCommitForInstance(instance, wasFirstMount)) return;
 	executeCommittedLifecycleOperations(instance, wasFirstMount);
 }
 function commitRenderedComponent(instance) {
-	if (instance.mounted && instance.commitOperations.length > 0) commitLifecycleForInstance(instance, false);
+	if (instance.mounted && (instance.commitOperations?.length ?? 0) > 0) commitLifecycleForInstance(instance, false);
 }
 //#endregion
-export { beginLifecycleCommitBatch, captureInlineRenderSnapshot, commitLifecycleForInstance, commitRenderedComponent, discardCommitOperations, discardLifecycleCommitBatch, executeCommittedLifecycleOperations, finalizeInlineReadSubscriptions, flushLifecycleCommitBatch, registerCommitOperationForInstance, registerMountOperationForInstance };
-
-//# sourceMappingURL=component-lifecycle.js.map
+export { beginLifecycleCommitBatch, captureInlineRenderSnapshot, commitLifecycleForInstance, commitRenderedComponent, discardCommitOperations, discardLifecycleCommitBatch, drainLifecycleCommitErrors, finalizeInlineReadSubscriptions, flushLifecycleCommitBatch, getCurrentLifecycleCommitBatch, registerCommitOperationForInstance, registerLifecycleRollback, registerLifecycleTransaction, registerMountOperationForInstance };

package/dist/runtime/component-scope.d.ts

@@ -35,8 +35,8 @@ declare function beginRenderTracking(instance: ComponentInstance): void;
 declare function clearRenderTracking(instance: ComponentInstance): void;
 declare function captureInlineRenderTracking(instance: ComponentInstance): InlineRenderTrackingSnapshot;
 declare function restoreInlineRenderTracking(instance: ComponentInstance, snapshot: InlineRenderTrackingSnapshot): void;
-declare function enterRenderScopedComponent(instance: ComponentInstance, startStateIndex: number): ComponentScopeSnapshot;
-declare function restoreRenderScopedComponent(snapshot: ComponentScopeSnapshot): void;
+declare function enterRenderScopedComponent(instance: ComponentInstance, startStateIndex: number): ComponentScopeSnapshot | null;
+declare function restoreRenderScopedComponent(snapshot: ComponentScopeSnapshot | null): void;
 declare function captureInlineComponentScope(): InstancePortalScopeSnapshot;
 declare function restoreInlineComponentScope(snapshot: InstancePortalScopeSnapshot): void;
 declare function enterComponentExecutionScope(instance: ComponentInstance): object | null;
@@ -51,5 +51,4 @@ declare function getCurrentStateIndex(): number;
 declare function resetStateIndex(): void;
 declare function setStateIndex(value: number): void;
 //#endregion
-export { getSignal };
-//# sourceMappingURL=component-scope.d.ts.map
+export { getSignal };

package/dist/runtime/component-scope.js

@@ -3,6 +3,10 @@ let currentInstance = null;
 let currentPortalScope = null;
 let stateIndex = 0;
 let globalRenderCounter = 0;
+let renderScopedDepth = 0;
+let outerRenderScopedInstance = null;
+let outerRenderScopedPortalScope = null;
+let outerRenderScopedStateIndex = 0;
 function ensureAbortController(instance) {
 	let controller = instance.abortController;
 	if (!controller || controller.signal.aborted) {
@@ -62,7 +66,7 @@ function getSignal() {
 }
 function resetRenderState(instance) {
 	instance.stateIndexCheck = -1;
-	for (const state of instance.stateValues) if (state) state._hasBeenRead = false;
+	for (const state of instance.stateValues ?? []) if (state) state._hasBeenRead = false;
 	instance._pendingReadSources = void 0;
 	instance._pendingReadSourceVersions = void 0;
 }
@@ -89,14 +93,30 @@ function restoreInlineRenderTracking(instance, snapshot) {
 	instance._pendingReadSourceVersions = snapshot.pendingReadSourceVersions;
 }
 function enterRenderScopedComponent(instance, startStateIndex) {
-	const savedScope = captureScope();
+	let savedScope = null;
+	if (renderScopedDepth === 0) {
+		outerRenderScopedInstance = currentInstance;
+		outerRenderScopedPortalScope = currentPortalScope;
+		outerRenderScopedStateIndex = stateIndex;
+	} else savedScope = captureScope();
+	renderScopedDepth += 1;
 	currentInstance = instance;
-	currentPortalScope = instance.portalScope ?? savedScope.portalScope;
+	currentPortalScope = instance.portalScope ?? (savedScope ? savedScope.portalScope : outerRenderScopedPortalScope);
 	stateIndex = startStateIndex;
 	return savedScope;
 }
 function restoreRenderScopedComponent(snapshot) {
-	restoreScope(snapshot);
+	renderScopedDepth -= 1;
+	if (snapshot) {
+		restoreScope(snapshot);
+		return;
+	}
+	currentInstance = outerRenderScopedInstance;
+	currentPortalScope = outerRenderScopedPortalScope;
+	stateIndex = outerRenderScopedStateIndex;
+	outerRenderScopedInstance = null;
+	outerRenderScopedPortalScope = null;
+	outerRenderScopedStateIndex = 0;
 }
 function captureInlineComponentScope() {
 	return captureInstancePortalScope();
@@ -140,9 +160,10 @@ function claimHookIndex(instance, hookName) {
 	const index = getNextStateIndex();
 	if (index < instance.stateIndexCheck) throw new Error(`Hook index violation: ${hookName}() call at index ${index}, but previously saw index ${instance.stateIndexCheck}. This happens when render-scoped hooks are called conditionally (inside if/for/etc). Move all ${hookName}() calls to the top level of your component function, before any conditionals.`);
 	instance.stateIndexCheck = index;
+	const expectedStateIndices = instance.expectedStateIndices ??= [];
 	if (instance.firstRenderComplete) {
-		if (instance.expectedStateIndices[index] !== index) throw new Error(`Hook order violation: ${hookName}() called at index ${index}, but this index was not in the first render's sequence [${instance.expectedStateIndices.join(", ")}]. This usually means ${hookName}() is inside a conditional or loop. Move all render-scoped hooks to the top level of your component function.`);
-	} else instance.expectedStateIndices.push(index);
+		if (expectedStateIndices[index] !== index) throw new Error(`Hook order violation: ${hookName}() called at index ${index}, but this index was not in the first render's sequence [${expectedStateIndices.join(", ")}]. This usually means ${hookName}() is inside a conditional or loop. Move all render-scoped hooks to the top level of your component function.`);
+	} else expectedStateIndices.push(index);
 	return index;
 }
 function getCurrentStateIndex() {
@@ -150,5 +171,3 @@ function getCurrentStateIndex() {
 }
 //#endregion
 export { beginRenderTracking, captureInlineComponentScope, captureInlineRenderTracking, claimHookIndex, clearCurrentComponentScope, clearRenderTracking, enterComponentExecutionScope, enterDomCommitScope, enterRenderScopedComponent, exitComponentExecutionScope, getCurrentComponentInstance, getCurrentInstance, getCurrentPortalScope, getCurrentStateIndex, getNextStateIndex, getSignal, getSignalForInstance, resetRenderState, restoreCurrentComponentScope, restoreDomCommitScope, restoreInlineComponentScope, restoreInlineRenderTracking, restoreRenderScopedComponent, setCurrentComponentInstance };
-
-//# sourceMappingURL=component-scope.js.map

package/dist/runtime/component.js

@@ -1,5 +1,6 @@
-import { claimHookIndex, getCurrentComponentInstance, getCurrentInstance, getCurrentPortalScope, getCurrentStateIndex, getSignal, setCurrentComponentInstance } from "./component-scope.js";
+import { claimHookIndex, enterDomCommitScope, getCurrentComponentInstance, getCurrentInstance, getCurrentPortalScope, getCurrentStateIndex, getSignal, restoreDomCommitScope, setCurrentComponentInstance } from "./component-scope.js";
 import { cleanupComponent, registerOwnedChildScope, unregisterOwnedChildScope } from "./component-cleanup.js";
-import { captureInlineRenderSnapshot, createComponentInstance, finalizeReadSubscriptions, mountComponent, mountInstanceInline, registerCommitOperation, renderComponentInline, renderScopedComponent, warnUnusedStateReads } from "./component-internal.js";
+import { getCurrentLifecycleCommitBatch, registerLifecycleRollback, registerLifecycleTransaction } from "./lifecycle-batch.js";
+import { captureInlineRenderSnapshot, createComponentInstance, mountComponent, mountInstanceInline, registerCommitOperation, renderComponentInline, renderScopedComponent, warnUnusedStateReads } from "./component-internal.js";
 import "./component-facade.js";
-export { captureInlineRenderSnapshot, claimHookIndex, cleanupComponent, createComponentInstance, finalizeReadSubscriptions, getCurrentComponentInstance, getCurrentInstance, getCurrentPortalScope, getCurrentStateIndex, getSignal, mountComponent, mountInstanceInline, registerCommitOperation, registerOwnedChildScope, renderComponentInline, renderScopedComponent, setCurrentComponentInstance, unregisterOwnedChildScope, warnUnusedStateReads };
+export { captureInlineRenderSnapshot, claimHookIndex, cleanupComponent, createComponentInstance, enterDomCommitScope, getCurrentComponentInstance, getCurrentInstance, getCurrentLifecycleCommitBatch, getCurrentPortalScope, getCurrentStateIndex, getSignal, mountComponent, mountInstanceInline, registerCommitOperation, registerLifecycleRollback, registerLifecycleTransaction, registerOwnedChildScope, renderComponentInline, renderScopedComponent, restoreDomCommitScope, setCurrentComponentInstance, unregisterOwnedChildScope, warnUnusedStateReads };

package/dist/runtime/context.d.ts

@@ -17,6 +17,8 @@ interface ContextFrame {
   parent: ContextFrame | null;
   values: Map<ContextKey, unknown> | null;
 }
+/** @internal Reuse immutable empty wrappers for the same provider snapshot. */
+declare function getExecutionContextFrame(parent: ContextFrame | null): ContextFrame;
 declare const CONTEXT_FRAME_SYMBOL: unique symbol;
 declare function getVNodeContextFrame(node: unknown): ContextFrame | undefined;
 declare function markVNodeWithContextFrame(node: unknown, frame: ContextFrame, overwrite?: boolean): void;
@@ -33,6 +35,8 @@ declare function markVNodeTreeWithContextFrame(node: unknown, frame: ContextFram
  * This ensures no context frame remains globally active across await.
  */
 declare function withContext<T>(frame: ContextFrame | null, fn: () => T): T;
+/** @internal Invoke a two-argument function without allocating a wrapper. */
+declare function callWithContext<TArgs, TContext, TResult>(frame: ContextFrame | null, fn: (args: TArgs, context: TContext) => TResult, args: TArgs, context: TContext): TResult;
 /**
  * Execute an async resource step within its frozen context snapshot.
  *
@@ -65,5 +69,4 @@ declare function getCurrentContextFrame(): ContextFrame | null;
  */
 declare function getTopContextSnapshot(): ContextFrame | null;
 //#endregion
-export { Context, ContextFrame, ContextKey, defineContext, readContext };
-//# sourceMappingURL=context.d.ts.map
+export { Context, ContextFrame, ContextKey, defineContext, readContext };

package/dist/runtime/context.js

@@ -2,6 +2,24 @@ import { ELEMENT_TYPE, STATIC_CHILDREN } from "../common/jsx.js";
 import { getCurrentComponentInstance } from "./component-scope.js";
 import "./component.js";
 //#region src/runtime/context.ts
+const ROOT_EXECUTION_FRAME = {
+	parent: null,
+	values: null
+};
+const executionFramesByParent = /* @__PURE__ */ new WeakMap();
+/** @internal Reuse immutable empty wrappers for the same provider snapshot. */
+function getExecutionContextFrame(parent) {
+	if (!parent) return ROOT_EXECUTION_FRAME;
+	let frame = executionFramesByParent.get(parent);
+	if (!frame) {
+		frame = {
+			parent,
+			values: null
+		};
+		executionFramesByParent.set(parent, frame);
+	}
+	return frame;
+}
 const CONTEXT_FRAME_SYMBOL = Symbol("__tempoContextFrame__");
 const vnodeContextFrames = /* @__PURE__ */ new WeakMap();
 function getVNodeContextFrame(node) {
@@ -81,6 +99,16 @@ function withContext(frame, fn) {
 		currentContextFrame = oldFrame;
 	}
 }
+/** @internal Invoke a two-argument function without allocating a wrapper. */
+function callWithContext(frame, fn, args, context) {
+	const oldFrame = currentContextFrame;
+	currentContextFrame = frame;
+	try {
+		return fn(args, context);
+	} finally {
+		currentContextFrame = oldFrame;
+	}
+}
 /**
 * Execute an async resource step within its frozen context snapshot.
 *
@@ -205,6 +233,4 @@ function getCurrentContextFrame() {
 	return currentContextFrame;
 }
 //#endregion
-export { CONTEXT_FRAME_SYMBOL, defineContext, getCurrentContextFrame, getVNodeContextFrame, markVNodeTreeWithContextFrame, markVNodeWithContextFrame, readContext, withAsyncResourceContext, withContext };
-
-//# sourceMappingURL=context.js.map
+export { CONTEXT_FRAME_SYMBOL, callWithContext, defineContext, getCurrentContextFrame, getExecutionContextFrame, getVNodeContextFrame, markVNodeTreeWithContextFrame, markVNodeWithContextFrame, readContext, withAsyncResourceContext, withContext };

package/dist/runtime/control.d.ts

@@ -1,5 +1,6 @@
 import { ComponentInstance } from "./component-internal.js";
-import { ChildScope } from "./child-scope.js";
+import { DOMRange } from "../common/dom-range.js";
+import { ChildScope, ChildScopeTransactionSnapshot } from "./child-scope.js";
 import { ForState } from "./for-internal.js";
 import { VNode } from "../common/vnode.js";
 
@@ -14,9 +15,11 @@ interface BranchControlStateBase {
   activeScope: ChildScope | null;
   activeVNodes: VNode[];
   lastRemovedNodes: Node[];
+  lastRemovedRanges: DOMRange[];
   parentInstance: ComponentInstance | null;
   _enqueueBoundaryCommit?: (() => void) | null;
   _hasPendingBoundaryCommit?: boolean;
+  _transaction?: ControlTransaction | null;
 }
 interface ShowState extends BranchControlStateBase {
   kind: 'show';
@@ -32,6 +35,23 @@ interface CaseState extends BranchControlStateBase {
   matches: MatchBranch[];
 }
 type ControlBoundaryState = ForState<unknown> | ShowState | CaseState;
+type BranchStateSnapshot = {
+  activeKey: string | number | null;
+  activeScope: ChildScope | null;
+  activeVNodes: VNode[];
+  lastRemovedNodes: Node[];
+  lastRemovedRanges: DOMRange[];
+  scopeSnapshots: Map<ChildScope, ChildScopeTransactionSnapshot>;
+  fallbackScope?: ChildScope | null;
+  truthyScope?: ChildScope | null;
+};
+interface ControlTransaction {
+  state: ShowState | CaseState;
+  snapshot: BranchStateSnapshot;
+  removedScopes: ChildScope[];
+  shouldClearDomUpdateState: boolean;
+  registered: boolean;
+}
 declare function createShowState(value: unknown, renderTruthy: ShowState['renderTruthy'], renderFallback: ShowState['renderFallback']): ShowState;
 declare function evaluateShowState(state: ShowState): VNode[];
 declare function clearShowDomUpdateState(state: ShowState): void;
@@ -39,5 +59,4 @@ declare function createCaseState(matches: MatchBranch[], fallback: (() => VNode)
 declare function evaluateCaseState(state: CaseState): VNode[];
 declare function clearCaseDomUpdateState(state: CaseState): void;
 //#endregion
-export { CaseState, ControlBoundaryState, MatchBranch, ShowState };
-//# sourceMappingURL=control.d.ts.map
+export { CaseState, ControlBoundaryState, ControlTransaction, MatchBranch, ShowState };