mindoodb 0.0.19 → 0.0.21

package/dist/browser/appendonlystores/IndexedDBContentAddressedStore.js

@@ -18,6 +18,7 @@
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.IndexedDBContentAddressedStore = void 0;
+exports.isIndexedDBConnectionLostError = isIndexedDBConnectionLostError;
 exports.readContentAddressedStoreBytes = readContentAddressedStoreBytes;
 const types_1 = require("../../core/appendonlystores/types");
 const AttachmentReadPlanner_1 = require("../../core/appendonlystores/AttachmentReadPlanner");
@@ -42,6 +43,7 @@ const BLOOM_CACHE_KEY = "current";
 const RECEIPT_ORDER_COUNTER_KEY = "receiptOrderCounter";
 const TOTAL_CONTENT_BYTES_KEY = "total_content_bytes";
 const TOTAL_METADATA_BYTES_KEY = "total_metadata_bytes";
+const RECONNECT_RETRY_DELAYS_MS = [50, 250, 1000];
 function qualifyIndexedDbNamespace(namespace, storeKind) {
     const separatorIndex = namespace.indexOf("-");
     if (separatorIndex === -1) {
@@ -49,6 +51,22 @@ function qualifyIndexedDbNamespace(namespace, storeKind) {
     }
     return `${namespace.slice(0, separatorIndex)}_${storeKind}${namespace.slice(separatorIndex)}`;
 }
+function isIndexedDBConnectionLostError(error) {
+    const name = error instanceof DOMException || error instanceof Error ? error.name : "";
+    const message = error instanceof DOMException || error instanceof Error
+        ? error.message
+        : String(error ?? "");
+    const normalized = message.toLowerCase();
+    return name === "InvalidStateError"
+        || name === "UnknownError"
+        || normalized.includes("connection to indexed database server lost")
+        || normalized.includes("connection to the database lost")
+        || normalized.includes("database connection is closing")
+        || normalized.includes("indexeddb transaction aborted");
+}
+function wait(ms) {
+    return new Promise((resolve) => window.setTimeout(resolve, ms));
+}
 // ---------------------------------------------------------------------------
 // Browser-compatible bloom filter helpers (no Buffer dependency)
 // ---------------------------------------------------------------------------
@@ -354,16 +372,16 @@ class IndexedDBContentAddressedStore {
                 this.db = request.result;
                 this.db.onversionchange = () => {
                     this.logger.warn("IndexedDB version change detected, closing connection");
-                    this.db?.close();
-                    this.db = null;
-                    this.openPromise = null;
+                    this.resetConnection();
+                };
+                this.db.onclose = () => {
+                    this.logger.warn(`IndexedDB connection closed for ${this.idbName}; future operations will reopen it`);
+                    this.resetConnection();
                 };
                 void this.backfillStoredBytesIfNeeded(this.db)
                     .then(() => resolve(this.db))
                     .catch((error) => {
-                    this.db?.close();
-                    this.db = null;
-                    this.openPromise = null;
+                    this.resetConnection();
                     reject(error);
                 });
             };
@@ -389,6 +407,36 @@ class IndexedDBContentAddressedStore {
     getCacheIdentity() {
         return `idb:${this.idbName}`;
     }
+    resetConnection() {
+        const db = this.db;
+        this.db = null;
+        this.openPromise = null;
+        try {
+            db?.close();
+        }
+        catch {
+            // Ignore close errors from already-invalid WebKit IDB handles.
+        }
+    }
+    async runWithReconnect(opName, operation) {
+        let lastError;
+        for (let attempt = 0; attempt <= RECONNECT_RETRY_DELAYS_MS.length; attempt++) {
+            try {
+                return await operation();
+            }
+            catch (error) {
+                lastError = error;
+                if (!isIndexedDBConnectionLostError(error) || attempt >= RECONNECT_RETRY_DELAYS_MS.length) {
+                    throw error;
+                }
+                this.logger.warn(`[idb-recovery] ${opName} failed for ${this.idbName}; reopening IndexedDB connection (attempt ${attempt + 1})`, error);
+                this.resetConnection();
+                await wait(RECONNECT_RETRY_DELAYS_MS[attempt]);
+                await this.ensureOpen();
+            }
+        }
+        throw lastError;
+    }
     /**
      * Returns approximate payload bytes currently stored in this browser-backed
      * content-addressed store.
@@ -400,131 +448,139 @@ class IndexedDBContentAddressedStore {
      * increase `refCount`.
      */
     async getStoredBytes() {
-        const db = await this.ensureOpen();
-        const tx = db.transaction(META_STORE, "readonly");
-        const metaOS = tx.objectStore(META_STORE);
-        const contentBytes = (await readNumericMetaValue(metaOS, TOTAL_CONTENT_BYTES_KEY)) ?? 0;
-        const metadataBytes = (await readNumericMetaValue(metaOS, TOTAL_METADATA_BYTES_KEY)) ?? 0;
-        return {
-            contentBytes,
-            metadataBytes,
-            totalBytes: contentBytes + metadataBytes,
-        };
+        return this.runWithReconnect("getStoredBytes", async () => {
+            const db = await this.ensureOpen();
+            const tx = db.transaction(META_STORE, "readonly");
+            const metaOS = tx.objectStore(META_STORE);
+            const contentBytes = (await readNumericMetaValue(metaOS, TOTAL_CONTENT_BYTES_KEY)) ?? 0;
+            const metadataBytes = (await readNumericMetaValue(metaOS, TOTAL_METADATA_BYTES_KEY)) ?? 0;
+            return {
+                contentBytes,
+                metadataBytes,
+                totalBytes: contentBytes + metadataBytes,
+            };
+        });
     }
     async putEntries(entries) {
         if (entries.length === 0)
             return;
-        const db = await this.ensureOpen();
-        const tx = db.transaction([ENTRIES_STORE, CONTENT_STORE, BLOOM_CACHE_STORE, META_STORE], "readwrite");
-        const entriesOS = tx.objectStore(ENTRIES_STORE);
-        const contentOS = tx.objectStore(CONTENT_STORE);
-        const bloomOS = tx.objectStore(BLOOM_CACHE_STORE);
-        const metaOS = tx.objectStore(META_STORE);
-        const insertedIds = [];
-        const counterRecord = (await reqToPromise(metaOS.get(RECEIPT_ORDER_COUNTER_KEY)));
-        let nextReceiptOrder = typeof counterRecord?.value === "number" ? counterRecord.value + 1 : 1;
-        let totalContentBytes = (await readNumericMetaValue(metaOS, TOTAL_CONTENT_BYTES_KEY)) ?? 0;
-        let totalMetadataBytes = (await readNumericMetaValue(metaOS, TOTAL_METADATA_BYTES_KEY)) ?? 0;
-        for (const entry of entries) {
-            // Check if entry already exists (skip duplicate)
-            const existing = await reqToPromise(entriesOS.get(entry.id));
-            if (existing) {
-                this.logger.debug(`Entry ${entry.id} already exists, skipping`);
-                continue;
-            }
-            // Separate metadata from encrypted data
-            const { encryptedData, receiptOrder: _ignoredReceiptOrder, ...rest } = entry;
-            const metadata = {
-                ...rest,
-                receiptOrder: nextReceiptOrder++,
-            };
-            totalMetadataBytes += getMetadataPayloadBytes(metadata);
-            // Store metadata
-            await reqToPromise(entriesOS.put(metadata));
-            // Deduplicate content
-            const existingContent = (await reqToPromise(contentOS.get(entry.contentHash)));
-            if (existingContent) {
-                existingContent.refCount += 1;
-                await reqToPromise(contentOS.put(existingContent));
-                this.logger.debug(`Content ${entry.contentHash.substring(0, 8)}... already exists (deduplicated)`);
+        return this.runWithReconnect("putEntries", async () => {
+            const db = await this.ensureOpen();
+            const tx = db.transaction([ENTRIES_STORE, CONTENT_STORE, BLOOM_CACHE_STORE, META_STORE], "readwrite");
+            const entriesOS = tx.objectStore(ENTRIES_STORE);
+            const contentOS = tx.objectStore(CONTENT_STORE);
+            const bloomOS = tx.objectStore(BLOOM_CACHE_STORE);
+            const metaOS = tx.objectStore(META_STORE);
+            const insertedIds = [];
+            const counterRecord = (await reqToPromise(metaOS.get(RECEIPT_ORDER_COUNTER_KEY)));
+            let nextReceiptOrder = typeof counterRecord?.value === "number" ? counterRecord.value + 1 : 1;
+            let totalContentBytes = (await readNumericMetaValue(metaOS, TOTAL_CONTENT_BYTES_KEY)) ?? 0;
+            let totalMetadataBytes = (await readNumericMetaValue(metaOS, TOTAL_METADATA_BYTES_KEY)) ?? 0;
+            for (const entry of entries) {
+                // Check if entry already exists (skip duplicate)
+                const existing = await reqToPromise(entriesOS.get(entry.id));
+                if (existing) {
+                    this.logger.debug(`Entry ${entry.id} already exists, skipping`);
+                    continue;
+                }
+                // Separate metadata from encrypted data
+                const { encryptedData, receiptOrder: _ignoredReceiptOrder, ...rest } = entry;
+                const metadata = {
+                    ...rest,
+                    receiptOrder: nextReceiptOrder++,
+                };
+                totalMetadataBytes += getMetadataPayloadBytes(metadata);
+                // Store metadata
+                await reqToPromise(entriesOS.put(metadata));
+                // Deduplicate content
+                const existingContent = (await reqToPromise(contentOS.get(entry.contentHash)));
+                if (existingContent) {
+                    existingContent.refCount += 1;
+                    await reqToPromise(contentOS.put(existingContent));
+                    this.logger.debug(`Content ${entry.contentHash.substring(0, 8)}... already exists (deduplicated)`);
+                }
+                else {
+                    await reqToPromise(contentOS.put({
+                        contentHash: entry.contentHash,
+                        data: encryptedData,
+                        refCount: 1,
+                    }));
+                    totalContentBytes += encryptedData.byteLength;
+                    this.logger.debug(`Stored content for hash ${entry.contentHash.substring(0, 8)}...`);
+                }
+                insertedIds.push(entry.id);
+                this.logger.debug(`Stored entry ${entry.id} for doc ${entry.docId}`);
             }
-            else {
-                await reqToPromise(contentOS.put({
-                    contentHash: entry.contentHash,
-                    data: encryptedData,
-                    refCount: 1,
-                }));
-                totalContentBytes += encryptedData.byteLength;
-                this.logger.debug(`Stored content for hash ${entry.contentHash.substring(0, 8)}...`);
+            if (insertedIds.length > 0) {
+                await writeNumericMetaValue(metaOS, RECEIPT_ORDER_COUNTER_KEY, nextReceiptOrder - 1);
+                await writeNumericMetaValue(metaOS, TOTAL_CONTENT_BYTES_KEY, totalContentBytes);
+                await writeNumericMetaValue(metaOS, TOTAL_METADATA_BYTES_KEY, totalMetadataBytes);
             }
-            insertedIds.push(entry.id);
-            this.logger.debug(`Stored entry ${entry.id} for doc ${entry.docId}`);
-        }
-        if (insertedIds.length > 0) {
-            await writeNumericMetaValue(metaOS, RECEIPT_ORDER_COUNTER_KEY, nextReceiptOrder - 1);
-            await writeNumericMetaValue(metaOS, TOTAL_CONTENT_BYTES_KEY, totalContentBytes);
-            await writeNumericMetaValue(metaOS, TOTAL_METADATA_BYTES_KEY, totalMetadataBytes);
-        }
-        // Incrementally update bloom cache with newly inserted IDs
-        if (insertedIds.length > 0) {
-            const cached = await reqToPromise(bloomOS.get(BLOOM_CACHE_KEY));
-            if (cached && !cached.dirty && cached.summary) {
-                // Try incremental update (returns null if rebuild is needed)
-                const updated = incrementalBloomUpdate(cached.summary, insertedIds);
-                if (updated) {
-                    await reqToPromise(bloomOS.put({
-                        key: BLOOM_CACHE_KEY,
-                        summary: updated,
-                        dirty: false,
-                    }));
-                    this.logger.debug(`Incrementally updated bloom cache (+${insertedIds.length} IDs, total ${updated.totalIds})`);
+            // Incrementally update bloom cache with newly inserted IDs
+            if (insertedIds.length > 0) {
+                const cached = await reqToPromise(bloomOS.get(BLOOM_CACHE_KEY));
+                if (cached && !cached.dirty && cached.summary) {
+                    // Try incremental update (returns null if rebuild is needed)
+                    const updated = incrementalBloomUpdate(cached.summary, insertedIds);
+                    if (updated) {
+                        await reqToPromise(bloomOS.put({
+                            key: BLOOM_CACHE_KEY,
+                            summary: updated,
+                            dirty: false,
+                        }));
+                        this.logger.debug(`Incrementally updated bloom cache (+${insertedIds.length} IDs, total ${updated.totalIds})`);
+                    }
+                    else {
+                        // Filter has grown past rebuild threshold; mark dirty for full recompute
+                        await reqToPromise(bloomOS.put({ key: BLOOM_CACHE_KEY, summary: null, dirty: true }));
+                        this.logger.debug("Bloom cache exceeded rebuild threshold, marked dirty");
+                    }
                 }
                 else {
-                    // Filter has grown past rebuild threshold; mark dirty for full recompute
+                    // No valid cache exists; mark dirty so next getIdBloomSummary() rebuilds
                     await reqToPromise(bloomOS.put({ key: BLOOM_CACHE_KEY, summary: null, dirty: true }));
-                    this.logger.debug("Bloom cache exceeded rebuild threshold, marked dirty");
                 }
             }
-            else {
-                // No valid cache exists; mark dirty so next getIdBloomSummary() rebuilds
-                await reqToPromise(bloomOS.put({ key: BLOOM_CACHE_KEY, summary: null, dirty: true }));
-            }
-        }
-        await txToPromise(tx);
+            await txToPromise(tx);
+        });
     }
     async getEntries(ids) {
         if (ids.length === 0)
             return [];
-        const db = await this.ensureOpen();
-        const tx = db.transaction([ENTRIES_STORE, CONTENT_STORE], "readonly");
-        const entriesOS = tx.objectStore(ENTRIES_STORE);
-        const contentOS = tx.objectStore(CONTENT_STORE);
-        const result = [];
-        for (const id of ids) {
-            const metadata = (await reqToPromise(entriesOS.get(id)));
-            if (!metadata) {
-                this.logger.warn(`Entry ${id} not found`);
-                continue;
-            }
-            const contentRecord = await reqToPromise(contentOS.get(metadata.contentHash));
-            if (!contentRecord) {
-                this.logger.warn(`Content ${metadata.contentHash} not found for entry ${id}`);
-                continue;
+        return this.runWithReconnect("getEntries", async () => {
+            const db = await this.ensureOpen();
+            const tx = db.transaction([ENTRIES_STORE, CONTENT_STORE], "readonly");
+            const entriesOS = tx.objectStore(ENTRIES_STORE);
+            const contentOS = tx.objectStore(CONTENT_STORE);
+            const result = [];
+            for (const id of ids) {
+                const metadata = (await reqToPromise(entriesOS.get(id)));
+                if (!metadata) {
+                    this.logger.warn(`Entry ${id} not found`);
+                    continue;
+                }
+                const contentRecord = await reqToPromise(contentOS.get(metadata.contentHash));
+                if (!contentRecord) {
+                    this.logger.warn(`Content ${metadata.contentHash} not found for entry ${id}`);
+                    continue;
+                }
+                result.push({
+                    ...metadata,
+                    encryptedData: new Uint8Array(contentRecord.data),
+                });
             }
-            result.push({
-                ...metadata,
-                encryptedData: new Uint8Array(contentRecord.data),
-            });
-        }
-        this.logger.debug(`Retrieved ${result.length} entries out of ${ids.length} requested`);
-        return result;
+            this.logger.debug(`Retrieved ${result.length} entries out of ${ids.length} requested`);
+            return result;
+        });
     }
     async getEntryMetadata(id) {
-        const db = await this.ensureOpen();
-        const tx = db.transaction(ENTRIES_STORE, "readonly");
-        const entriesOS = tx.objectStore(ENTRIES_STORE);
-        const metadata = (await reqToPromise(entriesOS.get(id)));
-        return metadata ?? null;
+        return this.runWithReconnect("getEntryMetadata", async () => {
+            const db = await this.ensureOpen();
+            const tx = db.transaction(ENTRIES_STORE, "readonly");
+            const entriesOS = tx.objectStore(ENTRIES_STORE);
+            const metadata = (await reqToPromise(entriesOS.get(id)));
+            return metadata ?? null;
+        });
     }
     async planAttachmentReadByWalkingMetadata(lastChunkId, attachmentSize, options) {
         return (0, AttachmentReadPlanner_1.planAttachmentReadByWalkingMetadata)(this, lastChunkId, attachmentSize, options);
@@ -532,304 +588,339 @@ class IndexedDBContentAddressedStore {
     async hasEntries(ids) {
         if (ids.length === 0)
             return [];
-        const db = await this.ensureOpen();
-        const tx = db.transaction(ENTRIES_STORE, "readonly");
-        const entriesOS = tx.objectStore(ENTRIES_STORE);
-        const existing = [];
-        for (const id of ids) {
-            const key = await reqToPromise(entriesOS.getKey(id));
-            if (key !== undefined) {
-                existing.push(id);
+        return this.runWithReconnect("hasEntries", async () => {
+            const db = await this.ensureOpen();
+            const tx = db.transaction(ENTRIES_STORE, "readonly");
+            const entriesOS = tx.objectStore(ENTRIES_STORE);
+            const existing = [];
+            for (const id of ids) {
+                const key = await reqToPromise(entriesOS.getKey(id));
+                if (key !== undefined) {
+                    existing.push(id);
+                }
             }
-        }
-        this.logger.debug(`Found ${existing.length} existing entries out of ${ids.length} checked`);
-        return existing;
+            this.logger.debug(`Found ${existing.length} existing entries out of ${ids.length} checked`);
+            return existing;
+        });
     }
     async findNewEntries(knownIds) {
-        const knownSet = new Set(knownIds);
-        const db = await this.ensureOpen();
-        const tx = db.transaction(ENTRIES_STORE, "readonly");
-        const entriesOS = tx.objectStore(ENTRIES_STORE);
-        const newEntries = [];
-        return new Promise((resolve, reject) => {
-            const cursorReq = entriesOS.openCursor();
-            cursorReq.onsuccess = () => {
-                const cursor = cursorReq.result;
-                if (!cursor) {
-                    this.logger.debug(`Found ${newEntries.length} new entries out of total`);
-                    resolve(newEntries);
-                    return;
-                }
-                const metadata = cursor.value;
-                if (!knownSet.has(metadata.id)) {
-                    newEntries.push(metadata);
-                }
-                cursor.continue();
-            };
-            cursorReq.onerror = () => reject(cursorReq.error);
+        return this.runWithReconnect("findNewEntries", async () => {
+            const knownSet = new Set(knownIds);
+            const db = await this.ensureOpen();
+            const tx = db.transaction(ENTRIES_STORE, "readonly");
+            const entriesOS = tx.objectStore(ENTRIES_STORE);
+            const newEntries = [];
+            return new Promise((resolve, reject) => {
+                const cursorReq = entriesOS.openCursor();
+                cursorReq.onsuccess = () => {
+                    const cursor = cursorReq.result;
+                    if (!cursor) {
+                        this.logger.debug(`Found ${newEntries.length} new entries out of total`);
+                        resolve(newEntries);
+                        return;
+                    }
+                    const metadata = cursor.value;
+                    if (!knownSet.has(metadata.id)) {
+                        newEntries.push(metadata);
+                    }
+                    cursor.continue();
+                };
+                cursorReq.onerror = () => reject(cursorReq.error);
+            });
         });
     }
     async findNewEntriesForDoc(knownIds, docId) {
-        const knownSet = new Set(knownIds);
-        const db = await this.ensureOpen();
-        const tx = db.transaction(ENTRIES_STORE, "readonly");
-        const entriesOS = tx.objectStore(ENTRIES_STORE);
-        const index = entriesOS.index(IDX_DOC_ID);
-        const newEntries = [];
-        return new Promise((resolve, reject) => {
-            const cursorReq = index.openCursor(IDBKeyRange.only(docId));
-            cursorReq.onsuccess = () => {
-                const cursor = cursorReq.result;
-                if (!cursor) {
-                    this.logger.debug(`Found ${newEntries.length} new entries for doc ${docId}`);
-                    resolve(newEntries);
-                    return;
-                }
-                const metadata = cursor.value;
-                if (!knownSet.has(metadata.id)) {
-                    newEntries.push(metadata);
-                }
-                cursor.continue();
-            };
-            cursorReq.onerror = () => reject(cursorReq.error);
+        return this.runWithReconnect("findNewEntriesForDoc", async () => {
+            const knownSet = new Set(knownIds);
+            const db = await this.ensureOpen();
+            const tx = db.transaction(ENTRIES_STORE, "readonly");
+            const entriesOS = tx.objectStore(ENTRIES_STORE);
+            const index = entriesOS.index(IDX_DOC_ID);
+            const newEntries = [];
+            return new Promise((resolve, reject) => {
+                const cursorReq = index.openCursor(IDBKeyRange.only(docId));
+                cursorReq.onsuccess = () => {
+                    const cursor = cursorReq.result;
+                    if (!cursor) {
+                        this.logger.debug(`Found ${newEntries.length} new entries for doc ${docId}`);
+                        resolve(newEntries);
+                        return;
+                    }
+                    const metadata = cursor.value;
+                    if (!knownSet.has(metadata.id)) {
+                        newEntries.push(metadata);
+                    }
+                    cursor.continue();
+                };
+                cursorReq.onerror = () => reject(cursorReq.error);
+            });
         });
     }
     async findEntries(type, creationDateFrom, creationDateUntil) {
-        const db = await this.ensureOpen();
-        const tx = db.transaction(ENTRIES_STORE, "readonly");
-        const entriesOS = tx.objectStore(ENTRIES_STORE);
-        const index = entriesOS.index(IDX_ENTRY_TYPE_CREATED_AT);
-        // Build key range on [entryType, createdAt]
-        const lower = [type, creationDateFrom ?? -Infinity];
-        const upper = [type, creationDateUntil ?? Infinity];
-        const range = IDBKeyRange.bound(lower, upper, false, // lowerOpen: inclusive
-        creationDateUntil !== null // upperOpen: exclusive when creationDateUntil is set
-        );
-        const results = [];
-        return new Promise((resolve, reject) => {
-            const cursorReq = index.openCursor(range);
-            cursorReq.onsuccess = () => {
-                const cursor = cursorReq.result;
-                if (!cursor) {
-                    this.logger.debug(`Found ${results.length} entries of type ${type} in date range`);
-                    resolve(results);
-                    return;
-                }
-                results.push(cursor.value);
-                cursor.continue();
-            };
-            cursorReq.onerror = () => reject(cursorReq.error);
+        return this.runWithReconnect("findEntries", async () => {
+            const db = await this.ensureOpen();
+            const tx = db.transaction(ENTRIES_STORE, "readonly");
+            const entriesOS = tx.objectStore(ENTRIES_STORE);
+            const index = entriesOS.index(IDX_ENTRY_TYPE_CREATED_AT);
+            // Build key range on [entryType, createdAt]
+            const lower = [type, creationDateFrom ?? -Infinity];
+            const upper = [type, creationDateUntil ?? Infinity];
+            const range = IDBKeyRange.bound(lower, upper, false, // lowerOpen: inclusive
+            creationDateUntil !== null // upperOpen: exclusive when creationDateUntil is set
+            );
+            const results = [];
+            return new Promise((resolve, reject) => {
+                const cursorReq = index.openCursor(range);
+                cursorReq.onsuccess = () => {
+                    const cursor = cursorReq.result;
+                    if (!cursor) {
+                        this.logger.debug(`Found ${results.length} entries of type ${type} in date range`);
+                        resolve(results);
+                        return;
+                    }
+                    results.push(cursor.value);
+                    cursor.continue();
+                };
+                cursorReq.onerror = () => reject(cursorReq.error);
+            });
         });
     }
     async getAllIds() {
-        const db = await this.ensureOpen();
-        const tx = db.transaction(ENTRIES_STORE, "readonly");
-        const entriesOS = tx.objectStore(ENTRIES_STORE);
-        const keys = [];
-        return new Promise((resolve, reject) => {
-            const cursorReq = entriesOS.openKeyCursor();
-            cursorReq.onsuccess = () => {
-                const cursor = cursorReq.result;
-                if (!cursor) {
-                    this.logger.debug(`Returning ${keys.length} entry IDs`);
-                    resolve(keys);
-                    return;
-                }
-                keys.push(String(cursor.primaryKey));
-                cursor.continue();
-            };
-            cursorReq.onerror = () => reject(cursorReq.error);
+        return this.runWithReconnect("getAllIds", async () => {
+            const db = await this.ensureOpen();
+            const tx = db.transaction(ENTRIES_STORE, "readonly");
+            const entriesOS = tx.objectStore(ENTRIES_STORE);
+            const keys = [];
+            return new Promise((resolve, reject) => {
+                const cursorReq = entriesOS.openKeyCursor();
+                cursorReq.onsuccess = () => {
+                    const cursor = cursorReq.result;
+                    if (!cursor) {
+                        this.logger.debug(`Returning ${keys.length} entry IDs`);
+                        resolve(keys);
+                        return;
+                    }
+                    keys.push(String(cursor.primaryKey));
+                    cursor.continue();
+                };
+                cursorReq.onerror = () => reject(cursorReq.error);
+            });
         });
     }
     async scanEntriesSince(cursor, limit = Number.MAX_SAFE_INTEGER, filters) {
-        const db = await this.ensureOpen();
-        const tx = db.transaction(ENTRIES_STORE, "readonly");
-        const entriesOS = tx.objectStore(ENTRIES_STORE);
-        const index = entriesOS.index(IDX_RECEIPT_ORDER_ID);
-        // Build lower bound from cursor
-        let range = null;
-        if (cursor) {
-            range = IDBKeyRange.lowerBound([cursor.receiptOrder, cursor.id], true);
-        }
-        const page = [];
-        return new Promise((resolve, reject) => {
-            const cursorReq = index.openCursor(range);
-            let hasMore = false;
-            cursorReq.onsuccess = () => {
-                const idbCursor = cursorReq.result;
-                if (!idbCursor) {
-                    const last = page.length > 0 ? page[page.length - 1] : null;
-                    resolve({
-                        entries: page,
-                        nextCursor: last
-                            ? { receiptOrder: last.receiptOrder ?? 0, id: last.id }
-                            : cursor,
-                        hasMore,
-                    });
-                    return;
-                }
-                const meta = idbCursor.value;
-                if (page.length >= limit) {
-                    // We already have enough entries. Check if this one matches filters
-                    // to determine hasMore.
+        return this.runWithReconnect("scanEntriesSince", async () => {
+            const db = await this.ensureOpen();
+            const tx = db.transaction(ENTRIES_STORE, "readonly");
+            const entriesOS = tx.objectStore(ENTRIES_STORE);
+            const index = entriesOS.index(IDX_RECEIPT_ORDER_ID);
+            // Build lower bound from cursor
+            let range = null;
+            if (cursor) {
+                range = IDBKeyRange.lowerBound([cursor.receiptOrder, cursor.id], true);
+            }
+            const page = [];
+            return new Promise((resolve, reject) => {
+                const cursorReq = index.openCursor(range);
+                let hasMore = false;
+                cursorReq.onsuccess = () => {
+                    const idbCursor = cursorReq.result;
+                    if (!idbCursor) {
+                        const last = page.length > 0 ? page[page.length - 1] : null;
+                        resolve({
+                            entries: page,
+                            nextCursor: last
+                                ? { receiptOrder: last.receiptOrder ?? 0, id: last.id }
+                                : cursor,
+                            hasMore,
+                        });
+                        return;
+                    }
+                    const meta = idbCursor.value;
+                    if (page.length >= limit) {
+                        // We already have enough entries. Check if this one matches filters
+                        // to determine hasMore.
+                        if (this.matchesScanFilters(meta, filters)) {
+                            hasMore = true;
+                        }
+                        const last = page[page.length - 1];
+                        resolve({
+                            entries: page,
+                            nextCursor: { receiptOrder: last.receiptOrder ?? 0, id: last.id },
+                            hasMore: true,
+                        });
+                        return;
+                    }
                     if (this.matchesScanFilters(meta, filters)) {
-                        hasMore = true;
+                        page.push(meta);
                     }
-                    const last = page[page.length - 1];
-                    resolve({
-                        entries: page,
-                        nextCursor: { receiptOrder: last.receiptOrder ?? 0, id: last.id },
-                        hasMore: true,
-                    });
-                    return;
-                }
-                if (this.matchesScanFilters(meta, filters)) {
-                    page.push(meta);
-                }
-                idbCursor.continue();
-            };
-            cursorReq.onerror = () => reject(cursorReq.error);
+                    idbCursor.continue();
+                };
+                cursorReq.onerror = () => reject(cursorReq.error);
+            });
         });
     }
     async getIdBloomSummary() {
-        const db = await this.ensureOpen();
-        // Try to read from cache first
-        const readTx = db.transaction(BLOOM_CACHE_STORE, "readonly");
-        const bloomOS = readTx.objectStore(BLOOM_CACHE_STORE);
-        const cached = await reqToPromise(bloomOS.get(BLOOM_CACHE_KEY));
-        if (cached && !cached.dirty && cached.summary) {
-            this.logger.debug("Returning cached bloom summary");
-            return cached.summary;
-        }
-        // Recompute bloom summary
-        this.logger.debug("Recomputing bloom summary");
-        const ids = await this.getAllIds();
-        const summary = createIdBloomSummaryBrowser(ids);
-        // Persist to cache
-        const writeTx = db.transaction(BLOOM_CACHE_STORE, "readwrite");
-        const writeBloomOS = writeTx.objectStore(BLOOM_CACHE_STORE);
-        await reqToPromise(writeBloomOS.put({
-            key: BLOOM_CACHE_KEY,
-            summary,
-            dirty: false,
-        }));
-        await txToPromise(writeTx);
-        return summary;
+        return this.runWithReconnect("getIdBloomSummary", async () => {
+            const db = await this.ensureOpen();
+            // Try to read from cache first
+            const readTx = db.transaction(BLOOM_CACHE_STORE, "readonly");
+            const bloomOS = readTx.objectStore(BLOOM_CACHE_STORE);
+            const cached = await reqToPromise(bloomOS.get(BLOOM_CACHE_KEY));
+            if (cached && !cached.dirty && cached.summary) {
+                this.logger.debug("Returning cached bloom summary");
+                return cached.summary;
+            }
+            // Recompute bloom summary
+            this.logger.debug("Recomputing bloom summary");
+            const ids = await this.getAllIds();
+            const summary = createIdBloomSummaryBrowser(ids);
+            // Persist to cache
+            const writeTx = db.transaction(BLOOM_CACHE_STORE, "readwrite");
+            const writeBloomOS = writeTx.objectStore(BLOOM_CACHE_STORE);
+            await reqToPromise(writeBloomOS.put({
+                key: BLOOM_CACHE_KEY,
+                summary,
+                dirty: false,
+            }));
+            await txToPromise(writeTx);
+            return summary;
+        });
     }
     async planDocumentMaterialization(docId, options) {
-        const entries = await this.readEntriesForDoc(docId);
-        return (0, MaterializationPlanner_1.computeDocumentMaterializationPlan)(docId, entries, options);
+        return this.runWithReconnect("planDocumentMaterialization", async () => {
+            const entries = await this.readEntriesForDoc(docId);
+            return (0, MaterializationPlanner_1.computeDocumentMaterializationPlan)(docId, entries, options);
+        });
     }
     async planDocumentMaterializationBatch(docIds, options) {
-        const all = [];
-        // Batch doc-scoped index reads so browser planning stays proportional to
-        // the requested documents instead of loading the entire entries store.
-        const concurrency = 16;
-        for (let offset = 0; offset < docIds.length; offset += concurrency) {
-            const batch = docIds.slice(offset, offset + concurrency);
-            const batchResults = await Promise.all(batch.map((docId) => this.readEntriesForDoc(docId)));
-            for (const entries of batchResults) {
-                all.push(...entries);
+        return this.runWithReconnect("planDocumentMaterializationBatch", async () => {
+            const all = [];
+            // Batch doc-scoped index reads so browser planning stays proportional to
+            // the requested documents instead of loading the entire entries store.
+            const concurrency = 16;
+            for (let offset = 0; offset < docIds.length; offset += concurrency) {
+                const batch = docIds.slice(offset, offset + concurrency);
+                const batchResults = await Promise.all(batch.map((docId) => this.readEntriesForDoc(docId)));
+                for (const entries of batchResults) {
+                    all.push(...entries);
+                }
             }
-        }
-        return (0, MaterializationPlanner_1.computeBatchMaterializationPlan)(all, docIds, options);
+            return (0, MaterializationPlanner_1.computeBatchMaterializationPlan)(all, docIds, options);
+        });
     }
     async resolveDependencies(startId, options) {
         const stopAtEntryType = options?.stopAtEntryType;
         const maxDepth = options?.maxDepth;
         const includeStart = options?.includeStart !== false;
-        const db = await this.ensureOpen();
-        const tx = db.transaction(ENTRIES_STORE, "readonly");
-        const entriesOS = tx.objectStore(ENTRIES_STORE);
-        const result = [];
-        const visited = new Set();
-        const queue = [
-            { id: startId, depth: 0 },
-        ];
-        let queueIdx = 0;
-        while (queueIdx < queue.length) {
-            const { id, depth } = queue[queueIdx++];
-            if (visited.has(id))
-                continue;
-            visited.add(id);
-            if (maxDepth !== undefined && depth > maxDepth)
-                continue;
-            const entry = (await reqToPromise(entriesOS.get(id)));
-            if (!entry) {
-                this.logger.warn(`Entry ${id} not found during dependency resolution`);
-                continue;
-            }
-            if (stopAtEntryType && entry.entryType === stopAtEntryType && id !== startId) {
-                result.push(id);
-                continue;
-            }
-            if (id !== startId || includeStart) {
-                result.push(id);
-            }
-            for (const depId of entry.dependencyIds) {
-                if (!visited.has(depId)) {
-                    queue.push({ id: depId, depth: depth + 1 });
+        return this.runWithReconnect("resolveDependencies", async () => {
+            const db = await this.ensureOpen();
+            const tx = db.transaction(ENTRIES_STORE, "readonly");
+            const entriesOS = tx.objectStore(ENTRIES_STORE);
+            const result = [];
+            const visited = new Set();
+            const queue = [
+                { id: startId, depth: 0 },
+            ];
+            let queueIdx = 0;
+            while (queueIdx < queue.length) {
+                const { id, depth } = queue[queueIdx++];
+                if (visited.has(id))
+                    continue;
+                visited.add(id);
+                if (maxDepth !== undefined && depth > maxDepth)
+                    continue;
+                const entry = (await reqToPromise(entriesOS.get(id)));
+                if (!entry) {
+                    this.logger.warn(`Entry ${id} not found during dependency resolution`);
+                    continue;
+                }
+                if (stopAtEntryType && entry.entryType === stopAtEntryType && id !== startId) {
+                    result.push(id);
+                    continue;
+                }
+                if (id !== startId || includeStart) {
+                    result.push(id);
+                }
+                for (const depId of entry.dependencyIds) {
+                    if (!visited.has(depId)) {
+                        queue.push({ id: depId, depth: depth + 1 });
+                    }
                 }
             }
-        }
-        result.reverse();
-        this.logger.debug(`Resolved ${result.length} dependencies for ${startId}`);
-        return result;
+            result.reverse();
+            this.logger.debug(`Resolved ${result.length} dependencies for ${startId}`);
+            return result;
+        });
     }
     async purgeDocHistory(docId) {
         this.logger.info(`Purging entry history for document: ${docId}`);
-        const db = await this.ensureOpen();
-        const tx = db.transaction([ENTRIES_STORE, CONTENT_STORE, BLOOM_CACHE_STORE, META_STORE], "readwrite");
-        const entriesOS = tx.objectStore(ENTRIES_STORE);
-        const contentOS = tx.objectStore(CONTENT_STORE);
-        const bloomOS = tx.objectStore(BLOOM_CACHE_STORE);
-        const metaOS = tx.objectStore(META_STORE);
-        const docIndex = entriesOS.index(IDX_DOC_ID);
-        let totalContentBytes = (await readNumericMetaValue(metaOS, TOTAL_CONTENT_BYTES_KEY)) ?? 0;
-        let totalMetadataBytes = (await readNumericMetaValue(metaOS, TOTAL_METADATA_BYTES_KEY)) ?? 0;
-        // Collect all entries for this docId
-        const entriesToPurge = [];
-        await new Promise((resolve, reject) => {
-            const cursorReq = docIndex.openCursor(IDBKeyRange.only(docId));
-            cursorReq.onsuccess = () => {
-                const cursor = cursorReq.result;
-                if (!cursor) {
-                    resolve();
-                    return;
-                }
-                entriesToPurge.push(cursor.value);
-                cursor.continue();
-            };
-            cursorReq.onerror = () => reject(cursorReq.error);
-        });
-        if (entriesToPurge.length === 0) {
-            this.logger.debug(`No entries found for document ${docId}, nothing to purge`);
-            return;
-        }
-        // Delete entries and decrement content ref counts
-        for (const entry of entriesToPurge) {
-            await reqToPromise(entriesOS.delete(entry.id));
-            totalMetadataBytes -= getMetadataPayloadBytes(entry);
-            const contentRecord = (await reqToPromise(contentOS.get(entry.contentHash)));
-            if (contentRecord) {
-                const newCount = contentRecord.refCount - 1;
-                if (newCount <= 0) {
-                    await reqToPromise(contentOS.delete(entry.contentHash));
-                    totalContentBytes -= contentRecord.data.byteLength;
-                    this.logger.debug(`Cleaned up orphaned content ${entry.contentHash.substring(0, 8)}...`);
-                }
-                else {
-                    contentRecord.refCount = newCount;
-                    await reqToPromise(contentOS.put(contentRecord));
+        return this.runWithReconnect("purgeDocHistory", async () => {
+            const db = await this.ensureOpen();
+            const tx = db.transaction([ENTRIES_STORE, CONTENT_STORE, BLOOM_CACHE_STORE, META_STORE], "readwrite");
+            const entriesOS = tx.objectStore(ENTRIES_STORE);
+            const contentOS = tx.objectStore(CONTENT_STORE);
+            const bloomOS = tx.objectStore(BLOOM_CACHE_STORE);
+            const metaOS = tx.objectStore(META_STORE);
+            const docIndex = entriesOS.index(IDX_DOC_ID);
+            let totalContentBytes = (await readNumericMetaValue(metaOS, TOTAL_CONTENT_BYTES_KEY)) ?? 0;
+            let totalMetadataBytes = (await readNumericMetaValue(metaOS, TOTAL_METADATA_BYTES_KEY)) ?? 0;
+            // Collect all entries for this docId
+            const entriesToPurge = [];
+            await new Promise((resolve, reject) => {
+                const cursorReq = docIndex.openCursor(IDBKeyRange.only(docId));
+                cursorReq.onsuccess = () => {
+                    const cursor = cursorReq.result;
+                    if (!cursor) {
+                        resolve();
+                        return;
+                    }
+                    entriesToPurge.push(cursor.value);
+                    cursor.continue();
+                };
+                cursorReq.onerror = () => reject(cursorReq.error);
+            });
+            if (entriesToPurge.length === 0) {
+                this.logger.debug(`No entries found for document ${docId}, nothing to purge`);
+                return;
+            }
+            // Delete entries and decrement content ref counts
+            for (const entry of entriesToPurge) {
+                await reqToPromise(entriesOS.delete(entry.id));
+                totalMetadataBytes -= getMetadataPayloadBytes(entry);
+                const contentRecord = (await reqToPromise(contentOS.get(entry.contentHash)));
+                if (contentRecord) {
+                    const newCount = contentRecord.refCount - 1;
+                    if (newCount <= 0) {
+                        await reqToPromise(contentOS.delete(entry.contentHash));
+                        totalContentBytes -= contentRecord.data.byteLength;
+                        this.logger.debug(`Cleaned up orphaned content ${entry.contentHash.substring(0, 8)}...`);
+                    }
+                    else {
+                        contentRecord.refCount = newCount;
+                        await reqToPromise(contentOS.put(contentRecord));
+                    }
                 }
             }
+            // Invalidate bloom cache
+            await reqToPromise(bloomOS.put({ key: BLOOM_CACHE_KEY, summary: null, dirty: true }));
+            await writeNumericMetaValue(metaOS, TOTAL_CONTENT_BYTES_KEY, Math.max(0, totalContentBytes));
+            await writeNumericMetaValue(metaOS, TOTAL_METADATA_BYTES_KEY, Math.max(0, totalMetadataBytes));
+            await txToPromise(tx);
+            this.logger.info(`Purged ${entriesToPurge.length} entries for document ${docId}`);
+        });
+    }
+    async deleteEntriesForAttachment(docId, attachmentId) {
+        const prefix = `${docId}_a_${attachmentId}_`;
+        return this.deleteEntriesWhere(`deleteEntriesForAttachment:${attachmentId}`, (entry) => entry.docId === docId
+            && entry.entryType === "attachment_chunk"
+            && (entry.attachmentId === attachmentId || entry.id.startsWith(prefix)));
+    }
+    async deleteEntriesById(entryIds) {
+        if (entryIds.length === 0) {
+            return 0;
         }
-        // Invalidate bloom cache
-        await reqToPromise(bloomOS.put({ key: BLOOM_CACHE_KEY, summary: null, dirty: true }));
-        await writeNumericMetaValue(metaOS, TOTAL_CONTENT_BYTES_KEY, Math.max(0, totalContentBytes));
-        await writeNumericMetaValue(metaOS, TOTAL_METADATA_BYTES_KEY, Math.max(0, totalMetadataBytes));
-        await txToPromise(tx);
-        this.logger.info(`Purged ${entriesToPurge.length} entries for document ${docId}`);
+        const ids = new Set(entryIds);
+        return this.deleteEntriesWhere("deleteEntriesById", (entry) => ids.has(entry.id));
     }
     async clearAllLocalData() {
         this.logger.info(`Clearing all local data for store ${this.storeId}`);
@@ -888,6 +979,61 @@ class IndexedDBContentAddressedStore {
         }
         return true;
     }
+    async deleteEntriesWhere(opName, predicate) {
+        return this.runWithReconnect(opName, async () => {
+            const db = await this.ensureOpen();
+            const tx = db.transaction([ENTRIES_STORE, CONTENT_STORE, BLOOM_CACHE_STORE, META_STORE], "readwrite");
+            const entriesOS = tx.objectStore(ENTRIES_STORE);
+            const contentOS = tx.objectStore(CONTENT_STORE);
+            const bloomOS = tx.objectStore(BLOOM_CACHE_STORE);
+            const metaOS = tx.objectStore(META_STORE);
+            let totalContentBytes = (await readNumericMetaValue(metaOS, TOTAL_CONTENT_BYTES_KEY)) ?? 0;
+            let totalMetadataBytes = (await readNumericMetaValue(metaOS, TOTAL_METADATA_BYTES_KEY)) ?? 0;
+            let removedCount = 0;
+            await new Promise((resolve, reject) => {
+                const cursorReq = entriesOS.openCursor();
+                cursorReq.onsuccess = async () => {
+                    const cursor = cursorReq.result;
+                    if (!cursor) {
+                        resolve();
+                        return;
+                    }
+                    try {
+                        const entry = cursor.value;
+                        if (predicate(entry)) {
+                            await reqToPromise(cursor.delete());
+                            totalMetadataBytes -= getMetadataPayloadBytes(entry);
+                            const contentRecord = (await reqToPromise(contentOS.get(entry.contentHash)));
+                            if (contentRecord) {
+                                const nextRefCount = contentRecord.refCount - 1;
+                                if (nextRefCount <= 0) {
+                                    await reqToPromise(contentOS.delete(entry.contentHash));
+                                    totalContentBytes -= contentRecord.data.byteLength;
+                                }
+                                else {
+                                    contentRecord.refCount = nextRefCount;
+                                    await reqToPromise(contentOS.put(contentRecord));
+                                }
+                            }
+                            removedCount++;
+                        }
+                        cursor.continue();
+                    }
+                    catch (error) {
+                        reject(error);
+                    }
+                };
+                cursorReq.onerror = () => reject(cursorReq.error);
+            });
+            if (removedCount > 0) {
+                await reqToPromise(bloomOS.put({ key: BLOOM_CACHE_KEY, summary: null, dirty: true }));
+                await writeNumericMetaValue(metaOS, TOTAL_CONTENT_BYTES_KEY, Math.max(0, totalContentBytes));
+                await writeNumericMetaValue(metaOS, TOTAL_METADATA_BYTES_KEY, Math.max(0, totalMetadataBytes));
+            }
+            await txToPromise(tx);
+            return removedCount;
+        });
+    }
     async readEntriesForDoc(docId) {
         const db = await this.ensureOpen();
         const tx = db.transaction(ENTRIES_STORE, "readonly");