@dabble/patches 0.6.0 → 0.7.1

package/dist/client/IndexedDBStore.js

@@ -1,24 +1,10 @@
-import {
-  __decorateElement,
-  __decoratorMetadata,
-  __decoratorStart,
-  __publicField,
-  __runInitializers
-} from "../chunk-IZ2YBCUP.js";
-var _getLastRevs_dec, _saveCommittedChanges_dec, _replacePendingChanges_dec, _getPendingChanges_dec, _savePendingChanges_dec, _saveDoc_dec, _confirmDeleteDoc_dec, _deleteDoc_dec, _getDoc_dec, _init;
-import { applyChanges } from "../algorithms/shared/applyChanges.js";
-import { transformPatch } from "../json-patch/transformPatch.js";
-import { blockable } from "../utils/concurrency.js";
+import "../chunk-IZ2YBCUP.js";
 import { deferred } from "../utils/deferred.js";
-const DB_VERSION = 1;
-const SNAPSHOT_INTERVAL = 200;
-_getDoc_dec = [blockable], _deleteDoc_dec = [blockable], _confirmDeleteDoc_dec = [blockable], _saveDoc_dec = [blockable], _savePendingChanges_dec = [blockable], _getPendingChanges_dec = [blockable], _replacePendingChanges_dec = [blockable], _saveCommittedChanges_dec = [blockable], _getLastRevs_dec = [blockable];
 class IndexedDBStore {
+  db = null;
+  dbName;
+  dbPromise;
   constructor(dbName) {
-    __runInitializers(_init, 5, this);
-    __publicField(this, "db", null);
-    __publicField(this, "dbName");
-    __publicField(this, "dbPromise");
     this.dbName = dbName;
     this.dbPromise = deferred();
     if (this.dbName) {
@@ -27,7 +13,7 @@ class IndexedDBStore {
   }
   async initDB() {
     if (!this.dbName) return;
-    const request = indexedDB.open(this.dbName, DB_VERSION);
+    const request = indexedDB.open(this.dbName, this.getDBVersion());
     request.onerror = () => this.dbPromise.reject(request.error);
     request.onsuccess = () => {
       this.db = request.result;
@@ -35,18 +21,14 @@ class IndexedDBStore {
     };
     request.onupgradeneeded = (event) => {
       const db = event.target.result;
+      const oldVersion = event.oldVersion;
       if (!db.objectStoreNames.contains("snapshots")) {
         db.createObjectStore("snapshots", { keyPath: "docId" });
       }
-      if (!db.objectStoreNames.contains("committedChanges")) {
-        db.createObjectStore("committedChanges", { keyPath: ["docId", "rev"] });
-      }
-      if (!db.objectStoreNames.contains("pendingChanges")) {
-        db.createObjectStore("pendingChanges", { keyPath: ["docId", "rev"] });
-      }
       if (!db.objectStoreNames.contains("docs")) {
         db.createObjectStore("docs", { keyPath: "docId" });
       }
+      this.onUpgrade(db, oldVersion);
     };
   }
   getDB() {
@@ -95,144 +77,15 @@ class IndexedDBStore {
     const stores = storeNames.map((name) => tx.getStore(name));
     return [tx, ...stores];
   }
-  async getDoc(docId) {
-    const [tx, docsStore, snapshots, committedChanges, pendingChanges] = await this.transaction(
-      ["docs", "snapshots", "committedChanges", "pendingChanges"],
-      "readonly"
-    );
-    const docMeta = await docsStore.get(docId);
-    if (docMeta?.deleted) {
-      await tx.complete();
-      return void 0;
-    }
-    const snapshot = await snapshots.get(docId);
-    const committed = await committedChanges.getAll([docId, snapshot?.rev ?? 0], [docId, Infinity]);
-    const pending = await pendingChanges.getAll([docId, 0], [docId, Infinity]);
-    if (!snapshot && !committed.length && !pending.length) return void 0;
-    const state = applyChanges(snapshot?.state, committed);
-    const lastCommitted = committed[committed.length - 1];
-    const baseRev = pending[0]?.baseRev;
-    if (lastCommitted && baseRev && baseRev < lastCommitted.rev) {
-      const patch = committed.filter((change) => change.rev > baseRev).map((change) => change.ops).flat();
-      const offset = lastCommitted.rev - baseRev;
-      pending.forEach((change) => {
-        change.rev += offset;
-        change.ops = transformPatch(state, patch, change.ops);
-      });
-    }
-    await tx.complete();
-    return {
-      state,
-      rev: committed[committed.length - 1]?.rev ?? snapshot?.rev ?? 0,
-      changes: pending
-    };
-  }
-  async deleteDoc(docId) {
-    const [tx, snapshots, committedChanges, pendingChanges, docsStore] = await this.transaction(
-      ["snapshots", "committedChanges", "pendingChanges", "docs"],
-      "readwrite"
-    );
-    const docMeta = await docsStore.get(docId) ?? { docId, committedRev: 0 };
-    await docsStore.put({ ...docMeta, deleted: true });
-    await Promise.all([
-      snapshots.delete(docId),
-      committedChanges.delete([docId, 0], [docId, Infinity]),
-      pendingChanges.delete([docId, 0], [docId, Infinity])
-    ]);
-    await tx.complete();
-  }
+  /**
+   * Confirm the deletion of a document.
+   * @param docId - The ID of the document to delete.
+   */
   async confirmDeleteDoc(docId) {
     const [tx, docsStore] = await this.transaction(["docs"], "readwrite");
     await docsStore.delete(docId);
     await tx.complete();
   }
-  async saveDoc(docId, docState) {
-    const [tx, snapshots, committedChanges, pendingChanges, docsStore] = await this.transaction(
-      ["snapshots", "committedChanges", "pendingChanges", "docs"],
-      "readwrite"
-    );
-    const { rev, state } = docState;
-    await Promise.all([
-      docsStore.put({ docId, committedRev: rev }),
-      snapshots.put({ docId, state, rev }),
-      committedChanges.delete([docId, 0], [docId, Infinity]),
-      pendingChanges.delete([docId, 0], [docId, Infinity])
-    ]);
-    await tx.complete();
-  }
-  async savePendingChanges(docId, changes) {
-    const [tx, pendingChanges, docsStore] = await this.transaction(["pendingChanges", "docs"], "readwrite");
-    let docMeta = await docsStore.get(docId);
-    if (!docMeta) {
-      docMeta = { docId, committedRev: 0 };
-      await docsStore.put(docMeta);
-    } else if (docMeta.deleted) {
-      delete docMeta.deleted;
-      await docsStore.put(docMeta);
-      console.warn(`Revived document ${docId} by saving pending changes.`);
-    }
-    await Promise.all(changes.map((change) => pendingChanges.put({ ...change, docId })));
-    await tx.complete();
-  }
-  async getPendingChanges(docId) {
-    const [tx, pendingChanges] = await this.transaction(["pendingChanges"], "readonly");
-    const result = await pendingChanges.getAll([docId, 0], [docId, Infinity]);
-    await tx.complete();
-    return result;
-  }
-  async replacePendingChanges(docId, changes) {
-    const [tx, pendingChanges, docsStore] = await this.transaction(["pendingChanges", "docs"], "readwrite");
-    let docMeta = await docsStore.get(docId);
-    if (!docMeta) {
-      docMeta = { docId, committedRev: 0 };
-      await docsStore.put(docMeta);
-    } else if (docMeta.deleted) {
-      delete docMeta.deleted;
-      await docsStore.put(docMeta);
-      console.warn(`Revived document ${docId} by replacing pending changes.`);
-    }
-    await pendingChanges.delete([docId, 0], [docId, Infinity]);
-    await Promise.all(changes.map((change) => pendingChanges.put({ ...change, docId })));
-    await tx.complete();
-  }
-  async saveCommittedChanges(docId, changes, sentPendingRange) {
-    const [tx, committedChanges, pendingChanges, snapshots, docsStore] = await this.transaction(
-      ["committedChanges", "pendingChanges", "snapshots", "docs"],
-      "readwrite"
-    );
-    await Promise.all(changes.map((change) => committedChanges.put({ ...change, docId })));
-    if (sentPendingRange) {
-      await pendingChanges.delete([docId, sentPendingRange[0]], [docId, sentPendingRange[1]]);
-    }
-    const count = await committedChanges.count([docId, 0], [docId, Infinity]);
-    if (count >= SNAPSHOT_INTERVAL) {
-      const [snapshot, committed, firstPending] = await Promise.all([
-        snapshots.get(docId),
-        committedChanges.getAll([docId, 0], [docId, Infinity], SNAPSHOT_INTERVAL),
-        pendingChanges.getFirstFromCursor([docId, 0], [docId, Infinity])
-      ]);
-      const lastRev = committed[committed.length - 1]?.rev;
-      if (!firstPending?.baseRev || firstPending?.baseRev >= lastRev) {
-        const state = applyChanges(snapshot?.state, committed);
-        await Promise.all([
-          snapshots.put({
-            docId,
-            rev: lastRev,
-            state
-          }),
-          committedChanges.delete([docId, 0], [docId, lastRev])
-        ]);
-      }
-    }
-    const lastCommittedRev = changes.at(-1)?.rev;
-    if (lastCommittedRev !== void 0) {
-      const docMeta = await docsStore.get(docId) ?? { docId, committedRev: 0 };
-      if (lastCommittedRev > docMeta.committedRev) {
-        await docsStore.put({ ...docMeta, committedRev: lastCommittedRev, deleted: void 0 });
-      }
-    }
-    await tx.complete();
-  }
   /**
    * List all documents in the store.
    * @param includeDeleted - Whether to include deleted documents.
@@ -265,75 +118,17 @@ class IndexedDBStore {
     await tx.complete();
   }
   /**
-   * Untrack a document.
-   * @param docIds - The IDs of the documents to untrack.
-   */
-  async untrackDocs(docIds) {
-    const [tx, docsStore, snapshots, committedChanges, pendingChanges] = await this.transaction(
-      ["docs", "snapshots", "committedChanges", "pendingChanges"],
-      "readwrite"
-    );
-    await Promise.all(
-      docIds.map((docId) => {
-        return Promise.all([
-          docsStore.delete(docId),
-          snapshots.delete(docId),
-          committedChanges.delete([docId, 0], [docId, Infinity]),
-          pendingChanges.delete([docId, 0], [docId, Infinity])
-        ]);
-      })
-    );
-    await tx.complete();
-  }
-  async getLastRevs(docId) {
-    const [tx, committedChanges, pendingChanges] = await this.transaction(
-      ["committedChanges", "pendingChanges"],
-      "readonly"
-    );
-    const [lastCommitted, lastPending] = await Promise.all([
-      committedChanges.getLastFromCursor([docId, 0], [docId, Infinity]),
-      pendingChanges.getLastFromCursor([docId, 0], [docId, Infinity])
-    ]);
-    await tx.complete();
-    return [lastCommitted?.rev ?? 0, lastPending?.rev ?? lastCommitted?.rev ?? 0];
-  }
-  // ─── Submission Bookmark ───────────────────────────────────────────────
-  /**
-   * Gets the last revision that was attempted to be submitted to the server.
+   * Returns the last committed revision for a document.
    * @param docId - The ID of the document.
-   * @returns The last attempted submission revision, or undefined if none.
+   * @returns The last committed revision, or 0 if not found.
    */
-  async getLastAttemptedSubmissionRev(docId) {
+  async getCommittedRev(docId) {
     const [tx, docsStore] = await this.transaction(["docs"], "readonly");
     const docMeta = await docsStore.get(docId);
     await tx.complete();
-    return docMeta?.lastAttemptedSubmissionRev;
-  }
-  /**
-   * Sets the last revision that was attempted to be submitted to the server.
-   * @param docId - The ID of the document.
-   * @param rev - The revision being submitted.
-   */
-  async setLastAttemptedSubmissionRev(docId, rev) {
-    const [tx, docsStore] = await this.transaction(["docs"], "readwrite");
-    const docMeta = await docsStore.get(docId);
-    if (docMeta) {
-      await docsStore.put({ ...docMeta, lastAttemptedSubmissionRev: rev });
-    }
-    await tx.complete();
+    return docMeta?.committedRev ?? 0;
   }
 }
-_init = __decoratorStart(null);
-__decorateElement(_init, 1, "getDoc", _getDoc_dec, IndexedDBStore);
-__decorateElement(_init, 1, "deleteDoc", _deleteDoc_dec, IndexedDBStore);
-__decorateElement(_init, 1, "confirmDeleteDoc", _confirmDeleteDoc_dec, IndexedDBStore);
-__decorateElement(_init, 1, "saveDoc", _saveDoc_dec, IndexedDBStore);
-__decorateElement(_init, 1, "savePendingChanges", _savePendingChanges_dec, IndexedDBStore);
-__decorateElement(_init, 1, "getPendingChanges", _getPendingChanges_dec, IndexedDBStore);
-__decorateElement(_init, 1, "replacePendingChanges", _replacePendingChanges_dec, IndexedDBStore);
-__decorateElement(_init, 1, "saveCommittedChanges", _saveCommittedChanges_dec, IndexedDBStore);
-__decorateElement(_init, 1, "getLastRevs", _getLastRevs_dec, IndexedDBStore);
-__decoratorMetadata(_init, IndexedDBStore);
 class IDBTransactionWrapper {
   tx;
   promise;
@@ -412,5 +207,7 @@ class IDBStoreWrapper {
   }
 }
 export {
+  IDBStoreWrapper,
+  IDBTransactionWrapper,
   IndexedDBStore
 };

package/dist/client/LWWAlgorithm.d.ts

@@ -0,0 +1,43 @@
+import { JSONPatchOp } from '../json-patch/types.js';
+import { PatchesSnapshot, Change } from '../types.js';
+import { ClientAlgorithm } from './ClientAlgorithm.js';
+import { LWWClientStore } from './LWWClientStore.js';
+import { a as PatchesDoc } from '../BaseDoc-DkP3tUhT.js';
+import { TrackedDoc } from './PatchesStore.js';
+import '../json-patch/JSONPatch.js';
+import '@dabble/delta';
+import '../event-signal.js';
+
+/**
+ * LWW (Last-Write-Wins) algorithm implementation.
+ *
+ * LWW uses timestamps for field-level conflict resolution.
+ * This algorithm owns an LWW-compatible store and handles all LWW-specific
+ * logic including consolidation of ops.
+ *
+ * Key differences from OT:
+ * - Single pending change at a time (not a list)
+ * - Field-level storage with timestamps
+ * - No rebasing - timestamps determine winner
+ * - Doc is very thin (just state, no committed/pending tracking)
+ */
+declare class LWWAlgorithm implements ClientAlgorithm {
+    readonly name = "lww";
+    readonly store: LWWClientStore;
+    constructor(store: LWWClientStore);
+    createDoc<T extends object>(docId: string, snapshot?: PatchesSnapshot<T>): PatchesDoc<T>;
+    loadDoc(docId: string): Promise<PatchesSnapshot | undefined>;
+    handleDocChange<T extends object>(docId: string, ops: JSONPatchOp[], doc: PatchesDoc<T> | undefined, metadata: Record<string, any>): Promise<Change[]>;
+    getPendingToSend(docId: string): Promise<Change[] | null>;
+    applyServerChanges<T extends object>(docId: string, serverChanges: Change[], doc: PatchesDoc<T> | undefined): Promise<Change[]>;
+    confirmSent(docId: string, _changes: Change[]): Promise<void>;
+    trackDocs(docIds: string[]): Promise<void>;
+    untrackDocs(docIds: string[]): Promise<void>;
+    listDocs(includeDeleted?: boolean): Promise<TrackedDoc[]>;
+    getCommittedRev(docId: string): Promise<number>;
+    deleteDoc(docId: string): Promise<void>;
+    confirmDeleteDoc(docId: string): Promise<void>;
+    close(): Promise<void>;
+}
+
+export { LWWAlgorithm };

package/dist/client/LWWAlgorithm.js

@@ -0,0 +1,87 @@
+import "../chunk-IZ2YBCUP.js";
+import { consolidateOps } from "../algorithms/lww/consolidateOps.js";
+import { mergeServerWithLocal } from "../algorithms/lww/mergeServerWithLocal.js";
+import { createChange } from "../data/change.js";
+import { LWWDoc } from "./LWWDoc.js";
+class LWWAlgorithm {
+  name = "lww";
+  store;
+  constructor(store) {
+    this.store = store;
+  }
+  createDoc(docId, snapshot) {
+    return new LWWDoc(docId, snapshot);
+  }
+  async loadDoc(docId) {
+    return this.store.getDoc(docId);
+  }
+  async handleDocChange(docId, ops, doc, metadata) {
+    if (ops.length === 0) return [];
+    const timestamp = Date.now();
+    const timedOps = ops.map((op) => ({ ...op, ts: timestamp }));
+    const pathPrefixes = timedOps.map((op) => op.path);
+    const existingOps = await this.store.getPendingOps(docId, pathPrefixes);
+    const { opsToSave, pathsToDelete } = consolidateOps(existingOps, timedOps);
+    await this.store.savePendingOps(docId, opsToSave, pathsToDelete);
+    const committedRev = doc?.committedRev ?? await this.store.getCommittedRev(docId);
+    const changes = [createChange(committedRev, committedRev + 1, timedOps, metadata)];
+    if (doc) {
+      doc.applyChanges(changes);
+    }
+    return changes;
+  }
+  async getPendingToSend(docId) {
+    const sendingChange = await this.store.getSendingChange(docId);
+    if (sendingChange) {
+      return [sendingChange];
+    }
+    const pendingOps = await this.store.getPendingOps(docId);
+    if (pendingOps.length === 0) {
+      return null;
+    }
+    const committedRev = await this.store.getCommittedRev(docId);
+    const change = createChange(committedRev, committedRev + 1, pendingOps);
+    await this.store.saveSendingChange(docId, change);
+    return [change];
+  }
+  async applyServerChanges(docId, serverChanges, doc) {
+    if (serverChanges.length === 0) return [];
+    await this.store.applyServerChanges(docId, serverChanges);
+    const sendingChange = await this.store.getSendingChange(docId);
+    const pendingOps = await this.store.getPendingOps(docId);
+    const localOps = [...sendingChange?.ops ?? [], ...pendingOps];
+    const mergedChanges = mergeServerWithLocal(serverChanges, localOps);
+    if (doc) {
+      doc.applyChanges(mergedChanges);
+    }
+    return mergedChanges;
+  }
+  async confirmSent(docId, _changes) {
+    await this.store.confirmSendingChange(docId);
+  }
+  // --- Store forwarding methods ---
+  async trackDocs(docIds) {
+    return this.store.trackDocs(docIds);
+  }
+  async untrackDocs(docIds) {
+    return this.store.untrackDocs(docIds);
+  }
+  async listDocs(includeDeleted) {
+    return this.store.listDocs(includeDeleted);
+  }
+  async getCommittedRev(docId) {
+    return this.store.getCommittedRev(docId);
+  }
+  async deleteDoc(docId) {
+    return this.store.deleteDoc(docId);
+  }
+  async confirmDeleteDoc(docId) {
+    return this.store.confirmDeleteDoc(docId);
+  }
+  async close() {
+    return this.store.close();
+  }
+}
+export {
+  LWWAlgorithm
+};

package/dist/client/LWWClientStore.d.ts

@@ -0,0 +1,73 @@
+import { JSONPatchOp } from '../json-patch/types.js';
+import { Change } from '../types.js';
+import { PatchesStore } from './PatchesStore.js';
+import '../json-patch/JSONPatch.js';
+import '@dabble/delta';
+
+/**
+ * LWW-specific client store interface.
+ * Extends PatchesStore with field-level operations and sending change lifecycle.
+ *
+ * State reconstruction in getDoc:
+ * snapshot -> apply committedFields -> apply sendingChange.ops -> apply pendingOps -> return {state, rev}
+ *
+ * Idempotency: sendingChange stays until acked. No cancel - just retry until success.
+ */
+interface LWWClientStore extends PatchesStore {
+    /**
+     * Get pending ops, optionally filtered by path prefixes for efficiency.
+     *
+     * When pathPrefixes is provided, returns all ops where the path starts with
+     * any of the given prefixes. For example, getPendingOps(docId, ['/user/name'])
+     * returns ops at '/user/name' or '/user/name/first', etc.
+     *
+     * @param docId Document identifier
+     * @param pathPrefixes Optional array of path prefixes to filter by
+     * @returns Array of pending JSONPatchOps
+     */
+    getPendingOps(docId: string, pathPrefixes?: string[]): Promise<JSONPatchOp[]>;
+    /**
+     * Save pending ops, optionally deleting paths.
+     *
+     * Used for consolidation when a parent path overwrites children. For example,
+     * when saving replace('/user/name', {first: 'Bob'}) we may need to delete
+     * the existing '/user/name/first' op.
+     *
+     * @param docId Document identifier
+     * @param ops Array of JSONPatchOps to save
+     * @param pathsToDelete Optional array of paths to delete (for consolidation)
+     */
+    savePendingOps(docId: string, ops: JSONPatchOp[], pathsToDelete?: string[]): Promise<void>;
+    /**
+     * Get the in-flight change for retry/reconnect scenarios.
+     *
+     * @param docId Document identifier
+     * @returns The sending change, or null if none
+     */
+    getSendingChange(docId: string): Promise<Change | null>;
+    /**
+     * Atomically save sending change AND clear all pending ops.
+     *
+     * This creates the in-flight change from pending ops. The pending ops
+     * are cleared because they are now encapsulated in the sending change.
+     *
+     * @param docId Document identifier
+     * @param change The change to save as sending
+     */
+    saveSendingChange(docId: string, change: Change): Promise<void>;
+    /**
+     * Clear sendingChange after server ack, move ops to committed.
+     *
+     * @param docId Document identifier
+     */
+    confirmSendingChange(docId: string): Promise<void>;
+    /**
+     * Apply server changes using LWW timestamp resolution.
+     *
+     * @param docId Document identifier
+     * @param serverChanges Changes from the server
+     */
+    applyServerChanges(docId: string, serverChanges: Change[]): Promise<void>;
+}
+
+export type { LWWClientStore };

package/dist/client/LWWDoc.d.ts

@@ -0,0 +1,56 @@
+import { PatchesSnapshot, Change } from '../types.js';
+import { B as BaseDoc } from '../BaseDoc-DkP3tUhT.js';
+import '../json-patch/JSONPatch.js';
+import '@dabble/delta';
+import '../json-patch/types.js';
+import '../event-signal.js';
+
+/**
+ * LWW (Last-Write-Wins) document implementation.
+ *
+ * The `change()` method (inherited from BaseDoc) captures ops and emits them
+ * via `onChange` - it does NOT apply locally. The LWWStrategy handles:
+ * - Packaging ops with timestamps
+ * - Merging with pending fields
+ * - Updating the doc's state via `applyChanges()`
+ *
+ * Unlike OTDoc, LWWDoc doesn't need to track committed vs pending state
+ * separately - the strategy handles all conflict resolution by timestamp.
+ *
+ * ## Wire Efficiency
+ * For Worker-Tab communication, `applyChanges()` sends only changes over the wire,
+ * not the full state.
+ */
+declare class LWWDoc<T extends object = object> extends BaseDoc<T> {
+    protected _committedRev: number;
+    protected _hasPending: boolean;
+    /**
+     * Creates an instance of LWWDoc.
+     * @param id The unique identifier for this document.
+     * @param snapshot Optional snapshot to initialize from.
+     */
+    constructor(id: string, snapshot?: PatchesSnapshot<T>);
+    /** Last committed revision number from the server. */
+    get committedRev(): number;
+    /** Are there local changes that haven't been committed yet? */
+    get hasPending(): boolean;
+    /**
+     * Imports document state from a snapshot (e.g., for recovery when out of sync).
+     * Resets state completely from the snapshot.
+     */
+    import(snapshot: PatchesSnapshot<T>): void;
+    /**
+     * Applies changes to the document state.
+     * Used for Worker→Tab communication where only changes are sent over the wire.
+     *
+     * For LWW, all ops are applied in order. The method distinguishes between
+     * committed and pending changes using `committedAt`:
+     * - `committedAt > 0`: Server-committed change (updates committedRev)
+     * - `committedAt === 0`: Pending local change (marks hasPending = true)
+     *
+     * @param changes Array of changes to apply
+     */
+    applyChanges(changes: Change[]): void;
+}
+
+export { LWWDoc };

package/dist/client/LWWDoc.js

@@ -0,0 +1,84 @@
+import "../chunk-IZ2YBCUP.js";
+import { applyPatch } from "../json-patch/applyPatch.js";
+import { BaseDoc } from "./BaseDoc.js";
+class LWWDoc extends BaseDoc {
+  _committedRev;
+  _hasPending;
+  /**
+   * Creates an instance of LWWDoc.
+   * @param id The unique identifier for this document.
+   * @param snapshot Optional snapshot to initialize from.
+   */
+  constructor(id, snapshot) {
+    const initialState = snapshot?.state ?? {};
+    super(id, initialState);
+    this._committedRev = snapshot?.rev ?? 0;
+    this._hasPending = (snapshot?.changes?.length ?? 0) > 0;
+    if (snapshot?.changes && snapshot.changes.length > 0) {
+      for (const change of snapshot.changes) {
+        for (const op of change.ops) {
+          this._state = applyPatch(this._state, [op], { partial: true });
+        }
+      }
+    }
+  }
+  /** Last committed revision number from the server. */
+  get committedRev() {
+    return this._committedRev;
+  }
+  /** Are there local changes that haven't been committed yet? */
+  get hasPending() {
+    return this._hasPending;
+  }
+  /**
+   * Imports document state from a snapshot (e.g., for recovery when out of sync).
+   * Resets state completely from the snapshot.
+   */
+  import(snapshot) {
+    this._state = snapshot.state;
+    this._committedRev = snapshot.rev;
+    this._hasPending = (snapshot.changes?.length ?? 0) > 0;
+    if (snapshot.changes && snapshot.changes.length > 0) {
+      for (const change of snapshot.changes) {
+        for (const op of change.ops) {
+          this._state = applyPatch(this._state, [op], { partial: true });
+        }
+      }
+    }
+    this.onUpdate.emit(this._state);
+  }
+  /**
+   * Applies changes to the document state.
+   * Used for Worker→Tab communication where only changes are sent over the wire.
+   *
+   * For LWW, all ops are applied in order. The method distinguishes between
+   * committed and pending changes using `committedAt`:
+   * - `committedAt > 0`: Server-committed change (updates committedRev)
+   * - `committedAt === 0`: Pending local change (marks hasPending = true)
+   *
+   * @param changes Array of changes to apply
+   */
+  applyChanges(changes) {
+    if (changes.length === 0) return;
+    for (const change of changes) {
+      for (const op of change.ops) {
+        this._state = applyPatch(this._state, [op], { partial: true });
+      }
+    }
+    let lastCommittedRev = this._committedRev;
+    let hasPendingChanges = false;
+    for (const change of changes) {
+      if (change.committedAt > 0) {
+        lastCommittedRev = change.rev;
+      } else {
+        hasPendingChanges = true;
+      }
+    }
+    this._committedRev = lastCommittedRev;
+    this._hasPending = hasPendingChanges;
+    this.onUpdate.emit(this._state);
+  }
+}
+export {
+  LWWDoc
+};