@contember/bindx 0.1.46 → 0.1.47

package/dist/undo/UndoManager.d.ts

@@ -3,117 +3,60 @@ import type { SnapshotStore } from '../store/SnapshotStore.js';
 import type { UndoManagerConfig, UndoState } from './types.js';
 type Subscriber = () => void;
 /**
- * UndoManager provides undo/redo functionality for the Bindx store.
+ * UndoManager — the policy layer over the {@link UndoJournal}.
  *
- * Features:
- * - Automatic debounced grouping of rapid changes
- * - Manual grouping via beginGroup/endGroup
- * - Configurable history size
- * - Block/unblock during persist operations
- * - React integration via subscribe/getState
+ * The journal records each gesture (one dispatch / one handle transaction) as a
+ * {@link JournalEntry} of editable-layer pre-images. UndoManager owns the undo /
+ * redo stacks and the grouping policy (debounced auto-grouping + manual
+ * begin/endGroup), blocks during persist, and keeps the stacks aligned across a
+ * temp→persisted rekey. Restore goes straight through the store's write paths, so
+ * the edge index and reachability cache rebuild themselves; the event/interceptor
+ * pipeline is NOT replayed.
  */
 export declare class UndoManager {
     private readonly store;
+    private readonly journal;
     private undoStack;
     private redoStack;
-    private pendingEntry;
+    /** Cells accumulated while a debounce window or manual group is open (first-writer-wins). */
+    private pending;
     private debounceTimer;
-    private isBlocked;
     private manualGroupId;
-    private manualGroupLabel;
+    private blockDepth;
     private subscribers;
     private cachedState;
     private readonly maxHistorySize;
     private readonly debounceMs;
     constructor(store: SnapshotStore, config?: UndoManagerConfig);
     /**
-     * Creates middleware for ActionDispatcher.
-     * Must be added to dispatcher to enable undo tracking.
+     * Wires the journal into the store so its write paths record gestures. The
+     * returned middleware is a backward-compatible pass-through (recording is native
+     * to the store transaction, not the middleware).
      */
     createMiddleware(): ActionMiddleware;
-    /**
-     * Handles an action, capturing state for undo if trackable.
-     */
-    private handleAction;
-    /**
-     * Handles action in manual group mode.
-     */
-    private handleManualGroupAction;
-    /**
-     * Handles action in debounced auto-group mode.
-     */
-    private handleDebouncedAction;
-    /**
-     * Gets keys that are in source but not in target.
-     */
-    private getNewKeys;
-    /**
-     * Checks if keys object is empty.
-     */
-    private isEmptyKeys;
-    /**
-     * Merges additional snapshot into target.
-     */
-    private mergeSnapshots;
-    /**
-     * Starts the debounce timer.
-     */
-    private startDebounceTimer;
-    /**
-     * Resets the debounce timer.
-     */
+    private onEntry;
+    private mergeIntoPending;
+    private flushPending;
+    private pushEntry;
     private resetDebounceTimer;
     /**
-     * Flushes pending entry to undo stack.
-     */
-    private flushPendingEntry;
-    /**
-     * Trims history to max size.
-     */
-    private trimHistory;
-    /**
-     * Starts a manual group. All actions until endGroup are grouped as one undo entry.
-     * Returns group ID that must be passed to endGroup.
-     */
-    beginGroup(label?: string): string;
-    /**
-     * Ends a manual group and pushes to undo stack.
+     * Starts a manual group: every gesture until {@link endGroup} folds into one
+     * undo entry. Returns a handle that must be passed back to endGroup.
      */
+    beginGroup(_label?: string): string;
     endGroup(groupId: string): void;
-    /**
-     * Undoes the last entry.
-     */
     undo(): void;
-    /**
-     * Redoes the last undone entry.
-     */
     redo(): void;
-    /**
-     * Blocks undo/redo operations.
-     * Use during persist to prevent inconsistent state.
-     */
     block(): void;
-    /**
-     * Unblocks undo/redo operations.
-     */
     unblock(): void;
     /**
-     * Clears all undo/redo history.
+     * Rewrites every stacked entry when a temp id is replaced by its persisted id,
+     * so stored cells keep valid keys / id references (and sealed creates drop out).
      */
+    private rekeyStacks;
     clear(): void;
-    /**
-     * Subscribes to state changes.
-     * Returns unsubscribe function.
-     */
     subscribe(callback: Subscriber): () => void;
-    /**
-     * Gets current state for React integration.
-     * Returns a cached object to satisfy useSyncExternalStore's referential equality requirement.
-     */
     getState(): UndoState;
-    /**
-     * Notifies all subscribers of state change.
-     */
     private notifySubscribers;
 }
 export {};

package/dist/undo/UndoManager.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"UndoManager.d.ts","sourceRoot":"","sources":["../../src/undo/UndoManager.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,6BAA6B,CAAA;AASnE,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,2BAA2B,CAAA;AAC9D,OAAO,KAAK,EAIX,iBAAiB,EACjB,SAAS,EACT,MAAM,YAAY,CAAA;AAEnB,KAAK,UAAU,GAAG,MAAM,IAAI,CAAA;AAS5B;;;;;;;;;GASG;AACH,qBAAa,WAAW;IAetB,OAAO,CAAC,QAAQ,CAAC,KAAK;IAdvB,OAAO,CAAC,SAAS,CAAkB;IACnC,OAAO,CAAC,SAAS,CAAkB;IACnC,OAAO,CAAC,YAAY,CAAgC;IACpD,OAAO,CAAC,aAAa,CAA6C;IAClE,OAAO,CAAC,SAAS,CAAQ;IACzB,OAAO,CAAC,aAAa,CAAsB;IAC3C,OAAO,CAAC,gBAAgB,CAAgC;IACxD,OAAO,CAAC,WAAW,CAAwB;IAC3C,OAAO,CAAC,WAAW,CAAyB;IAE5C,OAAO,CAAC,QAAQ,CAAC,cAAc,CAAQ;IACvC,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAQ;gBAGjB,KAAK,EAAE,aAAa,EACrC,MAAM,GAAE,iBAAsB;IAM/B;;;OAGG;IACH,gBAAgB,IAAI,gBAAgB;IAQpC;;OAEG;IACH,OAAO,CAAC,YAAY;IAuBpB;;OAEG;IACH,OAAO,CAAC,uBAAuB;IAsB/B;;OAEG;IACH,OAAO,CAAC,qBAAqB;IAqC7B;;OAEG;IACH,OAAO,CAAC,UAAU;IAQlB;;OAEG;IACH,OAAO,CAAC,WAAW;IAInB;;OAEG;IACH,OAAO,CAAC,cAAc;IAuBtB;;OAEG;IACH,OAAO,CAAC,kBAAkB;IAM1B;;OAEG;IACH,OAAO,CAAC,kBAAkB;IAO1B;;OAEG;IACH,OAAO,CAAC,iBAAiB;IAqBzB;;OAEG;IACH,OAAO,CAAC,WAAW;IAMnB;;;OAGG;IACH,UAAU,CAAC,KAAK,CAAC,EAAE,MAAM,GAAG,MAAM;IAUlC;;OAEG;IACH,QAAQ,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI;IAW/B;;OAEG;IACH,IAAI,IAAI,IAAI;IA4BZ;;OAEG;IACH,IAAI,IAAI,IAAI;IAyBZ;;;OAGG;IACH,KAAK,IAAI,IAAI;IAOb;;OAEG;IACH,OAAO,IAAI,IAAI;IAKf;;OAEG;IACH,KAAK,IAAI,IAAI;IAab;;;OAGG;IACH,SAAS,CAAC,QAAQ,EAAE,UAAU,GAAG,MAAM,IAAI;IAO3C;;;OAGG;IACH,QAAQ,IAAI,SAAS;IAarB;;OAEG;IACH,OAAO,CAAC,iBAAiB;CAMzB"}
+{"version":3,"file":"UndoManager.d.ts","sourceRoot":"","sources":["../../src/undo/UndoManager.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,6BAA6B,CAAA;AACnE,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,2BAA2B,CAAA;AAI9D,OAAO,KAAK,EAAE,iBAAiB,EAAE,SAAS,EAAE,MAAM,YAAY,CAAA;AAE9D,KAAK,UAAU,GAAG,MAAM,IAAI,CAAA;AAS5B;;;;;;;;;;GAUG;AACH,qBAAa,WAAW;IAkBtB,OAAO,CAAC,QAAQ,CAAC,KAAK;IAjBvB,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAa;IACrC,OAAO,CAAC,SAAS,CAAqB;IACtC,OAAO,CAAC,SAAS,CAAqB;IAEtC,6FAA6F;IAC7F,OAAO,CAAC,OAAO,CAA6C;IAC5D,OAAO,CAAC,aAAa,CAA6C;IAClE,OAAO,CAAC,aAAa,CAAsB;IAE3C,OAAO,CAAC,UAAU,CAAI;IACtB,OAAO,CAAC,WAAW,CAAwB;IAC3C,OAAO,CAAC,WAAW,CAAyB;IAE5C,OAAO,CAAC,QAAQ,CAAC,cAAc,CAAQ;IACvC,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAQ;gBAGjB,KAAK,EAAE,aAAa,EACrC,MAAM,GAAE,iBAAsB;IAY/B;;;;OAIG;IACH,gBAAgB,IAAI,gBAAgB;IAWpC,OAAO,CAAC,OAAO;IAwBf,OAAO,CAAC,gBAAgB;IAaxB,OAAO,CAAC,YAAY;IAYpB,OAAO,CAAC,SAAS;IAUjB,OAAO,CAAC,kBAAkB;IAS1B;;;OAGG;IACH,UAAU,CAAC,MAAM,CAAC,EAAE,MAAM,GAAG,MAAM;IAOnC,QAAQ,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI;IAW/B,IAAI,IAAI,IAAI;IAcZ,IAAI,IAAI,IAAI;IAaZ,KAAK,IAAI,IAAI;IAUb,OAAO,IAAI,IAAI;IAUf;;;OAGG;IACH,OAAO,CAAC,WAAW;IAiCnB,KAAK,IAAI,IAAI;IAYb,SAAS,CAAC,QAAQ,EAAE,UAAU,GAAG,MAAM,IAAI;IAO3C,QAAQ,IAAI,SAAS;IAcrB,OAAO,CAAC,iBAAiB;CAMzB"}

package/dist/undo/UnrecordedWriteError.d.ts

@@ -0,0 +1,16 @@
+import type { JournalCellKind } from './UndoJournal.js';
+/**
+ * Thrown when a journal transaction closes after an editable-layer store write
+ * that was NOT preceded by a matching `journal.record*` call — i.e. a mutating
+ * SnapshotStore method wrote primary state a gesture can no longer undo.
+ *
+ * This turns the "every mutating method must record before writing" convention
+ * into a checked invariant: the sub-store editable-write counters advanced for a
+ * kind the transaction never recorded. The named kinds pinpoint which record call
+ * is missing (recordEntity / recordRelation / recordHasMany).
+ */
+export declare class UnrecordedWriteError extends Error {
+    readonly kinds: ReadonlyArray<JournalCellKind>;
+    constructor(kinds: ReadonlyArray<JournalCellKind>);
+}
+//# sourceMappingURL=UnrecordedWriteError.d.ts.map

package/dist/undo/UnrecordedWriteError.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"UnrecordedWriteError.d.ts","sourceRoot":"","sources":["../../src/undo/UnrecordedWriteError.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,kBAAkB,CAAA;AAEvD;;;;;;;;;GASG;AACH,qBAAa,oBAAqB,SAAQ,KAAK;aAClB,KAAK,EAAE,aAAa,CAAC,eAAe,CAAC;gBAArC,KAAK,EAAE,aAAa,CAAC,eAAe,CAAC;CASjE"}

package/dist/undo/index.d.ts

@@ -1,3 +1,5 @@
 export { UndoManager } from './UndoManager.js';
-export type { PartialStoreSnapshot, PendingUndoEntry, UndoEntry, UndoManagerConfig, UndoState, StoreAffectedKeys, } from './types.js';
+export { UnrecordedWriteError } from './UnrecordedWriteError.js';
+export type { UndoManagerConfig, UndoState } from './types.js';
+export type { JournalEntry, JournalCellImage, EntityCellImage, RelationCellImage, HasManyCellImage, } from './UndoJournal.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/undo/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/undo/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAA;AAC9C,YAAY,EACX,oBAAoB,EACpB,gBAAgB,EAChB,SAAS,EACT,iBAAiB,EACjB,SAAS,EACT,iBAAiB,GACjB,MAAM,YAAY,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/undo/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAA;AAC9C,OAAO,EAAE,oBAAoB,EAAE,MAAM,2BAA2B,CAAA;AAChE,YAAY,EAAE,iBAAiB,EAAE,SAAS,EAAE,MAAM,YAAY,CAAA;AAC9D,YAAY,EACX,YAAY,EACZ,gBAAgB,EAChB,eAAe,EACf,iBAAiB,EACjB,gBAAgB,GAChB,MAAM,kBAAkB,CAAA"}

package/dist/undo/rekeyJournalEntry.d.ts

@@ -0,0 +1,20 @@
+import type { RekeyContext } from '../store/RekeyOrchestrator.js';
+import type { JournalEntry } from './UndoJournal.js';
+/**
+ * Rewrites a journal entry for a temp→persisted rekey so stored cells stay valid
+ * after persist:
+ *   - owner keys move from the temp prefix to the persisted prefix;
+ *   - embedded id references (snapshot ids, relation currentId/serverId, has-many
+ *     members) are remapped oldId→newId;
+ *   - the create is SEALED: an "absent" pre-image of the now-persisted entity (or
+ *     its owned relations) is dropped, so undo can no longer delete the
+ *     server-backed row — only later edits to it remain undoable.
+ */
+/**
+ * Looks up the live server-member ids of a has-many list by its key. Lets the
+ * rekey rebase a pre-image when the just-persisted create has become a permanent
+ * member of that list.
+ */
+export type LiveServerIdsLookup = (relationKey: string) => Set<string>;
+export declare function rekeyJournalEntry(entry: JournalEntry, ctx: RekeyContext, liveServerIds: LiveServerIdsLookup): JournalEntry;
+//# sourceMappingURL=rekeyJournalEntry.d.ts.map

package/dist/undo/rekeyJournalEntry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rekeyJournalEntry.d.ts","sourceRoot":"","sources":["../../src/undo/rekeyJournalEntry.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,+BAA+B,CAAA;AAIjE,OAAO,KAAK,EAAE,YAAY,EAAoB,MAAM,kBAAkB,CAAA;AAEtE;;;;;;;;;GASG;AACH;;;;GAIG;AACH,MAAM,MAAM,mBAAmB,GAAG,CAAC,WAAW,EAAE,MAAM,KAAK,GAAG,CAAC,MAAM,CAAC,CAAA;AAEtE,wBAAgB,iBAAiB,CAChC,KAAK,EAAE,YAAY,EACnB,GAAG,EAAE,YAAY,EACjB,aAAa,EAAE,mBAAmB,GAChC,YAAY,CAOd"}

package/dist/undo/types.d.ts

@@ -1,50 +1,3 @@
-import type { StoreAffectedKeys } from '../core/actionClassification.js';
-import type { EntitySnapshot } from '../store/snapshots.js';
-import type { StoredRelationState, StoredHasManyState, EntityMeta } from '../store/SnapshotStore.js';
-/**
- * Partial snapshot of store state.
- * Contains only the data affected by an action or group of actions.
- */
-export interface PartialStoreSnapshot {
-    /** Entity snapshots (frozen, immutable) */
-    entitySnapshots: Map<string, EntitySnapshot>;
-    /** Has-one relation states */
-    relationStates: Map<string, StoredRelationState>;
-    /** Has-many list states */
-    hasManyStates: Map<string, StoredHasManyState>;
-    /** Entity metadata (existsOnServer, deletion flags) */
-    entityMetas: Map<string, EntityMeta>;
-}
-/**
- * A single undo/redo entry.
- * Contains the snapshot of state BEFORE the action(s) were applied.
- */
-export interface UndoEntry {
-    /** Unique identifier for this entry */
-    id: string;
-    /** Optional human-readable label */
-    label?: string;
-    /** Snapshot of state BEFORE the action(s) */
-    beforeSnapshot: PartialStoreSnapshot;
-    /** Keys that were affected (for redo snapshot capture) */
-    affectedKeys: StoreAffectedKeys;
-    /** When this entry was created */
-    timestamp: number;
-}
-/**
- * Pending entry during debounce window.
- * Accumulates affected keys while waiting for debounce to complete.
- */
-export interface PendingUndoEntry {
-    /** Snapshot captured before the first action in the group */
-    beforeSnapshot: PartialStoreSnapshot;
-    /** Accumulated affected keys */
-    affectedKeys: StoreAffectedKeys;
-    /** When the first action occurred */
-    timestamp: number;
-    /** Optional label for manual grouping */
-    label?: string;
-}
 /**
  * Configuration options for UndoManager.
  */
@@ -70,5 +23,4 @@ export interface UndoState {
     /** Number of entries in redo stack */
     redoCount: number;
 }
-export type { StoreAffectedKeys } from '../core/actionClassification.js';
 //# sourceMappingURL=types.d.ts.map

package/dist/undo/types.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/undo/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,iCAAiC,CAAA;AACxE,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,uBAAuB,CAAA;AAC3D,OAAO,KAAK,EACX,mBAAmB,EACnB,kBAAkB,EAClB,UAAU,EACV,MAAM,2BAA2B,CAAA;AAElC;;;GAGG;AACH,MAAM,WAAW,oBAAoB;IACpC,2CAA2C;IAC3C,eAAe,EAAE,GAAG,CAAC,MAAM,EAAE,cAAc,CAAC,CAAA;IAC5C,8BAA8B;IAC9B,cAAc,EAAE,GAAG,CAAC,MAAM,EAAE,mBAAmB,CAAC,CAAA;IAChD,2BAA2B;IAC3B,aAAa,EAAE,GAAG,CAAC,MAAM,EAAE,kBAAkB,CAAC,CAAA;IAC9C,uDAAuD;IACvD,WAAW,EAAE,GAAG,CAAC,MAAM,EAAE,UAAU,CAAC,CAAA;CACpC;AAED;;;GAGG;AACH,MAAM,WAAW,SAAS;IACzB,uCAAuC;IACvC,EAAE,EAAE,MAAM,CAAA;IACV,oCAAoC;IACpC,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,6CAA6C;IAC7C,cAAc,EAAE,oBAAoB,CAAA;IACpC,0DAA0D;IAC1D,YAAY,EAAE,iBAAiB,CAAA;IAC/B,kCAAkC;IAClC,SAAS,EAAE,MAAM,CAAA;CACjB;AAED;;;GAGG;AACH,MAAM,WAAW,gBAAgB;IAChC,6DAA6D;IAC7D,cAAc,EAAE,oBAAoB,CAAA;IACpC,gCAAgC;IAChC,YAAY,EAAE,iBAAiB,CAAA;IAC/B,qCAAqC;IACrC,SAAS,EAAE,MAAM,CAAA;IACjB,yCAAyC;IACzC,KAAK,CAAC,EAAE,MAAM,CAAA;CACd;AAED;;GAEG;AACH,MAAM,WAAW,iBAAiB;IACjC,4DAA4D;IAC5D,cAAc,CAAC,EAAE,MAAM,CAAA;IACvB,qEAAqE;IACrE,UAAU,CAAC,EAAE,MAAM,CAAA;CACnB;AAED;;;GAGG;AACH,MAAM,WAAW,SAAS;IACzB,gCAAgC;IAChC,OAAO,EAAE,OAAO,CAAA;IAChB,gCAAgC;IAChC,OAAO,EAAE,OAAO,CAAA;IAChB,oEAAoE;IACpE,SAAS,EAAE,OAAO,CAAA;IAClB,sCAAsC;IACtC,SAAS,EAAE,MAAM,CAAA;IACjB,sCAAsC;IACtC,SAAS,EAAE,MAAM,CAAA;CACjB;AAGD,YAAY,EAAE,iBAAiB,EAAE,MAAM,iCAAiC,CAAA"}
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/undo/types.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,MAAM,WAAW,iBAAiB;IACjC,4DAA4D;IAC5D,cAAc,CAAC,EAAE,MAAM,CAAA;IACvB,qEAAqE;IACrE,UAAU,CAAC,EAAE,MAAM,CAAA;CACnB;AAED;;;GAGG;AACH,MAAM,WAAW,SAAS;IACzB,gCAAgC;IAChC,OAAO,EAAE,OAAO,CAAA;IAChB,gCAAgC;IAChC,OAAO,EAAE,OAAO,CAAA;IAChB,oEAAoE;IACpE,SAAS,EAAE,OAAO,CAAA;IAClB,sCAAsC;IACtC,SAAS,EAAE,MAAM,CAAA;IACjB,sCAAsC;IACtC,SAAS,EAAE,MAAM,CAAA;CACjB"}

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@contember/bindx",
-	"version": "0.1.46",
+	"version": "0.1.47",
 	"description": "Type-safe data binding framework (core)",
 	"type": "module",
 	"main": "./src/index.ts",
@@ -17,7 +17,7 @@
 	],
 	"license": "MIT",
 	"dependencies": {
-		"@contember/bindx-client": "0.1.46",
+		"@contember/bindx-client": "0.1.47",
 		"@contember/graphql-client": "^2.1.0-beta.1"
 	},
 	"repository": {

package/src/core/ActionDispatcher.ts

@@ -27,6 +27,7 @@ export class ActionDispatcher {
 		eventEmitter?: EventEmitter,
 	) {
 		this.eventEmitter = eventEmitter ?? new EventEmitter()
+		this.store.attachRekeyParticipant(this.eventEmitter)
 	}
 
 	/**
@@ -42,39 +43,46 @@ export class ActionDispatcher {
 	 * Async interceptors are skipped with a warning — use dispatchAsync() for those.
 	 */
 	dispatch(action: Action): void {
-		// Run through middlewares first
-		for (const middleware of this.middlewares) {
-			const result = middleware(action, this.store)
-			if (result === false) {
-				// Middleware can cancel the action
-				return
+		// One dispatch = one undoable gesture. The store records every primary write
+		// made between begin/commit into a single journal entry (no-op without undo).
+		this.store.beginTransaction()
+		try {
+			// Run through middlewares first
+			for (const middleware of this.middlewares) {
+				const result = middleware(action, this.store)
+				if (result === false) {
+					// Middleware can cancel the action
+					return
+				}
 			}
-		}
 
-		// Create and run before event through interceptors (synchronously)
-		const beforeEvent = createBeforeEvent(action, this.store)
-		if (beforeEvent) {
-			const result = this.eventEmitter.runInterceptorsSync(beforeEvent)
-			if (result === null) {
-				// Interceptor cancelled the action
-				return
-			}
-			// If event was modified, update action accordingly
-			if (result !== beforeEvent) {
-				action = this.updateActionFromEvent(action, result)
+			// Create and run before event through interceptors (synchronously)
+			const beforeEvent = createBeforeEvent(action, this.store)
+			if (beforeEvent) {
+				const result = this.eventEmitter.runInterceptorsSync(beforeEvent)
+				if (result === null) {
+					// Interceptor cancelled the action
+					return
+				}
+				// If event was modified, update action accordingly
+				if (result !== beforeEvent) {
+					action = this.updateActionFromEvent(action, result)
+				}
 			}
-		}
 
-		// Capture state before execution (for after events)
-		const stateBefore = captureStateBeforeAction(action, this.store)
+			// Capture state before execution (for after events)
+			const stateBefore = captureStateBeforeAction(action, this.store)
 
-		// Execute the action
-		this.execute(action)
+			// Execute the action
+			this.execute(action)
 
-		// Emit after event
-		const afterEvent = createAfterEvent(action, stateBefore, this.store)
-		if (afterEvent) {
-			this.eventEmitter.emit(afterEvent)
+			// Emit after event
+			const afterEvent = createAfterEvent(action, stateBefore, this.store)
+			if (afterEvent) {
+				this.eventEmitter.emit(afterEvent)
+			}
+		} finally {
+			this.store.commitTransaction()
 		}
 	}
 
@@ -108,16 +116,21 @@ export class ActionDispatcher {
 		// Capture state before execution (for after events)
 		const stateBefore = captureStateBeforeAction(action, this.store)
 
-		// Execute the action
-		this.execute(action)
+		this.store.beginTransaction()
+		try {
+			// Execute the action
+			this.execute(action)
 
-		// Emit after event
-		const afterEvent = createAfterEvent(action, stateBefore, this.store)
-		if (afterEvent) {
-			this.eventEmitter.emit(afterEvent)
-		}
+			// Emit after event
+			const afterEvent = createAfterEvent(action, stateBefore, this.store)
+			if (afterEvent) {
+				this.eventEmitter.emit(afterEvent)
+			}
 
-		return true
+			return true
+		} finally {
+			this.store.commitTransaction()
+		}
 	}
 
 	/**
@@ -174,6 +187,9 @@ export class ActionDispatcher {
 		const index = this.middlewares.indexOf(middleware)
 		if (index !== -1) {
 			this.middlewares.splice(index, 1)
+			if (!this.middlewares.includes(middleware)) {
+				middleware.dispose?.()
+			}
 		}
 	}
 
@@ -373,6 +389,7 @@ export class ActionDispatcher {
 					action.entityType,
 					action.entityId,
 					action.isPersisting,
+					action.pessimistic ?? false,
 				)
 				break
 
@@ -455,7 +472,10 @@ export class ActionDispatcher {
  * Can inspect/modify actions before execution.
  * Return false to cancel the action.
  */
-export type ActionMiddleware = (action: Action, store: SnapshotStore) => boolean | void
+export interface ActionMiddleware {
+	(action: Action, store: SnapshotStore): boolean | void
+	dispose?: () => void
+}
 
 /**
  * Creates a logging middleware for debugging.

package/src/core/actions.ts

@@ -202,6 +202,12 @@ export interface SetPersistingAction {
 	readonly entityType: string
 	readonly entityId: string
 	readonly isPersisting: boolean
+	/**
+	 * Whether this persist is pessimistic. While a pessimistic persist is
+	 * in-flight, handles present the server baseline instead of the (still dirty)
+	 * local data. Ignored when isPersisting is false.
+	 */
+	readonly pessimistic?: boolean
 }
 
 // ==================== Error Actions ====================
@@ -428,8 +434,9 @@ export function setPersisting(
 	entityType: string,
 	entityId: string,
 	isPersisting: boolean,
+	pessimistic: boolean = false,
 ): SetPersistingAction {
-	return { type: 'SET_PERSISTING', entityType, entityId, isPersisting }
+	return { type: 'SET_PERSISTING', entityType, entityId, isPersisting, pessimistic }
 }
 
 /**