@dabble/patches 0.7.4 → 0.7.6

package/dist/client/ClientAlgorithm.d.ts

@@ -80,7 +80,7 @@ interface ClientAlgorithm {
      * Called after successful server commit.
      */
     confirmSent(docId: string, changes: Change[]): Promise<void>;
-    /** Registers documents for local tracking. */
+    /** Registers documents for local tracking with the algorithm for this instance. */
     trackDocs(docIds: string[]): Promise<void>;
     /** Removes documents from local tracking. */
     untrackDocs(docIds: string[]): Promise<void>;
@@ -95,7 +95,5 @@ interface ClientAlgorithm {
     /** Closes the algorithm and its store. */
     close(): Promise<void>;
 }
-/** Available algorithm names */
-type AlgorithmName = 'ot' | 'lww';
 
-export type { AlgorithmName, ClientAlgorithm };
+export type { ClientAlgorithm };

package/dist/client/IndexedDBStore.d.ts

@@ -1,3 +1,4 @@
+import { Signal } from '../event-signal.js';
 import { PatchesSnapshot, PatchesState } from '../types.js';
 import { Deferred } from '../utils/deferred.js';
 import { PatchesStore, TrackedDoc } from './PatchesStore.js';
@@ -6,36 +7,34 @@ import '@dabble/delta';
 import '../json-patch/types.js';
 
 /**
- * Abstract base class for IndexedDB-based stores implementing PatchesStore.
+ * IndexedDB store providing common database operations for all sync strategies.
  *
- * Provides common functionality for IndexedDB operations:
+ * Can be used as a standalone store or as a shared database connection
+ * for multiple strategy-specific stores (OT, LWW).
+ *
+ * Provides:
  * - 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.
+ * - Extensibility via onUpgrade signal for strategy-specific stores
  */
-declare abstract class IndexedDBStore implements PatchesStore {
+declare class IndexedDBStore implements PatchesStore {
+    private static readonly DB_VERSION;
     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.
+     * Signal emitted during database upgrade, allowing strategy-specific stores
+     * to create their object stores.
      */
-    protected abstract getDBVersion(): number;
+    readonly onUpgrade: Signal<(db: IDBDatabase, oldVersion: number, transaction: IDBTransaction) => void>;
+    constructor(dbName?: string);
     /**
-     * Hook for subclasses to create strategy-specific object stores.
-     * Called during database upgrade.
-     *
-     * @param db - The IDBDatabase instance
-     * @param oldVersion - The previous database version
+     * Creates shared object stores used by all sync strategies.
      */
-    protected abstract onUpgrade(db: IDBDatabase, oldVersion: number): void;
+    protected createSharedStores(db: IDBDatabase, _oldVersion: number, _transaction: IDBTransaction): void;
     protected initDB(): Promise<void>;
     protected getDB(): Promise<IDBDatabase>;
     /**
@@ -50,21 +49,24 @@ declare abstract class IndexedDBStore implements PatchesStore {
      */
     close(): Promise<void>;
     deleteDB(): Promise<void>;
-    protected transaction(storeNames: string[], mode: IDBTransactionMode): Promise<[IDBTransactionWrapper, ...IDBStoreWrapper[]]>;
+    transaction(storeNames: string[], mode: IDBTransactionMode): Promise<[IDBTransactionWrapper, ...IDBStoreWrapper[]]>;
     /**
      * Retrieves the current document snapshot from storage.
      * Implementation varies by sync strategy (OT vs LWW).
+     * This base implementation throws an error - override in strategy-specific stores.
      */
-    abstract getDoc(docId: string): Promise<PatchesSnapshot | undefined>;
+    getDoc(_docId: string): Promise<PatchesSnapshot | undefined>;
     /**
      * Saves the current document state to persistent storage.
      * Implementation varies by sync strategy.
+     * This base implementation throws an error - override in strategy-specific stores.
      */
-    abstract saveDoc(docId: string, docState: PatchesState): Promise<void>;
+    saveDoc(_docId: string, _docState: PatchesState): Promise<void>;
     /**
      * Completely remove all data for this docId and mark it as deleted (tombstone).
+     * This base implementation throws an error - override in strategy-specific stores.
      */
-    abstract deleteDoc(docId: string): Promise<void>;
+    deleteDoc(_docId: string): Promise<void>;
     /**
      * Confirm the deletion of a document.
      * @param docId - The ID of the document to delete.
@@ -73,19 +75,22 @@ declare abstract class IndexedDBStore implements PatchesStore {
     /**
      * List all documents in the store.
      * @param includeDeleted - Whether to include deleted documents.
+     * @param algorithm - Optional algorithm filter ('ot' or 'lww'). If provided, uses index for efficient filtering.
      * @returns The list of documents.
      */
-    listDocs(includeDeleted?: boolean): Promise<TrackedDoc[]>;
+    listDocs(includeDeleted?: boolean, algorithm?: 'ot' | 'lww'): Promise<TrackedDoc[]>;
     /**
      * Track a document.
      * @param docIds - The IDs of the documents to track.
+     * @param algorithm - The algorithm to use for this document.
      */
-    trackDocs(docIds: string[]): Promise<void>;
+    trackDocs(docIds: string[], algorithm?: 'ot' | 'lww'): Promise<void>;
     /**
      * Untrack a document.
      * @param docIds - The IDs of the documents to untrack.
+     * This base implementation throws an error - override in strategy-specific stores.
      */
-    abstract untrackDocs(docIds: string[]): Promise<void>;
+    untrackDocs(_docIds: string[]): Promise<void>;
     /**
      * Returns the last committed revision for a document.
      * @param docId - The ID of the document.
@@ -105,6 +110,7 @@ declare class IDBStoreWrapper {
     constructor(store: IDBObjectStore);
     protected createRange(lower?: any, upper?: any): IDBKeyRange | undefined;
     getAll<T>(lower?: any, upper?: any, count?: number): Promise<T[]>;
+    getAllByIndex<T>(indexName: string, query?: IDBValidKey | IDBKeyRange): Promise<T[]>;
     get<T>(key: IDBValidKey): Promise<T | undefined>;
     put<T>(value: T): Promise<IDBValidKey>;
     delete(key: IDBValidKey): Promise<void>;

package/dist/client/IndexedDBStore.js

@@ -1,19 +1,41 @@
 import "../chunk-IZ2YBCUP.js";
 import { deferred } from "../utils/deferred.js";
+import { signal } from "../event-signal.js";
 class IndexedDBStore {
+  static DB_VERSION = 1;
   db = null;
   dbName;
   dbPromise;
+  /**
+   * Signal emitted during database upgrade, allowing strategy-specific stores
+   * to create their object stores.
+   */
+  onUpgrade = signal();
   constructor(dbName) {
     this.dbName = dbName;
     this.dbPromise = deferred();
+    this.onUpgrade((db, oldVersion, transaction) => {
+      this.createSharedStores(db, oldVersion, transaction);
+    });
     if (this.dbName) {
       this.initDB();
     }
   }
+  /**
+   * Creates shared object stores used by all sync strategies.
+   */
+  createSharedStores(db, _oldVersion, _transaction) {
+    if (!db.objectStoreNames.contains("docs")) {
+      const docsStore = db.createObjectStore("docs", { keyPath: "docId" });
+      docsStore.createIndex("algorithm", "algorithm", { unique: false });
+    }
+    if (!db.objectStoreNames.contains("snapshots")) {
+      db.createObjectStore("snapshots", { keyPath: "docId" });
+    }
+  }
   async initDB() {
     if (!this.dbName) return;
-    const request = indexedDB.open(this.dbName, this.getDBVersion());
+    const request = indexedDB.open(this.dbName, IndexedDBStore.DB_VERSION);
     request.onerror = () => this.dbPromise.reject(request.error);
     request.onsuccess = () => {
       this.db = request.result;
@@ -21,14 +43,9 @@ class IndexedDBStore {
     };
     request.onupgradeneeded = (event) => {
       const db = event.target.result;
+      const transaction = event.target.transaction;
       const oldVersion = event.oldVersion;
-      if (!db.objectStoreNames.contains("snapshots")) {
-        db.createObjectStore("snapshots", { keyPath: "docId" });
-      }
-      if (!db.objectStoreNames.contains("docs")) {
-        db.createObjectStore("docs", { keyPath: "docId" });
-      }
-      this.onUpgrade(db, oldVersion);
+      this.onUpgrade.emit(db, oldVersion, transaction);
     };
   }
   getDB() {
@@ -77,6 +94,31 @@ class IndexedDBStore {
     const stores = storeNames.map((name) => tx.getStore(name));
     return [tx, ...stores];
   }
+  // ─── Strategy-Specific Methods ───────────────────────────────────────────
+  // These are implemented by strategy-specific stores (OT, LWW)
+  /**
+   * Retrieves the current document snapshot from storage.
+   * Implementation varies by sync strategy (OT vs LWW).
+   * This base implementation throws an error - override in strategy-specific stores.
+   */
+  async getDoc(_docId) {
+    throw new Error("getDoc must be implemented by strategy-specific store");
+  }
+  /**
+   * Saves the current document state to persistent storage.
+   * Implementation varies by sync strategy.
+   * This base implementation throws an error - override in strategy-specific stores.
+   */
+  async saveDoc(_docId, _docState) {
+    throw new Error("saveDoc must be implemented by strategy-specific store");
+  }
+  /**
+   * Completely remove all data for this docId and mark it as deleted (tombstone).
+   * This base implementation throws an error - override in strategy-specific stores.
+   */
+  async deleteDoc(_docId) {
+    throw new Error("deleteDoc must be implemented by strategy-specific store");
+  }
   /**
    * Confirm the deletion of a document.
    * @param docId - The ID of the document to delete.
@@ -89,34 +131,60 @@ class IndexedDBStore {
   /**
    * List all documents in the store.
    * @param includeDeleted - Whether to include deleted documents.
+   * @param algorithm - Optional algorithm filter ('ot' or 'lww'). If provided, uses index for efficient filtering.
    * @returns The list of documents.
    */
-  async listDocs(includeDeleted = false) {
+  async listDocs(includeDeleted = false, algorithm) {
     const [tx, docsStore] = await this.transaction(["docs"], "readonly");
-    const allDocs = await docsStore.getAll();
+    let docs;
+    if (algorithm === "lww") {
+      docs = await docsStore.getAllByIndex("algorithm", "lww");
+    } else if (algorithm === "ot") {
+      const otDocs = await docsStore.getAllByIndex("algorithm", "ot");
+      const allDocs = await docsStore.getAll();
+      const noAlgoDocs = allDocs.filter((doc) => !doc.algorithm);
+      docs = [...otDocs, ...noAlgoDocs];
+    } else {
+      docs = await docsStore.getAll();
+    }
     await tx.complete();
-    return includeDeleted ? allDocs : allDocs.filter((doc) => !doc.deleted);
+    return includeDeleted ? docs : docs.filter((doc) => !doc.deleted);
   }
   /**
    * Track a document.
    * @param docIds - The IDs of the documents to track.
+   * @param algorithm - The algorithm to use for this document.
    */
-  async trackDocs(docIds) {
+  async trackDocs(docIds, algorithm) {
     const [tx, docsStore] = await this.transaction(["docs"], "readwrite");
     await Promise.all(
       docIds.map(async (docId) => {
         const existing = await docsStore.get(docId);
         if (existing) {
           if (existing.deleted) {
-            await docsStore.put({ ...existing, deleted: void 0 });
+            await docsStore.put({
+              ...existing,
+              deleted: void 0,
+              ...algorithm && { algorithm }
+            });
+          } else if (algorithm && existing.algorithm !== algorithm) {
+            await docsStore.put({ ...existing, algorithm });
           }
         } else {
-          await docsStore.put({ docId, committedRev: 0 });
+          await docsStore.put({ docId, committedRev: 0, ...algorithm && { algorithm } });
         }
       })
     );
     await tx.complete();
   }
+  /**
+   * Untrack a document.
+   * @param docIds - The IDs of the documents to untrack.
+   * This base implementation throws an error - override in strategy-specific stores.
+   */
+  async untrackDocs(_docIds) {
+    throw new Error("untrackDocs must be implemented by strategy-specific store");
+  }
   /**
    * Returns the last committed revision for a document.
    * @param docId - The ID of the document.
@@ -162,6 +230,14 @@ class IDBStoreWrapper {
       request.onerror = () => reject(request.error);
     });
   }
+  async getAllByIndex(indexName, query) {
+    return new Promise((resolve, reject) => {
+      const index = this.store.index(indexName);
+      const request = index.getAll(query);
+      request.onsuccess = () => resolve(request.result);
+      request.onerror = () => reject(request.error);
+    });
+  }
   async get(key) {
     return new Promise((resolve, reject) => {
       const request = this.store.get(key);

package/dist/client/LWWAlgorithm.js

@@ -62,7 +62,7 @@ class LWWAlgorithm {
   }
   // --- Store forwarding methods ---
   async trackDocs(docIds) {
-    return this.store.trackDocs(docIds);
+    return this.store.trackDocs(docIds, "lww");
   }
   async untrackDocs(docIds) {
     return this.store.untrackDocs(docIds);

package/dist/client/LWWInMemoryStore.d.ts

@@ -37,7 +37,7 @@ declare class LWWInMemoryStore implements LWWClientStore {
     /**
      * Track documents.
      */
-    trackDocs(docIds: string[]): Promise<void>;
+    trackDocs(docIds: string[], _algorithm?: 'ot' | 'lww'): Promise<void>;
     /**
      * Untrack documents by removing all their data.
      */

package/dist/client/LWWInMemoryStore.js

@@ -66,7 +66,7 @@ class LWWInMemoryStore {
   /**
    * Track documents.
    */
-  async trackDocs(docIds) {
+  async trackDocs(docIds, _algorithm) {
     for (const docId of docIds) {
       const buf = this.getOrCreateBuffer(docId);
       delete buf.deleted;

package/dist/client/LWWIndexedDBStore.d.ts

@@ -2,10 +2,11 @@ import { JSONPatchOp } from '../json-patch/types.js';
 import { PatchesSnapshot, PatchesState, Change } from '../types.js';
 import { IndexedDBStore } from './IndexedDBStore.js';
 import { LWWClientStore } from './LWWClientStore.js';
+import { TrackedDoc } from './PatchesStore.js';
 import '../json-patch/JSONPatch.js';
 import '@dabble/delta';
+import '../event-signal.js';
 import '../utils/deferred.js';
-import './PatchesStore.js';
 
 /**
  * IndexedDB store implementation for Last-Writer-Wins (LWW) sync strategy.
@@ -24,9 +25,42 @@ import './PatchesStore.js';
  *
  * Every 200 ops, committed ops are compacted into the snapshot.
  */
-declare class LWWIndexedDBStore extends IndexedDBStore implements LWWClientStore {
-    protected getDBVersion(): number;
-    protected onUpgrade(db: IDBDatabase, _oldVersion: number): void;
+declare class LWWIndexedDBStore implements LWWClientStore {
+    db: IndexedDBStore;
+    constructor(db?: string | IndexedDBStore);
+    /**
+     * Creates LWW-specific object stores during database upgrade.
+     */
+    protected createLWWStores(db: IDBDatabase): void;
+    /**
+     * List documents for the LWW algorithm.
+     * Uses the algorithm index for efficient querying.
+     */
+    listDocs(includeDeleted?: boolean): Promise<TrackedDoc[]>;
+    /**
+     * Track documents using the LWW algorithm.
+     */
+    trackDocs(docIds: string[]): Promise<void>;
+    /**
+     * Close the database connection.
+     */
+    close(): Promise<void>;
+    /**
+     * Delete the database.
+     */
+    deleteDB(): Promise<void>;
+    /**
+     * Set the database name.
+     */
+    setName(dbName: string): void;
+    /**
+     * Confirm the deletion of a document.
+     */
+    confirmDeleteDoc(docId: string): Promise<void>;
+    /**
+     * Get the committed revision for a document.
+     */
+    getCommittedRev(docId: string): Promise<number>;
     /**
      * Rebuilds a document state from snapshot + committed ops + sending + pending.
      *

package/dist/client/LWWIndexedDBStore.js

@@ -2,24 +2,29 @@ import {
   __decorateElement,
   __decoratorMetadata,
   __decoratorStart,
+  __publicField,
   __runInitializers
 } from "../chunk-IZ2YBCUP.js";
-var _applyServerChanges_dec, _confirmSendingChange_dec, _saveSendingChange_dec, _getSendingChange_dec, _savePendingOps_dec, _getPendingOps_dec, _deleteDoc_dec, _saveDoc_dec, _getDoc_dec, _a, _init;
+var _applyServerChanges_dec, _confirmSendingChange_dec, _saveSendingChange_dec, _getSendingChange_dec, _savePendingOps_dec, _getPendingOps_dec, _deleteDoc_dec, _saveDoc_dec, _getDoc_dec, _init;
 import { createChange } from "../data/change.js";
 import { applyPatch } from "../json-patch/applyPatch.js";
 import { blockable } from "../utils/concurrency.js";
 import { IDBStoreWrapper, IndexedDBStore } from "./IndexedDBStore.js";
-const DB_VERSION = 1;
 const SNAPSHOT_INTERVAL = 200;
-class LWWIndexedDBStore extends (_a = IndexedDBStore, _getDoc_dec = [blockable], _saveDoc_dec = [blockable], _deleteDoc_dec = [blockable], _getPendingOps_dec = [blockable], _savePendingOps_dec = [blockable], _getSendingChange_dec = [blockable], _saveSendingChange_dec = [blockable], _confirmSendingChange_dec = [blockable], _applyServerChanges_dec = [blockable], _a) {
-  constructor() {
-    super(...arguments);
+_getDoc_dec = [blockable], _saveDoc_dec = [blockable], _deleteDoc_dec = [blockable], _getPendingOps_dec = [blockable], _savePendingOps_dec = [blockable], _getSendingChange_dec = [blockable], _saveSendingChange_dec = [blockable], _confirmSendingChange_dec = [blockable], _applyServerChanges_dec = [blockable];
+class LWWIndexedDBStore {
+  constructor(db) {
     __runInitializers(_init, 5, this);
+    __publicField(this, "db");
+    this.db = !db || typeof db === "string" ? new IndexedDBStore(db) : db;
+    this.db.onUpgrade((db2, _oldVersion, _transaction) => {
+      this.createLWWStores(db2);
+    });
   }
-  getDBVersion() {
-    return DB_VERSION;
-  }
-  onUpgrade(db, _oldVersion) {
+  /**
+   * Creates LWW-specific object stores during database upgrade.
+   */
+  createLWWStores(db) {
     if (!db.objectStoreNames.contains("committedOps")) {
       db.createObjectStore("committedOps", { keyPath: ["docId", "path"] });
     }
@@ -30,8 +35,51 @@ class LWWIndexedDBStore extends (_a = IndexedDBStore, _getDoc_dec = [blockable],
       db.createObjectStore("sendingChanges", { keyPath: "docId" });
     }
   }
+  /**
+   * List documents for the LWW algorithm.
+   * Uses the algorithm index for efficient querying.
+   */
+  async listDocs(includeDeleted = false) {
+    return this.db.listDocs(includeDeleted, "lww");
+  }
+  /**
+   * Track documents using the LWW algorithm.
+   */
+  async trackDocs(docIds) {
+    return this.db.trackDocs(docIds, "lww");
+  }
+  /**
+   * Close the database connection.
+   */
+  async close() {
+    return this.db.close();
+  }
+  /**
+   * Delete the database.
+   */
+  async deleteDB() {
+    return this.db.deleteDB();
+  }
+  /**
+   * Set the database name.
+   */
+  setName(dbName) {
+    return this.db.setName(dbName);
+  }
+  /**
+   * Confirm the deletion of a document.
+   */
+  async confirmDeleteDoc(docId) {
+    return this.db.confirmDeleteDoc(docId);
+  }
+  /**
+   * Get the committed revision for a document.
+   */
+  async getCommittedRev(docId) {
+    return this.db.getCommittedRev(docId);
+  }
   async getDoc(docId) {
-    const [tx, docsStore, snapshots, committedOps, pendingOps, sendingChanges] = await this.transaction(
+    const [tx, docsStore, snapshots, committedOps, pendingOps, sendingChanges] = await this.db.transaction(
       ["docs", "snapshots", "committedOps", "pendingOps", "sendingChanges"],
       "readonly"
     );
@@ -74,7 +122,7 @@ class LWWIndexedDBStore extends (_a = IndexedDBStore, _getDoc_dec = [blockable],
     };
   }
   async saveDoc(docId, docState) {
-    const [tx, snapshots, committedOps, pendingOps, sendingChanges, docsStore] = await this.transaction(
+    const [tx, snapshots, committedOps, pendingOps, sendingChanges, docsStore] = await this.db.transaction(
       ["snapshots", "committedOps", "pendingOps", "sendingChanges", "docs"],
       "readwrite"
     );
@@ -89,7 +137,7 @@ class LWWIndexedDBStore extends (_a = IndexedDBStore, _getDoc_dec = [blockable],
     await tx.complete();
   }
   async deleteDoc(docId) {
-    const [tx, snapshots, committedOps, pendingOps, sendingChanges, docsStore] = await this.transaction(
+    const [tx, snapshots, committedOps, pendingOps, sendingChanges, docsStore] = await this.db.transaction(
       ["snapshots", "committedOps", "pendingOps", "sendingChanges", "docs"],
       "readwrite"
     );
@@ -107,7 +155,7 @@ class LWWIndexedDBStore extends (_a = IndexedDBStore, _getDoc_dec = [blockable],
    * Untracks documents by removing all their data.
    */
   async untrackDocs(docIds) {
-    const [tx, docsStore, snapshots, committedOps, pendingOps, sendingChanges] = await this.transaction(
+    const [tx, docsStore, snapshots, committedOps, pendingOps, sendingChanges] = await this.db.transaction(
       ["docs", "snapshots", "committedOps", "pendingOps", "sendingChanges"],
       "readwrite"
     );
@@ -125,7 +173,7 @@ class LWWIndexedDBStore extends (_a = IndexedDBStore, _getDoc_dec = [blockable],
     await tx.complete();
   }
   async getPendingOps(docId, pathPrefixes) {
-    const [tx, pendingOpsStore] = await this.transaction(["pendingOps"], "readonly");
+    const [tx, pendingOpsStore] = await this.db.transaction(["pendingOps"], "readonly");
     let pending;
     if (!pathPrefixes || pathPrefixes.length === 0) {
       pending = await pendingOpsStore.getAll([docId, ""], [docId, "\uFFFF"]);
@@ -144,10 +192,10 @@ class LWWIndexedDBStore extends (_a = IndexedDBStore, _getDoc_dec = [blockable],
     }));
   }
   async savePendingOps(docId, ops, pathsToDelete) {
-    const [tx, pendingOpsStore, docsStore] = await this.transaction(["pendingOps", "docs"], "readwrite");
+    const [tx, pendingOpsStore, docsStore] = await this.db.transaction(["pendingOps", "docs"], "readwrite");
     let docMeta = await docsStore.get(docId);
     if (!docMeta) {
-      docMeta = { docId, committedRev: 0 };
+      docMeta = { docId, committedRev: 0, algorithm: "lww" };
       await docsStore.put(docMeta);
     } else if (docMeta.deleted) {
       delete docMeta.deleted;
@@ -170,19 +218,22 @@ class LWWIndexedDBStore extends (_a = IndexedDBStore, _getDoc_dec = [blockable],
     await tx.complete();
   }
   async getSendingChange(docId) {
-    const [tx, sendingChanges] = await this.transaction(["sendingChanges"], "readonly");
+    const [tx, sendingChanges] = await this.db.transaction(["sendingChanges"], "readonly");
     const sending = await sendingChanges.get(docId);
     await tx.complete();
     return sending?.change ?? null;
   }
   async saveSendingChange(docId, change) {
-    const [tx, pendingOpsStore, sendingChanges] = await this.transaction(["pendingOps", "sendingChanges"], "readwrite");
+    const [tx, pendingOpsStore, sendingChanges] = await this.db.transaction(
+      ["pendingOps", "sendingChanges"],
+      "readwrite"
+    );
     await sendingChanges.put({ docId, change });
     await this.deleteFieldsForDoc(pendingOpsStore, docId);
     await tx.complete();
   }
   async confirmSendingChange(docId) {
-    const [tx, sendingChanges, committedOps, docsStore] = await this.transaction(
+    const [tx, sendingChanges, committedOps, docsStore] = await this.db.transaction(
       ["sendingChanges", "committedOps", "docs"],
       "readwrite"
     );
@@ -200,7 +251,7 @@ class LWWIndexedDBStore extends (_a = IndexedDBStore, _getDoc_dec = [blockable],
     await tx.complete();
   }
   async applyServerChanges(docId, serverChanges) {
-    const [tx, committedOps, snapshots, docsStore] = await this.transaction(
+    const [tx, committedOps, snapshots, docsStore] = await this.db.transaction(
       ["committedOps", "snapshots", "docs"],
       "readwrite"
     );
@@ -259,7 +310,7 @@ class LWWIndexedDBStore extends (_a = IndexedDBStore, _getDoc_dec = [blockable],
     await this.deleteFieldsForDoc(committedOps, docId);
   }
 }
-_init = __decoratorStart(_a);
+_init = __decoratorStart(null);
 __decorateElement(_init, 1, "getDoc", _getDoc_dec, LWWIndexedDBStore);
 __decorateElement(_init, 1, "saveDoc", _saveDoc_dec, LWWIndexedDBStore);
 __decorateElement(_init, 1, "deleteDoc", _deleteDoc_dec, LWWIndexedDBStore);

package/dist/client/OTAlgorithm.js

@@ -75,7 +75,7 @@ class OTAlgorithm {
   }
   // --- Store forwarding methods ---
   async trackDocs(docIds) {
-    return this.store.trackDocs(docIds);
+    return this.store.trackDocs(docIds, "ot");
   }
   async untrackDocs(docIds) {
     return this.store.untrackDocs(docIds);

package/dist/client/{InMemoryStore.d.ts → OTInMemoryStore.d.ts}

@@ -6,11 +6,11 @@ import '@dabble/delta';
 import '../json-patch/types.js';
 
 /**
- * A trivial in‑memory implementation of OfflineStore (soon PatchesStore).
+ * A trivial in‑memory implementation of OTClientStore.
  * 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 OTClientStore {
+declare class OTInMemoryStore implements OTClientStore {
     private docs;
     getDoc(docId: string): Promise<PatchesSnapshot | undefined>;
     getPendingChanges(docId: string): Promise<Change[]>;
@@ -19,11 +19,11 @@ declare class InMemoryStore implements OTClientStore {
     saveDoc(docId: string, snapshot: PatchesState): Promise<void>;
     savePendingChanges(docId: string, changes: Change[]): Promise<void>;
     applyServerChanges(docId: string, serverChanges: Change[], rebasedPendingChanges: Change[]): Promise<void>;
-    trackDocs(docIds: string[]): Promise<void>;
+    trackDocs(docIds: string[], _algorithm?: 'ot' | 'lww'): Promise<void>;
     untrackDocs(docIds: string[]): Promise<void>;
     deleteDoc(docId: string): Promise<void>;
     confirmDeleteDoc(docId: string): Promise<void>;
     close(): Promise<void>;
 }
 
-export { InMemoryStore };
+export { OTInMemoryStore };

package/dist/client/{InMemoryStore.js → OTInMemoryStore.js}

@@ -1,6 +1,6 @@
 import "../chunk-IZ2YBCUP.js";
 import { applyChanges } from "../algorithms/ot/shared/applyChanges.js";
-class InMemoryStore {
+class OTInMemoryStore {
   docs = /* @__PURE__ */ new Map();
   // ─── Reconstruction ────────────────────────────────────────────────────
   async getDoc(docId) {
@@ -31,7 +31,11 @@ class InMemoryStore {
   }
   // ─── Writes ────────────────────────────────────────────────────────────
   async saveDoc(docId, snapshot) {
-    this.docs.set(docId, { snapshot, committed: [], pending: [] });
+    this.docs.set(docId, {
+      snapshot,
+      committed: [],
+      pending: []
+    });
   }
   async savePendingChanges(docId, changes) {
     const buf = this.docs.get(docId) ?? { committed: [], pending: [] };
@@ -45,7 +49,7 @@ class InMemoryStore {
     buf.pending = [...rebasedPendingChanges];
   }
   // ─── Metadata / Tracking ───────────────────────────────────────────
-  async trackDocs(docIds) {
+  async trackDocs(docIds, _algorithm) {
     for (const docId of docIds) {
       const buf = this.docs.get(docId) ?? { committed: [], pending: [] };
       buf.deleted = void 0;
@@ -74,5 +78,5 @@ class InMemoryStore {
   }
 }
 export {
-  InMemoryStore
+  OTInMemoryStore
 };

package/dist/client/OTIndexedDBStore.d.ts

@@ -1,20 +1,21 @@
 import { PatchesSnapshot, PatchesState, Change } from '../types.js';
 import { IndexedDBStore } from './IndexedDBStore.js';
 import { OTClientStore } from './OTClientStore.js';
+import { TrackedDoc } from './PatchesStore.js';
 import '../json-patch/JSONPatch.js';
 import '@dabble/delta';
 import '../json-patch/types.js';
+import '../event-signal.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)
+ * - snapshots<{ docId: string; rev: number; state: any }> (primary key: docId) [shared]
  * - 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)
+ * - docs<{ docId: string; committedRev: number; deleted?: boolean }> (primary key: docId) [shared]
  *
  * 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
@@ -25,9 +26,42 @@ import './PatchesStore.js';
  * 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;
+declare class OTIndexedDBStore implements OTClientStore {
+    db: IndexedDBStore;
+    constructor(db?: string | IndexedDBStore);
+    /**
+     * Creates OT-specific object stores during database upgrade.
+     */
+    protected createOTStores(db: IDBDatabase): void;
+    /**
+     * List documents for the OT algorithm.
+     * Uses the algorithm index for efficient querying.
+     */
+    listDocs(includeDeleted?: boolean): Promise<TrackedDoc[]>;
+    /**
+     * Track documents using the OT algorithm.
+     */
+    trackDocs(docIds: string[]): Promise<void>;
+    /**
+     * Close the database connection.
+     */
+    close(): Promise<void>;
+    /**
+     * Delete the database.
+     */
+    deleteDB(): Promise<void>;
+    /**
+     * Set the database name.
+     */
+    setName(dbName: string): void;
+    /**
+     * Confirm the deletion of a document.
+     */
+    confirmDeleteDoc(docId: string): Promise<void>;
+    /**
+     * Get the committed revision for a document.
+     */
+    getCommittedRev(docId: string): Promise<number>;
     /**
      * Rebuilds a document snapshot + pending queue *without* loading
      * the full PatchesDoc into memory.

package/dist/client/OTIndexedDBStore.js

@@ -2,23 +2,28 @@ import {
   __decorateElement,
   __decoratorMetadata,
   __decoratorStart,
+  __publicField,
   __runInitializers
 } from "../chunk-IZ2YBCUP.js";
-var _applyServerChanges_dec, _getPendingChanges_dec, _savePendingChanges_dec, _saveDoc_dec, _deleteDoc_dec, _getDoc_dec, _a, _init;
+var _applyServerChanges_dec, _getPendingChanges_dec, _savePendingChanges_dec, _saveDoc_dec, _deleteDoc_dec, _getDoc_dec, _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);
+_getDoc_dec = [blockable], _deleteDoc_dec = [blockable], _saveDoc_dec = [blockable], _savePendingChanges_dec = [blockable], _getPendingChanges_dec = [blockable], _applyServerChanges_dec = [blockable];
+class OTIndexedDBStore {
+  constructor(db) {
     __runInitializers(_init, 5, this);
+    __publicField(this, "db");
+    this.db = !db || typeof db === "string" ? new IndexedDBStore(db) : db;
+    this.db.onUpgrade((db2, _oldVersion, _transaction) => {
+      this.createOTStores(db2);
+    });
   }
-  getDBVersion() {
-    return DB_VERSION;
-  }
-  onUpgrade(db, _oldVersion) {
+  /**
+   * Creates OT-specific object stores during database upgrade.
+   */
+  createOTStores(db) {
     if (!db.objectStoreNames.contains("committedChanges")) {
       db.createObjectStore("committedChanges", { keyPath: ["docId", "rev"] });
     }
@@ -26,8 +31,51 @@ class OTIndexedDBStore extends (_a = IndexedDBStore, _getDoc_dec = [blockable],
       db.createObjectStore("pendingChanges", { keyPath: ["docId", "rev"] });
     }
   }
+  /**
+   * List documents for the OT algorithm.
+   * Uses the algorithm index for efficient querying.
+   */
+  async listDocs(includeDeleted = false) {
+    return this.db.listDocs(includeDeleted, "ot");
+  }
+  /**
+   * Track documents using the OT algorithm.
+   */
+  async trackDocs(docIds) {
+    return this.db.trackDocs(docIds, "ot");
+  }
+  /**
+   * Close the database connection.
+   */
+  async close() {
+    return this.db.close();
+  }
+  /**
+   * Delete the database.
+   */
+  async deleteDB() {
+    return this.db.deleteDB();
+  }
+  /**
+   * Set the database name.
+   */
+  setName(dbName) {
+    return this.db.setName(dbName);
+  }
+  /**
+   * Confirm the deletion of a document.
+   */
+  async confirmDeleteDoc(docId) {
+    return this.db.confirmDeleteDoc(docId);
+  }
+  /**
+   * Get the committed revision for a document.
+   */
+  async getCommittedRev(docId) {
+    return this.db.getCommittedRev(docId);
+  }
   async getDoc(docId) {
-    const [tx, docsStore, snapshots, committedChanges, pendingChanges] = await this.transaction(
+    const [tx, docsStore, snapshots, committedChanges, pendingChanges] = await this.db.transaction(
       ["docs", "snapshots", "committedChanges", "pendingChanges"],
       "readonly"
     );
@@ -49,7 +97,7 @@ class OTIndexedDBStore extends (_a = IndexedDBStore, _getDoc_dec = [blockable],
     };
   }
   async deleteDoc(docId) {
-    const [tx, snapshots, committedChanges, pendingChanges, docsStore] = await this.transaction(
+    const [tx, snapshots, committedChanges, pendingChanges, docsStore] = await this.db.transaction(
       ["snapshots", "committedChanges", "pendingChanges", "docs"],
       "readwrite"
     );
@@ -63,7 +111,7 @@ class OTIndexedDBStore extends (_a = IndexedDBStore, _getDoc_dec = [blockable],
     await tx.complete();
   }
   async saveDoc(docId, docState) {
-    const [tx, snapshots, committedChanges, pendingChanges, docsStore] = await this.transaction(
+    const [tx, snapshots, committedChanges, pendingChanges, docsStore] = await this.db.transaction(
       ["snapshots", "committedChanges", "pendingChanges", "docs"],
       "readwrite"
     );
@@ -77,10 +125,10 @@ class OTIndexedDBStore extends (_a = IndexedDBStore, _getDoc_dec = [blockable],
     await tx.complete();
   }
   async savePendingChanges(docId, changes) {
-    const [tx, pendingChanges, docsStore] = await this.transaction(["pendingChanges", "docs"], "readwrite");
+    const [tx, pendingChanges, docsStore] = await this.db.transaction(["pendingChanges", "docs"], "readwrite");
     let docMeta = await docsStore.get(docId);
     if (!docMeta) {
-      docMeta = { docId, committedRev: 0 };
+      docMeta = { docId, committedRev: 0, algorithm: "ot" };
       await docsStore.put(docMeta);
     } else if (docMeta.deleted) {
       delete docMeta.deleted;
@@ -91,13 +139,13 @@ class OTIndexedDBStore extends (_a = IndexedDBStore, _getDoc_dec = [blockable],
     await tx.complete();
   }
   async getPendingChanges(docId) {
-    const [tx, pendingChanges] = await this.transaction(["pendingChanges"], "readonly");
+    const [tx, pendingChanges] = await this.db.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(
+    const [tx, committedChangesStore, pendingChangesStore, snapshots, docsStore] = await this.db.transaction(
       ["committedChanges", "pendingChanges", "snapshots", "docs"],
       "readwrite"
     );
@@ -133,7 +181,7 @@ class OTIndexedDBStore extends (_a = IndexedDBStore, _getDoc_dec = [blockable],
    * @param docIds - The IDs of the documents to untrack.
    */
   async untrackDocs(docIds) {
-    const [tx, docsStore, snapshots, committedChanges, pendingChanges] = await this.transaction(
+    const [tx, docsStore, snapshots, committedChanges, pendingChanges] = await this.db.transaction(
       ["docs", "snapshots", "committedChanges", "pendingChanges"],
       "readwrite"
     );
@@ -150,7 +198,7 @@ class OTIndexedDBStore extends (_a = IndexedDBStore, _getDoc_dec = [blockable],
     await tx.complete();
   }
 }
-_init = __decoratorStart(_a);
+_init = __decoratorStart(null);
 __decorateElement(_init, 1, "getDoc", _getDoc_dec, OTIndexedDBStore);
 __decorateElement(_init, 1, "deleteDoc", _deleteDoc_dec, OTIndexedDBStore);
 __decorateElement(_init, 1, "saveDoc", _saveDoc_dec, OTIndexedDBStore);

package/dist/client/Patches.d.ts

@@ -1,11 +1,11 @@
 import { Unsubscriber, Signal } from '../event-signal.js';
 import { JSONPatchOp } from '../json-patch/types.js';
 import { Change } from '../types.js';
-import { AlgorithmName, ClientAlgorithm } from './ClientAlgorithm.js';
+import { ClientAlgorithm } from './ClientAlgorithm.js';
 import { P as PatchesDocOptions, a as PatchesDoc } from '../BaseDoc-DkP3tUhT.js';
+import { AlgorithmName } from './PatchesStore.js';
 import '../json-patch/JSONPatch.js';
 import '@dabble/delta';
-import './PatchesStore.js';
 
 /**
  * Options for creating a Patches instance.

package/dist/client/Patches.js

@@ -114,7 +114,18 @@ class Patches {
   async openDoc(docId, opts = {}) {
     const existing = this.docs.get(docId);
     if (existing) return existing.doc;
-    const algorithmName = opts.algorithm ?? this.defaultAlgorithm;
+    let algorithmName = opts.algorithm;
+    if (!algorithmName) {
+      for (const algo of Object.values(this.algorithms)) {
+        const docs = await algo.listDocs(false);
+        const tracked = docs.find((d) => d.docId === docId);
+        if (tracked?.algorithm) {
+          algorithmName = tracked.algorithm;
+          break;
+        }
+      }
+      algorithmName = algorithmName ?? this.defaultAlgorithm;
+    }
     const algorithm = this._getAlgorithm(algorithmName);
     await this.trackDocs([docId], algorithmName);
     const snapshot = await algorithm.loadDoc(docId);

package/dist/client/PatchesStore.d.ts

@@ -3,6 +3,8 @@ import '../json-patch/JSONPatch.js';
 import '@dabble/delta';
 import '../json-patch/types.js';
 
+/** Available algorithm names */
+type AlgorithmName = 'ot' | 'lww';
 /** Represents metadata for a document tracked by the store. */
 interface TrackedDoc {
     docId: string;
@@ -10,6 +12,8 @@ interface TrackedDoc {
     committedRev: number;
     /** Optional flag indicating the document has been locally deleted. */
     deleted?: true;
+    /** The sync algorithm this document uses. */
+    algorithm?: AlgorithmName;
 }
 /**
  * Pluggable persistence layer contract used by Patches + PatchesSync.
@@ -24,14 +28,15 @@ interface PatchesStore {
      * Sets initial committedRev to 0 for new documents.
      *
      * @param docIds Array of document IDs to start tracking
+     * @param algorithm The algorithm to use for this document ('ot' or 'lww')
      * @example
      * // Start tracking two documents
-     * await store.trackDocs(['doc1', 'doc2']);
+     * await store.trackDocs(['doc1', 'doc2'], 'ot');
      *
      * // Reactivate a previously deleted document
-     * await store.trackDocs(['previously-deleted-doc']);
+     * await store.trackDocs(['previously-deleted-doc'], 'lww');
      */
-    trackDocs(docIds: string[]): Promise<void>;
+    trackDocs(docIds: string[], algorithm?: AlgorithmName): Promise<void>;
     /**
      * Permanently removes documents from local tracking and storage.
      *
@@ -153,4 +158,4 @@ interface PatchesStore {
     close(): Promise<void>;
 }
 
-export type { PatchesStore, TrackedDoc };
+export type { AlgorithmName, PatchesStore, TrackedDoc };

package/dist/client/factories.d.ts

@@ -1,12 +1,12 @@
-import { AlgorithmName } from './ClientAlgorithm.js';
+import { AlgorithmName } from './PatchesStore.js';
 import { Patches } from './Patches.js';
 import { P as PatchesDocOptions } from '../BaseDoc-DkP3tUhT.js';
-import '../json-patch/types.js';
 import '../types.js';
 import '../json-patch/JSONPatch.js';
 import '@dabble/delta';
-import './PatchesStore.js';
+import '../json-patch/types.js';
 import '../event-signal.js';
+import './ClientAlgorithm.js';
 
 /**
  * Options for factory functions that create Patches instances.
@@ -62,11 +62,12 @@ declare function createLWWIndexedDBPatches(options: IndexedDBFactoryOptions): Pa
  * Creates a Patches instance with both OT and LWW algorithms using in-memory stores.
  * Useful for testing or applications that need both algorithms without persistence.
  */
-declare function createAllPatches(options?: MultiAlgorithmFactoryOptions): Patches;
+declare function createMultiAlgorithmPatches(options?: MultiAlgorithmFactoryOptions): Patches;
 /**
  * Creates a Patches instance with both OT and LWW algorithms using IndexedDB stores.
  * For persistent storage in browser environments with support for both algorithms.
+ * Both algorithms share the same IndexedDB database with unified stores.
  */
-declare function createAllIndexedDBPatches(options: MultiAlgorithmIndexedDBFactoryOptions): Patches;
+declare function createMultiAlgorithmIndexedDBPatches(options: MultiAlgorithmIndexedDBFactoryOptions): Patches;
 
-export { type IndexedDBFactoryOptions, type MultiAlgorithmFactoryOptions, type MultiAlgorithmIndexedDBFactoryOptions, type PatchesFactoryOptions, createAllIndexedDBPatches, createAllPatches, createLWWIndexedDBPatches, createLWWPatches, createOTIndexedDBPatches, createOTPatches };
+export { type IndexedDBFactoryOptions, type MultiAlgorithmFactoryOptions, type MultiAlgorithmIndexedDBFactoryOptions, type PatchesFactoryOptions, createLWWIndexedDBPatches, createLWWPatches, createMultiAlgorithmIndexedDBPatches, createMultiAlgorithmPatches, createOTIndexedDBPatches, createOTPatches };

package/dist/client/factories.js

@@ -1,13 +1,14 @@
 import "../chunk-IZ2YBCUP.js";
-import { InMemoryStore } from "./InMemoryStore.js";
+import { OTInMemoryStore } from "./OTInMemoryStore.js";
 import { LWWInMemoryStore } from "./LWWInMemoryStore.js";
+import { IndexedDBStore } from "./IndexedDBStore.js";
 import { LWWIndexedDBStore } from "./LWWIndexedDBStore.js";
 import { LWWAlgorithm } from "./LWWAlgorithm.js";
 import { OTIndexedDBStore } from "./OTIndexedDBStore.js";
 import { OTAlgorithm } from "./OTAlgorithm.js";
 import { Patches } from "./Patches.js";
 function createOTPatches(options = {}) {
-  const store = new InMemoryStore();
+  const store = new OTInMemoryStore();
   const otAlgorithm = new OTAlgorithm(store, options.docOptions);
   return new Patches({
     algorithms: { ot: otAlgorithm },
@@ -46,8 +47,8 @@ function createLWWIndexedDBPatches(options) {
     docOptions: options.docOptions
   });
 }
-function createAllPatches(options = {}) {
-  const otStore = new InMemoryStore();
+function createMultiAlgorithmPatches(options = {}) {
+  const otStore = new OTInMemoryStore();
   const lwwStore = new LWWInMemoryStore();
   const otAlgorithm = new OTAlgorithm(otStore, options.docOptions);
   const lwwAlgorithm = new LWWAlgorithm(lwwStore);
@@ -58,9 +59,10 @@ function createAllPatches(options = {}) {
     docOptions: options.docOptions
   });
 }
-function createAllIndexedDBPatches(options) {
-  const otStore = new OTIndexedDBStore(options.dbName);
-  const lwwStore = new LWWIndexedDBStore(`${options.dbName}-lww`);
+function createMultiAlgorithmIndexedDBPatches(options) {
+  const baseStore = new IndexedDBStore(options.dbName);
+  const otStore = new OTIndexedDBStore(baseStore);
+  const lwwStore = new LWWIndexedDBStore(baseStore);
   const otAlgorithm = new OTAlgorithm(otStore, options.docOptions);
   const lwwAlgorithm = new LWWAlgorithm(lwwStore);
   return new Patches({
@@ -71,10 +73,10 @@ function createAllIndexedDBPatches(options) {
   });
 }
 export {
-  createAllIndexedDBPatches,
-  createAllPatches,
   createLWWIndexedDBPatches,
   createLWWPatches,
+  createMultiAlgorithmIndexedDBPatches,
+  createMultiAlgorithmPatches,
   createOTIndexedDBPatches,
   createOTPatches
 };

package/dist/client/index.d.ts

@@ -1,9 +1,9 @@
 export { B as BaseDoc, O as OTDoc, a as PatchesDoc, O as PatchesDocClass, P as PatchesDocOptions } from '../BaseDoc-DkP3tUhT.js';
-export { IndexedDBFactoryOptions, MultiAlgorithmFactoryOptions, MultiAlgorithmIndexedDBFactoryOptions, PatchesFactoryOptions, createAllIndexedDBPatches, createAllPatches, createLWWIndexedDBPatches, createLWWPatches, createOTIndexedDBPatches, createOTPatches } from './factories.js';
+export { IndexedDBFactoryOptions, MultiAlgorithmFactoryOptions, MultiAlgorithmIndexedDBFactoryOptions, PatchesFactoryOptions, createLWWIndexedDBPatches, createLWWPatches, createMultiAlgorithmIndexedDBPatches, createMultiAlgorithmPatches, createOTIndexedDBPatches, createOTPatches } from './factories.js';
 export { IDBStoreWrapper, IDBTransactionWrapper, IndexedDBStore } from './IndexedDBStore.js';
 export { OTIndexedDBStore } from './OTIndexedDBStore.js';
 export { LWWIndexedDBStore } from './LWWIndexedDBStore.js';
-export { InMemoryStore } from './InMemoryStore.js';
+export { OTInMemoryStore } from './OTInMemoryStore.js';
 export { LWWInMemoryStore } from './LWWInMemoryStore.js';
 export { LWWDoc } from './LWWDoc.js';
 export { LWWAlgorithm } from './LWWAlgorithm.js';
@@ -11,10 +11,10 @@ export { LWWBatcher } from './LWWBatcher.js';
 export { OTAlgorithm } from './OTAlgorithm.js';
 export { Patches, PatchesOptions } from './Patches.js';
 export { PatchesHistoryClient } from './PatchesHistoryClient.js';
-export { PatchesStore, TrackedDoc } from './PatchesStore.js';
+export { AlgorithmName, PatchesStore, TrackedDoc } from './PatchesStore.js';
 export { OTClientStore } from './OTClientStore.js';
 export { LWWClientStore } from './LWWClientStore.js';
-export { AlgorithmName, ClientAlgorithm } from './ClientAlgorithm.js';
+export { ClientAlgorithm } from './ClientAlgorithm.js';
 import '../event-signal.js';
 import '../json-patch/types.js';
 import '../types.js';

package/dist/client/index.js

@@ -3,7 +3,7 @@ export * from "./factories.js";
 export * from "./IndexedDBStore.js";
 export * from "./OTIndexedDBStore.js";
 export * from "./LWWIndexedDBStore.js";
-export * from "./InMemoryStore.js";
+export * from "./OTInMemoryStore.js";
 export * from "./LWWInMemoryStore.js";
 export * from "./LWWDoc.js";
 export * from "./LWWAlgorithm.js";

package/dist/index.d.ts

@@ -1,10 +1,10 @@
 export { Delta } from '@dabble/delta';
 export { B as BaseDoc, O as OTDoc, a as PatchesDoc, O as PatchesDocClass, P as PatchesDocOptions } from './BaseDoc-DkP3tUhT.js';
-export { IndexedDBFactoryOptions, MultiAlgorithmFactoryOptions, MultiAlgorithmIndexedDBFactoryOptions, PatchesFactoryOptions, createAllIndexedDBPatches, createAllPatches, createLWWIndexedDBPatches, createLWWPatches, createOTIndexedDBPatches, createOTPatches } from './client/factories.js';
+export { IndexedDBFactoryOptions, MultiAlgorithmFactoryOptions, MultiAlgorithmIndexedDBFactoryOptions, PatchesFactoryOptions, createLWWIndexedDBPatches, createLWWPatches, createMultiAlgorithmIndexedDBPatches, createMultiAlgorithmPatches, createOTIndexedDBPatches, createOTPatches } from './client/factories.js';
 export { IDBStoreWrapper, IDBTransactionWrapper, IndexedDBStore } from './client/IndexedDBStore.js';
 export { OTIndexedDBStore } from './client/OTIndexedDBStore.js';
 export { LWWIndexedDBStore } from './client/LWWIndexedDBStore.js';
-export { InMemoryStore } from './client/InMemoryStore.js';
+export { OTInMemoryStore } from './client/OTInMemoryStore.js';
 export { LWWInMemoryStore } from './client/LWWInMemoryStore.js';
 export { LWWDoc } from './client/LWWDoc.js';
 export { LWWAlgorithm } from './client/LWWAlgorithm.js';
@@ -12,10 +12,10 @@ export { LWWBatcher } from './client/LWWBatcher.js';
 export { OTAlgorithm } from './client/OTAlgorithm.js';
 export { Patches, PatchesOptions } from './client/Patches.js';
 export { PatchesHistoryClient } from './client/PatchesHistoryClient.js';
-export { PatchesStore, TrackedDoc } from './client/PatchesStore.js';
+export { AlgorithmName, PatchesStore, TrackedDoc } from './client/PatchesStore.js';
 export { OTClientStore } from './client/OTClientStore.js';
 export { LWWClientStore } from './client/LWWClientStore.js';
-export { AlgorithmName, ClientAlgorithm } from './client/ClientAlgorithm.js';
+export { ClientAlgorithm } from './client/ClientAlgorithm.js';
 export { createChange } from './data/change.js';
 export { createVersionId, createVersionMetadata } from './data/version.js';
 export { ErrorSubscriber, Signal, SignalSubscriber, Unsubscriber, signal } from './event-signal.js';

package/dist/net/PatchesSync.d.ts

@@ -6,14 +6,14 @@ import { PatchesWebSocket } from './websocket/PatchesWebSocket.js';
 import { WebSocketOptions } from './websocket/WebSocketTransport.js';
 import { SizeCalculator } from '../algorithms/ot/shared/changeBatching.js';
 import { Patches } from '../client/Patches.js';
-import { AlgorithmName, ClientAlgorithm } from '../client/ClientAlgorithm.js';
+import { AlgorithmName } from '../client/PatchesStore.js';
+import { ClientAlgorithm } from '../client/ClientAlgorithm.js';
 import '../json-patch/JSONPatch.js';
 import '@dabble/delta';
 import '../json-patch/types.js';
 import './PatchesClient.js';
 import '../utils/deferred.js';
 import '../BaseDoc-DkP3tUhT.js';
-import '../client/PatchesStore.js';
 
 interface PatchesSyncState {
     online: boolean;

package/dist/net/PatchesSync.js

@@ -138,13 +138,19 @@ class PatchesSync {
     if (!this.state.connected) return;
     this.updateState({ syncing: "updating" });
     try {
-      const defaultAlgorithm = this.patches.algorithms[this.patches.defaultAlgorithm];
-      if (!defaultAlgorithm) {
-        throw new Error("Default algorithm not found");
+      const allTracked = [];
+      for (const algorithm of Object.values(this.patches.algorithms)) {
+        if (!algorithm) continue;
+        const docs = await algorithm.listDocs(true);
+        allTracked.push(...docs);
+        for (const doc of docs) {
+          if (doc.algorithm) {
+            this.docAlgorithms.set(doc.docId, doc.algorithm);
+          }
+        }
       }
-      const tracked = await defaultAlgorithm.listDocs(true);
-      const activeDocs = tracked.filter((t) => !t.deleted);
-      const deletedDocs = tracked.filter((t) => t.deleted);
+      const activeDocs = allTracked.filter((t) => !t.deleted);
+      const deletedDocs = allTracked.filter((t) => t.deleted);
       const activeDocIds = activeDocs.map((t) => t.docId);
       this.trackedDocs = new Set(activeDocIds);
       if (activeDocIds.length > 0) {
@@ -313,6 +319,17 @@ class PatchesSync {
     const newIds = docIds.filter((id) => !this.trackedDocs.has(id));
     if (!newIds.length) return;
     newIds.forEach((id) => this.trackedDocs.add(id));
+    for (const docId of newIds) {
+      for (const algorithm of Object.values(this.patches.algorithms)) {
+        if (!algorithm) continue;
+        const docs = await algorithm.listDocs(false);
+        const tracked = docs.find((d) => d.docId === docId);
+        if (tracked?.algorithm) {
+          this.docAlgorithms.set(docId, tracked.algorithm);
+          break;
+        }
+      }
+    }
     let subscribeIds = newIds;
     if (this.options?.subscribeFilter) {
       const alreadyTracked = this.options.subscribeFilter([...this.trackedDocs]);
@@ -334,11 +351,12 @@ class PatchesSync {
     const existingIds = docIds.filter((id) => this.trackedDocs.has(id));
     if (!existingIds.length) return;
     existingIds.forEach((id) => this.trackedDocs.delete(id));
-    if (this.state.connected) {
+    const unsubscribeIds = this.options?.subscribeFilter?.(existingIds) || existingIds;
+    if (this.state.connected && unsubscribeIds.length) {
       try {
-        await this.ws.unsubscribe(existingIds);
+        await this.ws.unsubscribe(unsubscribeIds);
       } catch (err) {
-        console.warn(`Failed to unsubscribe docs: ${existingIds.join(", ")}`, err);
+        console.warn(`Failed to unsubscribe docs: ${unsubscribeIds.join(", ")}`, err);
       }
     }
   }

package/dist/server/LWWServer.js

@@ -87,7 +87,7 @@ class LWWServer {
     const change = changes[0];
     const serverNow = Date.now();
     const clientRev = change.rev;
-    const newOps = change.ops.map((op) => op.ts ? op : { ...op, ts: serverNow });
+    const newOps = change.ops.map((op) => op.ts ? op : { ...op, ts: change.createdAt ?? serverNow });
     const existingOps = await this.store.listOps(docId);
     const { opsToSave, pathsToDelete, opsToReturn } = consolidateOps(existingOps, newOps);
     const opsToStore = convertDeltaOps(opsToSave);

package/dist/solid/context.d.ts

@@ -38,9 +38,9 @@ interface PatchesProviderProps {
  * @example
  * ```tsx
  * import { PatchesProvider } from '@dabble/patches/solid';
- * import { Patches, InMemoryStore } from '@dabble/patches/client';
+ * import { Patches, OTInMemoryStore } from '@dabble/patches/client';
  *
- * const patches = new Patches({ store: new InMemoryStore() });
+ * const patches = new Patches({ store: new OTInMemoryStore() });
  *
  * <PatchesProvider patches={patches}>
  *   <App />

package/dist/vue/provider.d.ts

@@ -40,11 +40,11 @@ interface PatchesContext {
  * @example
  * ```typescript
  * import { createApp } from 'vue'
- * import { Patches, InMemoryStore } from '@dabble/patches/client'
+ * import { Patches, OTInMemoryStore } from '@dabble/patches/client'
  * import { PatchesSync } from '@dabble/patches/net'
  * import { providePatchesContext } from '@dabble/patches/vue'
  *
- * const patches = new Patches({ store: new InMemoryStore() })
+ * const patches = new Patches({ store: new OTInMemoryStore() })
  * const sync = new PatchesSync(patches, 'wss://your-server.com')
  *
  * const app = createApp(App)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dabble/patches",
-  "version": "0.7.4",
+  "version": "0.7.6",
   "description": "Immutable JSON Patch implementation based on RFC 6902 supporting operational transformation and last-writer-wins",
   "author": "Jacob Wright <jacwright@gmail.com>",
   "bugs": {