@dabble/patches 0.2.32 → 0.3.1

package/dist/client/IndexedDBStore.js

@@ -1,5 +1,41 @@
+var __runInitializers = (this && this.__runInitializers) || function (thisArg, initializers, value) {
+    var useValue = arguments.length > 2;
+    for (var i = 0; i < initializers.length; i++) {
+        value = useValue ? initializers[i].call(thisArg, value) : initializers[i].call(thisArg);
+    }
+    return useValue ? value : void 0;
+};
+var __esDecorate = (this && this.__esDecorate) || function (ctor, descriptorIn, decorators, contextIn, initializers, extraInitializers) {
+    function accept(f) { if (f !== void 0 && typeof f !== "function") throw new TypeError("Function expected"); return f; }
+    var kind = contextIn.kind, key = kind === "getter" ? "get" : kind === "setter" ? "set" : "value";
+    var target = !descriptorIn && ctor ? contextIn["static"] ? ctor : ctor.prototype : null;
+    var descriptor = descriptorIn || (target ? Object.getOwnPropertyDescriptor(target, contextIn.name) : {});
+    var _, done = false;
+    for (var i = decorators.length - 1; i >= 0; i--) {
+        var context = {};
+        for (var p in contextIn) context[p] = p === "access" ? {} : contextIn[p];
+        for (var p in contextIn.access) context.access[p] = contextIn.access[p];
+        context.addInitializer = function (f) { if (done) throw new TypeError("Cannot add initializers after decoration has completed"); extraInitializers.push(accept(f || null)); };
+        var result = (0, decorators[i])(kind === "accessor" ? { get: descriptor.get, set: descriptor.set } : descriptor[key], context);
+        if (kind === "accessor") {
+            if (result === void 0) continue;
+            if (result === null || typeof result !== "object") throw new TypeError("Object expected");
+            if (_ = accept(result.get)) descriptor.get = _;
+            if (_ = accept(result.set)) descriptor.set = _;
+            if (_ = accept(result.init)) initializers.unshift(_);
+        }
+        else if (_ = accept(result)) {
+            if (kind === "field") initializers.unshift(_);
+            else descriptor[key] = _;
+        }
+    }
+    if (target) Object.defineProperty(target, contextIn.name, descriptor);
+    done = true;
+};
+import { applyChanges } from '../algorithms/shared/applyChanges.js';
 import { transformPatch } from '../json-patch/transformPatch.js';
-import { applyChanges, deferred } from '../utils.js';
+import { blockable } from '../utils/concurrency.js';
+import { deferred } from '../utils/deferred.js';
 const DB_VERSION = 1;
 const SNAPSHOT_INTERVAL = 200;
 /**
@@ -14,299 +50,380 @@ const SNAPSHOT_INTERVAL = 200;
  * After every 200 committed changes, the class will save the current state to the snapshot store and delete the committed changes that went into it.
  * A snapshot will not be created if there are pending changes based on revisions older than the 200th committed change until those pending changes are committed.
  */
-export class IndexedDBStore {
-    constructor(dbName) {
-        this.db = null;
-        this.dbName = dbName;
-        this.dbPromise = deferred();
-        if (this.dbName) {
-            this.initDB();
-        }
-    }
-    async initDB() {
-        if (!this.dbName)
-            return;
-        const request = indexedDB.open(this.dbName, DB_VERSION);
-        request.onerror = () => this.dbPromise.reject(request.error);
-        request.onsuccess = () => {
-            this.db = request.result;
-            this.dbPromise.resolve(this.db);
-        };
-        request.onupgradeneeded = event => {
-            const db = event.target.result;
-            // Create stores
-            if (!db.objectStoreNames.contains('snapshots')) {
-                db.createObjectStore('snapshots', { keyPath: 'docId' });
+let IndexedDBStore = (() => {
+    var _a;
+    let _instanceExtraInitializers = [];
+    let _getDoc_decorators;
+    let _deleteDoc_decorators;
+    let _confirmDeleteDoc_decorators;
+    let _saveDoc_decorators;
+    let _savePendingChanges_decorators;
+    let _getPendingChanges_decorators;
+    let _replacePendingChanges_decorators;
+    let _saveCommittedChanges_decorators;
+    let _getLastRevs_decorators;
+    return _a = class IndexedDBStore {
+            constructor(dbName) {
+                this.db = (__runInitializers(this, _instanceExtraInitializers), null);
+                this.dbName = dbName;
+                this.dbPromise = deferred();
+                if (this.dbName) {
+                    this.initDB();
+                }
             }
-            if (!db.objectStoreNames.contains('committedChanges')) {
-                db.createObjectStore('committedChanges', { keyPath: ['docId', 'rev'] });
+            async initDB() {
+                if (!this.dbName)
+                    return;
+                const request = indexedDB.open(this.dbName, DB_VERSION);
+                request.onerror = () => this.dbPromise.reject(request.error);
+                request.onsuccess = () => {
+                    this.db = request.result;
+                    this.dbPromise.resolve(this.db);
+                };
+                request.onupgradeneeded = event => {
+                    const db = event.target.result;
+                    // Create stores
+                    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' });
+                    }
+                };
             }
-            if (!db.objectStoreNames.contains('pendingChanges')) {
-                db.createObjectStore('pendingChanges', { keyPath: ['docId', 'rev'] });
+            getDB() {
+                return this.dbPromise.promise;
             }
-            if (!db.objectStoreNames.contains('docs')) {
-                db.createObjectStore('docs', { keyPath: 'docId' });
+            /**
+             * Set the name of the database, loads a new database connection.
+             * @param dbName - The new name of the database.
+             */
+            setName(dbName) {
+                this.dbName = dbName;
+                if (this.db) {
+                    this.db.close();
+                    this.db = null;
+                    this.dbPromise = deferred();
+                }
+                this.initDB();
             }
-        };
-    }
-    getDB() {
-        return this.dbPromise.promise;
-    }
-    /**
-     * Set the name of the database, loads a new database connection.
-     * @param dbName - The new name of the database.
-     */
-    setName(dbName) {
-        this.dbName = dbName;
-        if (this.db) {
-            this.db.close();
-            this.db = null;
-            this.dbPromise = deferred();
-        }
-        this.initDB();
-    }
-    /**
-     * Closes the database connection. After calling this method, the store
-     * will no longer be usable. A new instance must be created to reopen
-     * the database.
-     */
-    async close() {
-        await this.dbPromise.promise;
-        if (this.db) {
-            this.db.close();
-            this.db = null;
-            this.dbPromise = deferred();
-            this.dbPromise.resolve(null);
-        }
-    }
-    async deleteDB() {
-        if (!this.dbName)
-            return;
-        await this.close();
-        await new Promise((resolve, reject) => {
-            const request = indexedDB.deleteDatabase(this.dbName);
-            request.onsuccess = () => resolve();
-            request.onerror = () => reject(request.error);
-            request.onblocked = () => reject(request.error);
-        });
-    }
-    async transaction(storeNames, mode) {
-        const db = await this.getDB();
-        const tx = new IDBTransactionWrapper(db.transaction(storeNames, mode));
-        const stores = storeNames.map(name => tx.getStore(name));
-        return [tx, ...stores];
-    }
-    // ─── Snapshots + Reconstruction ────────────────────────────────────────────
-    /**
-     * Rebuilds a document snapshot + pending queue *without* loading
-     * the full PatchesDoc into memory.
-     *
-     * 1. load the last snapshot (state + rev)
-     * 2. load committedChanges[rev > snapshot.rev]
-     * 3. load pendingChanges
-     * 4. apply committed changes, rebase pending
-     * 5. return { state, rev, changes: pending }
-     */
-    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 undefined;
-        }
-        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 undefined;
-        // Apply any committed changes to the snapshot state
-        const state = applyChanges(snapshot?.state, committed);
-        // Rebase pending changes if there are any committed changes received since their baseRev
-        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,
-        };
-    }
-    /**
-     * Completely remove all data for this docId and mark it as deleted (tombstone).
-     */
-    async deleteDoc(docId) {
-        const [tx, snapshots, committedChanges, pendingChanges, docsStore] = await this.transaction(['snapshots', 'committedChanges', 'pendingChanges', 'docs'], 'readwrite');
-        const docMeta = (await docsStore.get(docId)) ?? { docId, committedRev: 0 };
-        await docsStore.put({ ...docMeta, deleted: true });
-        await Promise.all([
-            snapshots.delete(docId),
-            committedChanges.delete([docId, 0], [docId, Infinity]),
-            pendingChanges.delete([docId, 0], [docId, Infinity]),
-        ]);
-        await tx.complete();
-    }
-    async confirmDeleteDoc(docId) {
-        const [tx, docsStore] = await this.transaction(['docs'], 'readwrite');
-        await docsStore.delete(docId);
-        await tx.complete();
-    }
-    // ─── Pending Changes ────────────────────────────────────────────────────────
-    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();
-    }
-    /**
-     * Append an array of local changes to the pending queue.
-     * Called *before* you attempt to send them to the server.
-     */
-    async savePendingChange(docId, change) {
-        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 pendingChanges.put({ ...change, docId });
-        await tx.complete();
-    }
-    /** Read back all pending changes for this docId (in order). */
-    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;
-    }
-    // ─── Committed Changes ─────────────────────────────────────────────────────
-    /**
-     * Store server‐confirmed changes.  Will:
-     * - persist them in the committedChanges store
-     * - remove any pending changes whose rev falls within `sentPendingRange`
-     * - optionally compact a new snapshot after N changes (hidden internally)
-     * @param docId - The ID of the document to save the changes for
-     * @param changes - The changes to save
-     * @param sentPendingRange - The range of pending changes to remove, *must* be provided after receiving the changes
-     * from the server in response to a patchesDoc request.
-     */
-    async saveCommittedChanges(docId, changes, sentPendingRange) {
-        const [tx, committedChanges, pendingChanges, snapshots, docsStore] = await this.transaction(['committedChanges', 'pendingChanges', 'snapshots', 'docs'], 'readwrite');
-        // Save committed changes
-        await Promise.all(changes.map(change => committedChanges.put({ ...change, docId })));
-        // Remove pending changes if range provided
-        if (sentPendingRange) {
-            await pendingChanges.delete([docId, sentPendingRange[0]], [docId, sentPendingRange[1]]);
-        }
-        // Check if we should create a snapshot
-        const count = await committedChanges.count([docId, 0], [docId, Infinity]);
-        if (count >= SNAPSHOT_INTERVAL) {
-            // Update the snapshot. A snapshot will not be updated if there are pending changes based on revisions older than
-            // the latest committed change until those pending changes are committed.
-            const [snapshot, committed, firstPending] = await Promise.all([
-                snapshots.get(docId),
-                committedChanges.getAll([docId, 0], [docId, Infinity], SNAPSHOT_INTERVAL),
-                pendingChanges.getFirstFromCursor([docId, 0], [docId, Infinity]),
-            ]);
-            // Update the snapshot
-            const lastRev = committed[committed.length - 1]?.rev;
-            if (!firstPending?.baseRev || firstPending?.baseRev >= lastRev) {
+            /**
+             * Closes the database connection. After calling this method, the store
+             * will no longer be usable. A new instance must be created to reopen
+             * the database.
+             */
+            async close() {
+                await this.dbPromise.promise;
+                if (this.db) {
+                    this.db.close();
+                    this.db = null;
+                    this.dbPromise = deferred();
+                    this.dbPromise.resolve(null);
+                }
+            }
+            async deleteDB() {
+                if (!this.dbName)
+                    return;
+                await this.close();
+                await new Promise((resolve, reject) => {
+                    const request = indexedDB.deleteDatabase(this.dbName);
+                    request.onsuccess = () => resolve();
+                    request.onerror = () => reject(request.error);
+                    request.onblocked = () => reject(request.error);
+                });
+            }
+            async transaction(storeNames, mode) {
+                const db = await this.getDB();
+                const tx = new IDBTransactionWrapper(db.transaction(storeNames, mode));
+                const stores = storeNames.map(name => tx.getStore(name));
+                return [tx, ...stores];
+            }
+            /**
+             * Rebuilds a document snapshot + pending queue *without* loading
+             * the full PatchesDoc into memory.
+             *
+             * 1. load the last snapshot (state + rev)
+             * 2. load committedChanges[rev > snapshot.rev]
+             * 3. load pendingChanges
+             * 4. apply committed changes, rebase pending
+             * 5. return { state, rev, changes: pending }
+             */
+            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 undefined;
+                }
+                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 undefined;
+                // Apply any committed changes to the snapshot state
                 const state = applyChanges(snapshot?.state, committed);
+                // Rebase pending changes if there are any committed changes received since their baseRev
+                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,
+                };
+            }
+            /**
+             * Completely remove all data for this docId and mark it as deleted (tombstone).
+             */
+            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.put({
-                        docId,
-                        rev: lastRev,
-                        state,
-                    }),
-                    committedChanges.delete([docId, 0], [docId, lastRev]),
+                    snapshots.delete(docId),
+                    committedChanges.delete([docId, 0], [docId, Infinity]),
+                    pendingChanges.delete([docId, 0], [docId, Infinity]),
                 ]);
+                await tx.complete();
             }
-        }
-        // Update committedRev in the docs store if changes were saved
-        const lastCommittedRev = changes.at(-1)?.rev;
-        if (lastCommittedRev !== undefined) {
-            const docMeta = (await docsStore.get(docId)) ?? { docId, committedRev: 0 };
-            if (lastCommittedRev > docMeta.committedRev) {
-                await docsStore.put({ ...docMeta, committedRev: lastCommittedRev, deleted: undefined });
+            /**
+             * 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();
             }
-        }
-        await tx.complete();
-    }
-    // --- New method for OfflineStore interface ---
-    async listDocs(includeDeleted = false) {
-        const [tx, docsStore] = await this.transaction(['docs'], 'readonly');
-        const allDocs = await docsStore.getAll();
-        await tx.complete();
-        return includeDeleted ? allDocs : allDocs.filter(doc => !doc.deleted);
-    }
-    // ─── Metadata / Tracking ───────────────────────────────────────────
-    async trackDocs(docIds) {
-        const [tx, docsStore] = await this.transaction(['docs'], 'readwrite');
-        await Promise.all(docIds.map(async (docId) => {
-            const existing = await docsStore.get(docId);
-            if (existing) {
-                // If exists but deleted, undelete it
-                if (existing.deleted) {
-                    await docsStore.put({ ...existing, deleted: undefined });
+            /**
+             * Save a document's state to the store.
+             * @param docId - The ID of the document to save.
+             * @param docState - The state of the document to save.
+             */
+            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();
+            }
+            /**
+             * Append an array of local changes to the pending queue.
+             * Called *before* you attempt to send them to the server.
+             */
+            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);
                 }
-                // Otherwise, it's already tracked and not deleted, do nothing
+                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();
             }
-            else {
-                // If doesn't exist, add it
-                await docsStore.put({ docId, committedRev: 0 });
+            /**
+             * Read back all pending changes for this docId (in order).
+             * @param docId - The ID of the document to get the pending changes for.
+             * @returns The pending changes.
+             */
+            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;
             }
-        }));
-        await tx.complete();
-    }
-    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();
-    }
-    // ─── Revision Tracking ─────────────────────────────────────────────────────
-    /**
-     * Tell me the last committed revision you have *and* the highest
-     * rev of any change.  Use these to drive:
-     *   - fetch changes:   api.getChangesSince(docId, committedRev)
-     *   - build new patch: newChange.rev = pendingRev; baseRev = committedRev
-     */
-    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];
-    }
-}
+            /**
+             * Replace all pending changes for a document (used after rebasing).
+             * @param docId - The ID of the document to replace the pending changes for.
+             * @param changes - The changes to replace the pending changes with.
+             */
+            async replacePendingChanges(docId, changes) {
+                const [tx, pendingChanges, docsStore] = await this.transaction(['pendingChanges', 'docs'], 'readwrite');
+                // Ensure the document is tracked
+                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.`);
+                }
+                // Remove all existing pending changes and add the new ones
+                await pendingChanges.delete([docId, 0], [docId, Infinity]);
+                await Promise.all(changes.map(change => pendingChanges.put({ ...change, docId })));
+                await tx.complete();
+            }
+            // ─── Committed Changes ─────────────────────────────────────────────────────
+            /**
+             * Store server‐confirmed changes.  Will:
+             * - persist them in the committedChanges store
+             * - remove any pending changes whose rev falls within `sentPendingRange`
+             * - optionally compact a new snapshot after N changes (hidden internally)
+             * @param docId - The ID of the document to save the changes for
+             * @param changes - The changes to save
+             * @param sentPendingRange - The range of pending changes to remove, *must* be provided after receiving the changes
+             * from the server in response to a patchesDoc request.
+             */
+            async saveCommittedChanges(docId, changes, sentPendingRange) {
+                const [tx, committedChanges, pendingChanges, snapshots, docsStore] = await this.transaction(['committedChanges', 'pendingChanges', 'snapshots', 'docs'], 'readwrite');
+                // Save committed changes
+                await Promise.all(changes.map(change => committedChanges.put({ ...change, docId })));
+                // Remove pending changes if range provided
+                if (sentPendingRange) {
+                    await pendingChanges.delete([docId, sentPendingRange[0]], [docId, sentPendingRange[1]]);
+                }
+                // Check if we should create a snapshot
+                const count = await committedChanges.count([docId, 0], [docId, Infinity]);
+                if (count >= SNAPSHOT_INTERVAL) {
+                    // Update the snapshot. A snapshot will not be updated if there are pending changes based on revisions older than
+                    // the latest committed change until those pending changes are committed.
+                    const [snapshot, committed, firstPending] = await Promise.all([
+                        snapshots.get(docId),
+                        committedChanges.getAll([docId, 0], [docId, Infinity], SNAPSHOT_INTERVAL),
+                        pendingChanges.getFirstFromCursor([docId, 0], [docId, Infinity]),
+                    ]);
+                    // Update the snapshot
+                    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]),
+                        ]);
+                    }
+                }
+                // Update committedRev in the docs store if changes were saved
+                const lastCommittedRev = changes.at(-1)?.rev;
+                if (lastCommittedRev !== undefined) {
+                    const docMeta = (await docsStore.get(docId)) ?? { docId, committedRev: 0 };
+                    if (lastCommittedRev > docMeta.committedRev) {
+                        await docsStore.put({ ...docMeta, committedRev: lastCommittedRev, deleted: undefined });
+                    }
+                }
+                await tx.complete();
+            }
+            /**
+             * List all documents in the store.
+             * @param includeDeleted - Whether to include deleted documents.
+             * @returns The list of documents.
+             */
+            async listDocs(includeDeleted = false) {
+                const [tx, docsStore] = await this.transaction(['docs'], 'readonly');
+                const allDocs = await docsStore.getAll();
+                await tx.complete();
+                return includeDeleted ? allDocs : allDocs.filter(doc => !doc.deleted);
+            }
+            /**
+             * Track a document.
+             * @param docIds - The IDs of the documents to track.
+             */
+            async trackDocs(docIds) {
+                const [tx, docsStore] = await this.transaction(['docs'], 'readwrite');
+                await Promise.all(docIds.map(async (docId) => {
+                    const existing = await docsStore.get(docId);
+                    if (existing) {
+                        // If exists but deleted, undelete it
+                        if (existing.deleted) {
+                            await docsStore.put({ ...existing, deleted: undefined });
+                        }
+                        // Otherwise, it's already tracked and not deleted, do nothing
+                    }
+                    else {
+                        // If doesn't exist, add it
+                        await docsStore.put({ docId, committedRev: 0 });
+                    }
+                }));
+                await tx.complete();
+            }
+            /**
+             * Untrack a document.
+             * @param docIds - The IDs of the documents to untrack.
+             */
+            async untrackDocs(docIds) {
+                const [tx, docsStore, snapshots, committedChanges, pendingChanges] = await this.transaction(['docs', 'snapshots', 'committedChanges', 'pendingChanges'], 'readwrite');
+                await Promise.all(docIds.map(docId => {
+                    return Promise.all([
+                        docsStore.delete(docId),
+                        snapshots.delete(docId),
+                        committedChanges.delete([docId, 0], [docId, Infinity]),
+                        pendingChanges.delete([docId, 0], [docId, Infinity]),
+                    ]);
+                }));
+                await tx.complete();
+            }
+            /**
+             * Tell me the last committed revision you have *and* the highest
+             * rev of any change.  Use these to drive:
+             *   - fetch changes:   api.getChangesSince(docId, committedRev)
+             *   - build new patch: newChange.rev = pendingRev; baseRev = committedRev
+             */
+            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];
+            }
+        },
+        (() => {
+            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(null) : void 0;
+            _getDoc_decorators = [blockable];
+            _deleteDoc_decorators = [blockable];
+            _confirmDeleteDoc_decorators = [blockable];
+            _saveDoc_decorators = [blockable];
+            _savePendingChanges_decorators = [blockable];
+            _getPendingChanges_decorators = [blockable];
+            _replacePendingChanges_decorators = [blockable];
+            _saveCommittedChanges_decorators = [blockable];
+            _getLastRevs_decorators = [blockable];
+            __esDecorate(_a, null, _getDoc_decorators, { kind: "method", name: "getDoc", static: false, private: false, access: { has: obj => "getDoc" in obj, get: obj => obj.getDoc }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(_a, null, _deleteDoc_decorators, { kind: "method", name: "deleteDoc", static: false, private: false, access: { has: obj => "deleteDoc" in obj, get: obj => obj.deleteDoc }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(_a, null, _confirmDeleteDoc_decorators, { kind: "method", name: "confirmDeleteDoc", static: false, private: false, access: { has: obj => "confirmDeleteDoc" in obj, get: obj => obj.confirmDeleteDoc }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(_a, null, _saveDoc_decorators, { kind: "method", name: "saveDoc", static: false, private: false, access: { has: obj => "saveDoc" in obj, get: obj => obj.saveDoc }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(_a, null, _savePendingChanges_decorators, { kind: "method", name: "savePendingChanges", static: false, private: false, access: { has: obj => "savePendingChanges" in obj, get: obj => obj.savePendingChanges }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(_a, null, _getPendingChanges_decorators, { kind: "method", name: "getPendingChanges", static: false, private: false, access: { has: obj => "getPendingChanges" in obj, get: obj => obj.getPendingChanges }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(_a, null, _replacePendingChanges_decorators, { kind: "method", name: "replacePendingChanges", static: false, private: false, access: { has: obj => "replacePendingChanges" in obj, get: obj => obj.replacePendingChanges }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(_a, null, _saveCommittedChanges_decorators, { kind: "method", name: "saveCommittedChanges", static: false, private: false, access: { has: obj => "saveCommittedChanges" in obj, get: obj => obj.saveCommittedChanges }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(_a, null, _getLastRevs_decorators, { kind: "method", name: "getLastRevs", static: false, private: false, access: { has: obj => "getLastRevs" in obj, get: obj => obj.getLastRevs }, metadata: _metadata }, null, _instanceExtraInitializers);
+            if (_metadata) Object.defineProperty(_a, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+        })(),
+        _a;
+})();
+export { IndexedDBStore };
 class IDBTransactionWrapper {
     constructor(tx) {
         this.tx = tx;