@dabble/patches 0.6.0 → 0.7.1

package/dist/algorithms/{server → ot/server}/getStateAtRevision.d.ts

@@ -1,8 +1,8 @@
-import { PatchesStoreBackend } from '../../server/types.js';
-import { PatchesState } from '../../types.js';
-import '../../json-patch/JSONPatch.js';
+import { OTStoreBackend } from '../../../server/types.js';
+import { PatchesState } from '../../../types.js';
+import '../../../json-patch/types.js';
+import '../../../json-patch/JSONPatch.js';
 import '@dabble/delta';
-import '../../json-patch/types.js';
 
 /**
  * Gets the state at a specific revision.
@@ -10,6 +10,6 @@ import '../../json-patch/types.js';
  * @param rev The revision number. If not provided, the latest state and its revision is returned.
  * @returns The state at the specified revision *and* its revision number.
  */
-declare function getStateAtRevision(store: PatchesStoreBackend, docId: string, rev?: number): Promise<PatchesState>;
+declare function getStateAtRevision(store: OTStoreBackend, docId: string, rev?: number): Promise<PatchesState>;
 
 export { getStateAtRevision };

package/dist/algorithms/{server → ot/server}/getStateAtRevision.js

@@ -1,4 +1,4 @@
-import "../../chunk-IZ2YBCUP.js";
+import "../../../chunk-IZ2YBCUP.js";
 import { applyChanges } from "../shared/applyChanges.js";
 import { getSnapshotAtRevision } from "./getSnapshotAtRevision.js";
 async function getStateAtRevision(store, docId, rev) {

package/dist/algorithms/{server → ot/server}/handleOfflineSessionsAndBatches.d.ts

@@ -1,8 +1,8 @@
-import { PatchesStoreBackend } from '../../server/types.js';
-import { Change } from '../../types.js';
-import '../../json-patch/JSONPatch.js';
+import { OTStoreBackend } from '../../../server/types.js';
+import { Change } from '../../../types.js';
+import '../../../json-patch/types.js';
+import '../../../json-patch/JSONPatch.js';
 import '@dabble/delta';
-import '../../json-patch/types.js';
 
 /**
  * Handles offline/large batch versioning logic for multi-batch uploads.
@@ -16,6 +16,6 @@ import '../../json-patch/types.js';
  * @param maxStorageBytes If set, break collapsed changes that exceed this size
  * @returns The changes (collapsed into one if divergent, unchanged if fast-forward)
  */
-declare function handleOfflineSessionsAndBatches(store: PatchesStoreBackend, sessionTimeoutMillis: number, docId: string, changes: Change[], baseRev: number, batchId?: string, origin?: 'main' | 'offline-branch', isOffline?: boolean, maxStorageBytes?: number): Promise<Change[]>;
+declare function handleOfflineSessionsAndBatches(store: OTStoreBackend, sessionTimeoutMillis: number, docId: string, changes: Change[], baseRev: number, batchId?: string, origin?: 'main' | 'offline-branch', isOffline?: boolean, maxStorageBytes?: number): Promise<Change[]>;
 
 export { handleOfflineSessionsAndBatches };

package/dist/algorithms/{server → ot/server}/handleOfflineSessionsAndBatches.js

@@ -1,5 +1,5 @@
-import "../../chunk-IZ2YBCUP.js";
-import { createVersionMetadata } from "../../data/version.js";
+import "../../../chunk-IZ2YBCUP.js";
+import { createVersionMetadata } from "../../../data/version.js";
 import { applyChanges } from "../shared/applyChanges.js";
 import { breakChanges } from "../shared/changeBatching.js";
 import { getStateAtRevision } from "./getStateAtRevision.js";
@@ -26,7 +26,7 @@ async function handleOfflineSessionsAndBatches(store, sessionTimeoutMillis, docI
       const sessionChanges = changes.slice(sessionStartIndex, i);
       if (sessionChanges.length > 0) {
         const isContinuation = !!lastVersion && sessionChanges[0].createdAt - lastVersion.endedAt <= sessionTimeoutMillis;
-        if (isContinuation) {
+        if (isContinuation && store.appendVersionChanges) {
           const mergedState = applyChanges(offlineBaseState, sessionChanges);
           const newEndedAt = sessionChanges[sessionChanges.length - 1].createdAt;
           const newRev = sessionChanges[sessionChanges.length - 1].rev;

package/dist/algorithms/{server → ot/server}/transformIncomingChanges.d.ts

@@ -1,7 +1,7 @@
-import { Change } from '../../types.js';
-import '../../json-patch/JSONPatch.js';
+import { Change } from '../../../types.js';
+import '../../../json-patch/JSONPatch.js';
 import '@dabble/delta';
-import '../../json-patch/types.js';
+import '../../../json-patch/types.js';
 
 /**
  * Transforms incoming changes against committed changes that happened *after* the client's baseRev.

package/dist/algorithms/{server → ot/server}/transformIncomingChanges.js

@@ -1,6 +1,6 @@
-import "../../chunk-IZ2YBCUP.js";
-import { applyPatch } from "../../json-patch/applyPatch.js";
-import { transformPatch } from "../../json-patch/transformPatch.js";
+import "../../../chunk-IZ2YBCUP.js";
+import { applyPatch } from "../../../json-patch/applyPatch.js";
+import { transformPatch } from "../../../json-patch/transformPatch.js";
 function transformIncomingChanges(changes, stateAtBaseRev, committedChanges, currentRev, forceCommit = false) {
   const committedOps = committedChanges.flatMap((c) => c.ops);
   let state = stateAtBaseRev;

package/dist/algorithms/{shared → ot/shared}/applyChanges.d.ts

@@ -1,7 +1,7 @@
-import { Change } from '../../types.js';
-import '../../json-patch/JSONPatch.js';
+import { Change } from '../../../types.js';
+import '../../../json-patch/JSONPatch.js';
 import '@dabble/delta';
-import '../../json-patch/types.js';
+import '../../../json-patch/types.js';
 
 /**
  * Applies a sequence of changes to a state object.

package/dist/algorithms/{shared → ot/shared}/applyChanges.js

@@ -1,5 +1,5 @@
-import "../../chunk-IZ2YBCUP.js";
-import { applyPatch } from "../../json-patch/applyPatch.js";
+import "../../../chunk-IZ2YBCUP.js";
+import { applyPatch } from "../../../json-patch/applyPatch.js";
 function applyChanges(state, changes) {
   if (!changes.length) return state;
   for (const change of changes) {

package/dist/algorithms/{shared → ot/shared}/changeBatching.d.ts

@@ -1,7 +1,7 @@
-import { Change } from '../../types.js';
-import '../../json-patch/JSONPatch.js';
+import { Change } from '../../../types.js';
+import '../../../json-patch/JSONPatch.js';
 import '@dabble/delta';
-import '../../json-patch/types.js';
+import '../../../json-patch/types.js';
 
 /**
  * Function that calculates the storage size of data.

package/dist/algorithms/{shared → ot/shared}/changeBatching.js

@@ -1,6 +1,6 @@
-import "../../chunk-IZ2YBCUP.js";
+import "../../../chunk-IZ2YBCUP.js";
 import { createId } from "crypto-id";
-import { createChange } from "../../data/change.js";
+import { createChange } from "../../../data/change.js";
 function getJSONByteSize(data) {
   try {
     const stringified = JSON.stringify(data);

package/dist/algorithms/{shared → ot/shared}/rebaseChanges.d.ts

@@ -1,7 +1,7 @@
-import { Change } from '../../types.js';
-import '../../json-patch/JSONPatch.js';
+import { Change } from '../../../types.js';
+import '../../../json-patch/JSONPatch.js';
 import '@dabble/delta';
-import '../../json-patch/types.js';
+import '../../../json-patch/types.js';
 
 /**
  * Rebases local changes against server changes using operational transformation.

package/dist/algorithms/{shared → ot/shared}/rebaseChanges.js

@@ -1,5 +1,5 @@
-import "../../chunk-IZ2YBCUP.js";
-import { JSONPatch } from "../../json-patch/JSONPatch.js";
+import "../../../chunk-IZ2YBCUP.js";
+import { JSONPatch } from "../../../json-patch/JSONPatch.js";
 function rebaseChanges(serverChanges, localChanges) {
   if (!serverChanges.length || !localChanges.length) {
     return localChanges;

package/dist/client/BaseDoc.d.ts

@@ -0,0 +1,6 @@
+import '../event-signal.js';
+import '../json-patch/types.js';
+import '../types.js';
+export { B as BaseDoc } from '../BaseDoc-DkP3tUhT.js';
+import '../json-patch/JSONPatch.js';
+import '@dabble/delta';

package/dist/client/BaseDoc.js

@@ -0,0 +1,70 @@
+import "../chunk-IZ2YBCUP.js";
+import { signal } from "../event-signal.js";
+import { createJSONPatch } from "../json-patch/createJSONPatch.js";
+class BaseDoc {
+  _id;
+  _state;
+  _syncing = null;
+  /**
+   * Subscribe to be notified when the user makes local changes.
+   * Emits the JSON Patch ops captured from the change() call.
+   * The strategy handles packaging these into Changes.
+   */
+  onChange = signal();
+  /** Subscribe to be notified whenever state changes from any source. */
+  onUpdate = signal();
+  /** Subscribe to be notified when syncing state changes. */
+  onSyncing = signal();
+  /**
+   * Creates an instance of BaseDoc.
+   * @param id The unique identifier for this document.
+   * @param initialState Optional initial state.
+   */
+  constructor(id, initialState = {}) {
+    this._id = id;
+    this._state = initialState;
+  }
+  /** The unique identifier for this document. */
+  get id() {
+    return this._id;
+  }
+  /** Current local state (committed + pending merged). */
+  get state() {
+    return this._state;
+  }
+  /** Are we currently syncing this document? */
+  get syncing() {
+    return this._syncing;
+  }
+  /** Subscribe to be notified whenever the state changes (calls immediately with current state). */
+  subscribe(onUpdate) {
+    const unsub = this.onUpdate(onUpdate);
+    onUpdate(this._state);
+    return unsub;
+  }
+  /**
+   * Captures an update to the document, emitting JSON Patch ops via onChange.
+   * Does NOT apply locally - the strategy handles state updates via applyChanges.
+   * @param mutator Function that uses JSONPatch methods with type-safe paths.
+   */
+  change(mutator) {
+    const patch = createJSONPatch(mutator);
+    if (patch.ops.length === 0) {
+      return;
+    }
+    this.onChange.emit(patch.ops);
+  }
+  // --- Internal methods (not on PatchesDoc interface) ---
+  /**
+   * Updates the syncing state of the document.
+   * Called by PatchesSync - not part of the app-facing PatchesDoc interface.
+   * @param newSyncing The new syncing state.
+   */
+  updateSyncing(newSyncing) {
+    this._syncing = newSyncing;
+    this.onSyncing.emit(newSyncing);
+  }
+}
+export {
+  BaseDoc
+};

package/dist/client/ClientAlgorithm.d.ts

@@ -0,0 +1,101 @@
+import { JSONPatchOp } from '../json-patch/types.js';
+import { PatchesSnapshot, Change } from '../types.js';
+import { a as PatchesDoc } from '../BaseDoc-DkP3tUhT.js';
+import { PatchesStore, TrackedDoc } from './PatchesStore.js';
+import '../json-patch/JSONPatch.js';
+import '@dabble/delta';
+import '../event-signal.js';
+
+/**
+ * Algorithm interface for client-side sync algorithms (OT or LWW).
+ *
+ * The ClientAlgorithm owns its store and provides methods for:
+ * - Creating appropriate doc types
+ * - Packaging ops for persistence
+ * - Getting pending changes to send
+ * - Applying server changes
+ * - Confirming sent changes
+ *
+ * Patches owns docs and coordinates between doc/algorithm/sync.
+ *
+ * This interface enables Worker-Tab architectures where a TabAlgorithm
+ * can proxy to a WorkerAlgorithm that holds the real store and sync connection.
+ * Key design decisions for Worker-Tab support:
+ * - `handleDocChange` and `applyServerChanges` return `Change[]` for broadcast
+ * - `doc` parameter can be undefined (Worker has no docs)
+ */
+interface ClientAlgorithm {
+    /** Algorithm identifier: 'ot' or 'lww' */
+    readonly name: string;
+    /** Algorithm owns its store */
+    readonly store: PatchesStore;
+    /**
+     * Creates a doc instance appropriate for this algorithm.
+     * OT creates OTDoc, LWW creates LWWDoc.
+     *
+     * @param docId The unique identifier for the document.
+     * @param snapshot Optional snapshot to initialize the doc with.
+     */
+    createDoc<T extends object>(docId: string, snapshot?: PatchesSnapshot<T>): PatchesDoc<T>;
+    /**
+     * Loads initial state for a document from the store.
+     * Returns undefined if the document doesn't exist.
+     */
+    loadDoc(docId: string): Promise<PatchesSnapshot | undefined>;
+    /**
+     * Packages ops from doc.onChange into algorithm-specific format for persistence.
+     * - OT: Creates a Change with baseRev, stores in pending
+     * - LWW: Extracts fields with timestamps, merges into pendingFields
+     *
+     * Also updates the doc's state (if provided) after processing.
+     *
+     * @param docId Document identifier
+     * @param ops The JSON Patch ops to process
+     * @param doc The open doc instance, or undefined if in Worker (no docs)
+     * @param metadata Metadata to attach to the change
+     * @returns The changes created (for broadcast to other tabs)
+     */
+    handleDocChange<T extends object>(docId: string, ops: JSONPatchOp[], doc: PatchesDoc<T> | undefined, metadata: Record<string, any>): Promise<Change[]>;
+    /**
+     * Gets pending data to send to the server.
+     * - OT: Returns all pending changes (may batch)
+     * - LWW: Creates single Change from pendingFields (or returns existing)
+     *
+     * Returns null if nothing to send.
+     */
+    getPendingToSend(docId: string): Promise<Change[] | null>;
+    /**
+     * Applies server changes and updates the doc (if provided).
+     * - OT: Calls applyCommittedChanges algorithm, rebases pending
+     * - LWW: Applies with LWW merge, filters old pending fields
+     *
+     * @param docId Document identifier
+     * @param serverChanges Changes from the server
+     * @param doc The open doc instance, or undefined if in Worker (no docs)
+     * @returns Changes to broadcast to tabs (OT: serverChanges + rebasedPending, LWW: serverChanges)
+     */
+    applyServerChanges<T extends object>(docId: string, serverChanges: Change[], doc: PatchesDoc<T> | undefined): Promise<Change[]>;
+    /**
+     * Confirms that changes were acknowledged by the server.
+     * Called after successful server commit.
+     */
+    confirmSent(docId: string, changes: Change[]): Promise<void>;
+    /** Registers documents for local tracking. */
+    trackDocs(docIds: string[]): Promise<void>;
+    /** Removes documents from local tracking. */
+    untrackDocs(docIds: string[]): Promise<void>;
+    /** Lists all tracked documents. */
+    listDocs(includeDeleted?: boolean): Promise<TrackedDoc[]>;
+    /** Gets the committed revision for a document. */
+    getCommittedRev(docId: string): Promise<number>;
+    /** Marks a document for deletion. */
+    deleteDoc(docId: string): Promise<void>;
+    /** Confirms server-side deletion. */
+    confirmDeleteDoc(docId: string): Promise<void>;
+    /** Closes the algorithm and its store. */
+    close(): Promise<void>;
+}
+/** Available algorithm names */
+type AlgorithmName = 'ot' | 'lww';
+
+export type { AlgorithmName, ClientAlgorithm };

package/dist/client/InMemoryStore.d.ts

@@ -1,5 +1,6 @@
 import { PatchesSnapshot, Change, PatchesState } from '../types.js';
-import { PatchesStore, TrackedDoc } from './PatchesStore.js';
+import { OTClientStore } from './OTClientStore.js';
+import { TrackedDoc } from './PatchesStore.js';
 import '../json-patch/JSONPatch.js';
 import '@dabble/delta';
 import '../json-patch/types.js';
@@ -9,23 +10,20 @@ import '../json-patch/types.js';
  * All data lives in JS objects – nothing survives a page reload.
  * Useful for unit tests or when you want the old 'stateless realtime' behaviour.
  */
-declare class InMemoryStore implements PatchesStore {
+declare class InMemoryStore implements OTClientStore {
     private docs;
     getDoc(docId: string): Promise<PatchesSnapshot | undefined>;
     getPendingChanges(docId: string): Promise<Change[]>;
-    getLastRevs(docId: string): Promise<[number, number]>;
+    getCommittedRev(docId: string): Promise<number>;
     listDocs(includeDeleted?: boolean): Promise<TrackedDoc[]>;
     saveDoc(docId: string, snapshot: PatchesState): Promise<void>;
     savePendingChanges(docId: string, changes: Change[]): Promise<void>;
-    saveCommittedChanges(docId: string, changes: Change[], sentPendingRange?: [number, number]): Promise<void>;
-    replacePendingChanges(docId: string, changes: Change[]): Promise<void>;
+    applyServerChanges(docId: string, serverChanges: Change[], rebasedPendingChanges: Change[]): Promise<void>;
     trackDocs(docIds: string[]): Promise<void>;
     untrackDocs(docIds: string[]): Promise<void>;
     deleteDoc(docId: string): Promise<void>;
     confirmDeleteDoc(docId: string): Promise<void>;
     close(): Promise<void>;
-    getLastAttemptedSubmissionRev(docId: string): Promise<number | undefined>;
-    setLastAttemptedSubmissionRev(docId: string, rev: number): Promise<void>;
 }
 
 export { InMemoryStore };

package/dist/client/InMemoryStore.js

@@ -1,6 +1,5 @@
 import "../chunk-IZ2YBCUP.js";
-import { applyChanges } from "../algorithms/shared/applyChanges.js";
-import { transformPatch } from "../json-patch/transformPatch.js";
+import { applyChanges } from "../algorithms/ot/shared/applyChanges.js";
 class InMemoryStore {
   docs = /* @__PURE__ */ new Map();
   // ─── Reconstruction ────────────────────────────────────────────────────
@@ -9,14 +8,6 @@ class InMemoryStore {
     if (!buf || buf.deleted) return void 0;
     const state = applyChanges(buf.snapshot?.state ?? null, buf.committed);
     const committedRev = buf.committed.at(-1)?.rev ?? buf.snapshot?.rev ?? 0;
-    if (buf.pending.length && buf.pending[0].baseRev < committedRev) {
-      const patch = buf.committed.filter((c) => c.rev > buf.pending[0].baseRev).flatMap((c) => c.ops);
-      const offset = committedRev - buf.pending[0].baseRev;
-      buf.pending.forEach((ch) => {
-        ch.rev += offset;
-        ch.ops = transformPatch(state, patch, ch.ops);
-      });
-    }
     return {
       state,
       rev: committedRev,
@@ -26,12 +17,10 @@ class InMemoryStore {
   async getPendingChanges(docId) {
     return this.docs.get(docId)?.pending.slice() ?? [];
   }
-  async getLastRevs(docId) {
+  async getCommittedRev(docId) {
     const buf = this.docs.get(docId);
-    if (!buf) return [0, 0];
-    const committedRev = buf.committed.at(-1)?.rev ?? buf.snapshot?.rev ?? 0;
-    const pendingRev = buf.pending.at(-1)?.rev ?? committedRev;
-    return [committedRev, pendingRev];
+    if (!buf) return 0;
+    return buf.committed.at(-1)?.rev ?? buf.snapshot?.rev ?? 0;
   }
   async listDocs(includeDeleted = false) {
     return Array.from(this.docs.entries()).filter(([, b]) => includeDeleted || !b.deleted).map(([docId, buf]) => ({
@@ -49,19 +38,11 @@ class InMemoryStore {
     if (!this.docs.has(docId)) this.docs.set(docId, buf);
     buf.pending.push(...changes);
   }
-  async saveCommittedChanges(docId, changes, sentPendingRange) {
-    const buf = this.docs.get(docId) ?? { committed: [], pending: [] };
-    if (!this.docs.has(docId)) this.docs.set(docId, buf);
-    buf.committed.push(...changes);
-    if (sentPendingRange) {
-      const [min, max] = sentPendingRange;
-      buf.pending = buf.pending.filter((p) => p.rev < min || p.rev > max);
-    }
-  }
-  async replacePendingChanges(docId, changes) {
+  async applyServerChanges(docId, serverChanges, rebasedPendingChanges) {
     const buf = this.docs.get(docId) ?? { committed: [], pending: [] };
     if (!this.docs.has(docId)) this.docs.set(docId, buf);
-    buf.pending = [...changes];
+    buf.committed.push(...serverChanges);
+    buf.pending = [...rebasedPendingChanges];
   }
   // ─── Metadata / Tracking ───────────────────────────────────────────
   async trackDocs(docIds) {
@@ -91,16 +72,6 @@ class InMemoryStore {
   async close() {
     this.docs.clear();
   }
-  // ─── Submission Bookmark ───────────────────────────────────────────────
-  async getLastAttemptedSubmissionRev(docId) {
-    return this.docs.get(docId)?.lastAttemptedSubmissionRev;
-  }
-  async setLastAttemptedSubmissionRev(docId, rev) {
-    const buf = this.docs.get(docId);
-    if (buf) {
-      buf.lastAttemptedSubmissionRev = rev;
-    }
-  }
 }
 export {
   InMemoryStore

package/dist/client/IndexedDBStore.d.ts

@@ -1,4 +1,4 @@
-import { PatchesSnapshot, PatchesState, Change } from '../types.js';
+import { PatchesSnapshot, PatchesState } from '../types.js';
 import { Deferred } from '../utils/deferred.js';
 import { PatchesStore, TrackedDoc } from './PatchesStore.js';
 import '../json-patch/JSONPatch.js';
@@ -6,22 +6,36 @@ import '@dabble/delta';
 import '../json-patch/types.js';
 
 /**
- * Creates a new IndexedDB database with stores:
- * - snapshots<{ docId: string; rev: number; state: any }> (primary key: docId)
- * - committedChanges<Change & { docId: string; }> (primary key: [docId, rev])
- * - pendingChanges<Change & { docId: string; }> (primary key: [docId, rev])
- * - docs<{ docId: string; committedRev: number; lastAttemptedSubmissionRev?: number; deleted?: boolean }> (primary key: docId)
+ * Abstract base class for IndexedDB-based stores implementing PatchesStore.
  *
- * Under the hood, this class will store snapshots of the document only for committed state. It will not update the
- * committed state on *every* received committed change as this can cause issues with IndexedDB with many small updates.
- * After every 200 committed changes, the class will save the current state to the snapshot store and delete the committed changes that went into it.
- * A snapshot will not be created if there are pending changes based on revisions older than the 200th committed change until those pending changes are committed.
+ * Provides common functionality for IndexedDB operations:
+ * - Database lifecycle management (open, close, delete)
+ * - Transaction helpers
+ * - Document tracking (listDocs, trackDocs, untrackDocs)
+ * - Basic document operations (deleteDoc, confirmDeleteDoc)
+ * - Revision tracking
+ *
+ * Subclasses must implement strategy-specific methods for document
+ * state management and change handling.
  */
-declare class IndexedDBStore implements PatchesStore {
+declare abstract class IndexedDBStore implements PatchesStore {
     protected db: IDBDatabase | null;
     protected dbName?: string;
     protected dbPromise: Deferred<IDBDatabase>;
     constructor(dbName?: string);
+    /**
+     * Returns the database version for this store.
+     * Subclasses should return their specific version number.
+     */
+    protected abstract getDBVersion(): number;
+    /**
+     * Hook for subclasses to create strategy-specific object stores.
+     * Called during database upgrade.
+     *
+     * @param db - The IDBDatabase instance
+     * @param oldVersion - The previous database version
+     */
+    protected abstract onUpgrade(db: IDBDatabase, oldVersion: number): void;
     protected initDB(): Promise<void>;
     protected getDB(): Promise<IDBDatabase>;
     /**
@@ -38,59 +52,24 @@ declare class IndexedDBStore implements PatchesStore {
     deleteDB(): Promise<void>;
     protected transaction(storeNames: string[], mode: IDBTransactionMode): Promise<[IDBTransactionWrapper, ...IDBStoreWrapper[]]>;
     /**
-     * Rebuilds a document snapshot + pending queue *without* loading
-     * the full PatchesDoc into memory.
-     *
-     * 1. load the last snapshot (state + rev)
-     * 2. load committedChanges[rev > snapshot.rev]
-     * 3. load pendingChanges
-     * 4. apply committed changes, rebase pending
-     * 5. return { state, rev, changes: pending }
+     * Retrieves the current document snapshot from storage.
+     * Implementation varies by sync strategy (OT vs LWW).
+     */
+    abstract getDoc(docId: string): Promise<PatchesSnapshot | undefined>;
+    /**
+     * Saves the current document state to persistent storage.
+     * Implementation varies by sync strategy.
      */
-    getDoc(docId: string): Promise<PatchesSnapshot | undefined>;
+    abstract saveDoc(docId: string, docState: PatchesState): Promise<void>;
     /**
      * Completely remove all data for this docId and mark it as deleted (tombstone).
      */
-    deleteDoc(docId: string): Promise<void>;
+    abstract deleteDoc(docId: string): Promise<void>;
     /**
      * Confirm the deletion of a document.
      * @param docId - The ID of the document to delete.
      */
     confirmDeleteDoc(docId: string): Promise<void>;
-    /**
-     * Save a document's state to the store.
-     * @param docId - The ID of the document to save.
-     * @param docState - The state of the document to save.
-     */
-    saveDoc(docId: string, docState: PatchesState): Promise<void>;
-    /**
-     * Append an array of local changes to the pending queue.
-     * Called *before* you attempt to send them to the server.
-     */
-    savePendingChanges(docId: string, changes: Change[]): Promise<void>;
-    /**
-     * Read back all pending changes for this docId (in order).
-     * @param docId - The ID of the document to get the pending changes for.
-     * @returns The pending changes.
-     */
-    getPendingChanges(docId: string): Promise<Change[]>;
-    /**
-     * Replace all pending changes for a document (used after rebasing).
-     * @param docId - The ID of the document to replace the pending changes for.
-     * @param changes - The changes to replace the pending changes with.
-     */
-    replacePendingChanges(docId: string, changes: Change[]): Promise<void>;
-    /**
-     * Store server‐confirmed changes.  Will:
-     * - persist them in the committedChanges store
-     * - remove any pending changes whose rev falls within `sentPendingRange`
-     * - optionally compact a new snapshot after N changes (hidden internally)
-     * @param docId - The ID of the document to save the changes for
-     * @param changes - The changes to save
-     * @param sentPendingRange - The range of pending changes to remove, *must* be provided after receiving the changes
-     * from the server in response to a patchesDoc request.
-     */
-    saveCommittedChanges(docId: string, changes: Change[], sentPendingRange?: [number, number]): Promise<void>;
     /**
      * List all documents in the store.
      * @param includeDeleted - Whether to include deleted documents.
@@ -106,26 +85,13 @@ declare class IndexedDBStore implements PatchesStore {
      * Untrack a document.
      * @param docIds - The IDs of the documents to untrack.
      */
-    untrackDocs(docIds: string[]): Promise<void>;
-    /**
-     * Tell me the last committed revision you have *and* the highest
-     * rev of any change.  Use these to drive:
-     *   - fetch changes:   api.getChangesSince(docId, committedRev)
-     *   - build new patch: newChange.rev = pendingRev; baseRev = committedRev
-     */
-    getLastRevs(docId: string): Promise<[number, number]>;
-    /**
-     * Gets the last revision that was attempted to be submitted to the server.
-     * @param docId - The ID of the document.
-     * @returns The last attempted submission revision, or undefined if none.
-     */
-    getLastAttemptedSubmissionRev(docId: string): Promise<number | undefined>;
+    abstract untrackDocs(docIds: string[]): Promise<void>;
     /**
-     * Sets the last revision that was attempted to be submitted to the server.
+     * Returns the last committed revision for a document.
      * @param docId - The ID of the document.
-     * @param rev - The revision being submitted.
+     * @returns The last committed revision, or 0 if not found.
      */
-    setLastAttemptedSubmissionRev(docId: string, rev: number): Promise<void>;
+    getCommittedRev(docId: string): Promise<number>;
 }
 declare class IDBTransactionWrapper {
     protected tx: IDBTransaction;
@@ -148,4 +114,4 @@ declare class IDBStoreWrapper {
     getLastFromCursor<T>(lower?: any, upper?: any): Promise<T | undefined>;
 }
 
-export { IndexedDBStore };
+export { IDBStoreWrapper, IDBTransactionWrapper, IndexedDBStore };