@fairfox/polly 0.62.0 → 0.64.0

package/dist/src/mesh.js

@@ -70,25 +70,22 @@ var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require
 });
 
 // src/shared/lib/idb-helpers.ts
-function openIDB(options) {
+function openIDB(options, openFn = defaultOpenFn) {
   return new Promise((resolve, reject) => {
     const start = Date.now();
-    const request = indexedDB.open(options.name, options.version);
+    const request = openFn(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 = () => {
+    const elapsed = () => Date.now() - start;
+    const rejectWith = (reason, cause) => {
       if (settled)
         return;
       settled = true;
       clearTimeout(timer);
-      reject(request.error);
+      reject(new IDBOpenError(reason, options.name, elapsed(), cause));
     };
+    const timer = setTimeout(() => rejectWith("timeout"), IDB_OPEN_TIMEOUT_MS);
+    request.onerror = () => rejectWith("error", request.error);
+    request.onblocked = () => rejectWith("blocked");
     request.onsuccess = () => {
       if (settled)
         return;
@@ -102,10 +99,10 @@ function openIDB(options) {
     };
   });
 }
-function cachedOpen(ref, options) {
+function cachedOpen(ref, options, openFn) {
   if (ref.promise)
     return ref.promise;
-  const pending = openIDB(options);
+  const pending = openIDB(options, openFn);
   pending.catch(() => {
     if (ref.promise === pending)
       ref.promise = null;
@@ -151,7 +148,21 @@ function iterateCursor(db, storeName, visit) {
     request.onerror = () => reject(request.error);
   });
 }
-var IDB_OPEN_TIMEOUT_MS = 5000;
+var IDB_OPEN_TIMEOUT_MS = 5000, IDBOpenError, defaultOpenFn = (name, version) => indexedDB.open(name, version);
+var init_idb_helpers = __esm(() => {
+  IDBOpenError = class IDBOpenError extends Error {
+    reason;
+    dbName;
+    elapsedMs;
+    constructor(reason, dbName, elapsedMs, cause) {
+      super(`Polly IndexedDB open of '${dbName}' ${reason} after ${elapsedMs}ms`, cause === undefined ? undefined : { cause });
+      this.name = "IDBOpenError";
+      this.reason = reason;
+      this.dbName = dbName;
+      this.elapsedMs = elapsedMs;
+    }
+  };
+});
 
 // src/shared/lib/encryption.ts
 var exports_encryption = {};
@@ -253,6 +264,8 @@ var wasmUrl = new URL(wasmPath, import.meta.url).href;
 await initializeWasm(wasmUrl);
 
 // src/shared/lib/blob-cache.ts
+init_idb_helpers();
+
 class MemoryBlobCache {
   store = new Map;
   pinned = new Set;
@@ -1716,25 +1729,10 @@ function $crdtState(options) {
   const inner = signal2(options.initialValue);
   let updating = false;
   let currentHandle;
-  const loaded = (async () => {
-    const handle = await options.getHandle();
-    await handle.whenReady();
-    currentHandle = handle;
-    if (options.schemaVersion !== undefined) {
-      const targetVersion = options.schemaVersion;
-      const migrations = options.migrations ?? {};
-      handle.change((doc) => {
-        runMigrations(doc, targetVersion, migrations);
-        setDocVersion(doc, targetVersion);
-      });
-    }
-    updating = true;
-    try {
-      inner.value = cloneDoc(handle.doc());
-    } finally {
-      updating = false;
-    }
-    handle.on("change", (payload) => {
+  let detachChangeListener;
+  let swapping = false;
+  function attachChangeListener(handle) {
+    const listener = (payload) => {
       if (updating)
         return;
       updating = true;
@@ -1743,7 +1741,75 @@ function $crdtState(options) {
       } finally {
         updating = false;
       }
+      if (options.resolveRedirect && !swapping) {
+        maybeRebind(handle, payload.doc);
+      }
+    };
+    handle.on("change", listener);
+    detachChangeListener = () => {
+      handle.off("change", listener);
+    };
+  }
+  async function maybeRebind(fromHandle, doc) {
+    if (!options.resolveRedirect)
+      return;
+    if (swapping)
+      return;
+    swapping = true;
+    try {
+      const next = await options.resolveRedirect(fromHandle, doc);
+      if (!next)
+        return;
+      if (next === currentHandle)
+        return;
+      if (next.documentId === fromHandle.documentId)
+        return;
+      detachChangeListener?.();
+      detachChangeListener = undefined;
+      currentHandle = next;
+      attachChangeListener(next);
+      updating = true;
+      try {
+        inner.value = cloneDoc(next.doc());
+      } finally {
+        updating = false;
+      }
+    } finally {
+      swapping = false;
+    }
+  }
+  async function followInitialRedirects(start) {
+    if (!options.resolveRedirect)
+      return start;
+    let handle = start;
+    const seen = new Set([handle.documentId]);
+    for (;; ) {
+      const doc = handle.doc();
+      if (!doc)
+        break;
+      const next = await options.resolveRedirect(handle, doc);
+      if (!next || next === handle)
+        break;
+      const nextIdString = next.documentId;
+      if (seen.has(nextIdString))
+        break;
+      seen.add(nextIdString);
+      handle = next;
+      await handle.whenReady();
+    }
+    return handle;
+  }
+  function applyPendingMigrations(handle) {
+    if (options.schemaVersion === undefined)
+      return;
+    const targetVersion = options.schemaVersion;
+    const migrations = options.migrations ?? {};
+    handle.change((doc) => {
+      runMigrations(doc, targetVersion, migrations);
+      setDocVersion(doc, targetVersion);
     });
+  }
+  function bindSignalToHandle() {
     effect2(() => {
       const value = inner.value;
       if (updating)
@@ -1759,6 +1825,21 @@ function $crdtState(options) {
         updating = false;
       }
     });
+  }
+  const loaded = (async () => {
+    const initialHandle = await options.getHandle();
+    await initialHandle.whenReady();
+    const handle = await followInitialRedirects(initialHandle);
+    currentHandle = handle;
+    applyPendingMigrations(handle);
+    updating = true;
+    try {
+      inner.value = cloneDoc(handle.doc());
+    } finally {
+      updating = false;
+    }
+    attachChangeListener(handle);
+    bindSignalToHandle();
   })();
   return {
     key: options.key,
@@ -1822,6 +1903,7 @@ function resetMeshState() {
   lastLoadedRejection = undefined;
   lastStorageOpenError = undefined;
   lazyWrappers = [];
+  docIdResolver = undefined;
 }
 function isMeshStateConfigured() {
   return defaultRepo !== undefined;
@@ -1927,8 +2009,25 @@ function deriveDocumentId(key) {
   const bytes = digest.slice(0, 16);
   return interpretAsDocumentId(bytes);
 }
+var docIdResolver;
+function registerDocIdResolver(resolver) {
+  docIdResolver = resolver;
+}
+function getDocIdResolver() {
+  return docIdResolver;
+}
+function resolveDocumentId(key) {
+  return docIdResolver?.(key) ?? deriveDocumentId(key);
+}
+var redirectDetector;
+function registerRedirectDetector(detector) {
+  redirectDetector = detector;
+}
+function getRedirectDetector() {
+  return redirectDetector;
+}
 function buildHandleFactory(repo, key, initialDoc) {
-  const documentId = deriveDocumentId(key);
+  const documentId = resolveDocumentId(key);
   return async () => {
     lazyInvocations++;
     let exitReason = "threw";
@@ -1937,23 +2036,22 @@ function buildHandleFactory(repo, key, initialDoc) {
       const cached = repo.handles[documentId];
       lazyReachedRepo++;
       const docIdString = documentId;
+      let handle;
       if (cached) {
         await withStorageTimeout("whenReady", docIdString, cached.whenReady(["ready", "unavailable"]));
         if (cached.state === "ready") {
           exitReason = "returned-cached";
-          return cached;
+          handle = cached;
+        } else {
+          handle = await loadOrSeed(repo, documentId, initialDoc, docIdString, (r) => {
+            exitReason = r;
+          });
         }
+      } else {
+        handle = await loadOrSeed(repo, documentId, initialDoc, docIdString, (r) => {
+          exitReason = r;
+        });
       }
-      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"] });
-      }
-      const seeded = Automerge.save(Automerge.from(initialDoc));
-      const handle = repo.import(seeded, { docId: documentId });
-      handle.doneLoading();
-      exitReason = "seeded-and-imported";
       return handle;
     } catch (err) {
       errorMessage = err instanceof Error ? err.message : String(err);
@@ -1973,6 +2071,19 @@ function buildHandleFactory(repo, key, initialDoc) {
     }
   };
 }
+async function loadOrSeed(repo, documentId, initialDoc, docIdString, setExitReason) {
+  const loadPromise = repo.storageSubsystem?.loadDoc(documentId);
+  const stored = loadPromise ? await withStorageTimeout("loadDoc", docIdString, loadPromise) : undefined;
+  if (stored) {
+    setExitReason("loaded-from-storage");
+    return repo.find(documentId, { allowableStates: ["ready"] });
+  }
+  const seeded = Automerge.save(Automerge.from(initialDoc));
+  const handle = repo.import(seeded, { docId: documentId });
+  handle.doneLoading();
+  setExitReason("seeded-and-imported");
+  return handle;
+}
 function attachLoadedRejectionSink(primitive) {
   primitive.loaded.catch((err) => {
     recordLoadedRejection(err);
@@ -1986,11 +2097,35 @@ function $meshState(key, initialValue, options = {}) {
     primitive: "meshState",
     initialValue,
     getHandle: buildHandleFactory(repo, key, initialValue),
+    resolveRedirect: buildRedirectResolver(repo),
     schemaVersion: options.schemaVersion,
     migrations: options.migrations,
     access: options.access
   }));
 }
+function buildRedirectResolver(repo) {
+  if (!redirectDetector) {}
+  return async (_handle, doc) => {
+    const detector = redirectDetector;
+    if (!detector)
+      return;
+    let nextId;
+    try {
+      nextId = detector(doc);
+    } catch {
+      return;
+    }
+    if (!nextId)
+      return;
+    try {
+      return await repo.find(nextId, {
+        allowableStates: ["ready", "unavailable"]
+      });
+    } catch {
+      return;
+    }
+  };
+}
 function $meshText(key, initialValue, options = {}) {
   const repo = resolveRepo(options.repo);
   return attachLoadedRejectionSink($crdtText(key, initialValue, {
@@ -3604,25 +3739,31 @@ export {
   serialisePairingToken,
   serialiseKeyring,
   revokePeerLocally,
+  resolveDocumentId,
   resetMeshState,
+  registerRedirectDetector,
+  registerDocIdResolver,
   parsePairingToken,
   memoryKeyringStorage,
   isPairingTokenExpired,
   isMeshStateConfigured,
   isBlobRef,
   getStorageOpenError,
+  getRedirectDetector,
   getMeshStateModuleId,
   getLazyWrappers,
   getLazyReachedRepo,
   getLazyInvocations,
   getLastLoadedRejection,
   getLastConfiguredRepoPeerId,
+  getDocIdResolver,
   generateSigningKeyPair,
   generateDocumentKey,
   encrypt,
   encodeRevocation,
   encodePairingToken,
   deserialiseKeyring,
+  deriveDocumentId,
   decryptOrThrow,
   decrypt,
   decodeRevocation,
@@ -3666,4 +3807,4 @@ export {
   $meshCounter
 };
 
-//# debugId=EFE12C3DC2653D4B64756E2164756E21
+//# debugId=32FAEA2DE6283FD764756E2164756E21