@replit/river 0.200.0-rc.6 → 0.200.0-rc.7

package/dist/util/testHelpers.cjs

@@ -41,12 +41,11 @@ __export(testHelpers_exports, {
   dummySession: () => dummySession,
   getIteratorFromStream: () => getIteratorFromStream,
   getTransportConnections: () => getTransportConnections,
-  getUnixSocketPath: () => getUnixSocketPath,
   iterNext: () => iterNext,
   numberOfConnections: () => numberOfConnections,
-  onUdsServeReady: () => onUdsServeReady,
   onWsServerReady: () => onWsServerReady,
   payloadToTransportMessage: () => payloadToTransportMessage,
+  testingClientSessionOptions: () => testingClientSessionOptions,
   testingSessionOptions: () => testingSessionOptions,
   waitForMessage: () => waitForMessage
 });
@@ -359,7 +358,7 @@ var UNCAUGHT_ERROR_CODE = "UNCAUGHT_ERROR";
 var UNEXPECTED_DISCONNECT_CODE = "UNEXPECTED_DISCONNECT";
 var INVALID_REQUEST_CODE = "INVALID_REQUEST";
 var ABORT_CODE = "ABORT";
-var OutputReaderErrorSchema = import_typebox2.Type.Object({
+var ResponseReaderErrorSchema = import_typebox2.Type.Object({
   code: import_typebox2.Type.Union([
     import_typebox2.Type.Literal(INTERNAL_RIVER_ERROR_CODE),
     import_typebox2.Type.Literal(UNCAUGHT_ERROR_CODE),
@@ -369,7 +368,7 @@ var OutputReaderErrorSchema = import_typebox2.Type.Object({
   ]),
   message: import_typebox2.Type.String()
 });
-var InputReaderErrorSchema = import_typebox2.Type.Object({
+var RequestReaderErrorSchema = import_typebox2.Type.Object({
   code: import_typebox2.Type.Union([
     import_typebox2.Type.Literal(UNCAUGHT_ERROR_CODE),
     import_typebox2.Type.Literal(UNEXPECTED_DISCONNECT_CODE),
@@ -480,7 +479,7 @@ function isAck(controlFlag) {
 var import_api = require("@opentelemetry/api");
 
 // package.json
-var version = "0.200.0-rc.6";
+var version = "0.200.0-rc.7";
 
 // tracing/index.ts
 function createSessionTelemetryInfo(sessionId, to, from, propagationCtx) {
@@ -510,9 +509,6 @@ function coerceErrorString(err) {
   return `[coerced to error] ${String(err)}`;
 }
 
-// util/testHelpers.ts
-var import_nanoid2 = require("nanoid");
-
 // codec/json.ts
 var encoder = new TextEncoder();
 var decoder = new TextDecoder();
@@ -575,7 +571,7 @@ var defaultTransportOptions = {
   codec: NaiveJsonCodec
 };
 var defaultConnectionRetryOptions = {
-  baseIntervalMs: 250,
+  baseIntervalMs: 150,
   maxJitterMs: 200,
   maxBackoffMs: 32e3,
   attemptBudgetCapacity: 5,
@@ -642,7 +638,7 @@ var CommonSession = class extends StateMachineState {
   from;
   options;
   log;
-  constructor(from, options, log) {
+  constructor({ from, options, log }) {
     super();
     this.from = from;
     this.options = options;
@@ -684,8 +680,9 @@ var IdentifiedSession = class extends CommonSession {
    */
   ack;
   sendBuffer;
-  constructor(id, from, to, seq, ack, sendBuffer, telemetry, options, protocolVersion, log) {
-    super(from, options, log);
+  constructor(props) {
+    const { id, to, seq, ack, sendBuffer, telemetry, log, protocolVersion } = props;
+    super(props);
     this.id = id;
     this.to = to;
     this.seq = seq;
@@ -741,23 +738,23 @@ var SessionConnecting = class extends IdentifiedSession {
   connPromise;
   listeners;
   connectionTimeout;
-  constructor(connPromise, listeners, ...args) {
-    super(...args);
-    this.connPromise = connPromise;
-    this.listeners = listeners;
+  constructor(props) {
+    super(props);
+    this.connPromise = props.connPromise;
+    this.listeners = props.listeners;
     this.connectionTimeout = setTimeout(() => {
-      listeners.onConnectionTimeout();
+      this.listeners.onConnectionTimeout();
     }, this.options.connectionTimeoutMs);
-    connPromise.then(
+    this.connPromise.then(
       (conn) => {
         if (this._isConsumed)
           return;
-        listeners.onConnectionEstablished(conn);
+        this.listeners.onConnectionEstablished(conn);
       },
       (err) => {
         if (this._isConsumed)
           return;
-        listeners.onConnectionFailed(err);
+        this.listeners.onConnectionFailed(err);
       }
     );
   }
@@ -783,9 +780,9 @@ var SessionNoConnection = class extends IdentifiedSession {
   state = "NoConnection" /* NoConnection */;
   listeners;
   gracePeriodTimeout;
-  constructor(listeners, ...args) {
-    super(...args);
-    this.listeners = listeners;
+  constructor(props) {
+    super(props);
+    this.listeners = props.listeners;
     this.gracePeriodTimeout = setTimeout(() => {
       this.listeners.onSessionGracePeriodElapsed();
     }, this.options.sessionDisconnectGraceMs);
@@ -808,16 +805,16 @@ var SessionWaitingForHandshake = class extends CommonSession {
   conn;
   listeners;
   handshakeTimeout;
-  constructor(conn, listeners, ...args) {
-    super(...args);
-    this.conn = conn;
-    this.listeners = listeners;
+  constructor(props) {
+    super(props);
+    this.conn = props.conn;
+    this.listeners = props.listeners;
     this.handshakeTimeout = setTimeout(() => {
-      listeners.onHandshakeTimeout();
+      this.listeners.onHandshakeTimeout();
     }, this.options.handshakeTimeoutMs);
     this.conn.addDataListener(this.onHandshakeData);
-    this.conn.addErrorListener(listeners.onConnectionErrored);
-    this.conn.addCloseListener(listeners.onConnectionClosed);
+    this.conn.addErrorListener(this.listeners.onConnectionErrored);
+    this.conn.addCloseListener(this.listeners.onConnectionClosed);
   }
   onHandshakeData = (msg) => {
     const parsedMsg = this.parseMsg(msg);
@@ -854,16 +851,16 @@ var SessionHandshaking = class extends IdentifiedSession {
   conn;
   listeners;
   handshakeTimeout;
-  constructor(conn, listeners, ...args) {
-    super(...args);
-    this.conn = conn;
-    this.listeners = listeners;
+  constructor(props) {
+    super(props);
+    this.conn = props.conn;
+    this.listeners = props.listeners;
     this.handshakeTimeout = setTimeout(() => {
-      listeners.onHandshakeTimeout();
+      this.listeners.onHandshakeTimeout();
     }, this.options.handshakeTimeoutMs);
     this.conn.addDataListener(this.onHandshakeData);
-    this.conn.addErrorListener(listeners.onConnectionErrored);
-    this.conn.addCloseListener(listeners.onConnectionClosed);
+    this.conn.addErrorListener(this.listeners.onConnectionErrored);
+    this.conn.addCloseListener(this.listeners.onConnectionClosed);
   }
   onHandshakeData = (msg) => {
     const parsedMsg = this.parseMsg(msg);
@@ -897,9 +894,7 @@ var SessionConnected = class extends IdentifiedSession {
   listeners;
   heartbeatHandle;
   heartbeatMisses = 0;
-  get isActivelyHeartbeating() {
-    return this.heartbeatHandle !== void 0;
-  }
+  isActivelyHeartbeating;
   updateBookkeeping(ack, seq) {
     this.sendBuffer = this.sendBuffer.filter((unacked) => unacked.seq >= ack);
     this.ack = seq + 1;
@@ -911,13 +906,13 @@ var SessionConnected = class extends IdentifiedSession {
     this.conn.send(this.options.codec.toBuffer(constructedMsg));
     return constructedMsg.id;
   }
-  constructor(conn, listeners, ...args) {
-    super(...args);
-    this.conn = conn;
-    this.listeners = listeners;
+  constructor(props) {
+    super(props);
+    this.conn = props.conn;
+    this.listeners = props.listeners;
     this.conn.addDataListener(this.onMessageData);
-    this.conn.addCloseListener(listeners.onConnectionClosed);
-    this.conn.addErrorListener(listeners.onConnectionErrored);
+    this.conn.addCloseListener(this.listeners.onConnectionClosed);
+    this.conn.addErrorListener(this.listeners.onConnectionErrored);
     if (this.sendBuffer.length > 0) {
       this.log?.debug(
         `sending ${this.sendBuffer.length} buffered messages`,
@@ -925,10 +920,9 @@ var SessionConnected = class extends IdentifiedSession {
       );
     }
     for (const msg of this.sendBuffer) {
-      conn.send(this.options.codec.toBuffer(msg));
+      this.conn.send(this.options.codec.toBuffer(msg));
     }
-  }
-  startActiveHeartbeat() {
+    this.isActivelyHeartbeating = false;
     this.heartbeatHandle = setInterval(() => {
       const misses = this.heartbeatMisses;
       const missDuration = misses * this.options.heartbeatIntervalMs;
@@ -943,11 +937,17 @@ var SessionConnected = class extends IdentifiedSession {
         this.heartbeatHandle = void 0;
         return;
       }
-      this.sendHeartbeat();
+      if (this.isActivelyHeartbeating) {
+        this.sendHeartbeat();
+      }
       this.heartbeatMisses++;
     }, this.options.heartbeatIntervalMs);
   }
+  startActiveHeartbeat() {
+    this.isActivelyHeartbeating = true;
+  }
   sendHeartbeat() {
+    this.log?.debug("sending heartbeat", this.loggingMetadata);
     this.send({
       streamId: "heartbeat",
       controlFlags: 1 /* AckBit */,
@@ -1015,54 +1015,78 @@ var SessionConnected = class extends IdentifiedSession {
   }
 };
 
+// transport/sessionStateMachine/SessionBackingOff.ts
+var SessionBackingOff = class extends IdentifiedSession {
+  state = "BackingOff" /* BackingOff */;
+  listeners;
+  backoffTimeout;
+  constructor(props) {
+    super(props);
+    this.listeners = props.listeners;
+    this.backoffTimeout = setTimeout(() => {
+      this.listeners.onBackoffFinished();
+    }, props.backoffMs);
+  }
+  _handleClose() {
+    super._handleClose();
+  }
+  _handleStateExit() {
+    super._handleStateExit();
+    if (this.backoffTimeout) {
+      clearTimeout(this.backoffTimeout);
+      this.backoffTimeout = void 0;
+    }
+  }
+};
+
 // transport/sessionStateMachine/transitions.ts
 function inheritSharedSession(session) {
-  return [
-    session.id,
-    session.from,
-    session.to,
-    session.seq,
-    session.ack,
-    session.sendBuffer,
-    session.telemetry,
-    session.options,
-    session.protocolVersion,
-    session.log
-  ];
+  return {
+    id: session.id,
+    from: session.from,
+    to: session.to,
+    seq: session.seq,
+    ack: session.ack,
+    sendBuffer: session.sendBuffer,
+    telemetry: session.telemetry,
+    options: session.options,
+    log: session.log,
+    protocolVersion: session.protocolVersion
+  };
 }
 var SessionStateGraph = {
   entrypoints: {
-    NoConnection(to, from, listeners, options, protocolVersion, log) {
+    NoConnection: (to, from, listeners, options, protocolVersion, log) => {
       const id = `session-${generateId()}`;
       const telemetry = createSessionTelemetryInfo(id, to, from);
       const sendBuffer = [];
-      const session = new SessionNoConnection(
+      const session = new SessionNoConnection({
         listeners,
         id,
         from,
         to,
-        0,
-        0,
+        seq: 0,
+        ack: 0,
         sendBuffer,
         telemetry,
         options,
         protocolVersion,
         log
-      );
+      });
       session.log?.info(`session ${session.id} created in NoConnection state`, {
         ...session.loggingMetadata,
         tags: ["state-transition"]
       });
       return session;
     },
-    WaitingForHandshake(from, conn, listeners, options, log) {
-      const session = new SessionWaitingForHandshake(
+    WaitingForHandshake: (from, conn, listeners, options, log) => {
+      const session = new SessionWaitingForHandshake({
         conn,
         listeners,
         from,
         options,
         log
-      );
+      });
       session.log?.info(`session created in WaitingForHandshake state`, {
         ...session.loggingMetadata,
         tags: ["state-transition"]
@@ -1074,16 +1098,33 @@ var SessionStateGraph = {
   // After a session is transitioned, any usage of the old session will throw.
   transition: {
     // happy path transitions
-    NoConnectionToConnecting(oldSession, connPromise, listeners) {
+    NoConnectionToBackingOff: (oldSession, backoffMs, listeners) => {
       const carriedState = inheritSharedSession(oldSession);
       oldSession._handleStateExit();
-      const session = new SessionConnecting(
-        connPromise,
+      const session = new SessionBackingOff({
+        backoffMs,
         listeners,
         ...carriedState
+      });
+      session.log?.info(
+        `session ${session.id} transition from NoConnection to BackingOff`,
+        {
+          ...session.loggingMetadata,
+          tags: ["state-transition"]
+        }
       );
+      return session;
+    },
+    BackingOffToConnecting: (oldSession, connPromise, listeners) => {
+      const carriedState = inheritSharedSession(oldSession);
+      oldSession._handleStateExit();
+      const session = new SessionConnecting({
+        connPromise,
+        listeners,
+        ...carriedState
+      });
       session.log?.info(
-        `session ${session.id} transition from NoConnection to Connecting`,
+        `session ${session.id} transition from BackingOff to Connecting`,
         {
           ...session.loggingMetadata,
           tags: ["state-transition"]
@@ -1091,10 +1132,14 @@ var SessionStateGraph = {
       );
       return session;
     },
-    ConnectingToHandshaking(oldSession, conn, listeners) {
+    ConnectingToHandshaking: (oldSession, conn, listeners) => {
       const carriedState = inheritSharedSession(oldSession);
       oldSession._handleStateExit();
-      const session = new SessionHandshaking(conn, listeners, ...carriedState);
+      const session = new SessionHandshaking({
+        conn,
+        listeners,
+        ...carriedState
+      });
       session.log?.info(
         `session ${session.id} transition from Connecting to Handshaking`,
         {
@@ -1104,11 +1149,15 @@ var SessionStateGraph = {
       );
       return session;
     },
-    HandshakingToConnected(oldSession, listeners) {
+    HandshakingToConnected: (oldSession, listeners) => {
       const carriedState = inheritSharedSession(oldSession);
       const conn = oldSession.conn;
       oldSession._handleStateExit();
-      const session = new SessionConnected(conn, listeners, ...carriedState);
+      const session = new SessionConnected({
+        conn,
+        listeners,
+        ...carriedState
+      });
       session.log?.info(
         `session ${session.id} transition from Handshaking to Connected`,
         {
@@ -1118,7 +1167,7 @@ var SessionStateGraph = {
       );
       return session;
     },
-    WaitingForHandshakeToConnected(pendingSession, oldSession, sessionId, to, propagationCtx, listeners, protocolVersion) {
+    WaitingForHandshakeToConnected: (pendingSession, oldSession, sessionId, to, propagationCtx, listeners, protocolVersion) => {
       const conn = pendingSession.conn;
       const { from, options } = pendingSession;
       const carriedState = oldSession ? (
@@ -1126,22 +1175,31 @@ var SessionStateGraph = {
         inheritSharedSession(oldSession)
       ) : (
         // old session does not exist, create new state
-        [
-          sessionId,
+        {
+          id: sessionId,
           from,
           to,
-          0,
-          0,
-          [],
-          createSessionTelemetryInfo(sessionId, to, from, propagationCtx),
+          seq: 0,
+          ack: 0,
+          sendBuffer: [],
+          telemetry: createSessionTelemetryInfo(
+            sessionId,
+            to,
+            from,
+            propagationCtx
+          ),
           options,
-          protocolVersion,
-          pendingSession.log
-        ]
+          log: pendingSession.log,
+          protocolVersion
+        }
       );
       pendingSession._handleStateExit();
       oldSession?._handleStateExit();
-      const session = new SessionConnected(conn, listeners, ...carriedState);
+      const session = new SessionConnected({
+        conn,
+        listeners,
+        ...carriedState
+      });
       session.log?.info(
         `session ${session.id} transition from WaitingForHandshake to Connected`,
         {
@@ -1152,11 +1210,24 @@ var SessionStateGraph = {
       return session;
     },
     // disconnect paths
-    ConnectingToNoConnection(oldSession, listeners) {
+    BackingOffToNoConnection: (oldSession, listeners) => {
+      const carriedState = inheritSharedSession(oldSession);
+      oldSession._handleStateExit();
+      const session = new SessionNoConnection({ listeners, ...carriedState });
+      session.log?.info(
+        `session ${session.id} transition from BackingOff to NoConnection`,
+        {
+          ...session.loggingMetadata,
+          tags: ["state-transition"]
+        }
+      );
+      return session;
+    },
+    ConnectingToNoConnection: (oldSession, listeners) => {
       const carriedState = inheritSharedSession(oldSession);
       oldSession.bestEffortClose();
       oldSession._handleStateExit();
-      const session = new SessionNoConnection(listeners, ...carriedState);
+      const session = new SessionNoConnection({ listeners, ...carriedState });
       session.log?.info(
         `session ${session.id} transition from Connecting to NoConnection`,
         {
@@ -1166,11 +1237,11 @@ var SessionStateGraph = {
       );
       return session;
     },
-    HandshakingToNoConnection(oldSession, listeners) {
+    HandshakingToNoConnection: (oldSession, listeners) => {
       const carriedState = inheritSharedSession(oldSession);
       oldSession.conn.close();
       oldSession._handleStateExit();
-      const session = new SessionNoConnection(listeners, ...carriedState);
+      const session = new SessionNoConnection({ listeners, ...carriedState });
       session.log?.info(
         `session ${session.id} transition from Handshaking to NoConnection`,
         {
@@ -1180,11 +1251,11 @@ var SessionStateGraph = {
       );
       return session;
     },
-    ConnectedToNoConnection(oldSession, listeners) {
+    ConnectedToNoConnection: (oldSession, listeners) => {
       const carriedState = inheritSharedSession(oldSession);
       oldSession.conn.close();
       oldSession._handleStateExit();
-      const session = new SessionNoConnection(listeners, ...carriedState);
+      const session = new SessionNoConnection({ listeners, ...carriedState });
       session.log?.info(
         `session ${session.id} transition from Connected to NoConnection`,
         {
@@ -1196,6 +1267,31 @@ var SessionStateGraph = {
     }
   }
 };
+var transitions = SessionStateGraph.transition;
+var ClientSessionStateGraph = {
+  entrypoint: SessionStateGraph.entrypoints.NoConnection,
+  transition: {
+    // happy paths
+    NoConnectionToBackingOff: transitions.NoConnectionToBackingOff,
+    BackingOffToConnecting: transitions.BackingOffToConnecting,
+    ConnectingToHandshaking: transitions.ConnectingToHandshaking,
+    HandshakingToConnected: transitions.HandshakingToConnected,
+    // disconnect paths
+    BackingOffToNoConnection: transitions.BackingOffToNoConnection,
+    ConnectingToNoConnection: transitions.ConnectingToNoConnection,
+    HandshakingToNoConnection: transitions.HandshakingToNoConnection,
+    ConnectedToNoConnection: transitions.ConnectedToNoConnection
+  }
+};
+var ServerSessionStateGraph = {
+  entrypoint: SessionStateGraph.entrypoints.WaitingForHandshake,
+  transition: {
+    // happy paths
+    WaitingForHandshakeToConnected: transitions.WaitingForHandshakeToConnected,
+    // disconnect paths
+    ConnectedToNoConnection: transitions.ConnectedToNoConnection
+  }
+};
 
 // util/testHelpers.ts
 function createLocalWebSocketClient(port) {
@@ -1218,11 +1314,6 @@ function onWsServerReady(server) {
     });
   });
 }
-function onUdsServeReady(server, path) {
-  return new Promise((resolve) => {
-    server.listen(path, resolve);
-  });
-}
 function getIteratorFromStream(readStream) {
   return readStream[Symbol.asyncIterator]();
 }
@@ -1264,6 +1355,7 @@ function catchProcError(err) {
   return Err({ code: UNCAUGHT_ERROR_CODE, message: errorMsg });
 }
 var testingSessionOptions = defaultTransportOptions;
+var testingClientSessionOptions = defaultClientTransportOptions;
 function dummySession() {
   return SessionStateGraph.entrypoints.NoConnection(
     "client",
@@ -1290,10 +1382,13 @@ function dummyCtx(state, session, extendedContext) {
 }
 function asClientRpc(state, proc, extendedContext, session = dummySession()) {
   return async (msg) => {
-    return proc.handler(dummyCtx(state, session, extendedContext), msg).catch(catchProcError);
+    return proc.handler({
+      ctx: dummyCtx(state, session, extendedContext),
+      reqInit: msg
+    }).catch(catchProcError);
   };
 }
-function createOutputPipe() {
+function createResponsePipe() {
   const reader = new ReadStreamImpl(() => {
     void Promise.resolve().then(() => {
       writer.triggerCloseRequest();
@@ -1311,7 +1406,7 @@ function createOutputPipe() {
   });
   return { reader, writer };
 }
-function createInputPipe() {
+function createRequestPipe() {
   const reader = new ReadStreamImpl(() => {
     void Promise.resolve().then(() => {
       writer.triggerCloseRequest();
@@ -1327,40 +1422,40 @@ function createInputPipe() {
   });
   return { reader, writer };
 }
-function asClientStream(state, proc, init, extendedContext, session = dummySession()) {
-  const inputPipe = createInputPipe();
-  const outputPipe = createOutputPipe();
-  void proc.handler(
-    dummyCtx(state, session, extendedContext),
-    init ?? {},
-    inputPipe.reader,
-    outputPipe.writer
-  ).catch((err) => outputPipe.writer.write(catchProcError(err)));
-  return [inputPipe.writer, outputPipe.reader];
+function asClientStream(state, proc, reqInit, extendedContext, session = dummySession()) {
+  const requestPipe = createRequestPipe();
+  const responsePipe = createResponsePipe();
+  void proc.handler({
+    ctx: dummyCtx(state, session, extendedContext),
+    reqInit: reqInit ?? {},
+    reqReader: requestPipe.reader,
+    resWriter: responsePipe.writer
+  }).catch((err) => responsePipe.writer.write(catchProcError(err)));
+  return {
+    reqWriter: requestPipe.writer,
+    resReader: responsePipe.reader
+  };
 }
 function asClientSubscription(state, proc, extendedContext, session = dummySession()) {
-  const outputPipe = createOutputPipe();
+  const responsePipe = createResponsePipe();
   return (msg) => {
-    void proc.handler(
-      dummyCtx(state, session, extendedContext),
-      msg,
-      outputPipe.writer
-    ).catch((err) => outputPipe.writer.write(catchProcError(err)));
-    return outputPipe.reader;
+    void proc.handler({
+      ctx: dummyCtx(state, session, extendedContext),
+      reqInit: msg,
+      resWriter: responsePipe.writer
+    }).catch((err) => responsePipe.writer.write(catchProcError(err)));
+    return { resReader: responsePipe.reader };
   };
 }
-function asClientUpload(state, proc, init, extendedContext, session = dummySession()) {
-  const inputPipe = createInputPipe();
-  const result = proc.handler(
-    dummyCtx(state, session, extendedContext),
-    init ?? {},
-    inputPipe.reader
-  ).catch(catchProcError);
-  return [inputPipe.writer, () => result];
+function asClientUpload(state, proc, reqInit, extendedContext, session = dummySession()) {
+  const requestPipe = createRequestPipe();
+  const result = proc.handler({
+    ctx: dummyCtx(state, session, extendedContext),
+    reqInit: reqInit ?? {},
+    reqReader: requestPipe.reader
+  }).catch(catchProcError);
+  return [requestPipe.writer, () => result];
 }
-var getUnixSocketPath = () => {
-  return `/tmp/${(0, import_nanoid2.nanoid)()}.sock`;
-};
 function getTransportConnections(transport) {
   const connections = [];
   for (const session of transport.sessions.values()) {
@@ -1391,12 +1486,11 @@ function closeAllConnections(transport) {
   dummySession,
   getIteratorFromStream,
   getTransportConnections,
-  getUnixSocketPath,
   iterNext,
   numberOfConnections,
-  onUdsServeReady,
   onWsServerReady,
   payloadToTransportMessage,
+  testingClientSessionOptions,
   testingSessionOptions,
   waitForMessage
 });