@replit/river 0.23.11 → 0.23.13

package/dist/transport/impls/ws/client.cjs

@@ -24,8 +24,8 @@ __export(client_exports, {
 });
 module.exports = __toCommonJS(client_exports);
 
-// transport/transport.ts
-var import_value = require("@sinclair/typebox/value");
+// transport/client.ts
+var import_api4 = require("@opentelemetry/api");
 
 // transport/message.ts
 var import_typebox = require("@sinclair/typebox");
@@ -105,6 +105,154 @@ function isAck(controlFlag) {
   return (controlFlag & 1 /* AckBit */) === 1 /* AckBit */;
 }
 
+// codec/json.ts
+var encoder = new TextEncoder();
+var decoder = new TextDecoder();
+function uint8ArrayToBase64(uint8Array) {
+  let binary = "";
+  uint8Array.forEach((byte) => {
+    binary += String.fromCharCode(byte);
+  });
+  return btoa(binary);
+}
+function base64ToUint8Array(base64) {
+  const binaryString = atob(base64);
+  const uint8Array = new Uint8Array(binaryString.length);
+  for (let i = 0; i < binaryString.length; i++) {
+    uint8Array[i] = binaryString.charCodeAt(i);
+  }
+  return uint8Array;
+}
+var NaiveJsonCodec = {
+  toBuffer: (obj) => {
+    return encoder.encode(
+      JSON.stringify(obj, function replacer(key) {
+        const val = this[key];
+        if (val instanceof Uint8Array) {
+          return { $t: uint8ArrayToBase64(val) };
+        } else {
+          return val;
+        }
+      })
+    );
+  },
+  fromBuffer: (buff) => {
+    try {
+      const parsed = JSON.parse(
+        decoder.decode(buff),
+        function reviver(_key, val) {
+          if (val?.$t) {
+            return base64ToUint8Array(val.$t);
+          } else {
+            return val;
+          }
+        }
+      );
+      if (typeof parsed === "object")
+        return parsed;
+      return null;
+    } catch {
+      return null;
+    }
+  }
+};
+
+// transport/options.ts
+var defaultTransportOptions = {
+  heartbeatIntervalMs: 1e3,
+  heartbeatsUntilDead: 2,
+  sessionDisconnectGraceMs: 5e3,
+  codec: NaiveJsonCodec
+};
+var defaultConnectionRetryOptions = {
+  baseIntervalMs: 250,
+  maxJitterMs: 200,
+  maxBackoffMs: 32e3,
+  attemptBudgetCapacity: 5,
+  budgetRestoreIntervalMs: 200
+};
+var defaultClientTransportOptions = {
+  ...defaultTransportOptions,
+  ...defaultConnectionRetryOptions
+};
+var defaultServerTransportOptions = {
+  ...defaultTransportOptions
+};
+
+// transport/rateLimit.ts
+var LeakyBucketRateLimit = class {
+  budgetConsumed;
+  intervalHandles;
+  options;
+  constructor(options) {
+    this.options = options;
+    this.budgetConsumed = /* @__PURE__ */ new Map();
+    this.intervalHandles = /* @__PURE__ */ new Map();
+  }
+  getBackoffMs(user) {
+    if (!this.budgetConsumed.has(user))
+      return 0;
+    const exponent = Math.max(0, this.getBudgetConsumed(user) - 1);
+    const jitter = Math.floor(Math.random() * this.options.maxJitterMs);
+    const backoffMs = Math.min(
+      this.options.baseIntervalMs * 2 ** exponent,
+      this.options.maxBackoffMs
+    );
+    return backoffMs + jitter;
+  }
+  get totalBudgetRestoreTime() {
+    return this.options.budgetRestoreIntervalMs * this.options.attemptBudgetCapacity;
+  }
+  consumeBudget(user) {
+    this.stopLeak(user);
+    this.budgetConsumed.set(user, this.getBudgetConsumed(user) + 1);
+  }
+  getBudgetConsumed(user) {
+    return this.budgetConsumed.get(user) ?? 0;
+  }
+  hasBudget(user) {
+    return this.getBudgetConsumed(user) < this.options.attemptBudgetCapacity;
+  }
+  startRestoringBudget(user) {
+    if (this.intervalHandles.has(user)) {
+      return;
+    }
+    const restoreBudgetForUser = () => {
+      const currentBudget = this.budgetConsumed.get(user);
+      if (!currentBudget) {
+        this.stopLeak(user);
+        return;
+      }
+      const newBudget = currentBudget - 1;
+      if (newBudget === 0) {
+        this.budgetConsumed.delete(user);
+        return;
+      }
+      this.budgetConsumed.set(user, newBudget);
+    };
+    const intervalHandle = setInterval(
+      restoreBudgetForUser,
+      this.options.budgetRestoreIntervalMs
+    );
+    this.intervalHandles.set(user, intervalHandle);
+  }
+  stopLeak(user) {
+    if (!this.intervalHandles.has(user)) {
+      return;
+    }
+    clearInterval(this.intervalHandles.get(user));
+    this.intervalHandles.delete(user);
+  }
+  close() {
+    for (const user of this.intervalHandles.keys()) {
+      this.stopLeak(user);
+    }
+  }
+};
+
+// transport/transport.ts
+var import_value = require("@sinclair/typebox/value");
+
 // logging/log.ts
 var LoggingLevels = {
   debug: -1,
@@ -202,7 +350,7 @@ var import_nanoid2 = require("nanoid");
 var import_api = require("@opentelemetry/api");
 
 // package.json
-var version = "0.23.11";
+var version = "0.23.13";
 
 // tracing/index.ts
 function getPropagationContext(ctx) {
@@ -461,10 +609,12 @@ var Session = class {
     this.connection.close();
     this.connection = void 0;
   }
-  replaceWithNewConnection(newConn) {
+  replaceWithNewConnection(newConn, isTransparentReconnect) {
     this.closeStaleConnection(newConn);
     this.cancelGrace();
-    this.sendBufferedMessages(newConn);
+    if (isTransparentReconnect) {
+      this.sendBufferedMessages(newConn);
+    }
     this.connection = newConn;
     this.handshakingConnection = void 0;
   }
@@ -535,159 +685,8 @@ var Session = class {
   }
 };
 
-// util/stringify.ts
-function coerceErrorString(err) {
-  if (err instanceof Error) {
-    return err.message || "unknown reason";
-  }
-  return `[coerced to error] ${String(err)}`;
-}
-
-// transport/rateLimit.ts
-var LeakyBucketRateLimit = class {
-  budgetConsumed;
-  intervalHandles;
-  options;
-  constructor(options) {
-    this.options = options;
-    this.budgetConsumed = /* @__PURE__ */ new Map();
-    this.intervalHandles = /* @__PURE__ */ new Map();
-  }
-  getBackoffMs(user) {
-    if (!this.budgetConsumed.has(user))
-      return 0;
-    const exponent = Math.max(0, this.getBudgetConsumed(user) - 1);
-    const jitter = Math.floor(Math.random() * this.options.maxJitterMs);
-    const backoffMs = Math.min(
-      this.options.baseIntervalMs * 2 ** exponent,
-      this.options.maxBackoffMs
-    );
-    return backoffMs + jitter;
-  }
-  get totalBudgetRestoreTime() {
-    return this.options.budgetRestoreIntervalMs * this.options.attemptBudgetCapacity;
-  }
-  consumeBudget(user) {
-    this.stopLeak(user);
-    this.budgetConsumed.set(user, this.getBudgetConsumed(user) + 1);
-  }
-  getBudgetConsumed(user) {
-    return this.budgetConsumed.get(user) ?? 0;
-  }
-  hasBudget(user) {
-    return this.getBudgetConsumed(user) < this.options.attemptBudgetCapacity;
-  }
-  startRestoringBudget(user) {
-    if (this.intervalHandles.has(user)) {
-      return;
-    }
-    const restoreBudgetForUser = () => {
-      const currentBudget = this.budgetConsumed.get(user);
-      if (!currentBudget) {
-        this.stopLeak(user);
-        return;
-      }
-      const newBudget = currentBudget - 1;
-      if (newBudget === 0) {
-        this.budgetConsumed.delete(user);
-        return;
-      }
-      this.budgetConsumed.set(user, newBudget);
-    };
-    const intervalHandle = setInterval(
-      restoreBudgetForUser,
-      this.options.budgetRestoreIntervalMs
-    );
-    this.intervalHandles.set(user, intervalHandle);
-  }
-  stopLeak(user) {
-    if (!this.intervalHandles.has(user)) {
-      return;
-    }
-    clearInterval(this.intervalHandles.get(user));
-    this.intervalHandles.delete(user);
-  }
-  close() {
-    for (const user of this.intervalHandles.keys()) {
-      this.stopLeak(user);
-    }
-  }
-};
-
-// codec/json.ts
-var encoder = new TextEncoder();
-var decoder = new TextDecoder();
-function uint8ArrayToBase64(uint8Array) {
-  let binary = "";
-  uint8Array.forEach((byte) => {
-    binary += String.fromCharCode(byte);
-  });
-  return btoa(binary);
-}
-function base64ToUint8Array(base64) {
-  const binaryString = atob(base64);
-  const uint8Array = new Uint8Array(binaryString.length);
-  for (let i = 0; i < binaryString.length; i++) {
-    uint8Array[i] = binaryString.charCodeAt(i);
-  }
-  return uint8Array;
-}
-var NaiveJsonCodec = {
-  toBuffer: (obj) => {
-    return encoder.encode(
-      JSON.stringify(obj, function replacer(key) {
-        const val = this[key];
-        if (val instanceof Uint8Array) {
-          return { $t: uint8ArrayToBase64(val) };
-        } else {
-          return val;
-        }
-      })
-    );
-  },
-  fromBuffer: (buff) => {
-    try {
-      const parsed = JSON.parse(
-        decoder.decode(buff),
-        function reviver(_key, val) {
-          if (val?.$t) {
-            return base64ToUint8Array(val.$t);
-          } else {
-            return val;
-          }
-        }
-      );
-      if (typeof parsed === "object")
-        return parsed;
-      return null;
-    } catch {
-      return null;
-    }
-  }
-};
-
 // transport/transport.ts
 var import_api3 = require("@opentelemetry/api");
-var defaultTransportOptions = {
-  heartbeatIntervalMs: 1e3,
-  heartbeatsUntilDead: 2,
-  sessionDisconnectGraceMs: 5e3,
-  codec: NaiveJsonCodec
-};
-var defaultConnectionRetryOptions = {
-  baseIntervalMs: 250,
-  maxJitterMs: 200,
-  maxBackoffMs: 32e3,
-  attemptBudgetCapacity: 5,
-  budgetRestoreIntervalMs: 200
-};
-var defaultClientTransportOptions = {
-  ...defaultTransportOptions,
-  ...defaultConnectionRetryOptions
-};
-var defaultServerTransportOptions = {
-  ...defaultTransportOptions
-};
 var Transport = class {
   /**
    * The status of the transport.
@@ -748,15 +747,13 @@ var Transport = class {
    * and we know the identity of the connected client.
    * @param conn The connection object.
    */
-  onConnect(conn, session, isReconnect) {
+  onConnect(conn, session, isTransparentReconnect) {
     this.eventDispatcher.dispatchEvent("connectionStatus", {
       status: "connect",
       conn
     });
     conn.telemetry = createConnectionTelemetryInfo(conn, session.telemetry);
-    if (isReconnect) {
-      session.replaceWithNewConnection(conn);
-    }
+    session.replaceWithNewConnection(conn, isTransparentReconnect);
     this.log?.info(`connected to ${session.to}`, {
       ...conn.loggingMetadata,
       ...session.loggingMetadata
@@ -788,7 +785,8 @@ var Transport = class {
     propagationCtx
   }) {
     let session = this.sessions.get(to);
-    let isReconnect = session !== void 0;
+    const isReconnect = session !== void 0;
+    let isTransparentReconnect = isReconnect;
     if (session?.advertisedSessionId !== void 0 && sessionId !== void 0 && session.advertisedSessionId !== sessionId) {
       this.log?.info(
         `session for ${to} already exists but has a different session id (expected: ${session.advertisedSessionId}, got: ${sessionId}), creating a new one`,
@@ -799,7 +797,7 @@ var Transport = class {
         closeHandshakingConnection: handshakingConn !== void 0,
         handshakingConn
       });
-      isReconnect = false;
+      isTransparentReconnect = false;
       session = void 0;
     }
     if (!session) {
@@ -815,7 +813,7 @@ var Transport = class {
     if (handshakingConn !== void 0) {
       session.replaceWithNewHandshakingConnection(handshakingConn);
     }
-    return { session, isReconnect };
+    return { session, isReconnect, isTransparentReconnect };
   }
   deleteSession({
     session,
@@ -843,6 +841,16 @@ var Transport = class {
    * @param connectedTo The peer we are connected to.
    */
   onDisconnect(conn, session) {
+    if (session.connection !== void 0 && session.connection.id !== conn.id) {
+      session.telemetry.span.addEvent("onDisconnect race");
+      this.log?.warn("onDisconnect race", {
+        clientId: this.clientId,
+        ...session.loggingMetadata,
+        ...conn.loggingMetadata,
+        tags: ["invariant-violation"]
+      });
+      return;
+    }
     conn.telemetry?.span.end();
     this.eventDispatcher.dispatchEvent("connectionStatus", {
       status: "disconnect",
@@ -850,6 +858,16 @@ var Transport = class {
     });
     session.connection = void 0;
     session.beginGrace(() => {
+      if (session.connection !== void 0) {
+        session.telemetry.span.addEvent("session grace period race");
+        this.log?.warn("session grace period race", {
+          clientId: this.clientId,
+          ...session.loggingMetadata,
+          ...conn.loggingMetadata,
+          tags: ["invariant-violation"]
+        });
+        return;
+      }
       session.telemetry.span.addEvent("session grace period expired");
       this.deleteSession({
         session,
@@ -1017,6 +1035,17 @@ var Transport = class {
     return this.status;
   }
 };
+
+// util/stringify.ts
+function coerceErrorString(err) {
+  if (err instanceof Error) {
+    return err.message || "unknown reason";
+  }
+  return `[coerced to error] ${String(err)}`;
+}
+
+// transport/client.ts
+var import_value2 = require("@sinclair/typebox/value");
 var ClientTransport = class extends Transport {
   /**
    * The options for this transport.
@@ -1077,7 +1106,7 @@ var ClientTransport = class extends Transport {
         const parsed = this.parseMsg(data2, conn);
         if (!parsed) {
           conn.telemetry?.span.setStatus({
-            code: import_api3.SpanStatusCode.ERROR,
+            code: import_api4.SpanStatusCode.ERROR,
             message: "message parse failure"
           });
           conn.close();
@@ -1108,7 +1137,7 @@ var ClientTransport = class extends Transport {
     });
     conn.addErrorListener((err) => {
       conn.telemetry?.span.setStatus({
-        code: import_api3.SpanStatusCode.ERROR,
+        code: import_api4.SpanStatusCode.ERROR,
         message: "connection error"
       });
       this.log?.warn(
@@ -1126,7 +1155,7 @@ var ClientTransport = class extends Transport {
     const parsed = this.parseMsg(data, conn);
     if (!parsed) {
       conn.telemetry?.span.setStatus({
-        code: import_api3.SpanStatusCode.ERROR,
+        code: import_api4.SpanStatusCode.ERROR,
         message: "non-transport message"
       });
       this.protocolError(
@@ -1135,9 +1164,9 @@ var ClientTransport = class extends Transport {
       );
       return false;
     }
-    if (!import_value.Value.Check(ControlMessageHandshakeResponseSchema, parsed.payload)) {
+    if (!import_value2.Value.Check(ControlMessageHandshakeResponseSchema, parsed.payload)) {
       conn.telemetry?.span.setStatus({
-        code: import_api3.SpanStatusCode.ERROR,
+        code: import_api4.SpanStatusCode.ERROR,
         message: "invalid handshake response"
       });
       this.log?.warn(`received invalid handshake resp`, {
@@ -1146,7 +1175,7 @@ var ClientTransport = class extends Transport {
         connectedTo: parsed.from,
         transportMessage: parsed,
         validationErrors: [
-          ...import_value.Value.Errors(
+          ...import_value2.Value.Errors(
             ControlMessageHandshakeResponseSchema,
             parsed.payload
           )
@@ -1160,7 +1189,7 @@ var ClientTransport = class extends Transport {
     }
     if (!parsed.payload.status.ok) {
       conn.telemetry?.span.setStatus({
-        code: import_api3.SpanStatusCode.ERROR,
+        code: import_api4.SpanStatusCode.ERROR,
         message: "handshake rejected"
       });
       this.log?.warn(`received handshake rejection`, {
@@ -1175,18 +1204,37 @@ var ClientTransport = class extends Transport {
       );
       return false;
     }
+    const previousSession = this.sessions.get(parsed.from);
+    if (previousSession?.advertisedSessionId && previousSession.advertisedSessionId !== parsed.payload.status.sessionId) {
+      this.deleteSession({
+        session: previousSession,
+        closeHandshakingConnection: true
+      });
+      conn.telemetry?.span.setStatus({
+        code: import_api4.SpanStatusCode.ERROR,
+        message: "session id mismatch"
+      });
+      this.log?.warn(`handshake from ${parsed.from} session id mismatch`, {
+        ...conn.loggingMetadata,
+        clientId: this.clientId,
+        connectedTo: parsed.from,
+        transportMessage: parsed
+      });
+      this.protocolError(ProtocolError.HandshakeFailed, "session id mismatch");
+      return false;
+    }
     this.log?.debug(`handshake from ${parsed.from} ok`, {
       ...conn.loggingMetadata,
       clientId: this.clientId,
       connectedTo: parsed.from,
       transportMessage: parsed
     });
-    const { session, isReconnect } = this.getOrCreateSession({
+    const { session, isTransparentReconnect } = this.getOrCreateSession({
       to: parsed.from,
       conn,
       sessionId: parsed.payload.status.sessionId
     });
-    this.onConnect(conn, session, isReconnect);
+    this.onConnect(conn, session, isTransparentReconnect);
     this.retryBudget.startRestoringBudget(session.to);
     return session;
   }
@@ -1263,7 +1311,7 @@ var ClientTransport = class extends Transport {
         } catch (err) {
           const errStr = coerceErrorString(err);
           span.recordException(errStr);
-          span.setStatus({ code: import_api3.SpanStatusCode.ERROR });
+          span.setStatus({ code: import_api4.SpanStatusCode.ERROR });
           throw err;
         } finally {
           span.end();
@@ -1314,13 +1362,13 @@ var ClientTransport = class extends Transport {
     let metadata = void 0;
     if (this.handshakeExtensions) {
       metadata = await this.handshakeExtensions.construct();
-      if (!import_value.Value.Check(this.handshakeExtensions.schema, metadata)) {
+      if (!import_value2.Value.Check(this.handshakeExtensions.schema, metadata)) {
         this.log?.error(`constructed handshake metadata did not match schema`, {
           ...conn.loggingMetadata,
           clientId: this.clientId,
           connectedTo: to,
           validationErrors: [
-            ...import_value.Value.Errors(this.handshakeExtensions.schema, metadata)
+            ...import_value2.Value.Errors(this.handshakeExtensions.schema, metadata)
           ],
           tags: ["invariant-violation"]
         });
@@ -1329,7 +1377,7 @@ var ClientTransport = class extends Transport {
           "handshake metadata did not match schema"
         );
         conn.telemetry?.span.setStatus({
-          code: import_api3.SpanStatusCode.ERROR,
+          code: import_api4.SpanStatusCode.ERROR,
           message: "handshake meta mismatch"
         });
         return false;