@replit/river 0.23.18 → 0.24.1

package/dist/chunk-HXOQQXL4.js

@@ -0,0 +1,382 @@
+import {
+  ProtocolError,
+  Transport
+} from "./chunk-6YFPHVNO.js";
+import {
+  SessionStateGraph,
+  defaultServerTransportOptions
+} from "./chunk-227EQHH5.js";
+import {
+  ControlMessageHandshakeRequestSchema,
+  PROTOCOL_VERSION,
+  coerceErrorString,
+  handshakeResponseMessage
+} from "./chunk-IYYQ7BII.js";
+
+// transport/server.ts
+import { SpanStatusCode } from "@opentelemetry/api";
+import { Value } from "@sinclair/typebox/value";
+var ServerTransport = class extends Transport {
+  /**
+   * The options for this transport.
+   */
+  options;
+  /**
+   * Optional handshake options for the server.
+   */
+  handshakeExtensions;
+  /**
+   * A map of session handshake data for each session.
+   */
+  sessionHandshakeMetadata = /* @__PURE__ */ new Map();
+  pendingSessions = /* @__PURE__ */ new Set();
+  constructor(clientId, providedOptions) {
+    super(clientId, providedOptions);
+    this.options = {
+      ...defaultServerTransportOptions,
+      ...providedOptions
+    };
+    this.log?.info(`initiated server transport`, {
+      clientId: this.clientId,
+      protocolVersion: PROTOCOL_VERSION
+    });
+  }
+  extendHandshake(options) {
+    this.handshakeExtensions = options;
+  }
+  send(to, msg) {
+    if (this.getStatus() === "closed") {
+      const err = "transport is closed, cant send";
+      this.log?.error(err, {
+        clientId: this.clientId,
+        transportMessage: msg,
+        tags: ["invariant-violation"]
+      });
+      throw new Error(err);
+    }
+    const session = this.sessions.get(to);
+    if (!session) {
+      const err = `session to ${to} does not exist`;
+      this.log?.error(err, {
+        clientId: this.clientId,
+        transportMessage: msg,
+        tags: ["invariant-violation"]
+      });
+      throw new Error(err);
+    }
+    return session.send(msg);
+  }
+  deletePendingSession(pendingSession) {
+    pendingSession.close();
+    this.pendingSessions.delete(pendingSession);
+  }
+  deleteSession(session) {
+    this.sessionHandshakeMetadata.delete(session.to);
+    super.deleteSession(session);
+  }
+  handleConnection(conn) {
+    if (this.getStatus() !== "open")
+      return;
+    this.log?.info(`new incoming connection`, {
+      ...conn.loggingMetadata,
+      clientId: this.clientId
+    });
+    let receivedHandshake = false;
+    const pendingSession = SessionStateGraph.entrypoints.WaitingForHandshake(
+      this.clientId,
+      conn,
+      {
+        onConnectionClosed: () => {
+          this.log?.warn(
+            `connection from unknown closed before handshake finished`,
+            pendingSession.loggingMetadata
+          );
+          this.deletePendingSession(pendingSession);
+        },
+        onConnectionErrored: (err) => {
+          const errorString = coerceErrorString(err);
+          this.log?.warn(
+            `connection from unknown errored before handshake finished: ${errorString}`,
+            pendingSession.loggingMetadata
+          );
+          this.deletePendingSession(pendingSession);
+        },
+        onHandshakeTimeout: () => {
+          this.log?.warn(
+            `connection from unknown timed out before handshake finished`,
+            pendingSession.loggingMetadata
+          );
+          this.deletePendingSession(pendingSession);
+        },
+        onHandshake: (msg) => {
+          if (receivedHandshake) {
+            this.log?.error(
+              `received multiple handshake messages from pending session`,
+              {
+                ...pendingSession.loggingMetadata,
+                connectedTo: msg.from,
+                transportMessage: msg
+              }
+            );
+            this.deletePendingSession(pendingSession);
+            return;
+          }
+          receivedHandshake = true;
+          void this.onHandshakeRequest(pendingSession, msg);
+        },
+        onInvalidHandshake: (reason) => {
+          this.log?.error(
+            `invalid handshake: ${reason}`,
+            pendingSession.loggingMetadata
+          );
+          this.deletePendingSession(pendingSession);
+          this.protocolError(ProtocolError.HandshakeFailed, reason);
+        }
+      },
+      this.options,
+      this.log
+    );
+    this.pendingSessions.add(pendingSession);
+  }
+  rejectHandshakeRequest(session, to, reason, code, metadata) {
+    session.conn.telemetry?.span.setStatus({
+      code: SpanStatusCode.ERROR,
+      message: reason
+    });
+    this.log?.warn(reason, metadata);
+    session.sendHandshake(
+      handshakeResponseMessage({
+        from: this.clientId,
+        to,
+        status: {
+          ok: false,
+          code,
+          reason
+        }
+      })
+    );
+    this.protocolError(ProtocolError.HandshakeFailed, reason);
+    this.deletePendingSession(session);
+  }
+  async onHandshakeRequest(session, msg) {
+    if (!Value.Check(ControlMessageHandshakeRequestSchema, msg.payload)) {
+      this.rejectHandshakeRequest(
+        session,
+        msg.from,
+        "received invalid handshake request",
+        "MALFORMED_HANDSHAKE",
+        {
+          ...session.loggingMetadata,
+          transportMessage: msg,
+          connectedTo: msg.from,
+          validationErrors: [
+            ...Value.Errors(ControlMessageHandshakeRequestSchema, msg.payload)
+          ]
+        }
+      );
+      return;
+    }
+    const gotVersion = msg.payload.protocolVersion;
+    if (gotVersion !== PROTOCOL_VERSION) {
+      this.rejectHandshakeRequest(
+        session,
+        msg.from,
+        `expected protocol version ${PROTOCOL_VERSION}, got ${gotVersion}`,
+        "PROTOCOL_VERSION_MISMATCH",
+        {
+          ...session.loggingMetadata,
+          connectedTo: msg.from,
+          transportMessage: msg
+        }
+      );
+      return;
+    }
+    let oldSession = this.sessions.get(msg.from);
+    const parsedMetadata = await this.validateHandshakeMetadata(
+      session,
+      oldSession,
+      msg.payload.metadata,
+      msg.from
+    );
+    if (parsedMetadata === false) {
+      return;
+    }
+    let connectCase = "new session";
+    if (oldSession && oldSession.id === msg.payload.sessionId) {
+      connectCase = "transparent reconnection";
+      const clientNextExpectedSeq = msg.payload.expectedSessionState.nextExpectedSeq;
+      const clientNextSentSeq = msg.payload.expectedSessionState.nextSentSeq ?? 0;
+      const ourNextSeq = oldSession.nextSeq();
+      const ourAck = oldSession.ack;
+      if (clientNextSentSeq > ourAck) {
+        this.rejectHandshakeRequest(
+          session,
+          msg.from,
+          `client is in the future: server wanted next message to be ${ourAck} but client would have sent ${clientNextSentSeq}`,
+          "SESSION_STATE_MISMATCH",
+          {
+            ...session.loggingMetadata,
+            connectedTo: msg.from,
+            transportMessage: msg
+          }
+        );
+        return;
+      }
+      if (ourNextSeq > clientNextExpectedSeq) {
+        this.rejectHandshakeRequest(
+          session,
+          msg.from,
+          `server is in the future: client wanted next message to be ${clientNextExpectedSeq} but server would have sent ${ourNextSeq}`,
+          "SESSION_STATE_MISMATCH",
+          {
+            ...session.loggingMetadata,
+            connectedTo: msg.from,
+            transportMessage: msg
+          }
+        );
+        return;
+      }
+      if (oldSession.state === "Connected" /* Connected */) {
+        const noConnectionSession = SessionStateGraph.transition.ConnectedToNoConnection(oldSession, {
+          onSessionGracePeriodElapsed: () => {
+            this.onSessionGracePeriodElapsed(noConnectionSession);
+          }
+        });
+        oldSession = noConnectionSession;
+      } else if (oldSession.state === "Handshaking" /* Handshaking */) {
+        const noConnectionSession = SessionStateGraph.transition.HandshakingToNoConnection(oldSession, {
+          onSessionGracePeriodElapsed: () => {
+            this.onSessionGracePeriodElapsed(noConnectionSession);
+          }
+        });
+        oldSession = noConnectionSession;
+      } else if (oldSession.state === "Connecting" /* Connecting */) {
+        const noConnectionSession = SessionStateGraph.transition.ConnectingToNoConnection(oldSession, {
+          onSessionGracePeriodElapsed: () => {
+            this.onSessionGracePeriodElapsed(noConnectionSession);
+          }
+        });
+        oldSession = noConnectionSession;
+      }
+      this.updateSession(oldSession);
+    } else if (oldSession) {
+      connectCase = "hard reconnection";
+      this.deleteSession(oldSession);
+      oldSession = void 0;
+    } else {
+      connectCase = "unknown session";
+      const clientNextExpectedSeq = msg.payload.expectedSessionState.nextExpectedSeq;
+      const clientNextSentSeq = msg.payload.expectedSessionState.nextSentSeq ?? 0;
+      if (clientNextSentSeq > 0 || clientNextExpectedSeq > 0) {
+        this.rejectHandshakeRequest(
+          session,
+          msg.from,
+          `client is trying to reconnect to a session the server don't know about: ${msg.payload.sessionId}`,
+          "SESSION_STATE_MISMATCH",
+          {
+            ...session.loggingMetadata,
+            connectedTo: msg.from,
+            transportMessage: msg
+          }
+        );
+        return;
+      }
+    }
+    const sessionId = msg.payload.sessionId;
+    this.log?.info(
+      `handshake from ${msg.from} ok (${connectCase}), responding with handshake success`,
+      {
+        ...session.loggingMetadata,
+        connectedTo: msg.from
+      }
+    );
+    const responseMsg = handshakeResponseMessage({
+      from: this.clientId,
+      to: msg.from,
+      status: {
+        ok: true,
+        sessionId
+      }
+    });
+    session.sendHandshake(responseMsg);
+    const connectedSession = SessionStateGraph.transition.WaitingForHandshakeToConnected(
+      session,
+      // by this point oldSession is either no connection or we dont have an old session
+      oldSession,
+      sessionId,
+      msg.from,
+      msg.tracing,
+      {
+        onConnectionErrored: (err) => {
+          const errStr = coerceErrorString(err);
+          this.log?.warn(
+            `connection to ${connectedSession.to} errored: ${errStr}`,
+            connectedSession.loggingMetadata
+          );
+        },
+        onConnectionClosed: () => {
+          this.log?.info(
+            `connection to ${connectedSession.to} closed`,
+            connectedSession.loggingMetadata
+          );
+          this.onConnClosed(connectedSession);
+        },
+        onMessage: (msg2) => this.handleMsg(msg2),
+        onInvalidMessage: (reason) => {
+          this.protocolError(ProtocolError.MessageOrderingViolated, reason);
+          this.deleteSession(connectedSession);
+        }
+      }
+    );
+    this.sessionHandshakeMetadata.set(connectedSession.to, parsedMetadata);
+    this.updateSession(connectedSession);
+    this.pendingSessions.delete(session);
+    connectedSession.startActiveHeartbeat();
+  }
+  async validateHandshakeMetadata(handshakingSession, existingSession, rawMetadata, from) {
+    let parsedMetadata = {};
+    if (this.handshakeExtensions) {
+      if (!Value.Check(this.handshakeExtensions.schema, rawMetadata)) {
+        this.rejectHandshakeRequest(
+          handshakingSession,
+          from,
+          "received malformed handshake metadata",
+          "MALFORMED_HANDSHAKE_META",
+          {
+            ...handshakingSession.loggingMetadata,
+            connectedTo: from,
+            validationErrors: [
+              ...Value.Errors(this.handshakeExtensions.schema, rawMetadata)
+            ]
+          }
+        );
+        return false;
+      }
+      const previousParsedMetadata = existingSession ? this.sessionHandshakeMetadata.get(existingSession.to) : void 0;
+      parsedMetadata = await this.handshakeExtensions.validate(
+        rawMetadata,
+        previousParsedMetadata
+      );
+      if (parsedMetadata === false) {
+        this.rejectHandshakeRequest(
+          handshakingSession,
+          from,
+          "rejected by handshake handler",
+          "REJECTED_BY_CUSTOM_HANDLER",
+          {
+            ...handshakingSession.loggingMetadata,
+            connectedTo: from,
+            clientId: this.clientId
+          }
+        );
+        return false;
+      }
+    }
+    return parsedMetadata;
+  }
+};
+
+export {
+  ServerTransport
+};
+//# sourceMappingURL=chunk-HXOQQXL4.js.map

package/dist/chunk-HXOQQXL4.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../transport/server.ts"],"sourcesContent":["import { SpanStatusCode } from '@opentelemetry/api';\nimport { ParsedMetadata } from '../router/context';\nimport { ServerHandshakeOptions } from '../router/handshake';\nimport {\n  ControlMessageHandshakeRequestSchema,\n  HandshakeErrorResponseCodes,\n  OpaqueTransportMessage,\n  PROTOCOL_VERSION,\n  PartialTransportMessage,\n  TransportClientId,\n  handshakeResponseMessage,\n} from './message';\nimport {\n  ProvidedServerTransportOptions,\n  ServerTransportOptions,\n  defaultServerTransportOptions,\n} from './options';\nimport { Transport } from './transport';\nimport { coerceErrorString } from '../util/stringify';\nimport { Static } from '@sinclair/typebox';\nimport { Value } from '@sinclair/typebox/value';\nimport { ProtocolError } from './events';\nimport { Connection } from './connection';\nimport { MessageMetadata } from '../logging';\nimport { SessionWaitingForHandshake } from './sessionStateMachine/SessionWaitingForHandshake';\nimport { Session, SessionState } from './sessionStateMachine/common';\nimport { SessionStateGraph } from './sessionStateMachine/transitions';\n\nexport abstract class ServerTransport<\n  ConnType extends Connection,\n> extends Transport<ConnType> {\n  /**\n   * The options for this transport.\n   */\n  protected options: ServerTransportOptions;\n\n  /**\n   * Optional handshake options for the server.\n   */\n  handshakeExtensions?: ServerHandshakeOptions;\n\n  /**\n   * A map of session handshake data for each session.\n   */\n  sessionHandshakeMetadata = new Map<TransportClientId, ParsedMetadata>();\n  pendingSessions = new Set<SessionWaitingForHandshake<ConnType>>();\n\n  constructor(\n    clientId: TransportClientId,\n    providedOptions?: ProvidedServerTransportOptions,\n  ) {\n    super(clientId, providedOptions);\n    this.options = {\n      ...defaultServerTransportOptions,\n      ...providedOptions,\n    };\n    this.log?.info(`initiated server transport`, {\n      clientId: this.clientId,\n      protocolVersion: PROTOCOL_VERSION,\n    });\n  }\n\n  extendHandshake(options: ServerHandshakeOptions) {\n    this.handshakeExtensions = options;\n  }\n\n  send(to: string, msg: PartialTransportMessage): string {\n    if (this.getStatus() === 'closed') {\n      const err = 'transport is closed, cant send';\n      this.log?.error(err, {\n        clientId: this.clientId,\n        transportMessage: msg,\n        tags: ['invariant-violation'],\n      });\n\n      throw new Error(err);\n    }\n\n    const session = this.sessions.get(to);\n    if (!session) {\n      const err = `session to ${to} does not exist`;\n      this.log?.error(err, {\n        clientId: this.clientId,\n        transportMessage: msg,\n        tags: ['invariant-violation'],\n      });\n\n      throw new Error(err);\n    }\n\n    return session.send(msg);\n  }\n\n  protected deletePendingSession(\n    pendingSession: SessionWaitingForHandshake<ConnType>,\n  ) {\n    pendingSession.close();\n    // we don't dispatch a session disconnect event\n    // for a non-identified session, just delete directly\n\n    this.pendingSessions.delete(pendingSession);\n  }\n\n  protected deleteSession(session: Session<ConnType>): void {\n    this.sessionHandshakeMetadata.delete(session.to);\n    super.deleteSession(session);\n  }\n\n  protected handleConnection(conn: ConnType) {\n    if (this.getStatus() !== 'open') return;\n\n    this.log?.info(`new incoming connection`, {\n      ...conn.loggingMetadata,\n      clientId: this.clientId,\n    });\n\n    let receivedHandshake = false;\n    const pendingSession = SessionStateGraph.entrypoints.WaitingForHandshake(\n      this.clientId,\n      conn,\n      {\n        onConnectionClosed: () => {\n          this.log?.warn(\n            `connection from unknown closed before handshake finished`,\n            pendingSession.loggingMetadata,\n          );\n\n          this.deletePendingSession(pendingSession);\n        },\n        onConnectionErrored: (err) => {\n          const errorString = coerceErrorString(err);\n          this.log?.warn(\n            `connection from unknown errored before handshake finished: ${errorString}`,\n            pendingSession.loggingMetadata,\n          );\n\n          this.deletePendingSession(pendingSession);\n        },\n        onHandshakeTimeout: () => {\n          this.log?.warn(\n            `connection from unknown timed out before handshake finished`,\n            pendingSession.loggingMetadata,\n          );\n\n          this.deletePendingSession(pendingSession);\n        },\n        onHandshake: (msg) => {\n          if (receivedHandshake) {\n            this.log?.error(\n              `received multiple handshake messages from pending session`,\n              {\n                ...pendingSession.loggingMetadata,\n                connectedTo: msg.from,\n                transportMessage: msg,\n              },\n            );\n\n            this.deletePendingSession(pendingSession);\n            return;\n          }\n\n          // let this resolve async, we just need to make sure its only\n          // called once so we don't race while transitioning to connected\n          // onHandshakeRequest is async as custom validation may be async\n          receivedHandshake = true;\n          void this.onHandshakeRequest(pendingSession, msg);\n        },\n        onInvalidHandshake: (reason) => {\n          this.log?.error(\n            `invalid handshake: ${reason}`,\n            pendingSession.loggingMetadata,\n          );\n          this.deletePendingSession(pendingSession);\n          this.protocolError(ProtocolError.HandshakeFailed, reason);\n        },\n      },\n      this.options,\n      this.log,\n    );\n\n    this.pendingSessions.add(pendingSession);\n  }\n\n  private rejectHandshakeRequest(\n    session: SessionWaitingForHandshake<ConnType>,\n    to: TransportClientId,\n    reason: string,\n    code: Static<typeof HandshakeErrorResponseCodes>,\n    metadata: MessageMetadata,\n  ) {\n    session.conn.telemetry?.span.setStatus({\n      code: SpanStatusCode.ERROR,\n      message: reason,\n    });\n\n    this.log?.warn(reason, metadata);\n\n    session.sendHandshake(\n      handshakeResponseMessage({\n        from: this.clientId,\n        to,\n        status: {\n          ok: false,\n          code,\n          reason,\n        },\n      }),\n    );\n\n    this.protocolError(ProtocolError.HandshakeFailed, reason);\n    this.deletePendingSession(session);\n  }\n\n  protected async onHandshakeRequest(\n    session: SessionWaitingForHandshake<ConnType>,\n    msg: OpaqueTransportMessage,\n  ) {\n    // invariant: msg is a handshake request\n    if (!Value.Check(ControlMessageHandshakeRequestSchema, msg.payload)) {\n      this.rejectHandshakeRequest(\n        session,\n        msg.from,\n        'received invalid handshake request',\n        'MALFORMED_HANDSHAKE',\n        {\n          ...session.loggingMetadata,\n          transportMessage: msg,\n          connectedTo: msg.from,\n          validationErrors: [\n            ...Value.Errors(ControlMessageHandshakeRequestSchema, msg.payload),\n          ],\n        },\n      );\n\n      return;\n    }\n\n    // invariant: handshake request passes all the validation\n    const gotVersion = msg.payload.protocolVersion;\n    if (gotVersion !== PROTOCOL_VERSION) {\n      this.rejectHandshakeRequest(\n        session,\n        msg.from,\n        `expected protocol version ${PROTOCOL_VERSION}, got ${gotVersion}`,\n        'PROTOCOL_VERSION_MISMATCH',\n        {\n          ...session.loggingMetadata,\n          connectedTo: msg.from,\n          transportMessage: msg,\n        },\n      );\n\n      return;\n    }\n\n    let oldSession = this.sessions.get(msg.from);\n\n    // invariant: must pass custom validation if defined\n    const parsedMetadata = await this.validateHandshakeMetadata(\n      session,\n      oldSession,\n      msg.payload.metadata,\n      msg.from,\n    );\n\n    if (parsedMetadata === false) {\n      return;\n    }\n\n    // 4 connect cases\n    // 1. new session\n    //    we dont have a session and the client is requesting a new one\n    //    we can create the session as normal\n    // 2. client is reconnecting to an existing session but we don't have it\n    //    reject this handshake, there's nothing we can do to salvage it\n    // 3. transparent reconnect (old session exists and is the same as the client wants)\n    //    assign to old session\n    // 4. hard reconnect (oldSession exists but but the client wants a new one)\n    //    we close the old session and create a new one\n    let connectCase:\n      | 'new session'\n      | 'unknown session'\n      | 'transparent reconnection'\n      | 'hard reconnection' = 'new session';\n    if (oldSession && oldSession.id === msg.payload.sessionId) {\n      connectCase = 'transparent reconnection';\n\n      // invariant: ordering must be correct\n      const clientNextExpectedSeq =\n        msg.payload.expectedSessionState.nextExpectedSeq;\n      // TODO: remove nullish coalescing when we're sure this is always set\n      const clientNextSentSeq =\n        msg.payload.expectedSessionState.nextSentSeq ?? 0;\n      const ourNextSeq = oldSession.nextSeq();\n      const ourAck = oldSession.ack;\n\n      // two incorrect cases where we cannot permit a reconnect:\n      // - if the client is about to send a message in the future w.r.t to the server\n      //  - client.seq > server.ack => nextSentSeq > oldSession.ack\n      if (clientNextSentSeq > ourAck) {\n        this.rejectHandshakeRequest(\n          session,\n          msg.from,\n          `client is in the future: server wanted next message to be ${ourAck} but client would have sent ${clientNextSentSeq}`,\n          'SESSION_STATE_MISMATCH',\n          {\n            ...session.loggingMetadata,\n            connectedTo: msg.from,\n            transportMessage: msg,\n          },\n        );\n\n        return;\n      }\n\n      // - if the server is about to send a message in the future w.r.t to the client\n      //  - server.seq > client.ack => oldSession.nextSeq() > nextExpectedSeq\n      if (ourNextSeq > clientNextExpectedSeq) {\n        this.rejectHandshakeRequest(\n          session,\n          msg.from,\n          `server is in the future: client wanted next message to be ${clientNextExpectedSeq} but server would have sent ${ourNextSeq}`,\n          'SESSION_STATE_MISMATCH',\n          {\n            ...session.loggingMetadata,\n            connectedTo: msg.from,\n            transportMessage: msg,\n          },\n        );\n\n        return;\n      }\n\n      // transparent reconnect seems ok, proceed by transitioning old session\n      // to not connected\n      if (oldSession.state === SessionState.Connected) {\n        const noConnectionSession =\n          SessionStateGraph.transition.ConnectedToNoConnection(oldSession, {\n            onSessionGracePeriodElapsed: () => {\n              this.onSessionGracePeriodElapsed(noConnectionSession);\n            },\n          });\n\n        oldSession = noConnectionSession;\n      } else if (oldSession.state === SessionState.Handshaking) {\n        const noConnectionSession =\n          SessionStateGraph.transition.HandshakingToNoConnection(oldSession, {\n            onSessionGracePeriodElapsed: () => {\n              this.onSessionGracePeriodElapsed(noConnectionSession);\n            },\n          });\n\n        oldSession = noConnectionSession;\n      } else if (oldSession.state === SessionState.Connecting) {\n        const noConnectionSession =\n          SessionStateGraph.transition.ConnectingToNoConnection(oldSession, {\n            onSessionGracePeriodElapsed: () => {\n              this.onSessionGracePeriodElapsed(noConnectionSession);\n            },\n          });\n\n        oldSession = noConnectionSession;\n      }\n\n      this.updateSession(oldSession);\n    } else if (oldSession) {\n      connectCase = 'hard reconnection';\n\n      // just nuke the old session entirely and proceed as if this was new\n      this.deleteSession(oldSession);\n      oldSession = undefined;\n    } else {\n      connectCase = 'unknown session';\n\n      const clientNextExpectedSeq =\n        msg.payload.expectedSessionState.nextExpectedSeq;\n      // TODO: remove nullish coalescing when we're sure this is always set\n      const clientNextSentSeq =\n        msg.payload.expectedSessionState.nextSentSeq ?? 0;\n\n      if (clientNextSentSeq > 0 || clientNextExpectedSeq > 0) {\n        // we don't have a session, but the client is trying to reconnect\n        // to an old session. we can't do anything about this, so we reject\n        this.rejectHandshakeRequest(\n          session,\n          msg.from,\n          `client is trying to reconnect to a session the server don't know about: ${msg.payload.sessionId}`,\n          'SESSION_STATE_MISMATCH',\n          {\n            ...session.loggingMetadata,\n            connectedTo: msg.from,\n            transportMessage: msg,\n          },\n        );\n        return;\n      }\n    }\n\n    // from this point on, we're committed to connecting\n    const sessionId = msg.payload.sessionId;\n    this.log?.info(\n      `handshake from ${msg.from} ok (${connectCase}), responding with handshake success`,\n      {\n        ...session.loggingMetadata,\n        connectedTo: msg.from,\n      },\n    );\n    const responseMsg = handshakeResponseMessage({\n      from: this.clientId,\n      to: msg.from,\n      status: {\n        ok: true,\n        sessionId,\n      },\n    });\n    session.sendHandshake(responseMsg);\n\n    // transition\n    const connectedSession =\n      SessionStateGraph.transition.WaitingForHandshakeToConnected(\n        session,\n        // by this point oldSession is either no connection or we dont have an old session\n        oldSession,\n        sessionId,\n        msg.from,\n        msg.tracing,\n        {\n          onConnectionErrored: (err) => {\n            // just log, when we error we also emit close\n            const errStr = coerceErrorString(err);\n            this.log?.warn(\n              `connection to ${connectedSession.to} errored: ${errStr}`,\n              connectedSession.loggingMetadata,\n            );\n          },\n          onConnectionClosed: () => {\n            this.log?.info(\n              `connection to ${connectedSession.to} closed`,\n              connectedSession.loggingMetadata,\n            );\n            this.onConnClosed(connectedSession);\n          },\n          onMessage: (msg) => this.handleMsg(msg),\n          onInvalidMessage: (reason) => {\n            this.protocolError(ProtocolError.MessageOrderingViolated, reason);\n            this.deleteSession(connectedSession);\n          },\n        },\n      );\n\n    this.sessionHandshakeMetadata.set(connectedSession.to, parsedMetadata);\n    this.updateSession(connectedSession);\n    this.pendingSessions.delete(session);\n    connectedSession.startActiveHeartbeat();\n  }\n\n  private async validateHandshakeMetadata(\n    handshakingSession: SessionWaitingForHandshake<ConnType>,\n    existingSession: Session<ConnType> | undefined,\n    rawMetadata: Static<\n      typeof ControlMessageHandshakeRequestSchema\n    >['metadata'],\n    from: TransportClientId,\n  ): Promise<ParsedMetadata | false> {\n    let parsedMetadata: ParsedMetadata = {};\n    if (this.handshakeExtensions) {\n      // check that the metadata that was sent is the correct shape\n      if (!Value.Check(this.handshakeExtensions.schema, rawMetadata)) {\n        this.rejectHandshakeRequest(\n          handshakingSession,\n          from,\n          'received malformed handshake metadata',\n          'MALFORMED_HANDSHAKE_META',\n          {\n            ...handshakingSession.loggingMetadata,\n            connectedTo: from,\n            validationErrors: [\n              ...Value.Errors(this.handshakeExtensions.schema, rawMetadata),\n            ],\n          },\n        );\n\n        return false;\n      }\n\n      const previousParsedMetadata = existingSession\n        ? this.sessionHandshakeMetadata.get(existingSession.to)\n        : undefined;\n\n      parsedMetadata = await this.handshakeExtensions.validate(\n        rawMetadata,\n        previousParsedMetadata,\n      );\n\n      // handler rejected the connection\n      if (parsedMetadata === false) {\n        this.rejectHandshakeRequest(\n          handshakingSession,\n          from,\n          'rejected by handshake handler',\n          'REJECTED_BY_CUSTOM_HANDLER',\n          {\n            ...handshakingSession.loggingMetadata,\n            connectedTo: from,\n            clientId: this.clientId,\n          },\n        );\n\n        return false;\n      }\n    }\n\n    return parsedMetadata;\n  }\n}\n"],"mappings":"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","names":["msg"]}

package/dist/{chunk-R2HAS3GM.js → chunk-IYYQ7BII.js}

@@ -1,6 +1,12 @@
+// transport/id.ts
+import { customAlphabet } from "nanoid";
+var alphabet = customAlphabet(
+  "1234567890abcdefghijklmnopqrstuvxyzABCDEFGHIJKLMNOPQRSTUVXYZ"
+);
+var generateId = () => alphabet(12);
+
 // transport/message.ts
 import { Type } from "@sinclair/typebox";
-import { nanoid } from "nanoid";
 var TransportMessageSchema = (t) => Type.Object({
   id: Type.String(),
   from: Type.String(),
@@ -35,18 +41,29 @@ var ControlMessageHandshakeRequestSchema = Type.Object({
    * 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: Type.Optional(
-    Type.Object({
-      /**
-       * reconnect is set to true if the client explicitly wants to reestablish an existing
-       * connection.
-       */
-      reconnect: Type.Boolean(),
-      nextExpectedSeq: Type.Integer()
-    })
-  ),
+  expectedSessionState: Type.Object({
+    // what the client expects the server to send next
+    nextExpectedSeq: Type.Integer(),
+    // TODO: remove optional once we know all servers
+    // are nextSentSeq here
+    // what the server expects the client to send next
+    nextSentSeq: Type.Optional(Type.Integer())
+  }),
   metadata: Type.Optional(Type.Unknown())
 });
+var HandshakeErrorRetriableResponseCodes = Type.Union([
+  Type.Literal("SESSION_STATE_MISMATCH")
+]);
+var HandshakeErrorFatalResponseCodes = Type.Union([
+  Type.Literal("MALFORMED_HANDSHAKE_META"),
+  Type.Literal("MALFORMED_HANDSHAKE"),
+  Type.Literal("PROTOCOL_VERSION_MISMATCH"),
+  Type.Literal("REJECTED_BY_CUSTOM_HANDLER")
+]);
+var HandshakeErrorResponseCodes = Type.Union([
+  HandshakeErrorRetriableResponseCodes,
+  HandshakeErrorFatalResponseCodes
+]);
 var ControlMessageHandshakeResponseSchema = Type.Object({
   type: Type.Literal("HANDSHAKE_RESP"),
   status: Type.Union([
@@ -56,7 +73,10 @@ var ControlMessageHandshakeResponseSchema = Type.Object({
     }),
     Type.Object({
       ok: Type.Literal(false),
-      reason: Type.String()
+      reason: Type.String(),
+      // TODO: remove optional once we know all servers
+      // are sending code here
+      code: Type.Optional(HandshakeErrorResponseCodes)
     })
   ])
 });
@@ -78,12 +98,12 @@ function handshakeRequestMessage({
   tracing
 }) {
   return {
-    id: nanoid(),
+    id: generateId(),
     from,
     to,
     seq: 0,
     ack: 0,
-    streamId: nanoid(),
+    streamId: generateId(),
     controlFlags: 0,
     tracing,
     payload: {
@@ -95,19 +115,18 @@ function handshakeRequestMessage({
     }
   };
 }
-var SESSION_STATE_MISMATCH = "session state mismatch";
 function handshakeResponseMessage({
   from,
   to,
   status
 }) {
   return {
-    id: nanoid(),
+    id: generateId(),
     from,
     to,
     seq: 0,
     ack: 0,
-    streamId: nanoid(),
+    streamId: generateId(),
     controlFlags: 0,
     payload: {
       type: "HANDSHAKE_RESP",
@@ -115,6 +134,15 @@ function handshakeResponseMessage({
     }
   };
 }
+function closeStreamMessage(streamId) {
+  return {
+    streamId,
+    controlFlags: 4 /* StreamClosedBit */,
+    payload: {
+      type: "CLOSE"
+    }
+  };
+}
 function isAck(controlFlag) {
   return (controlFlag & 1 /* AckBit */) === 1 /* AckBit */;
 }
@@ -132,7 +160,7 @@ function isStreamClose(controlFlag) {
 }
 
 // package.json
-var version = "0.23.18";
+var version = "0.24.1";
 
 // util/stringify.ts
 function coerceErrorString(err) {
@@ -157,16 +185,16 @@ function getPropagationContext(ctx) {
   propagation.inject(ctx, tracing);
   return tracing;
 }
-function createSessionTelemetryInfo(session, propagationCtx) {
+function createSessionTelemetryInfo(sessionId, to, from, propagationCtx) {
   const parentCtx = propagationCtx ? propagation.extract(context.active(), propagationCtx) : context.active();
   const span = tracer.startSpan(
-    `session ${session.id}`,
+    `session ${sessionId}`,
     {
       attributes: {
         component: "river",
-        "river.session.id": session.id,
-        "river.session.to": session.to,
-        "river.session.from": session.from
+        "river.session.id": sessionId,
+        "river.session.to": to,
+        "river.session.from": from
       }
     },
     parentCtx
@@ -174,21 +202,6 @@ function createSessionTelemetryInfo(session, propagationCtx) {
   const ctx = trace.setSpan(parentCtx, span);
   return { span, ctx };
 }
-function createConnectionTelemetryInfo(connection, info) {
-  const span = tracer.startSpan(
-    `connection ${connection.id}`,
-    {
-      attributes: {
-        component: "river",
-        "river.connection.id": connection.id
-      },
-      links: [{ context: info.span.spanContext() }]
-    },
-    info.ctx
-  );
-  const ctx = trace.setSpan(info.ctx, span);
-  return { span, ctx };
-}
 function createProcTelemetryInfo(transport, kind, serviceName, procedureName, streamId) {
   const baseCtx = context.active();
   const span = tracer.startSpan(
@@ -243,25 +256,26 @@ var tracer = trace.getTracer("river", version);
 var tracing_default = tracer;
 
 export {
+  generateId,
   TransportMessageSchema,
   PROTOCOL_VERSION,
   ControlMessageHandshakeRequestSchema,
+  HandshakeErrorRetriableResponseCodes,
   ControlMessageHandshakeResponseSchema,
   ControlMessagePayloadSchema,
   OpaqueTransportMessageSchema,
   handshakeRequestMessage,
-  SESSION_STATE_MISMATCH,
   handshakeResponseMessage,
+  closeStreamMessage,
   isAck,
   isStreamOpen,
   isStreamClose,
   version,
   getPropagationContext,
   createSessionTelemetryInfo,
-  createConnectionTelemetryInfo,
   createProcTelemetryInfo,
   createHandlerSpan,
   tracing_default,
   coerceErrorString
 };
-//# sourceMappingURL=chunk-R2HAS3GM.js.map
+//# sourceMappingURL=chunk-IYYQ7BII.js.map