@fairfox/polly 0.60.0 → 0.62.0

package/dist/src/mesh.js

@@ -69,6 +69,90 @@ var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require
   throw Error('Dynamic require of "' + x + '" is not supported');
 });
 
+// src/shared/lib/idb-helpers.ts
+function openIDB(options) {
+  return new Promise((resolve, reject) => {
+    const start = Date.now();
+    const request = indexedDB.open(options.name, options.version);
+    let settled = false;
+    const timer = setTimeout(() => {
+      if (settled)
+        return;
+      settled = true;
+      const elapsedMs = Date.now() - start;
+      reject(new Error(`Polly IndexedDB open of '${options.name}' timed out after ${elapsedMs}ms (cross-tab lock or zombie connection?)`));
+    }, IDB_OPEN_TIMEOUT_MS);
+    request.onerror = () => {
+      if (settled)
+        return;
+      settled = true;
+      clearTimeout(timer);
+      reject(request.error);
+    };
+    request.onsuccess = () => {
+      if (settled)
+        return;
+      settled = true;
+      clearTimeout(timer);
+      resolve(request.result);
+    };
+    request.onupgradeneeded = (event) => {
+      const db = event.target.result;
+      options.upgrade(db, event);
+    };
+  });
+}
+function cachedOpen(ref, options) {
+  if (ref.promise)
+    return ref.promise;
+  const pending = openIDB(options);
+  pending.catch(() => {
+    if (ref.promise === pending)
+      ref.promise = null;
+  });
+  ref.promise = pending;
+  return pending;
+}
+function runRequest(request) {
+  return new Promise((resolve, reject) => {
+    request.onsuccess = () => resolve(request.result);
+    request.onerror = () => reject(request.error);
+  });
+}
+function runTx(db, storeName, mode, fn) {
+  return new Promise((resolve, reject) => {
+    const tx = db.transaction(storeName, mode);
+    const store = tx.objectStore(storeName);
+    tx.oncomplete = () => resolve();
+    tx.onerror = () => reject(tx.error);
+    tx.onabort = () => reject(tx.error);
+    try {
+      fn(store);
+    } catch (err) {
+      try {
+        tx.abort();
+      } catch {}
+      reject(err);
+    }
+  });
+}
+function iterateCursor(db, storeName, visit) {
+  return new Promise((resolve, reject) => {
+    const tx = db.transaction(storeName, "readonly");
+    const store = tx.objectStore(storeName);
+    const request = store.openCursor();
+    request.onsuccess = () => {
+      const cursor = request.result;
+      if (!cursor)
+        return resolve();
+      visit(cursor.key, cursor.value);
+      cursor.continue();
+    };
+    request.onerror = () => reject(request.error);
+  });
+}
+var IDB_OPEN_TIMEOUT_MS = 5000;
+
 // src/shared/lib/encryption.ts
 var exports_encryption = {};
 __export(exports_encryption, {
@@ -255,42 +339,28 @@ class IndexedDBBlobCache {
   static DB_NAME = "polly-blobs";
   static DB_VERSION = 1;
   static STORE_NAME = "blobs";
-  dbPromise = null;
+  dbRef = { promise: null };
   urls = new Map;
   openDB() {
-    if (this.dbPromise)
-      return this.dbPromise;
-    this.dbPromise = new Promise((resolve, reject) => {
-      const request = indexedDB.open(IndexedDBBlobCache.DB_NAME, IndexedDBBlobCache.DB_VERSION);
-      request.onerror = () => reject(request.error);
-      request.onsuccess = () => resolve(request.result);
-      request.onupgradeneeded = (event) => {
-        const db = event.target.result;
+    return cachedOpen(this.dbRef, {
+      name: IndexedDBBlobCache.DB_NAME,
+      version: IndexedDBBlobCache.DB_VERSION,
+      upgrade: (db) => {
         if (!db.objectStoreNames.contains(IndexedDBBlobCache.STORE_NAME)) {
           db.createObjectStore(IndexedDBBlobCache.STORE_NAME);
         }
-      };
+      }
     });
-    return this.dbPromise;
   }
   async getRecord(hash) {
     const db = await this.openDB();
-    return new Promise((resolve, reject) => {
-      const tx = db.transaction(IndexedDBBlobCache.STORE_NAME, "readonly");
-      const store = tx.objectStore(IndexedDBBlobCache.STORE_NAME);
-      const request = store.get(hash);
-      request.onsuccess = () => resolve(request.result);
-      request.onerror = () => reject(request.error);
-    });
+    const tx = db.transaction(IndexedDBBlobCache.STORE_NAME, "readonly");
+    return runRequest(tx.objectStore(IndexedDBBlobCache.STORE_NAME).get(hash));
   }
   async putRecord(hash, record) {
     const db = await this.openDB();
-    return new Promise((resolve, reject) => {
-      const tx = db.transaction(IndexedDBBlobCache.STORE_NAME, "readwrite");
-      const store = tx.objectStore(IndexedDBBlobCache.STORE_NAME);
+    await runTx(db, IndexedDBBlobCache.STORE_NAME, "readwrite", (store) => {
       store.put(record, hash);
-      tx.oncomplete = () => resolve();
-      tx.onerror = () => reject(tx.error);
     });
   }
   async get(hash) {
@@ -311,13 +381,9 @@ class IndexedDBBlobCache {
   }
   async has(hash) {
     const db = await this.openDB();
-    return new Promise((resolve, reject) => {
-      const tx = db.transaction(IndexedDBBlobCache.STORE_NAME, "readonly");
-      const store = tx.objectStore(IndexedDBBlobCache.STORE_NAME);
-      const request = store.count(hash);
-      request.onsuccess = () => resolve(request.result > 0);
-      request.onerror = () => reject(request.error);
-    });
+    const tx = db.transaction(IndexedDBBlobCache.STORE_NAME, "readonly");
+    const count = await runRequest(tx.objectStore(IndexedDBBlobCache.STORE_NAME).count(hash));
+    return count > 0;
   }
   async delete(hash) {
     const url = this.urls.get(hash);
@@ -326,12 +392,8 @@ class IndexedDBBlobCache {
       this.urls.delete(hash);
     }
     const db = await this.openDB();
-    return new Promise((resolve, reject) => {
-      const tx = db.transaction(IndexedDBBlobCache.STORE_NAME, "readwrite");
-      const store = tx.objectStore(IndexedDBBlobCache.STORE_NAME);
+    await runTx(db, IndexedDBBlobCache.STORE_NAME, "readwrite", (store) => {
       store.delete(hash);
-      tx.oncomplete = () => resolve();
-      tx.onerror = () => reject(tx.error);
     });
   }
   async pin(hash) {
@@ -348,50 +410,25 @@ class IndexedDBBlobCache {
   }
   async size() {
     const db = await this.openDB();
-    return new Promise((resolve, reject) => {
-      const tx = db.transaction(IndexedDBBlobCache.STORE_NAME, "readonly");
-      const store = tx.objectStore(IndexedDBBlobCache.STORE_NAME);
-      const request = store.openCursor();
-      let total = 0;
-      request.onsuccess = () => {
-        const cursor = request.result;
-        if (cursor) {
-          const value = cursor.value;
-          total += value.size;
-          cursor.continue();
-        } else {
-          resolve(total);
-        }
-      };
-      request.onerror = () => reject(request.error);
+    let total = 0;
+    await iterateCursor(db, IndexedDBBlobCache.STORE_NAME, (_key, value) => {
+      total += value.size;
     });
+    return total;
   }
   async evict(maxBytes) {
     const db = await this.openDB();
     const candidates = [];
     let totalSize = 0;
-    await new Promise((resolve, reject) => {
-      const tx = db.transaction(IndexedDBBlobCache.STORE_NAME, "readonly");
-      const store = tx.objectStore(IndexedDBBlobCache.STORE_NAME);
-      const request = store.openCursor();
-      request.onsuccess = () => {
-        const cursor = request.result;
-        if (cursor) {
-          const value = cursor.value;
-          totalSize += value.size;
-          if (!value.pinned) {
-            candidates.push({
-              hash: cursor.key,
-              accessedAt: value.accessedAt,
-              size: value.size
-            });
-          }
-          cursor.continue();
-        } else {
-          resolve();
-        }
-      };
-      request.onerror = () => reject(request.error);
+    await iterateCursor(db, IndexedDBBlobCache.STORE_NAME, (key, value) => {
+      totalSize += value.size;
+      if (!value.pinned) {
+        candidates.push({
+          hash: key,
+          accessedAt: value.accessedAt,
+          size: value.size
+        });
+      }
     });
     if (totalSize <= maxBytes)
       return 0;
@@ -1783,6 +1820,7 @@ function resetMeshState() {
   lazyInvocations = 0;
   lazyReachedRepo = 0;
   lastLoadedRejection = undefined;
+  lastStorageOpenError = undefined;
   lazyWrappers = [];
 }
 function isMeshStateConfigured() {
@@ -1813,6 +1851,47 @@ function recordLoadedRejection(thrown) {
     at: Date.now()
   };
 }
+var STORAGE_OP_TIMEOUT_MS = 5000;
+var lastStorageOpenError;
+function getStorageOpenError() {
+  return lastStorageOpenError;
+}
+function recordStorageOpenError(error) {
+  lastStorageOpenError = error;
+}
+async function withStorageTimeout(operation, documentId, promise, timeoutMs = STORAGE_OP_TIMEOUT_MS) {
+  const start = Date.now();
+  let timer;
+  let timedOut = false;
+  try {
+    return await new Promise((resolve, reject) => {
+      timer = setTimeout(() => {
+        timedOut = true;
+        const elapsedMs = Date.now() - start;
+        const message = `Polly $meshState: storage operation '${operation}' on document '${documentId}' timed out after ${timeoutMs}ms`;
+        recordStorageOpenError({
+          operation,
+          documentId,
+          timeoutMs,
+          elapsedMs,
+          message,
+          at: Date.now()
+        });
+        reject(new Error(message));
+      }, timeoutMs);
+      promise.then((value) => {
+        if (!timedOut)
+          resolve(value);
+      }, (err) => {
+        if (!timedOut)
+          reject(err);
+      });
+    });
+  } finally {
+    if (timer !== undefined)
+      clearTimeout(timer);
+  }
+}
 var LAZY_WRAPPER_LOG_CAP = 64;
 var lazyWrappers = [];
 function getLazyWrappers() {
@@ -1857,14 +1936,16 @@ function buildHandleFactory(repo, key, initialDoc) {
     try {
       const cached = repo.handles[documentId];
       lazyReachedRepo++;
+      const docIdString = documentId;
       if (cached) {
-        await cached.whenReady(["ready", "unavailable"]);
+        await withStorageTimeout("whenReady", docIdString, cached.whenReady(["ready", "unavailable"]));
         if (cached.state === "ready") {
           exitReason = "returned-cached";
           return cached;
         }
       }
-      const stored = await repo.storageSubsystem?.loadDoc(documentId);
+      const loadPromise = repo.storageSubsystem?.loadDoc(documentId);
+      const stored = loadPromise ? await withStorageTimeout("loadDoc", docIdString, loadPromise) : undefined;
       if (stored) {
         exitReason = "loaded-from-storage";
         return repo.find(documentId, { allowableStates: ["ready"] });
@@ -2987,6 +3068,7 @@ function getReevaluateDocumentShare(repo) {
   return () => fn.call(sync);
 }
 function buildMeshStateModuleDiagnostics() {
+  const lazyWrappers2 = getLazyWrappers();
   return {
     moduleId: getMeshStateModuleId(),
     configured: isMeshStateConfigured(),
@@ -2995,9 +3077,30 @@ function buildMeshStateModuleDiagnostics() {
     lazyInvocations: getLazyInvocations(),
     lazyReachedRepo: getLazyReachedRepo(),
     lastLoadedRejection: getLastLoadedRejection(),
-    lazyWrappers: getLazyWrappers()
+    storageOpenError: getStorageOpenError(),
+    lazyWrappers: lazyWrappers2,
+    lazyWrapperDuplicateDocIds: findLazyWrapperDocIdDuplicates(lazyWrappers2)
   };
 }
+function findLazyWrapperDocIdDuplicates(records) {
+  const byDocId = new Map;
+  for (const record of records) {
+    let entry = byDocId.get(record.docId);
+    if (!entry) {
+      entry = { keys: new Set, count: 0 };
+      byDocId.set(record.docId, entry);
+    }
+    entry.keys.add(record.key);
+    entry.count++;
+  }
+  const duplicates = [];
+  for (const [docId, entry] of byDocId) {
+    if (entry.count > 1) {
+      duplicates.push({ docId, keys: [...entry.keys], recordCount: entry.count });
+    }
+  }
+  return duplicates;
+}
 function installPolly107SyncReevaluation(networkAdapter, repo) {
   const disable = typeof process !== "undefined" && process.env?.["POLLY_107_DISABLE_FIX"] === "1";
   if (disable)
@@ -3507,6 +3610,7 @@ export {
   isPairingTokenExpired,
   isMeshStateConfigured,
   isBlobRef,
+  getStorageOpenError,
   getMeshStateModuleId,
   getLazyWrappers,
   getLazyReachedRepo,
@@ -3562,4 +3666,4 @@ export {
   $meshCounter
 };
 
-//# debugId=CC67EB2297E1036764756E2164756E21
+//# debugId=EFE12C3DC2653D4B64756E2164756E21