@replit/river 0.16.1 → 0.17.0

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

@@ -48,18 +48,18 @@ var ControlMessageAckSchema = import_typebox.Type.Object({
 var ControlMessageCloseSchema = import_typebox.Type.Object({
   type: import_typebox.Type.Literal("CLOSE")
 });
-var PROTOCOL_VERSION = "v1";
+var PROTOCOL_VERSION = "v1.1";
 var ControlMessageHandshakeRequestSchema = import_typebox.Type.Object({
   type: import_typebox.Type.Literal("HANDSHAKE_REQ"),
   protocolVersion: import_typebox.Type.String(),
-  instanceId: import_typebox.Type.String()
+  sessionId: import_typebox.Type.String()
 });
 var ControlMessageHandshakeResponseSchema = import_typebox.Type.Object({
   type: import_typebox.Type.Literal("HANDSHAKE_RESP"),
   status: import_typebox.Type.Union([
     import_typebox.Type.Object({
       ok: import_typebox.Type.Literal(true),
-      instanceId: import_typebox.Type.String()
+      sessionId: import_typebox.Type.String()
     }),
     import_typebox.Type.Object({
       ok: import_typebox.Type.Literal(false),
@@ -76,7 +76,7 @@ var ControlMessagePayloadSchema = import_typebox.Type.Union([
 var OpaqueTransportMessageSchema = TransportMessageSchema(
   import_typebox.Type.Unknown()
 );
-function handshakeRequestMessage(from, to, instanceId) {
+function handshakeRequestMessage(from, to, sessionId) {
   return {
     id: (0, import_nanoid.nanoid)(),
     from,
@@ -88,7 +88,7 @@ function handshakeRequestMessage(from, to, instanceId) {
     payload: {
       type: "HANDSHAKE_REQ",
       protocolVersion: PROTOCOL_VERSION,
-      instanceId
+      sessionId
     }
   };
 }
@@ -103,7 +103,8 @@ var log;
 var ProtocolError = {
   RetriesExceeded: "conn_retry_exceeded",
   HandshakeFailed: "handshake_failed",
-  UseAfterDestroy: "use_after_destroy"
+  UseAfterDestroy: "use_after_destroy",
+  MessageOrderingViolated: "message_ordering_violated"
 };
 var EventDispatcher = class {
   eventListeners = {};
@@ -158,7 +159,12 @@ var Session = class {
   /**
    * The unique ID of this session.
    */
-  debugId;
+  id;
+  /**
+   * What the other side advertised as their session ID
+   * for this session.
+   */
+  advertisedSessionId;
   /**
    * Number of messages we've sent along this session (excluding handshake and acks)
    */
@@ -180,11 +186,11 @@ var Session = class {
    * The interval for sending heartbeats.
    */
   heartbeat;
-  constructor(from, connectedTo, conn, options) {
+  constructor(conn, from, to, options) {
+    this.id = `session-${nanoid2(12)}`;
     this.options = options;
-    this.debugId = `sess-${unsafeId()}`;
     this.from = from;
-    this.to = connectedTo;
+    this.to = to;
     this.connection = conn;
     this.codec = options.codec;
     this.heartbeatMisses = 0;
@@ -224,7 +230,7 @@ var Session = class {
         log?.info(
           `${this.from} -- closing connection (id: ${this.connection.debugId}) to ${this.to} due to inactivity`
         );
-        this.closeStaleConnection(this.connection);
+        this.closeStaleConnection();
       }
       return;
     }
@@ -255,33 +261,37 @@ var Session = class {
       log?.debug(`${this.from} -- resending ${msg.id} (seq: ${msg.seq})`);
       const ok = this.connection.send(this.codec.toBuffer(msg));
       if (!ok) {
-        const msg2 = `${this.from} -- failed to send buffered message to ${this.to} in session (id: ${this.debugId}) (if you hit this code path something is seriously wrong)`;
+        const msg2 = `${this.from} -- failed to send buffered message to ${this.to} in session (id: ${this.id}) (if you hit this code path something is seriously wrong)`;
         log?.error(msg2);
         throw new Error(msg2);
       }
     }
   }
   updateBookkeeping(ack, seq) {
+    if (seq + 1 < this.ack) {
+      log?.error(`${this.from} -- received stale seq ${seq} + 1 < ${this.ack}`);
+      return;
+    }
     this.sendBuffer = this.sendBuffer.filter((unacked) => unacked.seq > ack);
     this.ack = seq + 1;
   }
   closeStaleConnection(conn) {
-    if (!this.connection || this.connection !== conn)
+    if (this.connection === void 0 || this.connection === conn)
       return;
     log?.info(
-      `${this.from} -- closing old inner connection (id: ${this.connection.debugId}) from session (id: ${this.debugId}) to ${this.to}`
+      `${this.from} -- closing old inner connection (id: ${this.connection.debugId}) from session (id: ${this.id}) to ${this.to}`
     );
     this.connection.close();
     this.connection = void 0;
   }
   replaceWithNewConnection(newConn) {
-    this.closeStaleConnection(this.connection);
+    this.closeStaleConnection(newConn);
     this.cancelGrace();
     this.connection = newConn;
   }
   beginGrace(cb) {
     log?.info(
-      `${this.from} -- starting ${this.options.sessionDisconnectGraceMs}ms grace period until session (id: ${this.debugId}) to ${this.to} is closed`
+      `${this.from} -- starting ${this.options.sessionDisconnectGraceMs}ms grace period until session (id: ${this.id}) to ${this.to} is closed`
     );
     this.disconnectionGrace = setTimeout(() => {
       this.close();
@@ -292,11 +302,12 @@ var Session = class {
   cancelGrace() {
     this.heartbeatMisses = 0;
     clearTimeout(this.disconnectionGrace);
+    this.disconnectionGrace = void 0;
   }
   // closed when we want to discard the whole session
   // (i.e. shutdown or session disconnect)
   close() {
-    this.closeStaleConnection(this.connection);
+    this.closeStaleConnection();
     this.cancelGrace();
     this.resetBufferedMessages();
     clearInterval(this.heartbeat);
@@ -325,9 +336,6 @@ var Session = class {
   }
 };
 
-// transport/transport.ts
-var import_nanoid3 = require("nanoid");
-
 // util/stringify.ts
 function coerceErrorString(err) {
   if (err instanceof Error) {
@@ -474,17 +482,10 @@ var defaultConnectionRetryOptions = {
   budgetRestoreIntervalMs: 200
 };
 var defaultClientTransportOptions = {
-  connectionRetryOptions: defaultConnectionRetryOptions,
-  ...defaultTransportOptions
+  ...defaultTransportOptions,
+  ...defaultConnectionRetryOptions
 };
 var Transport = class {
-  /**
-   * Unique per instance of the transport.
-   * This allows us to distinguish reconnects to different
-   * transports.
-   */
-  instanceId = (0, import_nanoid3.nanoid)();
-  connectedInstanceIds = /* @__PURE__ */ new Map();
   /**
    * A flag indicating whether the transport has been destroyed.
    * A destroyed transport will not attempt to reconnect and cannot be used again.
@@ -537,41 +538,41 @@ var Transport = class {
    * and we know the identity of the connected client.
    * @param conn The connection object.
    */
-  onConnect(conn, connectedTo, instanceId) {
+  onConnect(conn, connectedTo, advertisedSessionId) {
     this.eventDispatcher.dispatchEvent("connectionStatus", {
       status: "connect",
       conn
     });
     let oldSession = this.sessions.get(connectedTo);
-    const lastInstanceId = this.connectedInstanceIds.get(connectedTo);
-    if (oldSession && lastInstanceId !== void 0 && lastInstanceId !== instanceId) {
+    if (oldSession?.advertisedSessionId && oldSession.advertisedSessionId !== advertisedSessionId) {
       log?.warn(
-        `${this.clientId} -- connection from ${connectedTo} is a different instance (got: ${instanceId}, last connected to: ${lastInstanceId}), starting a new session`
+        `${this.clientId} -- connection from ${connectedTo} is a different session (id: ${advertisedSessionId}, last connected to: ${oldSession.advertisedSessionId}), starting a new session`
       );
       oldSession.close();
       this.deleteSession(oldSession);
       oldSession = void 0;
     }
-    this.connectedInstanceIds.set(connectedTo, instanceId);
     if (oldSession === void 0) {
       const newSession = this.createSession(connectedTo, conn);
+      newSession.advertisedSessionId = advertisedSessionId;
       log?.info(
-        `${this.clientId} -- new connection (id: ${conn.debugId}) for new session (id: ${newSession.debugId}) to ${connectedTo}`
+        `${this.clientId} -- new connection (id: ${conn.debugId}) for new session (id: ${newSession.id}) to ${connectedTo}`
       );
       return newSession;
     }
     log?.info(
-      `${this.clientId} -- new connection (id: ${conn.debugId}) for existing session (id: ${oldSession.debugId}) to ${connectedTo}`
+      `${this.clientId} -- new connection (id: ${conn.debugId}) for existing session (id: ${oldSession.id}) to ${connectedTo}`
     );
     oldSession.replaceWithNewConnection(conn);
     oldSession.sendBufferedMessages();
+    oldSession.advertisedSessionId = advertisedSessionId;
     return oldSession;
   }
-  createSession(connectedTo, conn) {
+  createSession(to, conn) {
     const session = new Session(
-      this.clientId,
-      connectedTo,
       conn,
+      this.clientId,
+      to,
       this.options
     );
     this.sessions.set(session.to, session);
@@ -581,10 +582,20 @@ var Transport = class {
     });
     return session;
   }
+  getOrCreateSession(to, conn) {
+    let session = this.sessions.get(to);
+    if (!session) {
+      session = this.createSession(to, conn);
+      log?.info(
+        `${this.clientId} -- no session for ${to}, created a new one (id: ${session.id})`
+      );
+    }
+    return session;
+  }
   deleteSession(session) {
     this.sessions.delete(session.to);
     log?.info(
-      `${this.clientId} -- session ${session.debugId} disconnect from ${session.to}`
+      `${this.clientId} -- session ${session.id} disconnect from ${session.to}`
     );
     this.eventDispatcher.dispatchEvent("sessionStatus", {
       status: "disconnect",
@@ -652,11 +663,14 @@ var Transport = class {
           )}`
         );
       } else {
+        const errMsg = `received out-of-order msg (got seq: ${msg.seq}, wanted seq: ${session.nextExpectedSeq})`;
         log?.error(
-          `${this.clientId} -- received out-of-order msg (got: ${msg.seq}, wanted: ${session.nextExpectedSeq}), marking connection as dead: ${JSON.stringify(msg)}`
+          `${this.clientId} -- fatal: ${errMsg}, marking connection as dead: ${JSON.stringify(
+            msg
+          )}`
         );
+        this.protocolError(ProtocolError.MessageOrderingViolated, errMsg);
         session.close();
-        this.deleteSession(session);
       }
       return;
     }
@@ -703,14 +717,7 @@ var Transport = class {
       );
       return void 0;
     }
-    let session = this.sessions.get(to);
-    if (!session) {
-      session = this.createSession(to, void 0);
-      log?.info(
-        `${this.clientId} -- no session for ${to}, created a new one (id: ${session.debugId})`
-      );
-    }
-    return session.send(msg);
+    return this.getOrCreateSession(to).send(msg);
   }
   // control helpers
   sendCloseStream(to, streamId) {
@@ -762,7 +769,13 @@ var ClientTransport = class extends Transport {
    */
   inflightConnectionPromises;
   retryBudget;
-  tryReconnecting = true;
+  /**
+   * A flag indicating whether the transport should automatically reconnect
+   * when a connection is dropped.
+   * Realistically, this should always be true for clients unless you are writing
+   * tests or a special case where you don't want to reconnect.
+   */
+  reconnectOnConnectionDrop = true;
   constructor(clientId, providedOptions) {
     super(clientId, providedOptions);
     this.options = {
@@ -770,21 +783,20 @@ var ClientTransport = class extends Transport {
       ...providedOptions
     };
     this.inflightConnectionPromises = /* @__PURE__ */ new Map();
-    this.retryBudget = new LeakyBucketRateLimit(
-      this.options.connectionRetryOptions
-    );
+    this.retryBudget = new LeakyBucketRateLimit(this.options);
   }
   handleConnection(conn, to) {
     if (this.state !== "open")
       return;
     let session = void 0;
     const handshakeHandler = (data) => {
-      const handshake = this.receiveHandshakeResponseMessage(data);
-      if (!handshake) {
+      const maybeSession = this.receiveHandshakeResponseMessage(data, conn);
+      if (!maybeSession) {
         conn.close();
         return;
+      } else {
+        session = maybeSession;
       }
-      session = this.onConnect(conn, handshake.from, handshake.instanceId);
       conn.removeDataListener(handshakeHandler);
       conn.addDataListener((data2) => {
         const parsed = this.parseMsg(data2);
@@ -804,7 +816,7 @@ var ClientTransport = class extends Transport {
         `${this.clientId} -- connection (id: ${conn.debugId}) to ${to} disconnected`
       );
       this.inflightConnectionPromises.delete(to);
-      if (this.tryReconnecting) {
+      if (this.reconnectOnConnectionDrop) {
         void this.connect(to);
       }
     });
@@ -814,7 +826,7 @@ var ClientTransport = class extends Transport {
       );
     });
   }
-  receiveHandshakeResponseMessage(data) {
+  receiveHandshakeResponseMessage(data, conn) {
     const parsed = this.parseMsg(data);
     if (!parsed) {
       this.protocolError(
@@ -847,12 +859,14 @@ var ClientTransport = class extends Transport {
       );
       return false;
     }
-    const instanceId = parsed.payload.status.instanceId;
-    log?.debug(
-      `${this.clientId} -- handshake from ${parsed.from} ok (instance: ${instanceId})`
+    log?.debug(`${this.clientId} -- handshake from ${parsed.from} ok`);
+    const session = this.onConnect(
+      conn,
+      parsed.from,
+      parsed.payload.status.sessionId
     );
     this.retryBudget.startRestoringBudget(parsed.from);
-    return { instanceId, from: parsed.from };
+    return session;
   }
   /**
    * Manually attempts to connect to a client.
@@ -910,7 +924,7 @@ var ClientTransport = class extends Transport {
     } catch (error) {
       this.inflightConnectionPromises.delete(to);
       const errStr = coerceErrorString(error);
-      if (!this.tryReconnecting || !canProceedWithConnection()) {
+      if (!this.reconnectOnConnectionDrop || !canProceedWithConnection()) {
         log?.warn(`${this.clientId} -- connection to ${to} failed (${errStr})`);
       } else {
         log?.warn(
@@ -921,11 +935,8 @@ var ClientTransport = class extends Transport {
     }
   }
   sendHandshake(to, conn) {
-    const requestMsg = handshakeRequestMessage(
-      this.clientId,
-      to,
-      this.instanceId
-    );
+    const session = this.getOrCreateSession(to, conn);
+    const requestMsg = handshakeRequestMessage(this.clientId, to, session.id);
     log?.debug(`${this.clientId} -- sending handshake request to ${to}`);
     conn.send(this.codec.toBuffer(requestMsg));
   }

package/dist/transport/impls/ws/client.d.cts

@@ -1,6 +1,6 @@
 import WebSocket from 'isomorphic-ws';
-import { a as ClientTransport, b as TransportClientId, c as ProvidedClientTransportOptions } from '../../../index-2e402bb8.js';
-import { W as WebSocketConnection } from '../../../connection-99346822.js';
+import { a as ClientTransport, b as TransportClientId, c as ProvidedClientTransportOptions } from '../../../index-8df0bdfb.js';
+import { W as WebSocketConnection } from '../../../connection-f31edbcd.js';
 import '../../../types-3e5768ec.js';
 import '@sinclair/typebox';
 

package/dist/transport/impls/ws/client.d.ts

@@ -1,6 +1,6 @@
 import WebSocket from 'isomorphic-ws';
-import { a as ClientTransport, b as TransportClientId, c as ProvidedClientTransportOptions } from '../../../index-2e402bb8.js';
-import { W as WebSocketConnection } from '../../../connection-99346822.js';
+import { a as ClientTransport, b as TransportClientId, c as ProvidedClientTransportOptions } from '../../../index-8df0bdfb.js';
+import { W as WebSocketConnection } from '../../../connection-f31edbcd.js';
 import '../../../types-3e5768ec.js';
 import '@sinclair/typebox';
 

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

@@ -1,10 +1,10 @@
 import {
   WebSocketConnection
-} from "../../../chunk-XLJGKNV2.js";
+} from "../../../chunk-Y6DLSCKU.js";
 import {
   ClientTransport
-} from "../../../chunk-7SPCAA6Q.js";
-import "../../../chunk-GFRAOY75.js";
+} from "../../../chunk-LQMPJI3S.js";
+import "../../../chunk-VH3NGOXQ.js";
 import {
   log
 } from "../../../chunk-H4BYJELI.js";