deepspace 0.17.0 → 0.18.0

package/dist/index.js

@@ -1786,6 +1786,8 @@ function parseServerError(error) {
 // src/client/storage/record-socket.ts
 var WS_CONNECTING = 0;
 var WS_OPEN = 1;
+var PING_EVERY_MS = 15e3;
+var PONG_TIMEOUT_MS = 3e4;
 var RecordSocket = class {
   constructor(config) {
     this.config = config;
@@ -1801,6 +1803,14 @@ var RecordSocket = class {
   pendingRequests = /* @__PURE__ */ new Map();
   reconnectAttempt = 0;
   reconnectTimeout = null;
+  heartbeat = null;
+  /** Any inbound frame proves the peer is answering. */
+  lastInboundAt = 0;
+  /** Monotonic time of the one probe awaiting an inbound answer. */
+  outstandingPingAt = null;
+  /** Monotonic time of the prior heartbeat callback. A long gap means the
+   *  scheduler was suspended, so a pre-suspension probe cannot be judged. */
+  lastHeartbeatCheckAt = 0;
   // Bumped by connect() (on entry) and disconnect()/destroy(). connect()
   // captures it before awaiting the auth token and re-checks after; a
   // mismatch means a teardown (or a newer connect) raced in during the
@@ -1849,10 +1859,12 @@ var RecordSocket = class {
     ws.onopen = () => {
       config.log?.("connected", config.roomId);
       config.listeners.onStatus("connected");
+      this.startHeartbeat(ws);
       this.resubscribeAll(ws);
     };
     ws.onmessage = (event) => this.handleMessage(event);
     ws.onclose = () => {
+      this.stopHeartbeat();
       config.log?.("disconnected", config.roomId);
       config.listeners.onStatus("disconnected");
       config.listeners.onReady(false);
@@ -1907,8 +1919,48 @@ var RecordSocket = class {
       this.reconnectTimeout = null;
     }
   }
+  /**
+   * Turn a peer that stopped answering into a `close` event. That is the whole
+   * job — `onclose` already reports 'disconnected', marks every query stale,
+   * and reconnects with backoff. Without this it is never called, because
+   * nothing about the connection is actually broken.
+   */
+  startHeartbeat(ws) {
+    this.stopHeartbeat();
+    this.lastInboundAt = performance.now();
+    this.lastHeartbeatCheckAt = this.lastInboundAt;
+    this.outstandingPingAt = null;
+    this.heartbeat = setInterval(() => {
+      if (ws.readyState !== WS_OPEN) return;
+      const now = performance.now();
+      const callbackGap = now - this.lastHeartbeatCheckAt;
+      this.lastHeartbeatCheckAt = now;
+      if (this.outstandingPingAt !== null) {
+        if (now - this.outstandingPingAt >= PONG_TIMEOUT_MS) {
+          if (callbackGap >= PONG_TIMEOUT_MS) {
+            ws.send("ping");
+            this.outstandingPingAt = now;
+          } else {
+            ws.close();
+          }
+        }
+        return;
+      }
+      if (now - this.lastInboundAt >= PING_EVERY_MS) {
+        ws.send("ping");
+        this.outstandingPingAt = now;
+      }
+    }, PING_EVERY_MS);
+  }
+  stopHeartbeat() {
+    if (this.heartbeat) clearInterval(this.heartbeat);
+    this.heartbeat = null;
+    this.outstandingPingAt = null;
+    this.lastHeartbeatCheckAt = 0;
+  }
   /** Close without firing onclose — prevents the zombie-reconnect. */
   teardownSocket() {
+    this.stopHeartbeat();
     const ws = this.ws;
     if (!ws) return;
     this.config.log?.("closing", this.config.roomId);
@@ -1977,6 +2029,9 @@ var RecordSocket = class {
     }
   }
   handleMessage(event) {
+    this.lastInboundAt = performance.now();
+    this.outstandingPingAt = null;
+    if (event.data === "pong") return;
     if (event.data instanceof ArrayBuffer) {
       this.binaryHandlers.forEach((h) => h(event.data));
       return;