@replit/river 0.23.12 → 0.23.14

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

@@ -24,8 +24,8 @@ __export(server_exports, {
 });
 module.exports = __toCommonJS(server_exports);
 
-// transport/transport.ts
-var import_value = require("@sinclair/typebox/value");
+// transport/session.ts
+var import_nanoid2 = require("nanoid");
 
 // 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,12 @@ var ControlMessagePayloadSchema = import_typebox.Type.Union([
 var OpaqueTransportMessageSchema = TransportMessageSchema(
   import_typebox.Type.Unknown()
 );
-function handshakeResponseMessage(from, to, status) {
+var SESSION_STATE_MISMATCH = "session state mismatch";
+function handshakeResponseMessage({
+  from,
+  to,
+  status
+}) {
   return {
     id: (0, import_nanoid.nanoid)(),
     from,
@@ -102,104 +122,11 @@ function isAck(controlFlag) {
   return (controlFlag & 1 /* AckBit */) === 1 /* AckBit */;
 }
 
-// logging/log.ts
-var LoggingLevels = {
-  debug: -1,
-  info: 0,
-  warn: 1,
-  error: 2
-};
-var cleanedLogFn = (log) => {
-  return (msg, metadata) => {
-    if (!metadata?.transportMessage) {
-      log(msg, metadata);
-      return;
-    }
-    const { payload, ...rest } = metadata.transportMessage;
-    metadata.transportMessage = rest;
-    log(msg, metadata);
-  };
-};
-var BaseLogger = class {
-  minLevel;
-  output;
-  constructor(output, minLevel = "info") {
-    this.minLevel = minLevel;
-    this.output = output;
-  }
-  debug(msg, metadata) {
-    if (LoggingLevels[this.minLevel] <= LoggingLevels.debug) {
-      this.output(msg, metadata ?? {}, "debug");
-    }
-  }
-  info(msg, metadata) {
-    if (LoggingLevels[this.minLevel] <= LoggingLevels.info) {
-      this.output(msg, metadata ?? {}, "info");
-    }
-  }
-  warn(msg, metadata) {
-    if (LoggingLevels[this.minLevel] <= LoggingLevels.warn) {
-      this.output(msg, metadata ?? {}, "warn");
-    }
-  }
-  error(msg, metadata) {
-    if (LoggingLevels[this.minLevel] <= LoggingLevels.error) {
-      this.output(msg, metadata ?? {}, "error");
-    }
-  }
-};
-var createLogProxy = (log) => ({
-  debug: cleanedLogFn(log.debug.bind(log)),
-  info: cleanedLogFn(log.info.bind(log)),
-  warn: cleanedLogFn(log.warn.bind(log)),
-  error: cleanedLogFn(log.error.bind(log))
-});
-
-// transport/events.ts
-var ProtocolError = {
-  RetriesExceeded: "conn_retry_exceeded",
-  HandshakeFailed: "handshake_failed",
-  MessageOrderingViolated: "message_ordering_violated"
-};
-var EventDispatcher = class {
-  eventListeners = {};
-  removeAllListeners() {
-    this.eventListeners = {};
-  }
-  numberOfListeners(eventType) {
-    return this.eventListeners[eventType]?.size ?? 0;
-  }
-  addEventListener(eventType, handler) {
-    if (!this.eventListeners[eventType]) {
-      this.eventListeners[eventType] = /* @__PURE__ */ new Set();
-    }
-    this.eventListeners[eventType]?.add(handler);
-  }
-  removeEventListener(eventType, handler) {
-    const handlers = this.eventListeners[eventType];
-    if (handlers) {
-      this.eventListeners[eventType]?.delete(handler);
-    }
-  }
-  dispatchEvent(eventType, event) {
-    const handlers = this.eventListeners[eventType];
-    if (handlers) {
-      const copy = [...handlers];
-      for (const handler of copy) {
-        handler(event);
-      }
-    }
-  }
-};
-
-// transport/session.ts
-var import_nanoid2 = require("nanoid");
-
 // tracing/index.ts
 var import_api = require("@opentelemetry/api");
 
 // package.json
-var version = "0.23.12";
+var version = "0.23.14";
 
 // tracing/index.ts
 function createSessionTelemetryInfo(session, propagationCtx) {
@@ -504,9 +431,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,
@@ -525,13 +460,59 @@ var Session = class {
   }
 };
 
-// util/stringify.ts
-function coerceErrorString(err) {
-  if (err instanceof Error) {
-    return err.message || "unknown reason";
+// transport/impls/ws/connection.ts
+var WebSocketConnection = class extends Connection {
+  errorCb = null;
+  closeCb = null;
+  ws;
+  constructor(ws) {
+    super();
+    this.ws = ws;
+    this.ws.binaryType = "arraybuffer";
+    let didError = false;
+    this.ws.onerror = () => {
+      didError = true;
+    };
+    this.ws.onclose = ({ code, reason }) => {
+      if (didError && this.errorCb) {
+        this.errorCb(
+          new Error(
+            `websocket closed with code and reason: ${code} - ${reason}`
+          )
+        );
+      }
+      if (this.closeCb) {
+        this.closeCb();
+      }
+    };
   }
-  return `[coerced to error] ${String(err)}`;
-}
+  addDataListener(cb) {
+    this.ws.onmessage = (msg) => cb(msg.data);
+  }
+  removeDataListener() {
+    this.ws.onmessage = null;
+  }
+  addCloseListener(cb) {
+    this.closeCb = cb;
+  }
+  addErrorListener(cb) {
+    this.errorCb = cb;
+  }
+  send(payload) {
+    if (this.ws.readyState === this.ws.OPEN) {
+      this.ws.send(payload);
+      return true;
+    } else {
+      return false;
+    }
+  }
+  close() {
+    this.ws.close();
+  }
+};
+
+// transport/server.ts
+var import_api4 = require("@opentelemetry/api");
 
 // codec/json.ts
 var encoder = new TextEncoder();
@@ -585,8 +566,7 @@ var NaiveJsonCodec = {
   }
 };
 
-// transport/transport.ts
-var import_api3 = require("@opentelemetry/api");
+// transport/options.ts
 var defaultTransportOptions = {
   heartbeatIntervalMs: 1e3,
   heartbeatsUntilDead: 2,
@@ -607,6 +587,102 @@ var defaultClientTransportOptions = {
 var defaultServerTransportOptions = {
   ...defaultTransportOptions
 };
+
+// transport/transport.ts
+var import_value = require("@sinclair/typebox/value");
+
+// logging/log.ts
+var LoggingLevels = {
+  debug: -1,
+  info: 0,
+  warn: 1,
+  error: 2
+};
+var cleanedLogFn = (log) => {
+  return (msg, metadata) => {
+    if (!metadata?.transportMessage) {
+      log(msg, metadata);
+      return;
+    }
+    const { payload, ...rest } = metadata.transportMessage;
+    metadata.transportMessage = rest;
+    log(msg, metadata);
+  };
+};
+var BaseLogger = class {
+  minLevel;
+  output;
+  constructor(output, minLevel = "info") {
+    this.minLevel = minLevel;
+    this.output = output;
+  }
+  debug(msg, metadata) {
+    if (LoggingLevels[this.minLevel] <= LoggingLevels.debug) {
+      this.output(msg, metadata ?? {}, "debug");
+    }
+  }
+  info(msg, metadata) {
+    if (LoggingLevels[this.minLevel] <= LoggingLevels.info) {
+      this.output(msg, metadata ?? {}, "info");
+    }
+  }
+  warn(msg, metadata) {
+    if (LoggingLevels[this.minLevel] <= LoggingLevels.warn) {
+      this.output(msg, metadata ?? {}, "warn");
+    }
+  }
+  error(msg, metadata) {
+    if (LoggingLevels[this.minLevel] <= LoggingLevels.error) {
+      this.output(msg, metadata ?? {}, "error");
+    }
+  }
+};
+var createLogProxy = (log) => ({
+  debug: cleanedLogFn(log.debug.bind(log)),
+  info: cleanedLogFn(log.info.bind(log)),
+  warn: cleanedLogFn(log.warn.bind(log)),
+  error: cleanedLogFn(log.error.bind(log))
+});
+
+// transport/events.ts
+var ProtocolError = {
+  RetriesExceeded: "conn_retry_exceeded",
+  HandshakeFailed: "handshake_failed",
+  MessageOrderingViolated: "message_ordering_violated"
+};
+var EventDispatcher = class {
+  eventListeners = {};
+  removeAllListeners() {
+    this.eventListeners = {};
+  }
+  numberOfListeners(eventType) {
+    return this.eventListeners[eventType]?.size ?? 0;
+  }
+  addEventListener(eventType, handler) {
+    if (!this.eventListeners[eventType]) {
+      this.eventListeners[eventType] = /* @__PURE__ */ new Set();
+    }
+    this.eventListeners[eventType]?.add(handler);
+  }
+  removeEventListener(eventType, handler) {
+    const handlers = this.eventListeners[eventType];
+    if (handlers) {
+      this.eventListeners[eventType]?.delete(handler);
+    }
+  }
+  dispatchEvent(eventType, event) {
+    const handlers = this.eventListeners[eventType];
+    if (handlers) {
+      const copy = [...handlers];
+      for (const handler of copy) {
+        handler(event);
+      }
+    }
+  }
+};
+
+// transport/transport.ts
+var import_api3 = require("@opentelemetry/api");
 var Transport = class {
   /**
    * The status of the transport.
@@ -697,6 +773,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,
@@ -761,6 +880,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",
@@ -768,6 +897,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,
@@ -935,6 +1074,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/server.ts
+var import_value2 = require("@sinclair/typebox/value");
 var ServerTransport = class extends Transport {
   /**
    * The options for this transport.
@@ -983,7 +1133,7 @@ var ServerTransport = class extends Transport {
           }
         );
         conn.telemetry?.span.setStatus({
-          code: import_api3.SpanStatusCode.ERROR,
+          code: import_api4.SpanStatusCode.ERROR,
           message: "handshake timeout"
         });
         conn.close();
@@ -1034,7 +1184,7 @@ var ServerTransport = class extends Transport {
     });
     conn.addErrorListener((err) => {
       conn.telemetry?.span.setStatus({
-        code: import_api3.SpanStatusCode.ERROR,
+        code: import_api4.SpanStatusCode.ERROR,
         message: "connection error"
       });
       if (!session)
@@ -1048,22 +1198,26 @@ var ServerTransport = class extends Transport {
   async validateHandshakeMetadata(conn, session, rawMetadata, from) {
     let parsedMetadata = {};
     if (this.handshakeExtensions) {
-      if (!import_value.Value.Check(this.handshakeExtensions.schema, rawMetadata)) {
+      if (!import_value2.Value.Check(this.handshakeExtensions.schema, rawMetadata)) {
         conn.telemetry?.span.setStatus({
-          code: import_api3.SpanStatusCode.ERROR,
+          code: import_api4.SpanStatusCode.ERROR,
           message: "malformed handshake meta"
         });
         const reason = "received malformed handshake metadata";
-        const responseMsg = handshakeResponseMessage(this.clientId, from, {
-          ok: false,
-          reason
+        const responseMsg = handshakeResponseMessage({
+          from: this.clientId,
+          to: from,
+          status: {
+            ok: false,
+            reason
+          }
         });
         conn.send(this.codec.toBuffer(responseMsg));
         this.log?.warn(`received malformed handshake metadata from ${from}`, {
           ...conn.loggingMetadata,
           clientId: this.clientId,
           validationErrors: [
-            ...import_value.Value.Errors(this.handshakeExtensions.schema, rawMetadata)
+            ...import_value2.Value.Errors(this.handshakeExtensions.schema, rawMetadata)
           ]
         });
         this.protocolError(ProtocolError.HandshakeFailed, reason);
@@ -1077,12 +1231,16 @@ var ServerTransport = class extends Transport {
       if (parsedMetadata === false) {
         const reason = "rejected by handshake handler";
         conn.telemetry?.span.setStatus({
-          code: import_api3.SpanStatusCode.ERROR,
+          code: import_api4.SpanStatusCode.ERROR,
           message: reason
         });
-        const responseMsg = handshakeResponseMessage(this.clientId, from, {
-          ok: false,
-          reason
+        const responseMsg = handshakeResponseMessage({
+          from: this.clientId,
+          to: from,
+          status: {
+            ok: false,
+            reason
+          }
         });
         conn.send(this.codec.toBuffer(responseMsg));
         this.log?.warn(`rejected handshake from ${from}`, {
@@ -1099,7 +1257,7 @@ var ServerTransport = 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(
@@ -1108,15 +1266,19 @@ var ServerTransport = class extends Transport {
       );
       return false;
     }
-    if (!import_value.Value.Check(ControlMessageHandshakeRequestSchema, parsed.payload)) {
+    if (!import_value2.Value.Check(ControlMessageHandshakeRequestSchema, parsed.payload)) {
       conn.telemetry?.span.setStatus({
-        code: import_api3.SpanStatusCode.ERROR,
+        code: import_api4.SpanStatusCode.ERROR,
         message: "invalid handshake request"
       });
       const reason = "received invalid handshake msg";
-      const responseMsg2 = handshakeResponseMessage(this.clientId, parsed.from, {
-        ok: false,
-        reason
+      const responseMsg2 = handshakeResponseMessage({
+        from: this.clientId,
+        to: parsed.from,
+        status: {
+          ok: false,
+          reason
+        }
       });
       conn.send(this.codec.toBuffer(responseMsg2));
       this.log?.warn(reason, {
@@ -1126,7 +1288,7 @@ var ServerTransport = class extends Transport {
         // before passing it to user-land
         transportMessage: parsed,
         validationErrors: [
-          ...import_value.Value.Errors(ControlMessageHandshakeRequestSchema, parsed.payload)
+          ...import_value2.Value.Errors(ControlMessageHandshakeRequestSchema, parsed.payload)
         ]
       });
       this.protocolError(
@@ -1138,13 +1300,17 @@ var ServerTransport = class extends Transport {
     const gotVersion = parsed.payload.protocolVersion;
     if (gotVersion !== PROTOCOL_VERSION) {
       conn.telemetry?.span.setStatus({
-        code: import_api3.SpanStatusCode.ERROR,
+        code: import_api4.SpanStatusCode.ERROR,
         message: "incorrect protocol version"
       });
       const reason = `incorrect version (got: ${gotVersion} wanted ${PROTOCOL_VERSION})`;
-      const responseMsg2 = handshakeResponseMessage(this.clientId, parsed.from, {
-        ok: false,
-        reason
+      const responseMsg2 = handshakeResponseMessage({
+        from: this.clientId,
+        to: parsed.from,
+        status: {
+          ok: false,
+          reason
+        }
       });
       conn.send(this.codec.toBuffer(responseMsg2));
       this.log?.warn(
@@ -1164,20 +1330,67 @@ var ServerTransport = class extends Transport {
     if (parsedMetadata === false) {
       return false;
     }
-    const { session, isTransparentReconnect } = this.getOrCreateSession({
-      to: parsed.from,
-      conn,
-      sessionId: parsed.payload.sessionId,
-      propagationCtx: parsed.tracing
-    });
+    let session;
+    let isTransparentReconnect;
+    if (!parsed.payload.expectedSessionState) {
+      ({ session, isTransparentReconnect } = this.getOrCreateSession({
+        to: parsed.from,
+        conn,
+        sessionId: parsed.payload.sessionId,
+        propagationCtx: parsed.tracing
+      }));
+    } else if (parsed.payload.expectedSessionState.reconnect) {
+      const existingSession = this.getExistingSession({
+        to: parsed.from,
+        sessionId: parsed.payload.sessionId,
+        nextExpectedSeq: parsed.payload.expectedSessionState.nextExpectedSeq
+      });
+      if (existingSession === false) {
+        conn.telemetry?.span.setStatus({
+          code: import_api4.SpanStatusCode.ERROR,
+          message: SESSION_STATE_MISMATCH
+        });
+        const reason = SESSION_STATE_MISMATCH;
+        const responseMsg2 = handshakeResponseMessage({
+          from: this.clientId,
+          to: parsed.from,
+          status: {
+            ok: false,
+            reason
+          }
+        });
+        conn.send(this.codec.toBuffer(responseMsg2));
+        this.log?.warn(
+          `'received handshake msg with incompatible existing session state: ${parsed.payload.sessionId}`,
+          { ...conn.loggingMetadata, clientId: this.clientId }
+        );
+        this.protocolError(ProtocolError.HandshakeFailed, reason);
+        return false;
+      }
+      session = existingSession;
+      isTransparentReconnect = false;
+    } else {
+      const createdSession = this.createNewSession({
+        to: parsed.from,
+        conn,
+        sessionId: parsed.payload.sessionId,
+        propagationCtx: parsed.tracing
+      });
+      session = createdSession;
+      isTransparentReconnect = false;
+    }
     this.sessionHandshakeMetadata.set(session, parsedMetadata);
     this.log?.debug(
       `handshake from ${parsed.from} ok, responding with handshake success`,
       conn.loggingMetadata
     );
-    const responseMsg = handshakeResponseMessage(this.clientId, parsed.from, {
-      ok: true,
-      sessionId: session.id
+    const responseMsg = handshakeResponseMessage({
+      from: this.clientId,
+      to: parsed.from,
+      status: {
+        ok: true,
+        sessionId: session.id
+      }
     });
     conn.send(this.codec.toBuffer(responseMsg));
     this.onConnect(conn, session, isTransparentReconnect);
@@ -1185,57 +1398,6 @@ var ServerTransport = class extends Transport {
   }
 };
 
-// transport/impls/ws/connection.ts
-var WebSocketConnection = class extends Connection {
-  errorCb = null;
-  closeCb = null;
-  ws;
-  constructor(ws) {
-    super();
-    this.ws = ws;
-    this.ws.binaryType = "arraybuffer";
-    let didError = false;
-    this.ws.onerror = () => {
-      didError = true;
-    };
-    this.ws.onclose = ({ code, reason }) => {
-      if (didError && this.errorCb) {
-        this.errorCb(
-          new Error(
-            `websocket closed with code and reason: ${code} - ${reason}`
-          )
-        );
-      }
-      if (this.closeCb) {
-        this.closeCb();
-      }
-    };
-  }
-  addDataListener(cb) {
-    this.ws.onmessage = (msg) => cb(msg.data);
-  }
-  removeDataListener() {
-    this.ws.onmessage = null;
-  }
-  addCloseListener(cb) {
-    this.closeCb = cb;
-  }
-  addErrorListener(cb) {
-    this.errorCb = cb;
-  }
-  send(payload) {
-    if (this.ws.readyState === this.ws.OPEN) {
-      this.ws.send(payload);
-      return true;
-    } else {
-      return false;
-    }
-  }
-  close() {
-    this.ws.close();
-  }
-};
-
 // transport/impls/ws/server.ts
 var WebSocketServerTransport = class extends ServerTransport {
   wss;