@dabble/patches 0.6.0 → 0.7.0

package/dist/client/LWWInMemoryStore.d.ts

@@ -0,0 +1,88 @@
+import { JSONPatchOp } from '../json-patch/types.js';
+import { PatchesSnapshot, PatchesState, Change } from '../types.js';
+import { LWWClientStore } from './LWWClientStore.js';
+import { TrackedDoc } from './PatchesStore.js';
+import '../json-patch/JSONPatch.js';
+import '@dabble/delta';
+
+/**
+ * In-memory implementation of LWWClientStore for LWW (Last-Write-Wins) sync algorithm.
+ *
+ * Uses field-level storage for LWW conflict resolution:
+ * - committedFields: Server-confirmed field values
+ * - pendingOps: Local changes waiting to be sent (keyed by path)
+ * - sendingChange: In-flight change being sent to server
+ *
+ * Useful for unit tests or when you want stateless realtime behavior with LWW semantics.
+ */
+declare class LWWInMemoryStore implements LWWClientStore {
+    private docs;
+    /**
+     * Rebuilds a document state from snapshot + committed fields + sending + pending.
+     */
+    getDoc(docId: string): Promise<PatchesSnapshot | undefined>;
+    /**
+     * Returns the last committed revision for a document.
+     */
+    getCommittedRev(docId: string): Promise<number>;
+    /**
+     * List all documents in the store.
+     */
+    listDocs(includeDeleted?: boolean): Promise<TrackedDoc[]>;
+    /**
+     * Saves the current document state to storage.
+     * Clears all committed fields, pending ops, and sending change.
+     */
+    saveDoc(docId: string, docState: PatchesState): Promise<void>;
+    /**
+     * Track documents.
+     */
+    trackDocs(docIds: string[]): Promise<void>;
+    /**
+     * Untrack documents by removing all their data.
+     */
+    untrackDocs(docIds: string[]): Promise<void>;
+    /**
+     * Marks a document as deleted and clears all associated data.
+     */
+    deleteDoc(docId: string): Promise<void>;
+    /**
+     * Confirm the deletion of a document.
+     */
+    confirmDeleteDoc(docId: string): Promise<void>;
+    /**
+     * Closes the store and releases resources.
+     */
+    close(): Promise<void>;
+    /**
+     * Get pending ops, optionally filtered by path prefixes.
+     */
+    getPendingOps(docId: string, pathPrefixes?: string[]): Promise<JSONPatchOp[]>;
+    /**
+     * Save pending ops, optionally deleting paths.
+     */
+    savePendingOps(docId: string, ops: JSONPatchOp[], pathsToDelete?: string[]): Promise<void>;
+    /**
+     * Get the in-flight change for retry/reconnect scenarios.
+     */
+    getSendingChange(docId: string): Promise<Change | null>;
+    /**
+     * Atomically save sending change AND clear all pending ops.
+     */
+    saveSendingChange(docId: string, change: Change): Promise<void>;
+    /**
+     * Clear sendingChange after server ack, move ops to committed.
+     */
+    confirmSendingChange(docId: string): Promise<void>;
+    /**
+     * Apply server changes using LWW timestamp resolution.
+     */
+    applyServerChanges(docId: string, serverChanges: Change[]): Promise<void>;
+    private getOrCreateBuffer;
+    /**
+     * Converts pending ops to an array of Change objects.
+     */
+    private pendingOpsToChanges;
+}
+
+export { LWWInMemoryStore };

package/dist/client/LWWInMemoryStore.js

@@ -0,0 +1,208 @@
+import "../chunk-IZ2YBCUP.js";
+import { createChange } from "../data/change.js";
+import { applyPatch } from "../json-patch/applyPatch.js";
+class LWWInMemoryStore {
+  docs = /* @__PURE__ */ new Map();
+  // ─── Document Operations ─────────────────────────────────────────────────
+  /**
+   * Rebuilds a document state from snapshot + committed fields + sending + pending.
+   */
+  async getDoc(docId) {
+    const buf = this.docs.get(docId);
+    if (!buf || buf.deleted) return void 0;
+    let state = buf.snapshot?.state ? { ...buf.snapshot.state } : {};
+    const committedOps = Array.from(buf.committedFields.entries()).map(([path, value]) => ({
+      op: "replace",
+      path,
+      value
+    }));
+    if (committedOps.length > 0) {
+      state = applyPatch(state, committedOps, { partial: true });
+    }
+    if (buf.sendingChange?.ops?.length) {
+      state = applyPatch(state, buf.sendingChange.ops, { partial: true });
+    }
+    const pendingOps = Array.from(buf.pendingOps.values());
+    if (pendingOps.length > 0) {
+      state = applyPatch(state, pendingOps, { partial: true });
+    }
+    const pendingChanges = this.pendingOpsToChanges(buf.pendingOps, buf.committedRev);
+    return {
+      state,
+      rev: buf.committedRev,
+      changes: buf.sendingChange ? [buf.sendingChange, ...pendingChanges] : pendingChanges
+    };
+  }
+  /**
+   * Returns the last committed revision for a document.
+   */
+  async getCommittedRev(docId) {
+    return this.docs.get(docId)?.committedRev ?? 0;
+  }
+  /**
+   * List all documents in the store.
+   */
+  async listDocs(includeDeleted = false) {
+    return Array.from(this.docs.entries()).filter(([, buf]) => includeDeleted || !buf.deleted).map(([docId, buf]) => ({
+      docId,
+      committedRev: buf.committedRev,
+      deleted: buf.deleted
+    }));
+  }
+  /**
+   * Saves the current document state to storage.
+   * Clears all committed fields, pending ops, and sending change.
+   */
+  async saveDoc(docId, docState) {
+    this.docs.set(docId, {
+      snapshot: { state: docState.state, rev: docState.rev },
+      committedFields: /* @__PURE__ */ new Map(),
+      pendingOps: /* @__PURE__ */ new Map(),
+      sendingChange: null,
+      committedRev: docState.rev
+    });
+  }
+  // ─── Tracking ────────────────────────────────────────────────────────────
+  /**
+   * Track documents.
+   */
+  async trackDocs(docIds) {
+    for (const docId of docIds) {
+      const buf = this.getOrCreateBuffer(docId);
+      delete buf.deleted;
+    }
+  }
+  /**
+   * Untrack documents by removing all their data.
+   */
+  async untrackDocs(docIds) {
+    for (const docId of docIds) {
+      this.docs.delete(docId);
+    }
+  }
+  // ─── Deletion ────────────────────────────────────────────────────────────
+  /**
+   * Marks a document as deleted and clears all associated data.
+   */
+  async deleteDoc(docId) {
+    const buf = this.getOrCreateBuffer(docId);
+    buf.deleted = true;
+    buf.snapshot = void 0;
+    buf.committedFields.clear();
+    buf.pendingOps.clear();
+    buf.sendingChange = null;
+  }
+  /**
+   * Confirm the deletion of a document.
+   */
+  async confirmDeleteDoc(docId) {
+    this.docs.delete(docId);
+  }
+  /**
+   * Closes the store and releases resources.
+   */
+  async close() {
+    this.docs.clear();
+  }
+  // ─── LWWClientStore Methods ─────────────────────────────────────────────
+  /**
+   * Get pending ops, optionally filtered by path prefixes.
+   */
+  async getPendingOps(docId, pathPrefixes) {
+    const buf = this.docs.get(docId);
+    if (!buf) return [];
+    const ops = Array.from(buf.pendingOps.values());
+    if (!pathPrefixes || pathPrefixes.length === 0) {
+      return ops;
+    }
+    return ops.filter((op) => pathPrefixes.some((prefix) => op.path === prefix || op.path.startsWith(prefix + "/")));
+  }
+  /**
+   * Save pending ops, optionally deleting paths.
+   */
+  async savePendingOps(docId, ops, pathsToDelete) {
+    const buf = this.getOrCreateBuffer(docId);
+    if (buf.deleted) {
+      delete buf.deleted;
+    }
+    if (pathsToDelete) {
+      for (const path of pathsToDelete) {
+        buf.pendingOps.delete(path);
+      }
+    }
+    for (const op of ops) {
+      buf.pendingOps.set(op.path, op);
+    }
+  }
+  /**
+   * Get the in-flight change for retry/reconnect scenarios.
+   */
+  async getSendingChange(docId) {
+    return this.docs.get(docId)?.sendingChange ?? null;
+  }
+  /**
+   * Atomically save sending change AND clear all pending ops.
+   */
+  async saveSendingChange(docId, change) {
+    const buf = this.docs.get(docId);
+    if (!buf) return;
+    buf.sendingChange = change;
+    buf.pendingOps.clear();
+  }
+  /**
+   * Clear sendingChange after server ack, move ops to committed.
+   */
+  async confirmSendingChange(docId) {
+    const buf = this.docs.get(docId);
+    if (!buf?.sendingChange) return;
+    for (const op of buf.sendingChange.ops) {
+      buf.committedFields.set(op.path, op.value);
+    }
+    if (buf.sendingChange.rev > buf.committedRev) {
+      buf.committedRev = buf.sendingChange.rev;
+    }
+    buf.sendingChange = null;
+  }
+  /**
+   * Apply server changes using LWW timestamp resolution.
+   */
+  async applyServerChanges(docId, serverChanges) {
+    const buf = this.getOrCreateBuffer(docId);
+    for (const change of serverChanges) {
+      for (const op of change.ops) {
+        buf.committedFields.set(op.path, op.value);
+      }
+    }
+    const lastRev = serverChanges.at(-1)?.rev;
+    if (lastRev !== void 0 && lastRev > buf.committedRev) {
+      buf.committedRev = lastRev;
+    }
+  }
+  // ─── Helper Methods ──────────────────────────────────────────────────────
+  getOrCreateBuffer(docId) {
+    let buf = this.docs.get(docId);
+    if (!buf) {
+      buf = {
+        committedFields: /* @__PURE__ */ new Map(),
+        pendingOps: /* @__PURE__ */ new Map(),
+        sendingChange: null,
+        committedRev: 0
+      };
+      this.docs.set(docId, buf);
+    }
+    return buf;
+  }
+  /**
+   * Converts pending ops to an array of Change objects.
+   */
+  pendingOpsToChanges(ops, baseRev) {
+    if (ops.size === 0) {
+      return [];
+    }
+    const opsArray = Array.from(ops.values());
+    return [createChange(baseRev, baseRev + 1, opsArray)];
+  }
+}
+export {
+  LWWInMemoryStore
+};

package/dist/client/LWWIndexedDBStore.d.ts

@@ -0,0 +1,91 @@
+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 '../json-patch/JSONPatch.js';
+import '@dabble/delta';
+import '../utils/deferred.js';
+import './PatchesStore.js';
+
+/**
+ * IndexedDB store implementation for Last-Writer-Wins (LWW) sync strategy.
+ *
+ * Creates stores:
+ * - docs<{ docId: string; committedRev: number; deleted?: boolean }> (primary key: docId) [shared with OT]
+ * - snapshots<{ docId: string; rev: number; state: any }> (primary key: docId) [shared with OT]
+ * - committedOps<{ docId: string; op: string; path: string; from?: string; value?: any }> (primary key: [docId, path])
+ * - pendingOps<{ docId: string; path: string; op: string; ts: number; value: any }> (primary key: [docId, path])
+ * - sendingChanges<{ docId: string; change: Change }> (primary key: docId)
+ *
+ * This store manages field-level operations for LWW conflict resolution:
+ * - Committed ops represent confirmed server state
+ * - Pending ops are local changes waiting to be sent
+ * - Sending changes are in-flight operations
+ *
+ * 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;
+    /**
+     * Rebuilds a document state from snapshot + committed ops + sending + pending.
+     *
+     * 1. Load the snapshot (base state + rev)
+     * 2. Apply all committedOps for docId
+     * 3. Check sendingChanges - if exists, apply its ops
+     * 4. Apply all pendingOps
+     * 5. Return reconstructed state
+     */
+    getDoc(docId: string): Promise<PatchesSnapshot | undefined>;
+    /**
+     * Saves the current document state to storage.
+     * Clears all committed fields and pending ops.
+     */
+    saveDoc(docId: string, docState: PatchesState): Promise<void>;
+    /**
+     * Marks a document as deleted and clears all associated data.
+     */
+    deleteDoc(docId: string): Promise<void>;
+    /**
+     * Untracks documents by removing all their data.
+     */
+    untrackDocs(docIds: string[]): Promise<void>;
+    /**
+     * Get pending ops, optionally filtered by path prefixes.
+     */
+    getPendingOps(docId: string, pathPrefixes?: string[]): Promise<JSONPatchOp[]>;
+    /**
+     * Save pending ops, optionally deleting paths.
+     */
+    savePendingOps(docId: string, ops: JSONPatchOp[], pathsToDelete?: string[]): Promise<void>;
+    /**
+     * Get the in-flight change for retry/reconnect scenarios.
+     */
+    getSendingChange(docId: string): Promise<Change | null>;
+    /**
+     * Atomically save sending change AND clear all pending ops.
+     */
+    saveSendingChange(docId: string, change: Change): Promise<void>;
+    /**
+     * Clear sendingChange after server ack, move ops to committed.
+     */
+    confirmSendingChange(docId: string): Promise<void>;
+    /**
+     * Apply server changes using LWW timestamp resolution.
+     */
+    applyServerChanges(docId: string, serverChanges: Change[]): Promise<void>;
+    /**
+     * Converts pending ops to an array of Change objects.
+     */
+    private pendingOpsToChanges;
+    /**
+     * Deletes all entries for a document from a store.
+     */
+    private deleteFieldsForDoc;
+    /**
+     * Compacts committed ops into the snapshot.
+     */
+    private compactSnapshot;
+}
+
+export { LWWIndexedDBStore };

package/dist/client/LWWIndexedDBStore.js

@@ -0,0 +1,275 @@
+import {
+  __decorateElement,
+  __decoratorMetadata,
+  __decoratorStart,
+  __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;
+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);
+    __runInitializers(_init, 5, this);
+  }
+  getDBVersion() {
+    return DB_VERSION;
+  }
+  onUpgrade(db, _oldVersion) {
+    if (!db.objectStoreNames.contains("committedOps")) {
+      db.createObjectStore("committedOps", { keyPath: ["docId", "path"] });
+    }
+    if (!db.objectStoreNames.contains("pendingOps")) {
+      db.createObjectStore("pendingOps", { keyPath: ["docId", "path"] });
+    }
+    if (!db.objectStoreNames.contains("sendingChanges")) {
+      db.createObjectStore("sendingChanges", { keyPath: "docId" });
+    }
+  }
+  async getDoc(docId) {
+    const [tx, docsStore, snapshots, committedOps, pendingOps, sendingChanges] = await this.transaction(
+      ["docs", "snapshots", "committedOps", "pendingOps", "sendingChanges"],
+      "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 committedOps.getAll([docId, ""], [docId, "\uFFFF"]);
+    const sending = await sendingChanges.get(docId);
+    const pending = await pendingOps.getAll([docId, ""], [docId, "\uFFFF"]);
+    if (!snapshot && !committed.length && !pending.length && !sending) {
+      await tx.complete();
+      return void 0;
+    }
+    let state = snapshot?.state ? { ...snapshot.state } : {};
+    if (committed.length > 0) {
+      const ops = committed.map(({ docId: _docId, ...op }) => op);
+      state = applyPatch(state, ops, { partial: true });
+    }
+    if (sending?.change?.ops?.length) {
+      state = applyPatch(state, sending.change.ops, { partial: true });
+    }
+    if (pending.length > 0) {
+      const pendingOps2 = pending.map((op) => ({
+        op: op.op,
+        path: op.path,
+        value: op.value,
+        ts: op.ts
+      }));
+      state = applyPatch(state, pendingOps2, { partial: true });
+    }
+    const pendingChanges = this.pendingOpsToChanges(docId, pending, snapshot?.rev ?? 0);
+    await tx.complete();
+    return {
+      state,
+      rev: docMeta?.committedRev ?? snapshot?.rev ?? 0,
+      changes: sending?.change ? [sending.change, ...pendingChanges] : pendingChanges
+    };
+  }
+  async saveDoc(docId, docState) {
+    const [tx, snapshots, committedOps, pendingOps, sendingChanges, docsStore] = await this.transaction(
+      ["snapshots", "committedOps", "pendingOps", "sendingChanges", "docs"],
+      "readwrite"
+    );
+    const { rev, state } = docState;
+    await Promise.all([
+      docsStore.put({ docId, committedRev: rev }),
+      snapshots.put({ docId, state, rev }),
+      this.deleteFieldsForDoc(committedOps, docId),
+      this.deleteFieldsForDoc(pendingOps, docId),
+      sendingChanges.delete(docId)
+    ]);
+    await tx.complete();
+  }
+  async deleteDoc(docId) {
+    const [tx, snapshots, committedOps, pendingOps, sendingChanges, docsStore] = await this.transaction(
+      ["snapshots", "committedOps", "pendingOps", "sendingChanges", "docs"],
+      "readwrite"
+    );
+    const docMeta = await docsStore.get(docId) ?? { docId, committedRev: 0 };
+    await docsStore.put({ ...docMeta, deleted: true });
+    await Promise.all([
+      snapshots.delete(docId),
+      this.deleteFieldsForDoc(committedOps, docId),
+      this.deleteFieldsForDoc(pendingOps, docId),
+      sendingChanges.delete(docId)
+    ]);
+    await tx.complete();
+  }
+  /**
+   * Untracks documents by removing all their data.
+   */
+  async untrackDocs(docIds) {
+    const [tx, docsStore, snapshots, committedOps, pendingOps, sendingChanges] = await this.transaction(
+      ["docs", "snapshots", "committedOps", "pendingOps", "sendingChanges"],
+      "readwrite"
+    );
+    await Promise.all(
+      docIds.map(
+        (docId) => Promise.all([
+          docsStore.delete(docId),
+          snapshots.delete(docId),
+          this.deleteFieldsForDoc(committedOps, docId),
+          this.deleteFieldsForDoc(pendingOps, docId),
+          sendingChanges.delete(docId)
+        ])
+      )
+    );
+    await tx.complete();
+  }
+  async getPendingOps(docId, pathPrefixes) {
+    const [tx, pendingOpsStore] = await this.transaction(["pendingOps"], "readonly");
+    let pending;
+    if (!pathPrefixes || pathPrefixes.length === 0) {
+      pending = await pendingOpsStore.getAll([docId, ""], [docId, "\uFFFF"]);
+    } else {
+      const allPending = await pendingOpsStore.getAll([docId, ""], [docId, "\uFFFF"]);
+      pending = allPending.filter(
+        (op) => pathPrefixes.some((prefix) => op.path === prefix || op.path.startsWith(prefix + "/"))
+      );
+    }
+    await tx.complete();
+    return pending.map((op) => ({
+      op: op.op,
+      path: op.path,
+      value: op.value,
+      ts: op.ts
+    }));
+  }
+  async savePendingOps(docId, ops, pathsToDelete) {
+    const [tx, pendingOpsStore, docsStore] = await this.transaction(["pendingOps", "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);
+    }
+    if (pathsToDelete) {
+      await Promise.all(pathsToDelete.map((path) => pendingOpsStore.delete([docId, path])));
+    }
+    await Promise.all(
+      ops.map(
+        (op) => pendingOpsStore.put({
+          docId,
+          path: op.path,
+          op: op.op,
+          ts: op.ts ?? Date.now(),
+          value: op.value
+        })
+      )
+    );
+    await tx.complete();
+  }
+  async getSendingChange(docId) {
+    const [tx, sendingChanges] = await this.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");
+    await sendingChanges.put({ docId, change });
+    await this.deleteFieldsForDoc(pendingOpsStore, docId);
+    await tx.complete();
+  }
+  async confirmSendingChange(docId) {
+    const [tx, sendingChanges, committedOps, docsStore] = await this.transaction(
+      ["sendingChanges", "committedOps", "docs"],
+      "readwrite"
+    );
+    const sending = await sendingChanges.get(docId);
+    if (!sending) {
+      await tx.complete();
+      return;
+    }
+    await Promise.all(sending.change.ops.map((op) => committedOps.put({ ...op, docId })));
+    const docMeta = await docsStore.get(docId) ?? { docId, committedRev: 0 };
+    if (sending.change.rev > docMeta.committedRev) {
+      await docsStore.put({ ...docMeta, committedRev: sending.change.rev });
+    }
+    await sendingChanges.delete(docId);
+    await tx.complete();
+  }
+  async applyServerChanges(docId, serverChanges) {
+    const [tx, committedOps, snapshots, docsStore] = await this.transaction(
+      ["committedOps", "snapshots", "docs"],
+      "readwrite"
+    );
+    const allOps = serverChanges.flatMap((change) => change.ops);
+    await Promise.all(allOps.map((op) => committedOps.put({ ...op, docId })));
+    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 });
+      }
+    }
+    const fieldCount = await committedOps.count([docId, ""], [docId, "\uFFFF"]);
+    if (fieldCount >= SNAPSHOT_INTERVAL) {
+      await this.compactSnapshot(docId, snapshots, committedOps, docsStore);
+    }
+    await tx.complete();
+  }
+  // ─── Helper Methods ──────────────────────────────────────────────────────
+  /**
+   * Converts pending ops to an array of Change objects.
+   */
+  pendingOpsToChanges(_docId, ops, baseRev) {
+    if (ops.length === 0) {
+      return [];
+    }
+    const opsArray = ops.map((op) => ({
+      op: op.op,
+      path: op.path,
+      value: op.value,
+      ts: op.ts
+    }));
+    return [createChange(baseRev, baseRev + 1, opsArray)];
+  }
+  /**
+   * Deletes all entries for a document from a store.
+   */
+  async deleteFieldsForDoc(store, docId) {
+    const entries = await store.getAll([docId, ""], [docId, "\uFFFF"]);
+    await Promise.all(entries.map((e) => store.delete([e.docId, e.path])));
+  }
+  /**
+   * Compacts committed ops into the snapshot.
+   */
+  async compactSnapshot(docId, snapshots, committedOps, docsStore) {
+    const snapshot = await snapshots.get(docId);
+    const committed = await committedOps.getAll([docId, ""], [docId, "\uFFFF"]);
+    if (committed.length === 0) {
+      return;
+    }
+    let state = snapshot?.state ? { ...snapshot.state } : {};
+    state = applyPatch(state, committed, { partial: true });
+    const docMeta = await docsStore.get(docId);
+    const rev = docMeta?.committedRev ?? snapshot?.rev ?? 0;
+    await snapshots.put({ docId, state, rev });
+    await this.deleteFieldsForDoc(committedOps, docId);
+  }
+}
+_init = __decoratorStart(_a);
+__decorateElement(_init, 1, "getDoc", _getDoc_dec, LWWIndexedDBStore);
+__decorateElement(_init, 1, "saveDoc", _saveDoc_dec, LWWIndexedDBStore);
+__decorateElement(_init, 1, "deleteDoc", _deleteDoc_dec, LWWIndexedDBStore);
+__decorateElement(_init, 1, "getPendingOps", _getPendingOps_dec, LWWIndexedDBStore);
+__decorateElement(_init, 1, "savePendingOps", _savePendingOps_dec, LWWIndexedDBStore);
+__decorateElement(_init, 1, "getSendingChange", _getSendingChange_dec, LWWIndexedDBStore);
+__decorateElement(_init, 1, "saveSendingChange", _saveSendingChange_dec, LWWIndexedDBStore);
+__decorateElement(_init, 1, "confirmSendingChange", _confirmSendingChange_dec, LWWIndexedDBStore);
+__decorateElement(_init, 1, "applyServerChanges", _applyServerChanges_dec, LWWIndexedDBStore);
+__decoratorMetadata(_init, LWWIndexedDBStore);
+export {
+  LWWIndexedDBStore
+};