@fairfox/polly 0.63.0 → 0.64.0

package/dist/src/mesh.d.ts

@@ -28,7 +28,7 @@ export { DEFAULT_MESH_KEY_ID, MeshNetworkAdapter, } from "./shared/lib/mesh-netw
 export type { MeshSignalingClientOptions, SignalingMessage as MeshSignalingMessage, } from "./shared/lib/mesh-signaling-client";
 export { MeshSignalingClient } from "./shared/lib/mesh-signaling-client";
 export type { DocIdResolver, LazyWrapperExitReason, MeshStateLazyWrapperRecord, MeshStateLoadedRejectionBreadcrumb, MeshStateOptions, MeshStateStorageOpenError, } from "./shared/lib/mesh-state";
-export { $meshCounter, $meshList, $meshState, $meshText, configureMeshState, deriveDocumentId, getDocIdResolver, getLastConfiguredRepoPeerId, getLastLoadedRejection, getLazyInvocations, getLazyReachedRepo, getLazyWrappers, getMeshStateModuleId, getStorageOpenError, isMeshStateConfigured, MESH_STATE_MODULE_ID, registerDocIdResolver, resetMeshState, resolveDocumentId, wasMeshStateResolved, } from "./shared/lib/mesh-state";
+export { $meshCounter, $meshList, $meshState, $meshText, configureMeshState, deriveDocumentId, getDocIdResolver, getLastConfiguredRepoPeerId, getLastLoadedRejection, getLazyInvocations, getLazyReachedRepo, getLazyWrappers, getMeshStateModuleId, getRedirectDetector, getStorageOpenError, isMeshStateConfigured, MESH_STATE_MODULE_ID, registerDocIdResolver, registerRedirectDetector, resetMeshState, resolveDocumentId, wasMeshStateResolved, } from "./shared/lib/mesh-state";
 export type { HandleSyncSnapshot, InFlightSyncSnapshot, MeshWebRTCAdapterOptions, SlotInitiationDecision, SlotInitiationRejectionReason, SweepSnapshot, SyncHandshakeAttemptSnapshot, SyncProgressEvent, TransportSnapshot, } from "./shared/lib/mesh-webrtc-adapter";
 export { DEFAULT_ICE_SERVERS, MeshWebRTCAdapter } from "./shared/lib/mesh-webrtc-adapter";
 export type { CreatePairingTokenOptions, PairingToken, } from "./shared/lib/pairing";

package/dist/src/mesh.js

@@ -1729,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;
@@ -1756,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)
@@ -1772,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,
@@ -1951,6 +2019,13 @@ function getDocIdResolver() {
 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 = resolveDocumentId(key);
   return async () => {
@@ -1961,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);
@@ -1997,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);
@@ -2010,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, {
@@ -3630,6 +3741,7 @@ export {
   revokePeerLocally,
   resolveDocumentId,
   resetMeshState,
+  registerRedirectDetector,
   registerDocIdResolver,
   parsePairingToken,
   memoryKeyringStorage,
@@ -3637,6 +3749,7 @@ export {
   isMeshStateConfigured,
   isBlobRef,
   getStorageOpenError,
+  getRedirectDetector,
   getMeshStateModuleId,
   getLazyWrappers,
   getLazyReachedRepo,
@@ -3694,4 +3807,4 @@ export {
   $meshCounter
 };
 
-//# debugId=82752400E00815C464756E2164756E21
+//# debugId=32FAEA2DE6283FD764756E2164756E21