@fairfox/polly 0.63.0 → 0.65.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, {
@@ -2253,7 +2364,9 @@ function serialiseSlotView(slot) {
       selectedCandidatePair: slot.transport.selectedCandidatePair ? { ...slot.transport.selectedCandidatePair } : undefined
     } : undefined,
     lastSyncHandshakeAttempt: { ...slot.lastSyncHandshakeAttempt },
-    handles
+    handles,
+    createdAt: slot.createdAt,
+    lastInboundAt: slot.lastInboundAt
   };
 }
 function emptySyncHandshakeAttempt() {
@@ -2280,6 +2393,9 @@ var DEFAULT_ICE_SERVERS = [
   { urls: "stun:stun.l.google.com:19302" },
   { urls: "stun:stun1.l.google.com:19302" }
 ];
+var SLOT_NEVER_CONNECTED_TIMEOUT_MS = 30000;
+var SLOT_IDLE_TIMEOUT_MS = 120000;
+var SLOT_WATCHDOG_INTERVAL_MS = 5000;
 function emptyHandleSyncSnapshot() {
   return {
     lastSyncMessageOutAt: undefined,
@@ -2310,6 +2426,10 @@ class MeshWebRTCAdapter extends NetworkAdapter2 {
   lastSlotInitiationDecisions = new Map;
   sweepRunCount = 0;
   lastSweepAt;
+  slotWatchdogTimer;
+  slotNeverConnectedTimeoutMs;
+  slotIdleTimeoutMs;
+  slotWatchdogIntervalMs;
   get knownPeerIds() {
     if (this.keyringSource !== undefined) {
       return [...this.keyringSource().knownPeers.keys()].filter((id) => id !== this.localPeerId);
@@ -2335,6 +2455,9 @@ class MeshWebRTCAdapter extends NetworkAdapter2 {
     this.knownPeersRefreshIntervalMs = options.knownPeersRefreshIntervalMs ?? 2000;
     this.syncYieldEnabled = options.syncYieldEnabled ?? true;
     this.syncFragmentChunkSize = options.syncFragmentChunkSizeOverride ?? SYNC_FRAGMENT_CHUNK_SIZE;
+    this.slotNeverConnectedTimeoutMs = options.slotNeverConnectedTimeoutMs ?? SLOT_NEVER_CONNECTED_TIMEOUT_MS;
+    this.slotIdleTimeoutMs = options.slotIdleTimeoutMs ?? SLOT_IDLE_TIMEOUT_MS;
+    this.slotWatchdogIntervalMs = options.slotWatchdogIntervalMs ?? SLOT_WATCHDOG_INTERVAL_MS;
     this.localPeerId = options.peerId;
     const PC = options.RTCPeerConnection ?? globalThis.RTCPeerConnection;
     if (typeof PC !== "function") {
@@ -2492,9 +2615,11 @@ class MeshWebRTCAdapter extends NetworkAdapter2 {
     this.ready = true;
     this.readyResolver?.();
     this.startKnownPeersSweep();
+    this.startSlotWatchdog();
   }
   disconnect() {
     this.stopKnownPeersSweep();
+    this.stopSlotWatchdog();
     for (const slot of this.slots.values()) {
       slot.channel?.close();
       slot.connection.close();
@@ -2525,6 +2650,70 @@ class MeshWebRTCAdapter extends NetworkAdapter2 {
     clearInterval(this.knownPeersRefreshTimer);
     this.knownPeersRefreshTimer = undefined;
   }
+  tearDownWedgedSlot(peerId) {
+    const slot = this.slots.get(peerId);
+    if (!slot)
+      return;
+    this.slots.delete(peerId);
+    try {
+      slot.channel?.close();
+    } catch {}
+    try {
+      slot.connection.close();
+    } catch {}
+    this.emit("peer-disconnected", { peerId });
+  }
+  startSlotWatchdog() {
+    if (this.slotWatchdogIntervalMs <= 0)
+      return;
+    if (this.slotWatchdogTimer !== undefined)
+      return;
+    this.slotWatchdogTimer = setInterval(() => {
+      try {
+        this.sweepWedgedSlots();
+      } catch {}
+    }, this.slotWatchdogIntervalMs);
+  }
+  stopSlotWatchdog() {
+    if (this.slotWatchdogTimer === undefined)
+      return;
+    clearInterval(this.slotWatchdogTimer);
+    this.slotWatchdogTimer = undefined;
+  }
+  sweepWedgedSlots() {
+    const now = performance.now();
+    const peerIds = [...this.slots.keys()];
+    for (const peerId of peerIds) {
+      const slot = this.slots.get(peerId);
+      if (!slot)
+        continue;
+      const reason = this.classifyWedgedSlot(slot, now);
+      if (!reason)
+        continue;
+      this.lastSlotInitiationDecisions.set(peerId, {
+        decision: "rejected",
+        reason: "fatal-error",
+        error: reason,
+        at: now
+      });
+      this.tearDownWedgedSlot(peerId);
+    }
+  }
+  classifyWedgedSlot(slot, now) {
+    const state = slot.connection.connectionState;
+    const ageMs = now - slot.createdAt;
+    if (this.slotNeverConnectedTimeoutMs > 0 && (state === "new" || state === "connecting") && ageMs > this.slotNeverConnectedTimeoutMs) {
+      return `slot never reached connected (state=${state}) after ${Math.round(ageMs)}ms`;
+    }
+    if (this.slotIdleTimeoutMs > 0 && state === "connected" && slot.channel?.readyState === "open") {
+      const lastInbound = slot.lastInboundAt ?? slot.createdAt;
+      const idleMs = now - lastInbound;
+      if (idleMs > this.slotIdleTimeoutMs) {
+        return `slot idle: no inbound bytes for ${Math.round(idleMs)}ms (state=connected, dc=open)`;
+      }
+    }
+    return;
+  }
   send(message) {
     const targetId = message.targetId;
     const bytes = this.serialiseMessage(message);
@@ -2660,12 +2849,23 @@ class MeshWebRTCAdapter extends NetworkAdapter2 {
       transport: undefined,
       lastDataChannelError: undefined,
       lastSyncHandshakeAttempt: emptySyncHandshakeAttempt(),
-      handles: new Map
+      handles: new Map,
+      createdAt: performance.now(),
+      lastInboundAt: undefined
     };
     this.slots.set(targetId, slot);
     this.wireConnection(targetId, connection);
     this.wireDataChannel(targetId, channel);
-    this.initiateOffer(targetId, connection);
+    this.initiateOffer(targetId, connection).catch((err) => {
+      const message = err instanceof Error ? err.message : String(err);
+      this.lastSlotInitiationDecisions.set(targetId, {
+        decision: "rejected",
+        reason: "fatal-error",
+        error: message,
+        at: performance.now()
+      });
+      this.tearDownWedgedSlot(targetId);
+    });
     return slot;
   }
   async initiateOffer(targetId, connection) {
@@ -2703,7 +2903,9 @@ class MeshWebRTCAdapter extends NetworkAdapter2 {
       transport: undefined,
       lastDataChannelError: undefined,
       lastSyncHandshakeAttempt: emptySyncHandshakeAttempt(),
-      handles: new Map
+      handles: new Map,
+      createdAt: performance.now(),
+      lastInboundAt: undefined
     };
     this.slots.set(fromPeerId, slot);
     this.wireConnection(fromPeerId, connection);
@@ -2775,6 +2977,8 @@ class MeshWebRTCAdapter extends NetworkAdapter2 {
       if (state === "connected") {
         this.emitPeerCandidateOnce(peerId);
       } else if (state === "disconnected" || state === "failed" || state === "closed") {
+        if (!this.slots.has(peerId))
+          return;
         this.slots.delete(peerId);
         this.emit("peer-disconnected", { peerId });
       }
@@ -2805,6 +3009,9 @@ class MeshWebRTCAdapter extends NetworkAdapter2 {
       slot.pendingSends = [];
     };
     channel.onmessage = (event) => {
+      const liveSlot = this.slots.get(peerId);
+      if (liveSlot)
+        liveSlot.lastInboundAt = performance.now();
       const data = event.data;
       if (data instanceof ArrayBuffer) {
         this.dispatchMessage(peerId, new Uint8Array(data));
@@ -3630,6 +3837,7 @@ export {
   revokePeerLocally,
   resolveDocumentId,
   resetMeshState,
+  registerRedirectDetector,
   registerDocIdResolver,
   parsePairingToken,
   memoryKeyringStorage,
@@ -3637,6 +3845,7 @@ export {
   isMeshStateConfigured,
   isBlobRef,
   getStorageOpenError,
+  getRedirectDetector,
   getMeshStateModuleId,
   getLazyWrappers,
   getLazyReachedRepo,
@@ -3694,4 +3903,4 @@ export {
   $meshCounter
 };
 
-//# debugId=82752400E00815C464756E2164756E21
+//# debugId=9FE5660EB3793A1964756E2164756E21