@dabble/patches 0.6.0 → 0.7.1

package/dist/client/OTAlgorithm.d.ts

@@ -0,0 +1,42 @@
+import { JSONPatchOp } from '../json-patch/types.js';
+import { PatchesSnapshot, Change } from '../types.js';
+import { ClientAlgorithm } from './ClientAlgorithm.js';
+import { OTClientStore } from './OTClientStore.js';
+import { P as PatchesDocOptions, a as PatchesDoc } from '../BaseDoc-DkP3tUhT.js';
+import { TrackedDoc } from './PatchesStore.js';
+import '../json-patch/JSONPatch.js';
+import '@dabble/delta';
+import '../event-signal.js';
+
+/**
+ * OT (Operational Transformation) algorithm implementation.
+ *
+ * OT uses revision-based history and rebasing for concurrent edits.
+ * This algorithm owns an OT-compatible store and handles all OT-specific
+ * logic.
+ */
+declare class OTAlgorithm implements ClientAlgorithm {
+    readonly name = "ot";
+    readonly store: OTClientStore;
+    protected readonly _options: PatchesDocOptions;
+    constructor(store: OTClientStore, options?: PatchesDocOptions);
+    createDoc<T extends object>(docId: string, snapshot?: PatchesSnapshot<T>): PatchesDoc<T>;
+    loadDoc(docId: string): Promise<PatchesSnapshot | undefined>;
+    handleDocChange<T extends object>(docId: string, ops: JSONPatchOp[], doc: PatchesDoc<T> | undefined, metadata: Record<string, any>): Promise<Change[]>;
+    getPendingToSend(docId: string): Promise<Change[] | null>;
+    applyServerChanges<T extends object>(docId: string, serverChanges: Change[], doc: PatchesDoc<T> | undefined): Promise<Change[]>;
+    confirmSent(_docId: string, _changes: Change[]): Promise<void>;
+    trackDocs(docIds: string[]): Promise<void>;
+    untrackDocs(docIds: string[]): Promise<void>;
+    listDocs(includeDeleted?: boolean): Promise<TrackedDoc[]>;
+    getCommittedRev(docId: string): Promise<number>;
+    deleteDoc(docId: string): Promise<void>;
+    confirmDeleteDoc(docId: string): Promise<void>;
+    close(): Promise<void>;
+    /**
+     * Creates Change objects from raw ops.
+     */
+    protected _createChangesFromOps(committedRev: number, pendingRev: number, ops: JSONPatchOp[], metadata: Record<string, any>): Change[];
+}
+
+export { OTAlgorithm };

package/dist/client/OTAlgorithm.js

@@ -0,0 +1,113 @@
+import "../chunk-IZ2YBCUP.js";
+import { applyCommittedChanges } from "../algorithms/ot/client/applyCommittedChanges.js";
+import { breakChanges } from "../algorithms/ot/shared/changeBatching.js";
+import { createChange } from "../data/change.js";
+import { OTDoc } from "./OTDoc.js";
+class OTAlgorithm {
+  name = "ot";
+  store;
+  _options;
+  constructor(store, options = {}) {
+    this.store = store;
+    this._options = options;
+  }
+  createDoc(docId, snapshot) {
+    return new OTDoc(docId, snapshot);
+  }
+  async loadDoc(docId) {
+    return this.store.getDoc(docId);
+  }
+  async handleDocChange(docId, ops, doc, metadata) {
+    if (ops.length === 0) return [];
+    let committedRev;
+    let pendingRev;
+    if (doc) {
+      const otDoc = doc;
+      const pendingChanges = otDoc.getPendingChanges();
+      committedRev = otDoc.committedRev;
+      pendingRev = pendingChanges[pendingChanges.length - 1]?.rev ?? committedRev;
+    } else {
+      const snapshot = await this.store.getDoc(docId);
+      committedRev = snapshot?.rev ?? 0;
+      const pendingChanges = snapshot?.changes ?? [];
+      pendingRev = pendingChanges[pendingChanges.length - 1]?.rev ?? committedRev;
+    }
+    const changes = this._createChangesFromOps(committedRev, pendingRev, ops, metadata);
+    if (changes.length === 0) return [];
+    await this.store.savePendingChanges(docId, changes);
+    if (doc) {
+      doc.applyChanges(changes);
+    }
+    return changes;
+  }
+  async getPendingToSend(docId) {
+    const pending = await this.store.getPendingChanges(docId);
+    return pending.length > 0 ? pending : null;
+  }
+  async applyServerChanges(docId, serverChanges, doc) {
+    if (serverChanges.length === 0) return [];
+    const currentSnapshot = await this.store.getDoc(docId);
+    if (!currentSnapshot) {
+      console.warn(`Cannot apply server changes to non-existent doc: ${docId}`);
+      return [];
+    }
+    if (doc) {
+      const otDoc = doc;
+      const inMemoryPending = otDoc.getPendingChanges();
+      const latestRev = currentSnapshot.changes[currentSnapshot.changes.length - 1]?.rev ?? currentSnapshot.rev;
+      const newChanges = inMemoryPending.filter((change) => change.rev > latestRev);
+      currentSnapshot.changes.push(...newChanges);
+    }
+    const newSnapshot = applyCommittedChanges(currentSnapshot, serverChanges);
+    await this.store.applyServerChanges(docId, serverChanges, newSnapshot.changes);
+    const changesToBroadcast = [...serverChanges, ...newSnapshot.changes];
+    if (doc) {
+      const otDoc = doc;
+      if (otDoc.committedRev === serverChanges[0].rev - 1) {
+        otDoc.applyChanges(changesToBroadcast);
+      } else {
+        otDoc.import(newSnapshot);
+      }
+    }
+    return changesToBroadcast;
+  }
+  async confirmSent(_docId, _changes) {
+  }
+  // --- Store forwarding methods ---
+  async trackDocs(docIds) {
+    return this.store.trackDocs(docIds);
+  }
+  async untrackDocs(docIds) {
+    return this.store.untrackDocs(docIds);
+  }
+  async listDocs(includeDeleted) {
+    return this.store.listDocs(includeDeleted);
+  }
+  async getCommittedRev(docId) {
+    return this.store.getCommittedRev(docId);
+  }
+  async deleteDoc(docId) {
+    return this.store.deleteDoc(docId);
+  }
+  async confirmDeleteDoc(docId) {
+    return this.store.confirmDeleteDoc(docId);
+  }
+  async close() {
+    return this.store.close();
+  }
+  // --- Private helpers ---
+  /**
+   * Creates Change objects from raw ops.
+   */
+  _createChangesFromOps(committedRev, pendingRev, ops, metadata) {
+    const rev = pendingRev + 1;
+    let changes = [createChange(committedRev, rev, ops, metadata)];
+    if (this._options.maxStorageBytes) {
+      changes = breakChanges(changes, this._options.maxStorageBytes, this._options.sizeCalculator);
+    }
+    return changes;
+  }
+}
+export {
+  OTAlgorithm
+};

package/dist/client/OTClientStore.d.ts

@@ -0,0 +1,50 @@
+import { Change } from '../types.js';
+import { PatchesStore } from './PatchesStore.js';
+import '../json-patch/JSONPatch.js';
+import '@dabble/delta';
+import '../json-patch/types.js';
+
+/**
+ * OT-specific client store interface.
+ * Extends PatchesStore with methods for managing pending change lists
+ * and applying server changes with rebasing.
+ */
+interface OTClientStore extends PatchesStore {
+    /**
+     * Retrieves all pending (unconfirmed) changes for a document.
+     *
+     * Pending changes are local edits that haven't been confirmed by the server yet.
+     * Returns changes in chronological order as they were created locally.
+     * Used during sync to resend unconfirmed operations.
+     *
+     * @param docId Document identifier
+     * @returns Array of pending changes in chronological order
+     */
+    getPendingChanges(docId: string): Promise<Change[]>;
+    /**
+     * Appends new pending changes to the document's local change queue.
+     *
+     * Adds changes to the end of the pending changes list without replacing existing ones.
+     * Called when the user makes local edits that haven't been sent to the server yet.
+     * Changes should have sequential revision numbers starting after the last pending change.
+     *
+     * @param docId Document identifier
+     * @param changes Array of new changes to append
+     */
+    savePendingChanges(docId: string, changes: Change[]): Promise<void>;
+    /**
+     * Atomically applies server-confirmed changes and updates pending changes.
+     *
+     * This is the core sync operation that must be atomic: server changes become
+     * committed history, and pending changes are replaced with their rebased versions.
+     * Implementations must ensure both operations complete together (single transaction
+     * for databases) to prevent inconsistent state if the app crashes mid-operation.
+     *
+     * @param docId Document identifier
+     * @param serverChanges Changes confirmed by the server to add to committed history
+     * @param rebasedPendingChanges Pending changes after OT rebasing (replaces all existing pending)
+     */
+    applyServerChanges(docId: string, serverChanges: Change[], rebasedPendingChanges: Change[]): Promise<void>;
+}
+
+export type { OTClientStore };

package/dist/client/OTDoc.d.ts

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

package/dist/client/OTDoc.js

@@ -0,0 +1,97 @@
+import "../chunk-IZ2YBCUP.js";
+import { createStateFromSnapshot } from "../algorithms/ot/client/createStateFromSnapshot.js";
+import { applyChanges as applyChangesToState } from "../algorithms/ot/shared/applyChanges.js";
+import { BaseDoc } from "./BaseDoc.js";
+class OTDoc extends BaseDoc {
+  /** Base state from the server at the committed revision. */
+  _committedState;
+  /** Last committed revision number from the server. */
+  _committedRev;
+  /** Local changes not yet committed by server. */
+  _pendingChanges;
+  /**
+   * Creates an instance of OTDoc.
+   * @param id The unique identifier for this document.
+   * @param snapshot Optional snapshot to initialize from (state, rev, pending changes).
+   */
+  constructor(id, snapshot) {
+    const initialState = snapshot?.state ?? {};
+    super(id, initialState);
+    this._committedState = this._state;
+    this._committedRev = snapshot?.rev ?? 0;
+    this._pendingChanges = snapshot?.changes ?? [];
+    if (this._pendingChanges.length > 0) {
+      this._state = applyChangesToState(this._committedState, this._pendingChanges);
+    }
+  }
+  /** Last committed revision number from the server. */
+  get committedRev() {
+    return this._committedRev;
+  }
+  /** Are there local changes that haven't been committed yet? */
+  get hasPending() {
+    return this._pendingChanges.length > 0;
+  }
+  /**
+   * Returns the pending changes for this document.
+   * @returns The pending changes.
+   */
+  getPendingChanges() {
+    return this._pendingChanges;
+  }
+  /**
+   * Imports document state from a snapshot (e.g., for recovery when out of sync).
+   * Resets state and treats all imported changes as pending.
+   */
+  import(snapshot) {
+    this._committedState = snapshot.state;
+    this._committedRev = snapshot.rev;
+    this._pendingChanges = snapshot.changes;
+    this._state = createStateFromSnapshot(snapshot);
+    this.onUpdate.emit(this._state);
+  }
+  /**
+   * Unified entry point for applying changes.
+   * Used for Worker→Tab communication where only changes are sent over the wire.
+   *
+   * The method distinguishes between committed and pending changes using `committedAt`:
+   * - `committedAt > 0`: Server-committed change (apply to committed state)
+   * - `committedAt === 0`: Pending local change (append to pending)
+   *
+   * For server changes, all committed changes come first, followed by rebased pending.
+   *
+   * @param changes Array of changes to apply
+   */
+  applyChanges(changes) {
+    if (changes.length === 0) return;
+    if (changes[0].committedAt > 0) {
+      const serverEndIndex = changes.findIndex((c) => c.committedAt === 0);
+      const serverChanges = serverEndIndex === -1 ? changes : changes.slice(0, serverEndIndex);
+      const rebasedPending = serverEndIndex === -1 ? [] : changes.slice(serverEndIndex);
+      if (this._committedRev !== serverChanges[0].rev - 1) {
+        throw new Error("Cannot apply committed changes to a doc that is not at the correct revision");
+      }
+      this._committedState = applyChangesToState(this._committedState, serverChanges);
+      this._committedRev = serverChanges[serverChanges.length - 1].rev;
+      this._pendingChanges = rebasedPending;
+      this._state = applyChangesToState(this._committedState, this._pendingChanges);
+    } else {
+      this._state = applyChangesToState(this._state, changes);
+      this._pendingChanges.push(...changes);
+    }
+    this.onUpdate.emit(this._state);
+  }
+  /**
+   * Returns the document snapshot for serialization.
+   */
+  toJSON() {
+    return {
+      state: this._committedState,
+      rev: this._committedRev,
+      changes: this._pendingChanges
+    };
+  }
+}
+export {
+  OTDoc
+};

package/dist/client/OTIndexedDBStore.d.ts

@@ -0,0 +1,84 @@
+import { PatchesSnapshot, PatchesState, Change } from '../types.js';
+import { IndexedDBStore } from './IndexedDBStore.js';
+import { OTClientStore } from './OTClientStore.js';
+import '../json-patch/JSONPatch.js';
+import '@dabble/delta';
+import '../json-patch/types.js';
+import '../utils/deferred.js';
+import './PatchesStore.js';
+
+/**
+ * IndexedDB store implementation for Operational Transformation (OT) sync strategy.
+ *
+ * Creates 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; deleted?: boolean }> (primary key: docId)
+ *
+ * Under the hood, this class stores snapshots of the document only for committed state.
+ * It does 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 (SNAPSHOT_INTERVAL), the class saves the current
+ * state to the snapshot store and deletes 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.
+ */
+declare class OTIndexedDBStore extends IndexedDBStore implements OTClientStore {
+    protected getDBVersion(): number;
+    protected onUpgrade(db: IDBDatabase, _oldVersion: number): void;
+    /**
+     * 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 }
+     */
+    getDoc(docId: string): Promise<PatchesSnapshot | undefined>;
+    /**
+     * Completely remove all data for this docId and mark it as deleted (tombstone).
+     */
+    deleteDoc(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[]>;
+    /**
+     * Atomically applies server-confirmed changes and updates pending changes.
+     * This is the core sync operation that must be atomic.
+     *
+     * Will:
+     * - persist server changes in the committedChanges store
+     * - replace all pending changes with the rebased versions
+     * - optionally compact a new snapshot after N changes (hidden internally)
+     *
+     * @param docId - The ID of the document
+     * @param serverChanges - Changes confirmed by the server
+     * @param rebasedPendingChanges - Pending changes after OT rebasing
+     */
+    applyServerChanges(docId: string, serverChanges: Change[], rebasedPendingChanges: Change[]): Promise<void>;
+    /**
+     * Untrack a document.
+     * @param docIds - The IDs of the documents to untrack.
+     */
+    untrackDocs(docIds: string[]): Promise<void>;
+}
+
+export { OTIndexedDBStore };

package/dist/client/OTIndexedDBStore.js

@@ -0,0 +1,163 @@
+import {
+  __decorateElement,
+  __decoratorMetadata,
+  __decoratorStart,
+  __runInitializers
+} from "../chunk-IZ2YBCUP.js";
+var _applyServerChanges_dec, _getPendingChanges_dec, _savePendingChanges_dec, _saveDoc_dec, _deleteDoc_dec, _getDoc_dec, _a, _init;
+import { applyChanges } from "../algorithms/ot/shared/applyChanges.js";
+import { blockable } from "../utils/concurrency.js";
+import { IndexedDBStore } from "./IndexedDBStore.js";
+const DB_VERSION = 1;
+const SNAPSHOT_INTERVAL = 200;
+class OTIndexedDBStore extends (_a = IndexedDBStore, _getDoc_dec = [blockable], _deleteDoc_dec = [blockable], _saveDoc_dec = [blockable], _savePendingChanges_dec = [blockable], _getPendingChanges_dec = [blockable], _applyServerChanges_dec = [blockable], _a) {
+  constructor() {
+    super(...arguments);
+    __runInitializers(_init, 5, this);
+  }
+  getDBVersion() {
+    return DB_VERSION;
+  }
+  onUpgrade(db, _oldVersion) {
+    if (!db.objectStoreNames.contains("committedChanges")) {
+      db.createObjectStore("committedChanges", { keyPath: ["docId", "rev"] });
+    }
+    if (!db.objectStoreNames.contains("pendingChanges")) {
+      db.createObjectStore("pendingChanges", { keyPath: ["docId", "rev"] });
+    }
+  }
+  async getDoc(docId) {
+    const [tx, docsStore, snapshots, committedChanges, pendingChanges] = await this.transaction(
+      ["docs", "snapshots", "committedChanges", "pendingChanges"],
+      "readonly"
+    );
+    const docMeta = await docsStore.get(docId);
+    if (docMeta?.deleted) {
+      await tx.complete();
+      return void 0;
+    }
+    const snapshot = await snapshots.get(docId);
+    const committed = await committedChanges.getAll([docId, snapshot?.rev ?? 0], [docId, Infinity]);
+    const pending = await pendingChanges.getAll([docId, 0], [docId, Infinity]);
+    if (!snapshot && !committed.length && !pending.length) return void 0;
+    const state = applyChanges(snapshot?.state, committed);
+    await tx.complete();
+    return {
+      state,
+      rev: committed[committed.length - 1]?.rev ?? snapshot?.rev ?? 0,
+      changes: pending
+    };
+  }
+  async deleteDoc(docId) {
+    const [tx, snapshots, committedChanges, pendingChanges, docsStore] = await this.transaction(
+      ["snapshots", "committedChanges", "pendingChanges", "docs"],
+      "readwrite"
+    );
+    const docMeta = await docsStore.get(docId) ?? { docId, committedRev: 0 };
+    await docsStore.put({ ...docMeta, deleted: true });
+    await Promise.all([
+      snapshots.delete(docId),
+      committedChanges.delete([docId, 0], [docId, Infinity]),
+      pendingChanges.delete([docId, 0], [docId, Infinity])
+    ]);
+    await tx.complete();
+  }
+  async saveDoc(docId, docState) {
+    const [tx, snapshots, committedChanges, pendingChanges, docsStore] = await this.transaction(
+      ["snapshots", "committedChanges", "pendingChanges", "docs"],
+      "readwrite"
+    );
+    const { rev, state } = docState;
+    await Promise.all([
+      docsStore.put({ docId, committedRev: rev }),
+      snapshots.put({ docId, state, rev }),
+      committedChanges.delete([docId, 0], [docId, Infinity]),
+      pendingChanges.delete([docId, 0], [docId, Infinity])
+    ]);
+    await tx.complete();
+  }
+  async savePendingChanges(docId, changes) {
+    const [tx, pendingChanges, docsStore] = await this.transaction(["pendingChanges", "docs"], "readwrite");
+    let docMeta = await docsStore.get(docId);
+    if (!docMeta) {
+      docMeta = { docId, committedRev: 0 };
+      await docsStore.put(docMeta);
+    } else if (docMeta.deleted) {
+      delete docMeta.deleted;
+      await docsStore.put(docMeta);
+      console.warn(`Revived document ${docId} by saving pending changes.`);
+    }
+    await Promise.all(changes.map((change) => pendingChanges.put({ ...change, docId })));
+    await tx.complete();
+  }
+  async getPendingChanges(docId) {
+    const [tx, pendingChanges] = await this.transaction(["pendingChanges"], "readonly");
+    const result = await pendingChanges.getAll([docId, 0], [docId, Infinity]);
+    await tx.complete();
+    return result;
+  }
+  async applyServerChanges(docId, serverChanges, rebasedPendingChanges) {
+    const [tx, committedChangesStore, pendingChangesStore, snapshots, docsStore] = await this.transaction(
+      ["committedChanges", "pendingChanges", "snapshots", "docs"],
+      "readwrite"
+    );
+    await Promise.all(serverChanges.map((change) => committedChangesStore.put({ ...change, docId })));
+    await pendingChangesStore.delete([docId, 0], [docId, Infinity]);
+    await Promise.all(rebasedPendingChanges.map((change) => pendingChangesStore.put({ ...change, docId })));
+    const count = await committedChangesStore.count([docId, 0], [docId, Infinity]);
+    if (count >= SNAPSHOT_INTERVAL) {
+      const [snapshot, committed] = await Promise.all([
+        snapshots.get(docId),
+        committedChangesStore.getAll([docId, 0], [docId, Infinity], SNAPSHOT_INTERVAL)
+      ]);
+      const lastRev = committed[committed.length - 1]?.rev;
+      if (lastRev) {
+        const state = applyChanges(snapshot?.state, committed);
+        await Promise.all([
+          snapshots.put({ docId, rev: lastRev, state }),
+          committedChangesStore.delete([docId, 0], [docId, lastRev])
+        ]);
+      }
+    }
+    const lastCommittedRev = serverChanges.at(-1)?.rev;
+    if (lastCommittedRev !== void 0) {
+      const docMeta = await docsStore.get(docId) ?? { docId, committedRev: 0 };
+      if (lastCommittedRev > docMeta.committedRev) {
+        await docsStore.put({ ...docMeta, committedRev: lastCommittedRev, deleted: void 0 });
+      }
+    }
+    await tx.complete();
+  }
+  /**
+   * Untrack a document.
+   * @param docIds - The IDs of the documents to untrack.
+   */
+  async untrackDocs(docIds) {
+    const [tx, docsStore, snapshots, committedChanges, pendingChanges] = await this.transaction(
+      ["docs", "snapshots", "committedChanges", "pendingChanges"],
+      "readwrite"
+    );
+    await Promise.all(
+      docIds.map((docId) => {
+        return Promise.all([
+          docsStore.delete(docId),
+          snapshots.delete(docId),
+          committedChanges.delete([docId, 0], [docId, Infinity]),
+          pendingChanges.delete([docId, 0], [docId, Infinity])
+        ]);
+      })
+    );
+    await tx.complete();
+  }
+}
+_init = __decoratorStart(_a);
+__decorateElement(_init, 1, "getDoc", _getDoc_dec, OTIndexedDBStore);
+__decorateElement(_init, 1, "deleteDoc", _deleteDoc_dec, OTIndexedDBStore);
+__decorateElement(_init, 1, "saveDoc", _saveDoc_dec, OTIndexedDBStore);
+__decorateElement(_init, 1, "savePendingChanges", _savePendingChanges_dec, OTIndexedDBStore);
+__decorateElement(_init, 1, "getPendingChanges", _getPendingChanges_dec, OTIndexedDBStore);
+__decorateElement(_init, 1, "applyServerChanges", _applyServerChanges_dec, OTIndexedDBStore);
+__decoratorMetadata(_init, OTIndexedDBStore);
+export {
+  OTIndexedDBStore
+};

package/dist/client/Patches.d.ts

@@ -1,15 +1,21 @@
 import { Unsubscriber, Signal } from '../event-signal.js';
+import { JSONPatchOp } from '../json-patch/types.js';
 import { Change } from '../types.js';
-import { PatchesDocOptions, PatchesDoc } from './PatchesDoc.js';
-import { PatchesStore } from './PatchesStore.js';
+import { AlgorithmName, ClientAlgorithm } from './ClientAlgorithm.js';
+import { P as PatchesDocOptions, a as PatchesDoc } from '../BaseDoc-DkP3tUhT.js';
 import '../json-patch/JSONPatch.js';
 import '@dabble/delta';
-import '../json-patch/types.js';
-import '../algorithms/shared/changeBatching.js';
+import './PatchesStore.js';
 
+/**
+ * Options for creating a Patches instance.
+ * Provides algorithms map and optional default algorithm.
+ */
 interface PatchesOptions {
-    /** Persistence layer instance (e.g., new IndexedDBStore('my-db') or new InMemoryStore()). */
-    store: PatchesStore;
+    /** Map of algorithm name to algorithm instance. Each algorithm owns its store. */
+    algorithms: Partial<Record<AlgorithmName, ClientAlgorithm>>;
+    /** Default algorithm to use when opening docs. Must be a key in algorithms map. */
+    defaultAlgorithm?: AlgorithmName;
     /** Initial metadata to attach to changes from this client (merged with per-doc metadata). */
     metadata?: Record<string, any>;
     /** Document-level options to pass to each PatchesDoc instance */
@@ -17,18 +23,22 @@ interface PatchesOptions {
 }
 interface ManagedDoc<T extends object> {
     doc: PatchesDoc<T>;
+    algorithm: ClientAlgorithm;
     unsubscribe: Unsubscriber;
 }
 /**
  * Main client-side entry point for the Patches library.
- * Manages document instances (`PatchesDoc`) and persistence (`PatchesStore`).
+ * Manages document instances (`PatchesDoc`) and coordinates with algorithms.
  * Can be used standalone or with PatchesSync for network synchronization.
+ *
+ * Patches owns docs. Algorithms own their stores.
  */
 declare class Patches {
     protected options: PatchesOptions;
     protected docs: Map<string, ManagedDoc<any>>;
     readonly docOptions: PatchesDocOptions;
-    readonly store: PatchesStore;
+    readonly algorithms: Partial<Record<AlgorithmName, ClientAlgorithm>>;
+    readonly defaultAlgorithm: AlgorithmName;
     readonly trackedDocs: Set<string>;
     readonly onError: Signal<(error: Error, context?: {
         docId?: string;
@@ -37,15 +47,25 @@ declare class Patches {
     readonly onTrackDocs: Signal<(docIds: string[]) => void>;
     readonly onUntrackDocs: Signal<(docIds: string[]) => void>;
     readonly onDeleteDoc: Signal<(docId: string) => void>;
-    readonly onChange: Signal<(docId: string, changes: Change[]) => void>;
+    /** Emitted when a doc has pending changes ready to send */
+    readonly onChange: Signal<(docId: string) => void>;
     constructor(opts: PatchesOptions);
+    /**
+     * Gets an algorithm by name, throwing if not found.
+     */
+    protected _getAlgorithm(name: AlgorithmName): ClientAlgorithm;
+    /**
+     * Gets the algorithm for an open document.
+     */
+    getDocAlgorithm(docId: string): ClientAlgorithm | undefined;
     /**
      * Tracks the given document IDs, adding them to the set of tracked documents and notifying listeners.
      * Tracked docs are kept in sync with the server, even when not open locally.
      * This allows for background syncing and updates of unopened documents.
      * @param docIds - Array of document IDs to track.
+     * @param algorithmName - Algorithm to use for tracking (defaults to defaultAlgorithm).
      */
-    trackDocs(docIds: string[]): Promise<void>;
+    trackDocs(docIds: string[], algorithmName?: AlgorithmName): Promise<void>;
     /**
      * Untracks the given document IDs, removing them from the set of tracked documents and notifying listeners.
      * Untracked docs will no longer be kept in sync with the server.
@@ -57,11 +77,12 @@ declare class Patches {
      * Opens a document by ID, loading its state from the store and setting up change listeners.
      * If the doc is already open, returns the existing instance.
      * @param docId - The document ID to open.
-     * @param opts - Optional metadata to merge with the doc's metadata.
+     * @param opts - Optional metadata and algorithm override.
      * @returns The opened PatchesDoc instance.
      */
     openDoc<T extends object>(docId: string, opts?: {
         metadata?: Record<string, any>;
+        algorithm?: AlgorithmName;
     }): Promise<PatchesDoc<T>>;
     /**
      * Closes an open document by ID, removing listeners and optionally untracking it.
@@ -88,13 +109,12 @@ declare class Patches {
      * Closes all open documents and cleans up listeners and store connections.
      * Should be called when shutting down the client.
      */
-    close(): void;
+    close(): Promise<void>;
     /**
-     * Internal handler for saving pending changes to the store.
-     * @param docId - The document ID to save the changes for.
-     * @param changes - The changes to save.
+     * Internal handler for doc changes. Called when doc.onChange emits ops.
+     * Delegates to algorithm for packaging and persisting.
      */
-    protected _savePendingChanges(docId: string, changes: Change[]): Promise<void>;
+    protected _handleDocChange<T extends object>(docId: string, ops: JSONPatchOp[], doc: PatchesDoc<T>, algorithm: ClientAlgorithm, metadata: Record<string, any>): Promise<void>;
 }
 
 export { Patches, type PatchesOptions };