@glassly/cloud-client 0.3.1-beta.536 → 0.3.1-beta.551

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@glassly/cloud-client",
-  "version": "0.3.1-beta.536",
+  "version": "0.3.1-beta.551",
   "type": "module",
   "main": "./src/index.ts",
   "exports": {
@@ -12,7 +12,7 @@
     "test": "bun test"
   },
   "dependencies": {
-    "@glassly/cloud-protocol": "0.3.1-beta.536",
+    "@glassly/cloud-protocol": "0.3.1-beta.551",
     "tweetnacl": "^1.0.3"
   },
   "devDependencies": {

package/src/modules/runtime/connection.ts

@@ -26,6 +26,7 @@
  */
 import {
   PROTOCOL_MAJOR,
+  WS_CLOSE_CODES,
   cloudToClientMessage,
   type ConnectionInit,
   type ConnectionAck,
@@ -150,10 +151,18 @@ function isUnauthorizedUpgrade(reason: string): boolean {
   return /\b401\b|unauthorized/i.test(reason);
 }
 
-function isSupersededByNewerSession(reason: string): boolean {
-  return /superseded by newer session/i.test(reason);
+// The code is authoritative; the reason text is kept for runtimes that still
+// close with 1012 (iOS's SocketRocket drops the reason for that code, which is
+// why the server moved to the application range in the first place).
+function isSupersededByNewerSession(code: number, reason: string): boolean {
+  return code === WS_CLOSE_CODES.SUPERSEDED || /superseded by newer session/i.test(reason);
 }
 
+// A socket that stayed open this long earned a backoff reset. Resetting on
+// the ack itself let a server that closes us right after every handshake be
+// retried at base delay forever.
+const BACKOFF_RESET_AFTER_MS = 30_000;
+
 export class Connection {
   private readonly deps: ConnectionDeps;
   private readonly timers: CloudClientTimers;
@@ -178,14 +187,15 @@ export class Connection {
   // stop" from "the network dropped".
   private closedByHost = false;
 
-  // True when the cloud closed us with 1012 "superseded by newer session".
-  // Another live socket for this user won; reconnecting would just kill it
-  // and start a two-client fight. Stays down until the host calls open().
+  // True when the cloud closed us with WS_CLOSE_CODES.SUPERSEDED. Another live
+  // socket for this user won; reconnecting would just kill it and start a
+  // two-client fight. Stays down until the host calls open().
   private replacedByNewerSession = false;
 
-  // How many consecutive failed (re)connect attempts, used to grow the backoff.
-  // Reset to zero on a successful handshake.
+  // How many consecutive (re)connect attempts, used to grow the backoff.
+  // Reset to zero once a handshaken socket has stayed open BACKOFF_RESET_AFTER_MS.
   private reconnectAttempt = 0;
+  private backoffResetTimer: unknown | null = null;
 
   // The pending reconnect timer, or null when no retry is queued. This single
   // field makes `scheduleReconnect` idempotent: a second call while a timer is
@@ -285,6 +295,7 @@ export class Connection {
     // Cancel any queued reconnect and stop the watchdog: the host wants us down,
     // so neither the loop nor its backstop should bring the socket back up.
     this.clearReconnectTimer();
+    this.clearBackoffReset();
     this.stopWatchdog();
     this.failPendingAck(new Error("Connection closed by host"));
     this.teardownSocket();
@@ -502,7 +513,7 @@ export class Connection {
    */
   private handleAck(ack: ConnectionAck): void {
     this.currentAck = ack;
-    this.reconnectAttempt = 0;
+    this.armBackoffReset();
 
     if (this.pendingAck) {
       this.timers.clearTimeout(this.pendingAck.timer);
@@ -538,20 +549,22 @@ export class Connection {
       new Error(`Socket closed during handshake: ${info.code}`),
     );
 
+    this.clearBackoffReset();
+
     if (this.closedByHost) {
       this.setState("closed");
       return;
     }
 
-    this.setState("closed");
-
     const reason = info.reason || `code ${info.code}`;
-    if (isSupersededByNewerSession(reason)) {
+    if (isSupersededByNewerSession(info.code, reason)) {
       // Newest-wins on the server. Coming back up here would supersede the
       // winner, which then reconnects, forever. Stay down until open().
+      // Flag first: "closed" subscribers read isReplacedByNewerSession.
       this.replacedByNewerSession = true;
       this.clearReconnectTimer();
       this.stopWatchdog();
+      this.setState("closed");
       this.deps.logger.info("ws-session-debug staying down after supersede", {
         code: info.code,
         reason,
@@ -560,6 +573,9 @@ export class Connection {
       });
       return;
     }
+
+    this.setState("closed");
+
     if (isUnauthorizedUpgrade(reason)) {
       void Promise.resolve(this.deps.onAuthRejected?.())
         .catch((err) => {
@@ -632,6 +648,22 @@ export class Connection {
     }, delay);
   }
 
+  /** Reset the backoff once this socket has proven it can stay up. */
+  private armBackoffReset(): void {
+    this.clearBackoffReset();
+    this.backoffResetTimer = this.timers.setTimeout(() => {
+      this.backoffResetTimer = null;
+      this.reconnectAttempt = 0;
+    }, BACKOFF_RESET_AFTER_MS);
+  }
+
+  private clearBackoffReset(): void {
+    if (this.backoffResetTimer !== null) {
+      this.timers.clearTimeout(this.backoffResetTimer);
+      this.backoffResetTimer = null;
+    }
+  }
+
   /** Cancel a queued reconnect, if any. Safe to call when none is pending. */
   private clearReconnectTimer(): void {
     if (this.reconnectTimer !== null) {