@q9labsai/chalk-client 5.0.0 → 5.1.0

package/dist/{chunk-AVXJ4HQU.js → chunk-K7PNW3KI.js}

@@ -217,6 +217,47 @@ function unsubscribe(subscription) {
   }
 }
 
+// src/sync/v1-health.ts
+var SYNC_HEALTH_BUDGET = {
+  probeIntervalMs: 500,
+  degradedAfterMs: 750,
+  recoveringAfterMs: 4e3,
+  stablePongsForMs: 2e3
+};
+var V1SyncHealth = class {
+  health = "healthy";
+  #lastPongAt;
+  #stableSince = null;
+  constructor(now) {
+    this.#lastPongAt = now;
+  }
+  observePong(now) {
+    this.check(now);
+    const gap = now - this.#lastPongAt;
+    this.#lastPongAt = now;
+    if (this.health === "healthy") return;
+    if (gap > SYNC_HEALTH_BUDGET.degradedAfterMs || this.#stableSince === null) this.#stableSince = now;
+    if (now - this.#stableSince >= SYNC_HEALTH_BUDGET.stablePongsForMs) {
+      this.health = "healthy";
+      this.#stableSince = null;
+    }
+  }
+  check(now) {
+    const silence = now - this.#lastPongAt;
+    if (silence >= SYNC_HEALTH_BUDGET.degradedAfterMs) this.#stableSince = null;
+    if (silence >= SYNC_HEALTH_BUDGET.recoveringAfterMs) this.health = "recovering";
+    else if (silence >= SYNC_HEALTH_BUDGET.degradedAfterMs && this.health === "healthy") this.health = "degraded";
+  }
+};
+
+// src/sync/dial-deadline.ts
+var SYNC_DIAL_TIMEOUT_MS = 1e4;
+function scheduleSyncDialDeadline(clock, onTimeout, timeoutMs = SYNC_DIAL_TIMEOUT_MS) {
+  const allowance = Number.isFinite(timeoutMs) ? Math.min(6e4, Math.max(SYNC_DIAL_TIMEOUT_MS, timeoutMs)) : SYNC_DIAL_TIMEOUT_MS;
+  const timer = clock.setTimeout(onTimeout, allowance);
+  return () => clock.clearTimeout(timer);
+}
+
 // src/generated/sync.ts
 import { Schema } from "effect";
 var SyncProtocolMetadata = {
@@ -1719,6 +1760,12 @@ var V1ReplicaError = class extends Error {
     this.name = "V1ReplicaError";
   }
 };
+var V1StateDigestMismatchError = class extends V1ReplicaError {
+  constructor() {
+    super("control state digest mismatch");
+    this.name = "V1StateDigestMismatchError";
+  }
+};
 async function restoreV1Snapshot(snapshot) {
   const state = snapshotToState(snapshot);
   assertV1ControlSemantics(state);
@@ -1832,7 +1879,7 @@ function durableProjection(state) {
   };
 }
 async function assertDigest(state) {
-  if (await computeV1StateDigest(state) !== state.stateDigest) throw new V1ReplicaError("control state digest mismatch");
+  if (await computeV1StateDigest(state) !== state.stateDigest) throw new V1StateDigestMismatchError();
 }
 function reduceEvent(state, event) {
   switch (event.name) {
@@ -1971,9 +2018,11 @@ function sameStrings2(left, right) {
 
 // src/sync/v1-collaboration-state.ts
 var MAX_COLLABORATION_REQUESTS_IN_FLIGHT = 64;
+var REACTION_ACK_TIMEOUT_MS = 5e3;
 var V1CollaborationState = class {
   #options;
   #listeners = /* @__PURE__ */ new Set();
+  #reactionTimers = /* @__PURE__ */ new Map();
   #reactions = /* @__PURE__ */ new Map();
   #chatSends = /* @__PURE__ */ new Map();
   #chatPages = /* @__PURE__ */ new Map();
@@ -2044,7 +2093,18 @@ var V1CollaborationState = class {
     this.#assertCapacity();
     const operationId = this.#nextRequestId();
     const frame = { type: "reaction_send", operation_id: operationId, reaction };
-    return this.#sendTrackedRequest(operationId, frame, this.#reactions);
+    const pending = this.#sendTrackedRequest(operationId, frame, this.#reactions);
+    this.#reactionTimers.set(
+      operationId,
+      this.#options.clock().setTimeout(() => {
+        this.#reactionTimers.delete(operationId);
+        const deferred = this.#reactions.get(operationId);
+        if (!deferred) return;
+        this.#reactions.delete(operationId);
+        rejectV1Deferred(deferred, new V1SyncError("Reaction acknowledgement timed out", "reaction_ack_timeout"));
+      }, REACTION_ACK_TIMEOUT_MS)
+    );
+    return pending;
   }
   sendChatMessage(input) {
     this.#assertReady("sendChat");
@@ -2108,6 +2168,8 @@ var V1CollaborationState = class {
     this.#requireNegotiated();
     const deferred = this.#reactions.get(frame.operation_id);
     if (!deferred) return;
+    this.#options.clock().clearTimeout(this.#reactionTimers.get(frame.operation_id));
+    this.#reactionTimers.delete(frame.operation_id);
     this.#reactions.delete(frame.operation_id);
     if (frame.outcome === "accepted") resolveV1Deferred(deferred, reactionFromFrame(frame.reaction));
     else rejectV1Deferred(deferred, new V1SyncError(frame.error_code, frame.error_code));
@@ -2178,6 +2240,8 @@ var V1CollaborationState = class {
     for (const deferred of this.#chatSends.values()) rejectV1Deferred(deferred, new V1SyncError(code, code));
     for (const deferred of this.#chatPages.values()) rejectV1Deferred(deferred, new V1SyncError(code, code));
     for (const deferred of this.#chatReads.values()) rejectV1Deferred(deferred, new V1SyncError(code, code));
+    for (const timer of this.#reactionTimers.values()) this.#options.clock().clearTimeout(timer);
+    this.#reactionTimers.clear();
     this.#reactions.clear();
     this.#chatSends.clear();
     this.#chatPages.clear();
@@ -2863,15 +2927,16 @@ var CLIENT_RESTART_CLOSE_CODE = 4e3;
 var DEFAULT_RECONNECT_DELAY_MS = 250;
 var MAX_RECONNECT_DELAY_MS = 5e3;
 var FAST_RECONNECT_ATTEMPTS = 8;
-var NOTICE_PROBE_INTERVAL_MS = 500;
-var NOTICE_SILENCE_MS = 750;
+var DIGEST_RECOVERY_COOLDOWN_MS = 6e4;
 var V1SyncClient = class {
   #options;
   #commandScheduler;
   #listeners = /* @__PURE__ */ new Set();
+  #mediaPauseListeners = /* @__PURE__ */ new Set();
   #requestListeners = /* @__PURE__ */ new Set();
   #collaborationState;
   #controlHeads = /* @__PURE__ */ new Map();
+  #snapshotRevision = null;
   #controlEvents = /* @__PURE__ */ new Map();
   #liveTargets;
   #requests = /* @__PURE__ */ new Map();
@@ -2885,17 +2950,20 @@ var V1SyncClient = class {
   #participantId = null;
   #participantGeneration = null;
   #recovery = null;
+  #snapshotRecoveryRequested = false;
+  #lastDigestRecoveryAt = null;
   #started = false;
   #startupGeneration = 0;
   #connectionGeneration = 0;
   #reconnectTimer;
+  #cancelDial;
+  #dialTimeoutCount = 0;
   #reconnectAttempt = 0;
   #heartbeatTimer;
   #missedHeartbeats = 0;
   #noticeTimer;
   #noticeProbeTimer;
-  #noticeLastInboundAt = 0;
-  #noticeUnresponsive = false;
+  #health = new V1SyncHealth(0);
   #unsubscribeLifecycle;
   #inbound = Promise.resolve();
   #transportAvailable = true;
@@ -2935,6 +3003,7 @@ var V1SyncClient = class {
       stateChanged: () => this.#emit()
     });
     this.#collaborationState = new V1CollaborationState({
+      clock: () => this.#clock(),
       request: options.collaboration,
       requestIds: options.requestIds,
       maxPendingRequests: options.maxPendingCollaborationRequests,
@@ -2971,6 +3040,7 @@ var V1SyncClient = class {
     this.#unsubscribeLifecycle?.();
     this.#unsubscribeLifecycle = void 0;
     this.#clearReconnect();
+    this.#clearDial();
     this.#clearHeartbeat();
     this.#clearNoticeProbe();
     this.#commandScheduler.stop("client_stopped");
@@ -2989,7 +3059,7 @@ var V1SyncClient = class {
     const pendingCommands = this.#commandScheduler.pendingCommands;
     const optimisticControl = this.#control && this.#participantId ? optimisticV1Control(this.#control, this.#participantId, pendingCommands) : this.#control;
     return {
-      connection: this.#phase.phase === "live" ? { ...this.#phase, noticeUnresponsive: this.#noticeUnresponsive } : { ...this.#phase },
+      connection: { ...this.#phase, ...this.#phase.phase === "live" ? { noticeUnresponsive: this.#health.health === "recovering", health: this.#health.health } : {}, ...this.#dialTimeoutCount ? { dialTimeoutCount: this.#dialTimeoutCount } : {} },
       participantId: this.#participantId,
       participantGeneration: this.#participantGeneration,
       control: this.#control,
@@ -3006,6 +3076,16 @@ var V1SyncClient = class {
     listener(this.getSnapshot());
     return () => this.#listeners.delete(listener);
   }
+  onMediaPause(listener) {
+    this.#mediaPauseListeners.add(listener);
+    return () => this.#mediaPauseListeners.delete(listener);
+  }
+  #notifyMediaPause(event) {
+    const source = event.name === "participant_microphone_stopped" ? "microphone" : event.name === "participant_camera_stopped" ? "camera" : event.name === "participant_screen_share_stopped" ? "screen" : null;
+    if (source && "participant_id" in event.payload && event.payload.participant_id === this.#participantId) {
+      for (const listener of this.#mediaPauseListeners) listener({ source, revision: event.revision });
+    }
+  }
   onDirectedRequest(listener) {
     this.#requestListeners.add(listener);
     return () => this.#requestListeners.delete(listener);
@@ -3117,13 +3197,24 @@ var V1SyncClient = class {
     return promise;
   }
   #connect() {
-    if (!this.#started || !this.#transportAvailable || this.#socket) return;
+    if (!this.#started || !this.#transportAvailable || this.#socket || this.#phase.phase === "terminal") return;
     this.#phase = { phase: "connecting" };
     this.#emit();
     const socket = this.#options.webSocket.connect(this.#options.url);
     const connectionGeneration = ++this.#connectionGeneration;
     this.#socket = socket;
+    this.#cancelDial = scheduleSyncDialDeadline(
+      this.#clock(),
+      () => {
+        this.#cancelDial = void 0;
+        this.#dialTimeoutCount += 1;
+        this.#recover("WebSocket dial timeout");
+      },
+      this.#options.dialTimeoutMs
+    );
     socket.onopen = () => {
+      if (socket !== this.#socket) return;
+      this.#clearDial();
       void this.#authenticate(socket);
     };
     socket.onmessage = (event) => {
@@ -3169,17 +3260,11 @@ var V1SyncClient = class {
     try {
       if (typeof data !== "string" || encoder3.encode(data).byteLength > SyncProtocolLimits.snapshotEncodedBytes) throw new V1ReplicaError("invalid inbound frame size");
       const frame = decodeV1ServerFrame(data);
-      if (this.#phase.phase === "live") {
-        this.#noticeLastInboundAt = this.#now();
-        this.#scheduleNoticeCheck();
-        if (this.#noticeUnresponsive) {
-          this.#noticeUnresponsive = false;
-          this.#emit();
-        }
-      }
       await this.#handleFrame(frame);
-    } catch {
-      this.#recover("invalid_frame");
+    } catch (error) {
+      if (this.#snapshotRecoveryRequested) this.#failDigestRecovery();
+      else if (error instanceof V1StateDigestMismatchError) this.#recoverDigestMismatch();
+      else this.#recover("invalid_frame");
     }
   }
   async #handleFrame(frame) {
@@ -3207,6 +3292,7 @@ var V1SyncClient = class {
           this.#control = await applyV1Event(this.#requireControl(), frame);
           this.#rememberControlHead(this.#control.revision, this.#control.stateDigest);
           this.#rememberControlEvent(frame);
+          this.#notifyMediaPause(frame);
         }
         await this.#commandScheduler.settleTerminalLifecycle(frame, this.#participantId);
         await this.#commandScheduler.settleProven();
@@ -3269,10 +3355,14 @@ var V1SyncClient = class {
         return;
       case "error":
         throw new V1ReplicaError(frame.code);
-      case "pong":
+      case "pong": {
         this.#requireLive();
         this.#missedHeartbeats = 0;
+        const previous = this.#health.health;
+        this.#health.observePong(this.#now());
+        if (previous !== this.#health.health) this.#emit();
         return;
+      }
     }
   }
   async #welcome(frame) {
@@ -3288,15 +3378,20 @@ var V1SyncClient = class {
       this.#emit();
       return;
     }
+    if (this.#snapshotRecoveryRequested && frame.mode !== "snapshot") throw new V1ReplicaError("digest recovery requires a full snapshot");
     if (frame.mode === "snapshot") {
-      this.#control = await restoreV1Snapshot(frame.snapshot);
+      const control = await restoreV1Snapshot(frame.snapshot);
+      if (!sameHead(control, frame.head)) throw new V1ReplicaError("snapshot head mismatch");
+      this.#control = control;
+      this.#snapshotRevision = control.revision;
+      this.#snapshotRecoveryRequested = false;
       this.#controlHeads.clear();
       this.#controlEvents.clear();
       this.#rememberControlHead(this.#control.revision, this.#control.stateDigest);
+      await this.#commandScheduler.settleProven();
     }
     if (frame.mode === "replay" && (!this.#control || this.#control.revision >= frame.head.revision)) throw new V1ReplicaError("invalid replay welcome");
     if (frame.mode === "up_to_date" && !sameHead(this.#control, frame.head)) throw new V1ReplicaError("up-to-date head mismatch");
-    if (frame.mode === "snapshot" && !sameHead(this.#control, frame.head)) throw new V1ReplicaError("snapshot head mismatch");
     this.#recovery = { id: frame.recovery_id, head: frame.head, replayEvents: 0, replayBytes: 0, controlComplete: false };
     if (frame.mode === "snapshot") this.#ackRecovery();
     this.#emit();
@@ -3311,6 +3406,7 @@ var V1SyncClient = class {
       this.#control = await applyV1Event(this.#requireControl(), event);
       this.#rememberControlHead(this.#control.revision, this.#control.stateDigest);
       this.#rememberControlEvent(event);
+      this.#notifyMediaPause(event);
     }
     this.#ackRecovery();
     this.#emit();
@@ -3404,7 +3500,7 @@ var V1SyncClient = class {
     this.#send({ type: "recovery_ack", recovery_id: recovery.id, revision: control.revision, state_digest: control.stateDigest });
   }
   #ackHeadIsProven(ack) {
-    return this.#controlHeads.get(ack.revision) === ack.state_digest;
+    return this.#snapshotRevision !== null && ack.revision < this.#snapshotRevision || this.#controlHeads.get(ack.revision) === ack.state_digest;
   }
   #rememberControlHead(revision, digest) {
     this.#controlHeads.set(revision, digest);
@@ -3423,6 +3519,7 @@ var V1SyncClient = class {
   #disconnected(socket) {
     if (socket !== this.#socket) return;
     this.#socket = null;
+    this.#clearDial();
     this.#recovery = null;
     this.#clearHeartbeat();
     this.#clearNoticeProbe();
@@ -3452,6 +3549,29 @@ var V1SyncClient = class {
     socket.close(CLIENT_RESTART_CLOSE_CODE, reason);
     this.#disconnected(socket);
   }
+  #recoverDigestMismatch() {
+    const now = this.#clock().now();
+    if (this.#lastDigestRecoveryAt !== null && now - this.#lastDigestRecoveryAt < DIGEST_RECOVERY_COOLDOWN_MS) {
+      this.#failDigestRecovery();
+      return;
+    }
+    this.#lastDigestRecoveryAt = now;
+    this.#snapshotRecoveryRequested = true;
+    this.#control = null;
+    this.#snapshotRevision = null;
+    this.#controlHeads.clear();
+    this.#controlEvents.clear();
+    this.#recover("state_digest_mismatch");
+  }
+  #failDigestRecovery() {
+    this.#phase = { phase: "terminal", terminalReason: "state_digest_recovery_failed" };
+    this.#clearReconnect();
+    this.#commandScheduler.stop("state_digest_recovery_failed");
+    const socket = this.#socket;
+    socket?.close(CLIENT_RESTART_CLOSE_CODE, "state_digest_recovery_failed");
+    if (socket) this.#disconnected(socket);
+    this.#emit();
+  }
   #handleLifecycle(event) {
     if (event === "online" || event === "offline") this.#online = event === "online";
     else this.#active = event === "active";
@@ -3500,6 +3620,10 @@ var V1SyncClient = class {
   #now() {
     return this.#clock().now();
   }
+  #clearDial() {
+    this.#cancelDial?.();
+    this.#cancelDial = void 0;
+  }
   #clearReconnect() {
     if (this.#reconnectTimer === void 0) return;
     this.#clock().clearTimeout(this.#reconnectTimer);
@@ -3557,33 +3681,29 @@ var V1SyncClient = class {
   }
   #startNoticeProbe() {
     this.#clearNoticeProbe();
-    this.#noticeLastInboundAt = this.#now();
-    this.#scheduleNoticeCheck();
+    this.#send({ type: "ping" });
+    this.#health = new V1SyncHealth(this.#now());
     const tick = () => {
       this.#noticeProbeTimer = void 0;
       if (this.#phase.phase !== "live") return;
+      const previous = this.#health.health;
+      this.#health.check(this.#now());
+      if (previous !== this.#health.health) this.#emit();
       this.#send({ type: "ping" });
-      this.#noticeProbeTimer = this.#clock().setTimeout(tick, NOTICE_PROBE_INTERVAL_MS);
+      this.#noticeProbeTimer = this.#clock().setTimeout(tick, SYNC_HEALTH_BUDGET.probeIntervalMs);
     };
-    this.#noticeProbeTimer = this.#clock().setTimeout(tick, NOTICE_PROBE_INTERVAL_MS);
-  }
-  #scheduleNoticeCheck() {
-    if (this.#noticeTimer !== void 0) this.#clock().clearTimeout(this.#noticeTimer);
-    const remaining = Math.max(0, NOTICE_SILENCE_MS - (this.#now() - this.#noticeLastInboundAt));
+    this.#noticeProbeTimer = this.#clock().setTimeout(tick, SYNC_HEALTH_BUDGET.probeIntervalMs);
     this.#noticeTimer = this.#clock().setTimeout(() => {
       this.#noticeTimer = void 0;
-      if (this.#phase.phase !== "live" || this.#noticeUnresponsive) return;
-      if (this.#now() - this.#noticeLastInboundAt < NOTICE_SILENCE_MS) return this.#scheduleNoticeCheck();
-      this.#noticeUnresponsive = true;
+      this.#health.check(this.#now());
       this.#emit();
-    }, remaining);
+    }, SYNC_HEALTH_BUDGET.degradedAfterMs);
   }
   #clearNoticeProbe() {
     if (this.#noticeTimer !== void 0) this.#clock().clearTimeout(this.#noticeTimer);
     if (this.#noticeProbeTimer !== void 0) this.#clock().clearTimeout(this.#noticeProbeTimer);
     this.#noticeTimer = void 0;
     this.#noticeProbeTimer = void 0;
-    this.#noticeUnresponsive = false;
   }
   #emit() {
     const snapshot = this.getSnapshot();
@@ -3786,6 +3906,7 @@ export {
   createBrowserSyncLifecycle,
   createReactNativeWebSocketFactory,
   createReactNativeSyncLifecycle,
+  scheduleSyncDialDeadline,
   encodeV1ClientFrame,
   decodeV1ServerFrame,
   decodeV1ClientFrame,

package/dist/{chunk-CMVO7USN.js → chunk-KHHULLBZ.js}

@@ -1,7 +1,7 @@
 import {
   createChalkEffectClient,
   parseAccessGrant
-} from "./chunk-2HJIJVE2.js";
+} from "./chunk-3ZN7IXOZ.js";
 
 // src/public-invites/client.ts
 import { Effect } from "effect";