@replit/river 0.23.12 → 0.23.14

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");
@@ -59,6 +59,21 @@ var ControlMessageHandshakeRequestSchema = import_typebox.Type.Object({
   type: import_typebox.Type.Literal("HANDSHAKE_REQ"),
   protocolVersion: import_typebox.Type.String(),
   sessionId: import_typebox.Type.String(),
+  /**
+   * Specifies what the server's expected session state (from the pov of the client). This can be
+   * used by the server to know whether this is a new or a reestablished connection, and whether it
+   * is compatible with what it already has.
+   */
+  expectedSessionState: import_typebox.Type.Optional(
+    import_typebox.Type.Object({
+      /**
+       * reconnect is set to true if the client explicitly wants to reestablish an existing
+       * connection.
+       */
+      reconnect: import_typebox.Type.Boolean(),
+      nextExpectedSeq: import_typebox.Type.Integer()
+    })
+  ),
   metadata: import_typebox.Type.Optional(import_typebox.Type.Unknown())
 });
 var ControlMessageHandshakeResponseSchema = import_typebox.Type.Object({
@@ -83,7 +98,14 @@ var ControlMessagePayloadSchema = import_typebox.Type.Union([
 var OpaqueTransportMessageSchema = TransportMessageSchema(
   import_typebox.Type.Unknown()
 );
-function handshakeRequestMessage(from, to, sessionId, metadata, tracing) {
+function handshakeRequestMessage({
+  from,
+  to,
+  sessionId,
+  expectedSessionState,
+  metadata,
+  tracing
+}) {
   return {
     id: (0, import_nanoid.nanoid)(),
     from,
@@ -97,14 +119,164 @@ function handshakeRequestMessage(from, to, sessionId, metadata, tracing) {
       type: "HANDSHAKE_REQ",
       protocolVersion: PROTOCOL_VERSION,
       sessionId,
+      expectedSessionState,
       metadata
     }
   };
 }
+var SESSION_STATE_MISMATCH = "session state mismatch";
 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 +374,7 @@ var import_nanoid2 = require("nanoid");
 var import_api = require("@opentelemetry/api");
 
 // package.json
-var version = "0.23.12";
+var version = "0.23.14";
 
 // tracing/index.ts
 function getPropagationContext(ctx) {
@@ -516,9 +688,17 @@ var Session = class {
   get connected() {
     return this.connection !== void 0;
   }
+  get nextExpectedAck() {
+    return this.seq;
+  }
   get nextExpectedSeq() {
     return this.ack;
   }
+  // This is only used in tests to make the session misbehave.
+  /* @internal */
+  advanceAckForTesting(by) {
+    this.ack += by;
+  }
   constructMsg(partialMsg) {
     const msg = {
       ...partialMsg,
@@ -537,159 +717,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.
@@ -780,6 +809,49 @@ var Transport = class {
     });
     return session;
   }
+  createNewSession({
+    to,
+    conn,
+    sessionId,
+    propagationCtx
+  }) {
+    let session = this.sessions.get(to);
+    if (session !== void 0) {
+      this.log?.info(
+        `session for ${to} already exists, replacing it with a new session as requested`,
+        session.loggingMetadata
+      );
+      this.deleteSession({
+        session,
+        closeHandshakingConnection: false
+      });
+      session = void 0;
+    }
+    session = this.createSession(to, conn, propagationCtx);
+    session.advertisedSessionId = sessionId;
+    this.log?.info(`created new session for ${to}`, session.loggingMetadata);
+    return session;
+  }
+  getExistingSession({
+    to,
+    sessionId,
+    nextExpectedSeq
+  }) {
+    const session = this.sessions.get(to);
+    if (
+      // reject this request if there was no previous session to replace
+      session === void 0 || // or if both parties do not agree about the next expected sequence number
+      session.nextExpectedAck < nextExpectedSeq || // or if both parties do not agree on the advertised session id
+      session.advertisedSessionId !== sessionId
+    ) {
+      return false;
+    }
+    this.log?.info(
+      `reused existing session for ${to}`,
+      session.loggingMetadata
+    );
+    return session;
+  }
   getOrCreateSession({
     to,
     conn,
@@ -844,6 +916,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",
@@ -851,6 +933,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,
@@ -1018,6 +1110,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.
@@ -1078,7 +1181,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();
@@ -1109,7 +1212,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(
@@ -1127,7 +1230,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(
@@ -1136,9 +1239,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`, {
@@ -1147,7 +1250,7 @@ var ClientTransport = class extends Transport {
         connectedTo: parsed.from,
         transportMessage: parsed,
         validationErrors: [
-          ...import_value.Value.Errors(
+          ...import_value2.Value.Errors(
             ControlMessageHandshakeResponseSchema,
             parsed.payload
           )
@@ -1159,31 +1262,47 @@ var ClientTransport = class extends Transport {
       );
       return false;
     }
+    const previousSession = this.sessions.get(parsed.from);
     if (!parsed.payload.status.ok) {
-      conn.telemetry?.span.setStatus({
-        code: import_api3.SpanStatusCode.ERROR,
-        message: "handshake rejected"
-      });
-      this.log?.warn(`received handshake rejection`, {
-        ...conn.loggingMetadata,
-        clientId: this.clientId,
-        connectedTo: parsed.from,
-        transportMessage: parsed
-      });
+      if (parsed.payload.status.reason === SESSION_STATE_MISMATCH) {
+        if (previousSession) {
+          this.deleteSession({
+            session: previousSession,
+            closeHandshakingConnection: true
+          });
+        }
+        conn.telemetry?.span.setStatus({
+          code: import_api4.SpanStatusCode.ERROR,
+          message: parsed.payload.status.reason
+        });
+      } else {
+        conn.telemetry?.span.setStatus({
+          code: import_api4.SpanStatusCode.ERROR,
+          message: "handshake rejected"
+        });
+      }
+      this.log?.warn(
+        `received handshake rejection: ${parsed.payload.status.reason}`,
+        {
+          ...conn.loggingMetadata,
+          clientId: this.clientId,
+          connectedTo: parsed.from,
+          transportMessage: parsed
+        }
+      );
       this.protocolError(
         ProtocolError.HandshakeFailed,
         parsed.payload.status.reason
       );
       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_api3.SpanStatusCode.ERROR,
+        code: import_api4.SpanStatusCode.ERROR,
         message: "session id mismatch"
       });
       this.log?.warn(`handshake from ${parsed.from} session id mismatch`, {
@@ -1283,7 +1402,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();
@@ -1334,13 +1453,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"]
         });
@@ -1349,20 +1468,24 @@ 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;
       }
     }
     const { session } = this.getOrCreateSession({ to, handshakingConn: conn });
-    const requestMsg = handshakeRequestMessage(
-      this.clientId,
+    const requestMsg = handshakeRequestMessage({
+      from: this.clientId,
       to,
-      session.id,
+      sessionId: session.id,
+      expectedSessionState: {
+        reconnect: session.advertisedSessionId !== void 0,
+        nextExpectedSeq: session.nextExpectedSeq
+      },
       metadata,
-      getPropagationContext(session.telemetry.ctx)
-    );
+      tracing: getPropagationContext(session.telemetry.ctx)
+    });
     this.log?.debug(`sending handshake request to ${to}`, {
       ...conn.loggingMetadata,
       clientId: this.clientId,