@replit/river 0.16.2 → 0.17.0

package/dist/transport/impls/ws/server.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 handshakeResponseMessage(from, instanceId, to, ok, reason) {
+function handshakeResponseMessage(from, to, status) {
   return {
     id: (0, import_nanoid.nanoid)(),
     from,
@@ -85,18 +85,9 @@ function handshakeResponseMessage(from, instanceId, to, ok, reason) {
     ack: 0,
     streamId: (0, import_nanoid.nanoid)(),
     controlFlags: 0,
-    payload: ok ? {
+    payload: {
       type: "HANDSHAKE_RESP",
-      status: {
-        ok: true,
-        instanceId
-      }
-    } : {
-      type: "HANDSHAKE_RESP",
-      status: {
-        ok: false,
-        reason: reason ?? "Unknown reason"
-      }
+      status
     }
   };
 }
@@ -167,7 +158,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)
    */
@@ -189,11 +185,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;
@@ -233,7 +229,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;
     }
@@ -264,33 +260,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();
@@ -301,11 +301,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);
@@ -334,9 +335,6 @@ var Session = class {
   }
 };
 
-// transport/transport.ts
-var import_nanoid3 = require("nanoid");
-
 // util/stringify.ts
 function coerceErrorString(err) {
   if (err instanceof Error) {
@@ -416,13 +414,6 @@ var defaultClientTransportOptions = {
   ...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.
@@ -475,41 +466,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);
@@ -519,10 +510,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",
@@ -592,9 +593,12 @@ var Transport = class {
       } else {
         const errMsg = `received out-of-order msg (got seq: ${msg.seq}, wanted seq: ${session.nextExpectedSeq})`;
         log?.error(
-          `${this.clientId} -- ${errMsg}, 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();
       }
       return;
     }
@@ -641,14 +645,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) {
@@ -694,7 +691,7 @@ var ServerTransport = class extends Transport {
   constructor(clientId, providedOptions) {
     super(clientId, providedOptions);
     log?.info(
-      `${this.clientId} -- initiated server transport (instance id: ${this.instanceId}, protocol: ${PROTOCOL_VERSION})`
+      `${this.clientId} -- initiated server transport (protocol: ${PROTOCOL_VERSION})`
     );
   }
   handleConnection(conn) {
@@ -706,12 +703,13 @@ var ServerTransport = class extends Transport {
     let session = void 0;
     const client = () => session?.to ?? "unknown";
     const handshakeHandler = (data) => {
-      const handshake = this.receiveHandshakeRequestMessage(data, conn);
-      if (!handshake) {
+      const maybeSession = this.receiveHandshakeRequestMessage(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);
@@ -749,18 +747,13 @@ var ServerTransport = class extends Transport {
       return false;
     }
     if (!import_value.Value.Check(ControlMessageHandshakeRequestSchema, parsed.payload)) {
-      const responseMsg2 = handshakeResponseMessage(
-        this.clientId,
-        this.instanceId,
-        parsed.from,
-        false
-      );
+      const reason = "received invalid handshake msg";
+      const responseMsg2 = handshakeResponseMessage(this.clientId, parsed.from, {
+        ok: false,
+        reason
+      });
       conn.send(this.codec.toBuffer(responseMsg2));
-      log?.warn(
-        `${this.clientId} -- received invalid handshake msg: ${JSON.stringify(
-          parsed
-        )}`
-      );
+      log?.warn(`${this.clientId} -- ${reason}: ${JSON.stringify(parsed)}`);
       this.protocolError(
         ProtocolError.HandshakeFailed,
         "invalid handshake request"
@@ -769,34 +762,28 @@ var ServerTransport = class extends Transport {
     }
     const gotVersion = parsed.payload.protocolVersion;
     if (gotVersion !== PROTOCOL_VERSION) {
-      const responseMsg2 = handshakeResponseMessage(
-        this.clientId,
-        this.instanceId,
-        parsed.from,
-        false
-      );
+      const reason = `incorrect version (got: ${gotVersion} wanted ${PROTOCOL_VERSION})`;
+      const responseMsg2 = handshakeResponseMessage(this.clientId, parsed.from, {
+        ok: false,
+        reason
+      });
       conn.send(this.codec.toBuffer(responseMsg2));
       log?.warn(
         `${this.clientId} -- received handshake msg with incompatible protocol version (got: ${gotVersion}, expected: ${PROTOCOL_VERSION})`
       );
-      this.protocolError(
-        ProtocolError.HandshakeFailed,
-        `incorrect version (got: ${gotVersion} wanted ${PROTOCOL_VERSION})`
-      );
+      this.protocolError(ProtocolError.HandshakeFailed, reason);
       return false;
     }
-    const instanceId = parsed.payload.instanceId;
+    const session = this.getOrCreateSession(parsed.from, conn);
     log?.debug(
-      `${this.clientId} -- handshake from ${parsed.from} ok (instance id: ${instanceId}), responding with handshake success`
-    );
-    const responseMsg = handshakeResponseMessage(
-      this.clientId,
-      this.instanceId,
-      parsed.from,
-      true
+      `${this.clientId} -- handshake from ${parsed.from} ok, responding with handshake success`
     );
+    const responseMsg = handshakeResponseMessage(this.clientId, parsed.from, {
+      ok: true,
+      sessionId: session.id
+    });
     conn.send(this.codec.toBuffer(responseMsg));
-    return { instanceId, from: parsed.from };
+    return this.onConnect(conn, parsed.from, parsed.payload.sessionId);
   }
 };
 

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

@@ -1,7 +1,7 @@
-import { S as ServerTransport, b as TransportClientId, d as ProvidedTransportOptions } from '../../../index-c9e9977f.js';
+import { d as ServerTransport, b as TransportClientId, e as ProvidedTransportOptions } from '../../../index-8df0bdfb.js';
 import { WebSocketServer } from 'ws';
 import { WebSocket } from 'isomorphic-ws';
-import { W as WebSocketConnection } from '../../../connection-c97da681.js';
+import { W as WebSocketConnection } from '../../../connection-f31edbcd.js';
 import '../../../types-3e5768ec.js';
 import '@sinclair/typebox';
 

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

@@ -1,7 +1,7 @@
-import { S as ServerTransport, b as TransportClientId, d as ProvidedTransportOptions } from '../../../index-c9e9977f.js';
+import { d as ServerTransport, b as TransportClientId, e as ProvidedTransportOptions } from '../../../index-8df0bdfb.js';
 import { WebSocketServer } from 'ws';
 import { WebSocket } from 'isomorphic-ws';
-import { W as WebSocketConnection } from '../../../connection-c97da681.js';
+import { W as WebSocketConnection } from '../../../connection-f31edbcd.js';
 import '../../../types-3e5768ec.js';
 import '@sinclair/typebox';
 

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

@@ -1,10 +1,10 @@
 import {
   WebSocketConnection
-} from "../../../chunk-HKVP6XEL.js";
+} from "../../../chunk-Y6DLSCKU.js";
 import {
   ServerTransport
-} from "../../../chunk-CJGD7CNG.js";
-import "../../../chunk-GFRAOY75.js";
+} from "../../../chunk-LQMPJI3S.js";
+import "../../../chunk-VH3NGOXQ.js";
 import "../../../chunk-H4BYJELI.js";
 import "../../../chunk-GZ7HCLLM.js";