@dabble/patches 0.6.0 → 0.7.0

package/dist/client/Patches.js

@@ -8,7 +8,6 @@ import {
 var _openDoc_dec, _init;
 import { signal } from "../event-signal.js";
 import { singleInvocation } from "../utils/concurrency.js";
-import { PatchesDoc } from "./PatchesDoc.js";
 _openDoc_dec = [singleInvocation(true)];
 class Patches {
   constructor(opts) {
@@ -16,7 +15,8 @@ class Patches {
     __publicField(this, "options");
     __publicField(this, "docs", /* @__PURE__ */ new Map());
     __publicField(this, "docOptions");
-    __publicField(this, "store");
+    __publicField(this, "algorithms");
+    __publicField(this, "defaultAlgorithm");
     __publicField(this, "trackedDocs", /* @__PURE__ */ new Set());
     // Public signals
     __publicField(this, "onError", signal());
@@ -24,27 +24,54 @@ class Patches {
     __publicField(this, "onTrackDocs", signal());
     __publicField(this, "onUntrackDocs", signal());
     __publicField(this, "onDeleteDoc", signal());
+    /** Emitted when a doc has pending changes ready to send */
     __publicField(this, "onChange", signal());
     this.options = opts;
-    this.store = opts.store;
+    this.algorithms = opts.algorithms;
+    const algorithmNames = Object.keys(opts.algorithms);
+    if (algorithmNames.length === 0) {
+      throw new Error("At least one algorithm must be provided");
+    }
+    this.defaultAlgorithm = opts.defaultAlgorithm ?? algorithmNames[0];
+    if (!opts.algorithms[this.defaultAlgorithm]) {
+      throw new Error(`Default algorithm '${this.defaultAlgorithm}' not found in algorithms map`);
+    }
     this.docOptions = opts.docOptions ?? {};
-    this.store.listDocs().then((docs) => {
+    this._getAlgorithm(this.defaultAlgorithm).listDocs().then((docs) => {
       this.trackDocs(docs.map(({ docId }) => docId));
     });
   }
+  /**
+   * Gets an algorithm by name, throwing if not found.
+   */
+  _getAlgorithm(name) {
+    const algorithm = this.algorithms[name];
+    if (!algorithm) {
+      throw new Error(`Algorithm '${name}' not found`);
+    }
+    return algorithm;
+  }
+  /**
+   * Gets the algorithm for an open document.
+   */
+  getDocAlgorithm(docId) {
+    return this.docs.get(docId)?.algorithm;
+  }
   // --- Public API Methods ---
   /**
    * 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).
    */
-  async trackDocs(docIds) {
+  async trackDocs(docIds, algorithmName) {
     docIds = docIds.filter((id) => !this.trackedDocs.has(id));
     if (!docIds.length) return;
     docIds.forEach(this.trackedDocs.add, this.trackedDocs);
     this.onTrackDocs.emit(docIds);
-    await this.store.trackDocs(docIds);
+    const algorithm = this._getAlgorithm(algorithmName ?? this.defaultAlgorithm);
+    await algorithm.trackDocs(docIds);
   }
   /**
    * Untracks the given document IDs, removing them from the set of tracked documents and notifying listeners.
@@ -59,23 +86,28 @@ class Patches {
     this.onUntrackDocs.emit(docIds);
     const closedPromises = docIds.filter((id) => this.docs.has(id)).map((id) => this.closeDoc(id));
     await Promise.all(closedPromises);
-    await this.store.untrackDocs(docIds);
+    const byAlgorithm = /* @__PURE__ */ new Map();
+    for (const docId of docIds) {
+      const managed = this.docs.get(docId);
+      const algorithm = managed?.algorithm ?? this._getAlgorithm(this.defaultAlgorithm);
+      const list = byAlgorithm.get(algorithm) ?? [];
+      list.push(docId);
+      byAlgorithm.set(algorithm, list);
+    }
+    await Promise.all([...byAlgorithm.entries()].map(([algorithm, ids]) => algorithm.untrackDocs(ids)));
   }
   // ensure a second call to openDoc with the same docId returns the same promise while opening
   async openDoc(docId, opts = {}) {
     const existing = this.docs.get(docId);
     if (existing) return existing.doc;
-    await this.trackDocs([docId]);
-    const snapshot = await this.store.getDoc(docId);
-    const initialState = snapshot?.state ?? {};
+    const algorithmName = opts.algorithm ?? this.defaultAlgorithm;
+    const algorithm = this._getAlgorithm(algorithmName);
+    await this.trackDocs([docId], algorithmName);
+    const snapshot = await algorithm.loadDoc(docId);
     const mergedMetadata = { ...this.options.metadata, ...opts.metadata };
-    const doc = new PatchesDoc(initialState, mergedMetadata, this.docOptions);
-    doc.setId(docId);
-    if (snapshot) {
-      doc.import(snapshot);
-    }
-    const unsubscribe = doc.onChange((changes) => this._savePendingChanges(docId, changes));
-    this.docs.set(docId, { doc, unsubscribe });
+    const doc = algorithm.createDoc(docId, snapshot);
+    const unsubscribe = doc.onChange((ops) => this._handleDocChange(docId, ops, doc, algorithm, mergedMetadata));
+    this.docs.set(docId, { doc, algorithm, unsubscribe });
     return doc;
   }
   /**
@@ -99,13 +131,15 @@ class Patches {
    * @param docId - The document ID to delete.
    */
   async deleteDoc(docId) {
+    const managed = this.docs.get(docId);
+    const algorithm = managed?.algorithm ?? this._getAlgorithm(this.defaultAlgorithm);
     if (this.docs.has(docId)) {
       await this.closeDoc(docId);
     }
     if (this.trackedDocs.has(docId)) {
       await this.untrackDocs([docId]);
     }
-    await this.store.deleteDoc(docId);
+    await algorithm.deleteDoc(docId);
     await this.onDeleteDoc.emit(docId);
   }
   /**
@@ -121,10 +155,10 @@ class Patches {
    * Closes all open documents and cleans up listeners and store connections.
    * Should be called when shutting down the client.
    */
-  close() {
+  async close() {
     this.docs.forEach((managed) => managed.unsubscribe());
     this.docs.clear();
-    this.store.close();
+    await Promise.all(Object.values(this.algorithms).map((s) => s?.close()));
     this.onChange.clear();
     this.onDeleteDoc.clear();
     this.onUntrackDocs.clear();
@@ -133,16 +167,15 @@ class Patches {
     this.onError.clear();
   }
   /**
-   * 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.
    */
-  async _savePendingChanges(docId, changes) {
+  async _handleDocChange(docId, ops, doc, algorithm, metadata) {
     try {
-      await this.store.savePendingChanges(docId, changes);
-      this.onChange.emit(docId, changes);
+      await algorithm.handleDocChange(docId, ops, doc, metadata);
+      this.onChange.emit(docId);
     } catch (err) {
-      console.error(`Error saving pending changes for doc ${docId}:`, err);
+      console.error(`Error handling doc change for ${docId}:`, err);
       this.onError.emit(err, { docId });
     }
   }

package/dist/client/PatchesDoc.d.ts

@@ -1,115 +1,6 @@
-import { Signal, Unsubscriber } from '../event-signal.js';
-import { SizeCalculator } from '../algorithms/shared/changeBatching.js';
-import { PatchesSnapshot, SyncingState, Change, ChangeMutator } from '../types.js';
+import '../event-signal.js';
+import '../json-patch/types.js';
+import '../types.js';
+export { O as OTDoc, a as PatchesDoc, O as PatchesDocClass, P as PatchesDocOptions } from '../BaseDoc-DkP3tUhT.js';
 import '../json-patch/JSONPatch.js';
 import '@dabble/delta';
-import '../json-patch/types.js';
-
-/**
- * Options for creating a PatchesDoc instance
- */
-interface PatchesDocOptions {
-    /**
-     * Maximum size in bytes for a single change's storage representation.
-     * Changes exceeding this will be split. Used for backends with row size limits.
-     */
-    maxStorageBytes?: number;
-    /**
-     * Custom size calculator for storage limit checks.
-     * Import from '@dabble/patches/compression' for actual compression measurement,
-     * or provide your own function (e.g., ratio estimate).
-     *
-     * @example
-     * import { compressedSizeBase64 } from '@dabble/patches/compression';
-     * { sizeCalculator: compressedSizeBase64, maxStorageBytes: 1_000_000 }
-     */
-    sizeCalculator?: SizeCalculator;
-}
-/**
- * Represents a document synchronized using JSON patches.
- * Manages committed state, pending (local-only) changes, and
- * changes currently being sent to the server.
- */
-declare class PatchesDoc<T extends object = object> {
-    protected _id: string | null;
-    protected _state: T;
-    protected _snapshot: PatchesSnapshot<T>;
-    protected _changeMetadata: Record<string, any>;
-    protected _syncing: SyncingState;
-    protected readonly _maxStorageBytes?: number;
-    protected readonly _sizeCalculator?: SizeCalculator;
-    /** Subscribe to be notified before local state changes. */
-    readonly onBeforeChange: Signal<(change: Change) => void>;
-    /** Subscribe to be notified after local state changes are applied. */
-    readonly onChange: Signal<(changes: Change[]) => void>;
-    /** Subscribe to be notified whenever state changes from any source. */
-    readonly onUpdate: Signal<(newState: T) => void>;
-    /** Subscribe to be notified when syncing state changes. */
-    readonly onSyncing: Signal<(newSyncing: SyncingState) => void>;
-    /**
-     * Creates an instance of PatchesDoc.
-     * @param initialState Optional initial state.
-     * @param initialMetadata Optional metadata to add to generated changes.
-     * @param options Additional options for the document.
-     */
-    constructor(initialState?: T, initialMetadata?: Record<string, any>, options?: PatchesDocOptions);
-    /** The unique identifier for this document, once assigned. */
-    get id(): string | null;
-    /** Current local state (committed + pending). */
-    get state(): T;
-    /** Are we currently syncing this document? */
-    get syncing(): SyncingState;
-    /** Last committed revision number from the server. */
-    get committedRev(): number;
-    /** Are there local changes that haven't been sent yet? */
-    get hasPending(): boolean;
-    /** Subscribe to be notified whenever the state changes. */
-    subscribe(onUpdate: (newValue: T) => void): Unsubscriber;
-    /**
-     * Exports the document state for persistence.
-     * NOTE: Any changes currently marked as `sending` are included in the
-     * `changes` array alongside `pending` changes. On import, all changes
-     * are treated as pending.
-     */
-    export(): PatchesSnapshot<T>;
-    /**
-     * Imports previously exported document state.
-     * Resets sending state and treats all imported changes as pending.
-     */
-    import(snapshot: PatchesSnapshot<T>): void;
-    /**
-     * Sets metadata to be added to future changes.
-     */
-    setChangeMetadata(metadata: Record<string, any>): void;
-    /**
-     * Applies an update to the local state, generating a patch and adding it to pending changes.
-     * @param mutator Function that uses JSONPatch methods with type-safe paths.
-     * @returns The generated Change objects.
-     */
-    change(mutator: ChangeMutator<T>): Change[];
-    /**
-     * Returns the pending changes for this document.
-     * @returns The pending changes.
-     */
-    getPendingChanges(): Change[];
-    /**
-     * Applies committed changes to the document. Should only be called from a sync provider.
-     * @param serverChanges The changes to apply.
-     * @param rebasedPendingChanges The rebased pending changes to apply.
-     */
-    applyCommittedChanges(serverChanges: Change[], rebasedPendingChanges: Change[]): void;
-    /**
-     * Assigns an identifier to this document. Can only be set once.
-     * @param id The unique identifier for the document.
-     * @throws Error if the ID has already been set.
-     */
-    setId(id: string): void;
-    /**
-     * Updates the syncing state of the document.
-     * @param newSyncing The new syncing state.
-     */
-    updateSyncing(newSyncing: SyncingState): void;
-    toJSON(): PatchesSnapshot<T>;
-}
-
-export { PatchesDoc, type PatchesDocOptions };

package/dist/client/PatchesDoc.js

@@ -1,156 +1,6 @@
 import "../chunk-IZ2YBCUP.js";
-import { createStateFromSnapshot } from "../algorithms/client/createStateFromSnapshot.js";
-import { makeChange } from "../algorithms/client/makeChange.js";
-import { applyChanges } from "../algorithms/shared/applyChanges.js";
-import { signal } from "../event-signal.js";
-class PatchesDoc {
-  _id = null;
-  _state;
-  _snapshot;
-  _changeMetadata = {};
-  _syncing = null;
-  _maxStorageBytes;
-  _sizeCalculator;
-  /** Subscribe to be notified before local state changes. */
-  onBeforeChange = signal();
-  /** Subscribe to be notified after local state changes are applied. */
-  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 PatchesDoc.
-   * @param initialState Optional initial state.
-   * @param initialMetadata Optional metadata to add to generated changes.
-   * @param options Additional options for the document.
-   */
-  constructor(initialState = {}, initialMetadata = {}, options = {}) {
-    this._state = structuredClone(initialState);
-    this._snapshot = { state: this._state, rev: 0, changes: [] };
-    this._changeMetadata = initialMetadata;
-    this._maxStorageBytes = options.maxStorageBytes;
-    this._sizeCalculator = options.sizeCalculator;
-  }
-  /** The unique identifier for this document, once assigned. */
-  get id() {
-    return this._id;
-  }
-  /** Current local state (committed + pending). */
-  get state() {
-    return this._state;
-  }
-  /** Are we currently syncing this document? */
-  get syncing() {
-    return this._syncing;
-  }
-  /** Last committed revision number from the server. */
-  get committedRev() {
-    return this._snapshot.rev;
-  }
-  /** Are there local changes that haven't been sent yet? */
-  get hasPending() {
-    return this._snapshot.changes.length > 0;
-  }
-  /** Subscribe to be notified whenever the state changes. */
-  subscribe(onUpdate) {
-    const unsub = this.onUpdate(onUpdate);
-    onUpdate(this._state);
-    return unsub;
-  }
-  /**
-   * Exports the document state for persistence.
-   * NOTE: Any changes currently marked as `sending` are included in the
-   * `changes` array alongside `pending` changes. On import, all changes
-   * are treated as pending.
-   */
-  export() {
-    return structuredClone(this._snapshot);
-  }
-  /**
-   * Imports previously exported document state.
-   * Resets sending state and treats all imported changes as pending.
-   */
-  import(snapshot) {
-    this._snapshot = structuredClone(snapshot);
-    this._state = createStateFromSnapshot(snapshot);
-    this.onUpdate.emit(this._state);
-  }
-  /**
-   * Sets metadata to be added to future changes.
-   */
-  setChangeMetadata(metadata) {
-    this._changeMetadata = metadata;
-  }
-  /**
-   * Applies an update to the local state, generating a patch and adding it to pending changes.
-   * @param mutator Function that uses JSONPatch methods with type-safe paths.
-   * @returns The generated Change objects.
-   */
-  change(mutator) {
-    const changes = makeChange(
-      this._snapshot,
-      mutator,
-      this._changeMetadata,
-      this._maxStorageBytes,
-      this._sizeCalculator
-    );
-    if (changes.length === 0) {
-      return changes;
-    }
-    this._state = applyChanges(this._state, changes);
-    this._snapshot.changes.push(...changes);
-    this.onChange.emit(changes);
-    this.onUpdate.emit(this._state);
-    return changes;
-  }
-  /**
-   * Returns the pending changes for this document.
-   * @returns The pending changes.
-   */
-  getPendingChanges() {
-    return this._snapshot.changes;
-  }
-  /**
-   * Applies committed changes to the document. Should only be called from a sync provider.
-   * @param serverChanges The changes to apply.
-   * @param rebasedPendingChanges The rebased pending changes to apply.
-   */
-  applyCommittedChanges(serverChanges, rebasedPendingChanges) {
-    if (this._snapshot.rev !== serverChanges[0].rev - 1) {
-      throw new Error("Cannot apply committed changes to a doc that is not at the correct revision");
-    }
-    this._snapshot.state = applyChanges(this._snapshot.state, serverChanges);
-    this._snapshot.rev = serverChanges[serverChanges.length - 1].rev;
-    this._snapshot.changes = rebasedPendingChanges;
-    this._state = createStateFromSnapshot(this._snapshot);
-    this.onUpdate.emit(this._state);
-  }
-  /**
-   * Assigns an identifier to this document. Can only be set once.
-   * @param id The unique identifier for the document.
-   * @throws Error if the ID has already been set.
-   */
-  setId(id) {
-    if (this._id !== null && this._id !== id) {
-      throw new Error(`Document ID cannot be changed once set. Current: ${this._id}, Attempted: ${id}`);
-    }
-    if (this._id === null) {
-      this._id = id;
-    }
-  }
-  /**
-   * Updates the syncing state of the document.
-   * @param newSyncing The new syncing state.
-   */
-  updateSyncing(newSyncing) {
-    this._syncing = newSyncing;
-    this.onSyncing.emit(newSyncing);
-  }
-  toJSON() {
-    return this.export();
-  }
-}
+import { OTDoc, OTDoc as OTDoc2 } from "./OTDoc.js";
 export {
-  PatchesDoc
+  OTDoc,
+  OTDoc2 as PatchesDocClass
 };

package/dist/client/PatchesStore.d.ts

@@ -1,4 +1,4 @@
-import { PatchesSnapshot, Change, PatchesState } from '../types.js';
+import { PatchesSnapshot, PatchesState } from '../types.js';
 import '../json-patch/JSONPatch.js';
 import '@dabble/delta';
 import '../json-patch/types.js';
@@ -10,8 +10,6 @@ interface TrackedDoc {
     committedRev: number;
     /** Optional flag indicating the document has been locally deleted. */
     deleted?: true;
-    /** The last revision that was attempted to be submitted to the server. */
-    lastAttemptedSubmissionRev?: number;
 }
 /**
  * Pluggable persistence layer contract used by Patches + PatchesSync.
@@ -81,36 +79,18 @@ interface PatchesStore {
      */
     getDoc(docId: string): Promise<PatchesSnapshot | undefined>;
     /**
-     * Retrieves all pending (unconfirmed) changes for a document.
+     * Returns the last committed revision 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.
+     * The committed revision is the last revision confirmed by the server.
+     * Used during sync to fetch changes since this revision.
      *
      * @param docId Document identifier
-     * @returns Array of pending changes in chronological order
+     * @returns The last committed revision, or 0 if not found
      * @example
-     * const pendingChanges = await store.getPendingChanges('my-document');
-     * console.log(`${pendingChanges.length} changes waiting for server confirmation`);
+     * const committedRev = await store.getCommittedRev('my-document');
+     * const serverChanges = await api.getChangesSince(docId, committedRev);
      */
-    getPendingChanges(docId: string): Promise<Change[]>;
-    /**
-     * Returns revision counters for tracking document sync state.
-     *
-     * committedRev: Last revision confirmed by the server
-     * pendingRev: Next revision number for new local changes
-     * The gap between these indicates how many changes are pending server confirmation.
-     *
-     * @param docId Document identifier
-     * @returns Tuple of [committedRev, pendingRev]
-     * @example
-     * const [committed, pending] = await store.getLastRevs('my-document');
-     * console.log(`Server confirmed through rev ${committed}, local changes at rev ${pending}`);
-     * if (pending > committed) {
-     *   console.log(`${pending - committed} changes pending server confirmation`);
-     * }
-     */
-    getLastRevs(docId: string): Promise<[committedRev: number, pendingRev: number]>;
+    getCommittedRev(docId: string): Promise<number>;
     /**
      * Saves the current document state to persistent storage.
      *
@@ -129,54 +109,6 @@ interface PatchesStore {
      * });
      */
     saveDoc(docId: string, docState: PatchesState): Promise<void>;
-    /**
-     * 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
-     * @example
-     * // User made a local edit
-     * const newChange = { rev: 15, patches: [...], clientId: 'client-123' };
-     * await store.savePendingChanges('my-document', [newChange]);
-     */
-    savePendingChanges(docId: string, changes: Change[]): Promise<void>;
-    /**
-     * Records changes confirmed by the server and optionally removes sent pending changes.
-     *
-     * Adds server-confirmed changes to the document's history and updates the committed revision.
-     * If sentPendingRange is provided, removes the specified range of pending changes that
-     * were confirmed by the server (they're no longer pending).
-     *
-     * @param docId Document identifier
-     * @param changes Server-confirmed changes to record
-     * @param sentPendingRange Optional range [startRev, endRev] of pending changes to remove
-     * @example
-     * // Server confirmed our changes
-     * await store.saveCommittedChanges('my-document', serverChanges, [10, 12]);
-     *
-     * // Server sent changes from other clients
-     * await store.saveCommittedChanges('my-document', serverChanges);
-     */
-    saveCommittedChanges(docId: string, changes: Change[], sentPendingRange?: [number, number]): Promise<void>;
-    /**
-     * Completely replaces the document's pending changes with a new set.
-     *
-     * Discards all existing pending changes and replaces them with the provided array.
-     * Used when operational transformation rebases pending changes after receiving server updates.
-     * The new changes should have sequential revision numbers.
-     *
-     * @param docId Document identifier
-     * @param changes New complete set of pending changes
-     * @example
-     * // After rebasing pending changes due to server conflicts
-     * const rebasedChanges = transformPendingChanges(serverChanges, currentPending);
-     * await store.replacePendingChanges('my-document', rebasedChanges);
-     */
-    replacePendingChanges(docId: string, changes: Change[]): Promise<void>;
     /**
      * Marks a document for collaborative deletion.
      *
@@ -219,35 +151,6 @@ interface PatchesStore {
      * // Store is no longer usable
      */
     close(): Promise<void>;
-    /**
-     * Gets the last revision that was attempted to be submitted to the server.
-     *
-     * This bookmark is used by change collapsing to avoid modifying changes that
-     * may have been partially committed by the server. Returns undefined if no
-     * submission has been attempted yet.
-     *
-     * @param docId Document identifier
-     * @returns The last attempted submission revision, or undefined if none
-     * @example
-     * const lastAttempted = await store.getLastAttemptedSubmissionRev('my-document');
-     * // Use this to protect changes from collapsing
-     */
-    getLastAttemptedSubmissionRev?(docId: string): Promise<number | undefined>;
-    /**
-     * Sets the last revision that was attempted to be submitted to the server.
-     *
-     * Called before sending changes to the server to mark them as "in flight".
-     * This prevents change collapsing from modifying these changes in case the
-     * server commits them but the client doesn't receive confirmation.
-     *
-     * @param docId Document identifier
-     * @param rev The revision being submitted
-     * @example
-     * // Before sending batch to server
-     * await store.setLastAttemptedSubmissionRev('my-document', lastChange.rev);
-     * await sendToServer(batch);
-     */
-    setLastAttemptedSubmissionRev?(docId: string, rev: number): Promise<void>;
 }
 
 export type { PatchesStore, TrackedDoc };

package/dist/client/factories.d.ts

@@ -0,0 +1,72 @@
+import { AlgorithmName } from './ClientAlgorithm.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 '../event-signal.js';
+
+/**
+ * Options for factory functions that create Patches instances.
+ */
+interface PatchesFactoryOptions {
+    /** Initial metadata to attach to changes from this client. */
+    metadata?: Record<string, any>;
+    /** Document-level options to pass to each PatchesDoc instance. */
+    docOptions?: PatchesDocOptions;
+}
+/**
+ * Options for factory functions with multiple algorithms.
+ */
+interface MultiAlgorithmFactoryOptions extends PatchesFactoryOptions {
+    /** Default algorithm to use when opening docs. */
+    defaultAlgorithm?: AlgorithmName;
+}
+/**
+ * Options for IndexedDB-based factory functions.
+ */
+interface IndexedDBFactoryOptions extends PatchesFactoryOptions {
+    /** Database name for IndexedDB storage. */
+    dbName: string;
+}
+/**
+ * Options for IndexedDB-based factory functions with multiple algorithms.
+ */
+interface MultiAlgorithmIndexedDBFactoryOptions extends MultiAlgorithmFactoryOptions {
+    /** Database name for IndexedDB storage. */
+    dbName: string;
+}
+/**
+ * Creates a Patches instance with OT algorithm and in-memory store.
+ * Useful for testing or when persistence isn't needed.
+ */
+declare function createOTPatches(options?: PatchesFactoryOptions): Patches;
+/**
+ * Creates a Patches instance with OT algorithm and IndexedDB store.
+ * For persistent storage in browser environments.
+ */
+declare function createOTIndexedDBPatches(options: IndexedDBFactoryOptions): Patches;
+/**
+ * Creates a Patches instance with LWW algorithm and in-memory store.
+ * Useful for testing or when persistence isn't needed.
+ */
+declare function createLWWPatches(options?: PatchesFactoryOptions): Patches;
+/**
+ * Creates a Patches instance with LWW algorithm and IndexedDB store.
+ * For persistent storage in browser environments.
+ */
+declare function createLWWIndexedDBPatches(options: IndexedDBFactoryOptions): Patches;
+/**
+ * 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;
+/**
+ * Creates a Patches instance with both OT and LWW algorithms using IndexedDB stores.
+ * For persistent storage in browser environments with support for both algorithms.
+ */
+declare function createAllIndexedDBPatches(options: MultiAlgorithmIndexedDBFactoryOptions): Patches;
+
+export { type IndexedDBFactoryOptions, type MultiAlgorithmFactoryOptions, type MultiAlgorithmIndexedDBFactoryOptions, type PatchesFactoryOptions, createAllIndexedDBPatches, createAllPatches, createLWWIndexedDBPatches, createLWWPatches, createOTIndexedDBPatches, createOTPatches };