@replit/river 0.23.15 → 0.23.18

package/dist/{chunk-JMVKSGND.js → chunk-RJOWZIWB.js}

@@ -1,17 +1,17 @@
 import {
   ProtocolError,
   Transport
-} from "./chunk-MD4S7GO2.js";
+} from "./chunk-J6N6H2WU.js";
 import {
   defaultServerTransportOptions
-} from "./chunk-5HK7ZQYH.js";
+} from "./chunk-MW5JXLHY.js";
 import {
   ControlMessageHandshakeRequestSchema,
   PROTOCOL_VERSION,
   SESSION_STATE_MISMATCH,
   coerceErrorString,
   handshakeResponseMessage
-} from "./chunk-OXVWMLID.js";
+} from "./chunk-R2HAS3GM.js";
 
 // transport/server.ts
 import { SpanStatusCode } from "@opentelemetry/api";
@@ -69,7 +69,7 @@ var ServerTransport = class extends Transport {
         });
         conn.close();
       }
-    }, this.options.sessionDisconnectGraceMs);
+    }, this.options.handshakeTimeoutMs);
     const buffer = [];
     let receivedHandshakeMessage = false;
     const handshakeHandler = (data) => {
@@ -332,4 +332,4 @@ var ServerTransport = class extends Transport {
 export {
   ServerTransport
 };
-//# sourceMappingURL=chunk-JMVKSGND.js.map
+//# sourceMappingURL=chunk-RJOWZIWB.js.map

package/dist/chunk-RJOWZIWB.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  PROTOCOL_VERSION,\n  SESSION_STATE_MISMATCH,\n  TransportClientId,\n  handshakeResponseMessage,\n} from './message';\nimport {\n  ProvidedServerTransportOptions,\n  ServerTransportOptions,\n  defaultServerTransportOptions,\n} from './options';\nimport { Connection, Session } from './session';\nimport { Transport } from './transport';\nimport { coerceErrorString } from '../util/stringify';\nimport { Static } from '@sinclair/typebox';\nimport { Value } from '@sinclair/typebox/value';\nimport { ProtocolError } from './events';\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: WeakMap<Session<ConnType>, ParsedMetadata>;\n\n  constructor(\n    clientId: TransportClientId,\n    providedOptions?: ProvidedServerTransportOptions,\n  ) {\n    super(clientId, providedOptions);\n    this.options = {\n      ...defaultServerTransportOptions,\n      ...providedOptions,\n    };\n    this.sessionHandshakeMetadata = new WeakMap();\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  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 session: Session<ConnType> | undefined = undefined;\n    const client = () => session?.to ?? 'unknown';\n\n    // kill the conn after the grace period if we haven't received a handshake\n    const handshakeTimeout = setTimeout(() => {\n      if (!session) {\n        this.log?.warn(\n          `connection to ${client()} timed out waiting for handshake, closing`,\n          {\n            ...conn.loggingMetadata,\n            clientId: this.clientId,\n            connectedTo: client(),\n          },\n        );\n        conn.telemetry?.span.setStatus({\n          code: SpanStatusCode.ERROR,\n          message: 'handshake timeout',\n        });\n        conn.close();\n      }\n    }, this.options.handshakeTimeoutMs);\n\n    const buffer: Array<Uint8Array> = [];\n    let receivedHandshakeMessage = false;\n\n    const handshakeHandler = (data: Uint8Array) => {\n      // if we've already received, just buffer the data\n      if (receivedHandshakeMessage) {\n        buffer.push(data);\n        return;\n      }\n\n      receivedHandshakeMessage = true;\n      clearTimeout(handshakeTimeout);\n\n      void this.receiveHandshakeRequestMessage(data, conn).then(\n        (maybeSession) => {\n          if (!maybeSession) {\n            conn.close();\n            return;\n          }\n\n          session = maybeSession;\n\n          // when we are done handshake sequence,\n          // remove handshake listener and use the normal message listener\n          const dataHandler = (data: Uint8Array) => {\n            const parsed = this.parseMsg(data, conn);\n            if (!parsed) {\n              conn.close();\n              return;\n            }\n\n            this.handleMsg(parsed, conn);\n          };\n\n          // process any data we missed\n          for (const data of buffer) {\n            dataHandler(data);\n          }\n\n          conn.removeDataListener(handshakeHandler);\n          conn.addDataListener(dataHandler);\n          buffer.length = 0;\n        },\n      );\n    };\n\n    conn.addDataListener(handshakeHandler);\n    conn.addCloseListener(() => {\n      if (!session) return;\n      this.log?.info(`connection to ${client()} disconnected`, {\n        ...conn.loggingMetadata,\n        clientId: this.clientId,\n      });\n      this.onDisconnect(conn, session);\n    });\n\n    conn.addErrorListener((err) => {\n      conn.telemetry?.span.setStatus({\n        code: SpanStatusCode.ERROR,\n        message: 'connection error',\n      });\n      if (!session) return;\n      this.log?.warn(\n        `connection to ${client()} got an error: ${coerceErrorString(err)}`,\n        { ...conn.loggingMetadata, clientId: this.clientId },\n      );\n    });\n  }\n\n  private async validateHandshakeMetadata(\n    conn: ConnType,\n    session: 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        conn.telemetry?.span.setStatus({\n          code: SpanStatusCode.ERROR,\n          message: 'malformed handshake meta',\n        });\n        const reason = 'received malformed handshake metadata';\n        const responseMsg = handshakeResponseMessage({\n          from: this.clientId,\n          to: from,\n          status: {\n            ok: false,\n            reason,\n          },\n        });\n        conn.send(this.codec.toBuffer(responseMsg));\n        this.log?.warn(`received malformed handshake metadata from ${from}`, {\n          ...conn.loggingMetadata,\n          clientId: this.clientId,\n          validationErrors: [\n            ...Value.Errors(this.handshakeExtensions.schema, rawMetadata),\n          ],\n        });\n        this.protocolError(ProtocolError.HandshakeFailed, reason);\n        return false;\n      }\n\n      const previousParsedMetadata = session\n        ? this.sessionHandshakeMetadata.get(session)\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        const reason = 'rejected by handshake handler';\n        conn.telemetry?.span.setStatus({\n          code: SpanStatusCode.ERROR,\n          message: reason,\n        });\n        const responseMsg = handshakeResponseMessage({\n          from: this.clientId,\n          to: from,\n          status: {\n            ok: false,\n            reason,\n          },\n        });\n        conn.send(this.codec.toBuffer(responseMsg));\n        this.log?.warn(`rejected handshake from ${from}`, {\n          ...conn.loggingMetadata,\n          clientId: this.clientId,\n        });\n        this.protocolError(ProtocolError.HandshakeFailed, reason);\n        return false;\n      }\n    }\n\n    return parsedMetadata;\n  }\n\n  async receiveHandshakeRequestMessage(\n    data: Uint8Array,\n    conn: ConnType,\n  ): Promise<Session<ConnType> | false> {\n    const parsed = this.parseMsg(data, conn);\n    if (!parsed) {\n      conn.telemetry?.span.setStatus({\n        code: SpanStatusCode.ERROR,\n        message: 'non-transport message',\n      });\n      this.protocolError(\n        ProtocolError.HandshakeFailed,\n        'received non-transport message',\n      );\n      return false;\n    }\n\n    if (!Value.Check(ControlMessageHandshakeRequestSchema, parsed.payload)) {\n      conn.telemetry?.span.setStatus({\n        code: SpanStatusCode.ERROR,\n        message: 'invalid handshake request',\n      });\n      const reason = 'received invalid handshake msg';\n      const responseMsg = handshakeResponseMessage({\n        from: this.clientId,\n        to: parsed.from,\n        status: {\n          ok: false,\n          reason,\n        },\n      });\n      conn.send(this.codec.toBuffer(responseMsg));\n      this.log?.warn(reason, {\n        ...conn.loggingMetadata,\n        clientId: this.clientId,\n        // safe to this.log metadata here as we remove the payload\n        // before passing it to user-land\n        transportMessage: parsed,\n        validationErrors: [\n          ...Value.Errors(ControlMessageHandshakeRequestSchema, parsed.payload),\n        ],\n      });\n      this.protocolError(\n        ProtocolError.HandshakeFailed,\n        'invalid handshake request',\n      );\n      return false;\n    }\n\n    // double check protocol version here\n    const gotVersion = parsed.payload.protocolVersion;\n    if (gotVersion !== PROTOCOL_VERSION) {\n      conn.telemetry?.span.setStatus({\n        code: SpanStatusCode.ERROR,\n        message: 'incorrect protocol version',\n      });\n\n      const reason = `incorrect version (got: ${gotVersion} wanted ${PROTOCOL_VERSION})`;\n      const responseMsg = handshakeResponseMessage({\n        from: this.clientId,\n        to: parsed.from,\n        status: {\n          ok: false,\n          reason,\n        },\n      });\n      conn.send(this.codec.toBuffer(responseMsg));\n      this.log?.warn(\n        `received handshake msg with incompatible protocol version (got: ${gotVersion}, expected: ${PROTOCOL_VERSION})`,\n        { ...conn.loggingMetadata, clientId: this.clientId },\n      );\n      this.protocolError(ProtocolError.HandshakeFailed, reason);\n      return false;\n    }\n\n    const oldSession = this.sessions.get(parsed.from);\n    const parsedMetadata = await this.validateHandshakeMetadata(\n      conn,\n      oldSession,\n      parsed.payload.metadata,\n      parsed.from,\n    );\n\n    if (parsedMetadata === false) {\n      return false;\n    }\n\n    let session: Session<ConnType>;\n    let isTransparentReconnect: boolean;\n    if (!parsed.payload.expectedSessionState) {\n      // TODO: remove once we have upgraded all clients.\n      ({ session, isTransparentReconnect } = this.getOrCreateSession({\n        to: parsed.from,\n        conn,\n        sessionId: parsed.payload.sessionId,\n        propagationCtx: parsed.tracing,\n      }));\n    } else if (parsed.payload.expectedSessionState.reconnect) {\n      // this has to be an existing session. if it doesn't match what we expect, reject the\n      // handshake\n      const existingSession = this.getExistingSession({\n        to: parsed.from,\n        sessionId: parsed.payload.sessionId,\n        nextExpectedSeq: parsed.payload.expectedSessionState.nextExpectedSeq,\n      });\n      if (existingSession === false) {\n        conn.telemetry?.span.setStatus({\n          code: SpanStatusCode.ERROR,\n          message: SESSION_STATE_MISMATCH,\n        });\n\n        const reason = SESSION_STATE_MISMATCH;\n        const responseMsg = handshakeResponseMessage({\n          from: this.clientId,\n          to: parsed.from,\n          status: {\n            ok: false,\n            reason,\n          },\n        });\n        conn.send(this.codec.toBuffer(responseMsg));\n        this.log?.warn(\n          `'received handshake msg with incompatible existing session state: ${parsed.payload.sessionId}`,\n          { ...conn.loggingMetadata, clientId: this.clientId },\n        );\n        this.protocolError(ProtocolError.HandshakeFailed, reason);\n        return false;\n      }\n      session = existingSession;\n      isTransparentReconnect = false;\n    } else {\n      // this has to be a new session. if one already exists, it will be replaced silently\n      const createdSession = this.createNewSession({\n        to: parsed.from,\n        conn,\n        sessionId: parsed.payload.sessionId,\n        propagationCtx: parsed.tracing,\n      });\n      session = createdSession;\n      isTransparentReconnect = false;\n    }\n\n    this.sessionHandshakeMetadata.set(session, parsedMetadata);\n\n    this.log?.debug(\n      `handshake from ${parsed.from} ok, responding with handshake success`,\n      conn.loggingMetadata,\n    );\n    const responseMsg = handshakeResponseMessage({\n      from: this.clientId,\n      to: parsed.from,\n      status: {\n        ok: true,\n        sessionId: session.id,\n      },\n    });\n    conn.send(this.codec.toBuffer(responseMsg));\n    this.onConnect(conn, session, isTransparentReconnect);\n\n    return session;\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;AAAA,SAAS,sBAAsB;AAmB/B,SAAS,aAAa;AAGf,IAAe,kBAAf,cAEG,UAAoB;AAAA;AAAA;AAAA;AAAA,EAIlB;AAAA;AAAA;AAAA;AAAA,EAKV;AAAA;AAAA;AAAA;AAAA,EAKA;AAAA,EAEA,YACE,UACA,iBACA;AACA,UAAM,UAAU,eAAe;AAC/B,SAAK,UAAU;AAAA,MACb,GAAG;AAAA,MACH,GAAG;AAAA,IACL;AACA,SAAK,2BAA2B,oBAAI,QAAQ;AAC5C,SAAK,KAAK,KAAK,8BAA8B;AAAA,MAC3C,UAAU,KAAK;AAAA,MACf,iBAAiB;AAAA,IACnB,CAAC;AAAA,EACH;AAAA,EAEA,gBAAgB,SAAiC;AAC/C,SAAK,sBAAsB;AAAA,EAC7B;AAAA,EAEU,iBAAiB,MAAgB;AACzC,QAAI,KAAK,UAAU,MAAM;AAAQ;AAEjC,SAAK,KAAK,KAAK,2BAA2B;AAAA,MACxC,GAAG,KAAK;AAAA,MACR,UAAU,KAAK;AAAA,IACjB,CAAC;AAED,QAAI,UAAyC;AAC7C,UAAM,SAAS,MAAM,SAAS,MAAM;AAGpC,UAAM,mBAAmB,WAAW,MAAM;AACxC,UAAI,CAAC,SAAS;AACZ,aAAK,KAAK;AAAA,UACR,iBAAiB,OAAO,CAAC;AAAA,UACzB;AAAA,YACE,GAAG,KAAK;AAAA,YACR,UAAU,KAAK;AAAA,YACf,aAAa,OAAO;AAAA,UACtB;AAAA,QACF;AACA,aAAK,WAAW,KAAK,UAAU;AAAA,UAC7B,MAAM,eAAe;AAAA,UACrB,SAAS;AAAA,QACX,CAAC;AACD,aAAK,MAAM;AAAA,MACb;AAAA,IACF,GAAG,KAAK,QAAQ,kBAAkB;AAElC,UAAM,SAA4B,CAAC;AACnC,QAAI,2BAA2B;AAE/B,UAAM,mBAAmB,CAAC,SAAqB;AAE7C,UAAI,0BAA0B;AAC5B,eAAO,KAAK,IAAI;AAChB;AAAA,MACF;AAEA,iCAA2B;AAC3B,mBAAa,gBAAgB;AAE7B,WAAK,KAAK,+BAA+B,MAAM,IAAI,EAAE;AAAA,QACnD,CAAC,iBAAiB;AAChB,cAAI,CAAC,cAAc;AACjB,iBAAK,MAAM;AACX;AAAA,UACF;AAEA,oBAAU;AAIV,gBAAM,cAAc,CAACA,UAAqB;AACxC,kBAAM,SAAS,KAAK,SAASA,OAAM,IAAI;AACvC,gBAAI,CAAC,QAAQ;AACX,mBAAK,MAAM;AACX;AAAA,YACF;AAEA,iBAAK,UAAU,QAAQ,IAAI;AAAA,UAC7B;AAGA,qBAAWA,SAAQ,QAAQ;AACzB,wBAAYA,KAAI;AAAA,UAClB;AAEA,eAAK,mBAAmB,gBAAgB;AACxC,eAAK,gBAAgB,WAAW;AAChC,iBAAO,SAAS;AAAA,QAClB;AAAA,MACF;AAAA,IACF;AAEA,SAAK,gBAAgB,gBAAgB;AACrC,SAAK,iBAAiB,MAAM;AAC1B,UAAI,CAAC;AAAS;AACd,WAAK,KAAK,KAAK,iBAAiB,OAAO,CAAC,iBAAiB;AAAA,QACvD,GAAG,KAAK;AAAA,QACR,UAAU,KAAK;AAAA,MACjB,CAAC;AACD,WAAK,aAAa,MAAM,OAAO;AAAA,IACjC,CAAC;AAED,SAAK,iBAAiB,CAAC,QAAQ;AAC7B,WAAK,WAAW,KAAK,UAAU;AAAA,QAC7B,MAAM,eAAe;AAAA,QACrB,SAAS;AAAA,MACX,CAAC;AACD,UAAI,CAAC;AAAS;AACd,WAAK,KAAK;AAAA,QACR,iBAAiB,OAAO,CAAC,kBAAkB,kBAAkB,GAAG,CAAC;AAAA,QACjE,EAAE,GAAG,KAAK,iBAAiB,UAAU,KAAK,SAAS;AAAA,MACrD;AAAA,IACF,CAAC;AAAA,EACH;AAAA,EAEA,MAAc,0BACZ,MACA,SACA,aAGA,MACiC;AACjC,QAAI,iBAAiC,CAAC;AACtC,QAAI,KAAK,qBAAqB;AAE5B,UAAI,CAAC,MAAM,MAAM,KAAK,oBAAoB,QAAQ,WAAW,GAAG;AAC9D,aAAK,WAAW,KAAK,UAAU;AAAA,UAC7B,MAAM,eAAe;AAAA,UACrB,SAAS;AAAA,QACX,CAAC;AACD,cAAM,SAAS;AACf,cAAM,cAAc,yBAAyB;AAAA,UAC3C,MAAM,KAAK;AAAA,UACX,IAAI;AAAA,UACJ,QAAQ;AAAA,YACN,IAAI;AAAA,YACJ;AAAA,UACF;AAAA,QACF,CAAC;AACD,aAAK,KAAK,KAAK,MAAM,SAAS,WAAW,CAAC;AAC1C,aAAK,KAAK,KAAK,8CAA8C,IAAI,IAAI;AAAA,UACnE,GAAG,KAAK;AAAA,UACR,UAAU,KAAK;AAAA,UACf,kBAAkB;AAAA,YAChB,GAAG,MAAM,OAAO,KAAK,oBAAoB,QAAQ,WAAW;AAAA,UAC9D;AAAA,QACF,CAAC;AACD,aAAK,cAAc,cAAc,iBAAiB,MAAM;AACxD,eAAO;AAAA,MACT;AAEA,YAAM,yBAAyB,UAC3B,KAAK,yBAAyB,IAAI,OAAO,IACzC;AAEJ,uBAAiB,MAAM,KAAK,oBAAoB;AAAA,QAC9C;AAAA,QACA;AAAA,MACF;AAGA,UAAI,mBAAmB,OAAO;AAC5B,cAAM,SAAS;AACf,aAAK,WAAW,KAAK,UAAU;AAAA,UAC7B,MAAM,eAAe;AAAA,UACrB,SAAS;AAAA,QACX,CAAC;AACD,cAAM,cAAc,yBAAyB;AAAA,UAC3C,MAAM,KAAK;AAAA,UACX,IAAI;AAAA,UACJ,QAAQ;AAAA,YACN,IAAI;AAAA,YACJ;AAAA,UACF;AAAA,QACF,CAAC;AACD,aAAK,KAAK,KAAK,MAAM,SAAS,WAAW,CAAC;AAC1C,aAAK,KAAK,KAAK,2BAA2B,IAAI,IAAI;AAAA,UAChD,GAAG,KAAK;AAAA,UACR,UAAU,KAAK;AAAA,QACjB,CAAC;AACD,aAAK,cAAc,cAAc,iBAAiB,MAAM;AACxD,eAAO;AAAA,MACT;AAAA,IACF;AAEA,WAAO;AAAA,EACT;AAAA,EAEA,MAAM,+BACJ,MACA,MACoC;AACpC,UAAM,SAAS,KAAK,SAAS,MAAM,IAAI;AACvC,QAAI,CAAC,QAAQ;AACX,WAAK,WAAW,KAAK,UAAU;AAAA,QAC7B,MAAM,eAAe;AAAA,QACrB,SAAS;AAAA,MACX,CAAC;AACD,WAAK;AAAA,QACH,cAAc;AAAA,QACd;AAAA,MACF;AACA,aAAO;AAAA,IACT;AAEA,QAAI,CAAC,MAAM,MAAM,sCAAsC,OAAO,OAAO,GAAG;AACtE,WAAK,WAAW,KAAK,UAAU;AAAA,QAC7B,MAAM,eAAe;AAAA,QACrB,SAAS;AAAA,MACX,CAAC;AACD,YAAM,SAAS;AACf,YAAMC,eAAc,yBAAyB;AAAA,QAC3C,MAAM,KAAK;AAAA,QACX,IAAI,OAAO;AAAA,QACX,QAAQ;AAAA,UACN,IAAI;AAAA,UACJ;AAAA,QACF;AAAA,MACF,CAAC;AACD,WAAK,KAAK,KAAK,MAAM,SAASA,YAAW,CAAC;AAC1C,WAAK,KAAK,KAAK,QAAQ;AAAA,QACrB,GAAG,KAAK;AAAA,QACR,UAAU,KAAK;AAAA;AAAA;AAAA,QAGf,kBAAkB;AAAA,QAClB,kBAAkB;AAAA,UAChB,GAAG,MAAM,OAAO,sCAAsC,OAAO,OAAO;AAAA,QACtE;AAAA,MACF,CAAC;AACD,WAAK;AAAA,QACH,cAAc;AAAA,QACd;AAAA,MACF;AACA,aAAO;AAAA,IACT;AAGA,UAAM,aAAa,OAAO,QAAQ;AAClC,QAAI,eAAe,kBAAkB;AACnC,WAAK,WAAW,KAAK,UAAU;AAAA,QAC7B,MAAM,eAAe;AAAA,QACrB,SAAS;AAAA,MACX,CAAC;AAED,YAAM,SAAS,2BAA2B,UAAU,WAAW,gBAAgB;AAC/E,YAAMA,eAAc,yBAAyB;AAAA,QAC3C,MAAM,KAAK;AAAA,QACX,IAAI,OAAO;AAAA,QACX,QAAQ;AAAA,UACN,IAAI;AAAA,UACJ;AAAA,QACF;AAAA,MACF,CAAC;AACD,WAAK,KAAK,KAAK,MAAM,SAASA,YAAW,CAAC;AAC1C,WAAK,KAAK;AAAA,QACR,mEAAmE,UAAU,eAAe,gBAAgB;AAAA,QAC5G,EAAE,GAAG,KAAK,iBAAiB,UAAU,KAAK,SAAS;AAAA,MACrD;AACA,WAAK,cAAc,cAAc,iBAAiB,MAAM;AACxD,aAAO;AAAA,IACT;AAEA,UAAM,aAAa,KAAK,SAAS,IAAI,OAAO,IAAI;AAChD,UAAM,iBAAiB,MAAM,KAAK;AAAA,MAChC;AAAA,MACA;AAAA,MACA,OAAO,QAAQ;AAAA,MACf,OAAO;AAAA,IACT;AAEA,QAAI,mBAAmB,OAAO;AAC5B,aAAO;AAAA,IACT;AAEA,QAAI;AACJ,QAAI;AACJ,QAAI,CAAC,OAAO,QAAQ,sBAAsB;AAExC,OAAC,EAAE,SAAS,uBAAuB,IAAI,KAAK,mBAAmB;AAAA,QAC7D,IAAI,OAAO;AAAA,QACX;AAAA,QACA,WAAW,OAAO,QAAQ;AAAA,QAC1B,gBAAgB,OAAO;AAAA,MACzB,CAAC;AAAA,IACH,WAAW,OAAO,QAAQ,qBAAqB,WAAW;AAGxD,YAAM,kBAAkB,KAAK,mBAAmB;AAAA,QAC9C,IAAI,OAAO;AAAA,QACX,WAAW,OAAO,QAAQ;AAAA,QAC1B,iBAAiB,OAAO,QAAQ,qBAAqB;AAAA,MACvD,CAAC;AACD,UAAI,oBAAoB,OAAO;AAC7B,aAAK,WAAW,KAAK,UAAU;AAAA,UAC7B,MAAM,eAAe;AAAA,UACrB,SAAS;AAAA,QACX,CAAC;AAED,cAAM,SAAS;AACf,cAAMA,eAAc,yBAAyB;AAAA,UAC3C,MAAM,KAAK;AAAA,UACX,IAAI,OAAO;AAAA,UACX,QAAQ;AAAA,YACN,IAAI;AAAA,YACJ;AAAA,UACF;AAAA,QACF,CAAC;AACD,aAAK,KAAK,KAAK,MAAM,SAASA,YAAW,CAAC;AAC1C,aAAK,KAAK;AAAA,UACR,qEAAqE,OAAO,QAAQ,SAAS;AAAA,UAC7F,EAAE,GAAG,KAAK,iBAAiB,UAAU,KAAK,SAAS;AAAA,QACrD;AACA,aAAK,cAAc,cAAc,iBAAiB,MAAM;AACxD,eAAO;AAAA,MACT;AACA,gBAAU;AACV,+BAAyB;AAAA,IAC3B,OAAO;AAEL,YAAM,iBAAiB,KAAK,iBAAiB;AAAA,QAC3C,IAAI,OAAO;AAAA,QACX;AAAA,QACA,WAAW,OAAO,QAAQ;AAAA,QAC1B,gBAAgB,OAAO;AAAA,MACzB,CAAC;AACD,gBAAU;AACV,+BAAyB;AAAA,IAC3B;AAEA,SAAK,yBAAyB,IAAI,SAAS,cAAc;AAEzD,SAAK,KAAK;AAAA,MACR,kBAAkB,OAAO,IAAI;AAAA,MAC7B,KAAK;AAAA,IACP;AACA,UAAM,cAAc,yBAAyB;AAAA,MAC3C,MAAM,KAAK;AAAA,MACX,IAAI,OAAO;AAAA,MACX,QAAQ;AAAA,QACN,IAAI;AAAA,QACJ,WAAW,QAAQ;AAAA,MACrB;AAAA,IACF,CAAC;AACD,SAAK,KAAK,KAAK,MAAM,SAAS,WAAW,CAAC;AAC1C,SAAK,UAAU,MAAM,SAAS,sBAAsB;AAEpD,WAAO;AAAA,EACT;AACF;","names":["data","responseMsg"]}

package/dist/{client-e13979ac.d.ts → client-5776a6bb.d.ts}

@@ -1,4 +1,4 @@
-import { C as Connection, T as Transport, j as ClientTransportOptions, L as LeakyBucketRateLimit, k as ClientHandshakeOptions, b as ProvidedClientTransportOptions, S as Session } from './handshake-5665ffd3.js';
+import { C as Connection, T as Transport, j as ClientTransportOptions, L as LeakyBucketRateLimit, k as ClientHandshakeOptions, b as ProvidedClientTransportOptions, S as Session } from './handshake-a947c234.js';
 import { c as TransportClientId } from './index-ea74cdbb.js';
 
 declare abstract class ClientTransport<ConnType extends Connection> extends Transport<ConnType> {

package/dist/{connection-e57e98ea.d.ts → connection-bd35d442.d.ts}

@@ -1,4 +1,4 @@
-import { C as Connection } from './handshake-5665ffd3.js';
+import { C as Connection } from './handshake-a947c234.js';
 import { Socket } from 'node:net';
 import stream, { Transform, TransformCallback, TransformOptions } from 'node:stream';
 

package/dist/{connection-5d0978ce.d.ts → connection-df85db7e.d.ts}

@@ -1,4 +1,4 @@
-import { C as Connection } from './handshake-5665ffd3.js';
+import { C as Connection } from './handshake-a947c234.js';
 import { W as WsLike } from './wslike-e0b32dd5.js';
 
 declare class WebSocketConnection extends Connection {

package/dist/{handshake-5665ffd3.d.ts → handshake-a947c234.d.ts}

@@ -62,6 +62,10 @@ interface SessionOptions {
      * Duration to wait between connection disconnect and actual session disconnect
      */
     sessionDisconnectGraceMs: number;
+    /**
+     * Duration to wait for a handshake to complete before considering the connection dead.
+     */
+    handshakeTimeoutMs?: number;
     /**
      * The codec to use for encoding/decoding messages over the wire
      */
@@ -153,6 +157,11 @@ declare class Session<ConnType extends Connection> {
     get connected(): boolean;
     get nextExpectedAck(): number;
     get nextExpectedSeq(): number;
+    /**
+     * Check that the peer's next expected seq number matches something that is in our send buffer
+     * _or_ matches our actual next seq.
+     */
+    nextExpectedSeqInRange(nextExpectedSeq: number): boolean;
     advanceAckForTesting(by: number): void;
     constructMsg<Payload>(partialMsg: PartialTransportMessage<Payload>): TransportMessage<Payload>;
     inspectSendBuffer(): ReadonlyArray<OpaqueTransportMessage>;

package/dist/router/index.cjs

@@ -31,7 +31,6 @@ __export(router_exports, {
   createClientHandshakeOptions: () => createClientHandshakeOptions,
   createServer: () => createServer,
   createServerHandshakeOptions: () => createServerHandshakeOptions,
-  diffServerSchema: () => diffServerSchema,
   serializeSchema: () => serializeSchema
 });
 module.exports = __toCommonJS(router_exports);
@@ -174,9 +173,9 @@ var ServiceSchema = class _ServiceSchema {
    * You probably don't need this, usually the River server will handle this
    * for you.
    */
-  instantiate() {
+  instantiate(extendedContext) {
     return Object.freeze({
-      state: this.initializeState(),
+      state: this.initializeState(extendedContext),
       procedures: this.procedures
     });
   }
@@ -238,468 +237,6 @@ var ServiceScaffold = class {
   }
 };
 
-// router/diff.ts
-function diffServerSchema(oldServer, newServer, options) {
-  const allServices = /* @__PURE__ */ new Set([
-    ...Object.keys(oldServer.services),
-    ...Object.keys(newServer.services)
-  ]);
-  const breakages = {};
-  for (const serviceName of allServices) {
-    const oldService = oldServer.services[serviceName];
-    const newService = newServer.services[serviceName];
-    const breakage = diffService(oldService, newService, options);
-    if (breakage) {
-      breakages[serviceName] = breakage;
-    }
-  }
-  if (Object.keys(breakages).length) {
-    return { serviceBreakages: breakages };
-  }
-  return null;
-}
-function diffService(oldService, newService, options) {
-  if (!newService) {
-    return options?.allowServiceRemoval ? null : { reason: "removed" };
-  }
-  if (!oldService) {
-    return null;
-  }
-  const allProcedures = /* @__PURE__ */ new Set([
-    ...Object.keys(oldService.procedures),
-    ...Object.keys(newService.procedures)
-  ]);
-  const breakages = {};
-  for (const procedureName of allProcedures) {
-    const aProcedure = oldService.procedures[procedureName];
-    const bProcedure = newService.procedures[procedureName];
-    const breakage = diffProcedure(aProcedure, bProcedure, options);
-    if (breakage) {
-      breakages[procedureName] = breakage;
-    }
-  }
-  if (Object.keys(breakages).length) {
-    return { reason: "modified", procedureBreakages: breakages };
-  }
-  return null;
-}
-function diffProcedure(oldProcedure, newProcedure, options) {
-  if (!newProcedure) {
-    return options?.allowProcedureRemoval ? null : { reason: "removed" };
-  }
-  if (!oldProcedure) {
-    return null;
-  }
-  if (oldProcedure.type !== newProcedure.type) {
-    return {
-      reason: "type-changed",
-      oldType: oldProcedure.type,
-      newType: newProcedure.type
-    };
-  }
-  const inputBreakage = diffProcedureField(
-    oldProcedure.input,
-    newProcedure.input,
-    "client"
-  );
-  const initBreakage = diffProcedureField(
-    oldProcedure.init,
-    newProcedure.init,
-    "client"
-  );
-  const outputBreakage = diffProcedureField(
-    oldProcedure.output,
-    newProcedure.output,
-    "server"
-  );
-  if (inputBreakage ?? initBreakage ?? outputBreakage) {
-    const result = {
-      reason: "modified"
-    };
-    if (inputBreakage) {
-      result.input = inputBreakage;
-    }
-    if (initBreakage) {
-      result.init = initBreakage;
-    }
-    if (outputBreakage) {
-      result.output = outputBreakage;
-    }
-    return result;
-  }
-  return null;
-}
-function diffProcedureField(oldSchema, newSchema, origin) {
-  if (!oldSchema && !newSchema) {
-    return null;
-  }
-  const diffBreakage = diffRequired(oldSchema, newSchema, origin, false, false);
-  if (diffBreakage) {
-    return diffBreakage;
-  }
-  if (!oldSchema || !newSchema) {
-    throw new Error("Appease typescript, this should never happen");
-  }
-  return diffJSONSchema(oldSchema, newSchema, origin);
-}
-function diffRequired(oldSchema, newSchema, origin, oldRequired, newRequired) {
-  if (!newSchema && !oldSchema) {
-    throw new Error("Both old and new schema are undefined");
-  }
-  if (!newSchema) {
-    if (!oldRequired && origin == "server") {
-      return null;
-    }
-    return { reason: "removed-required" };
-  }
-  if (!oldSchema) {
-    if (newRequired && origin === "client") {
-      return { reason: "new-required" };
-    }
-    return null;
-  }
-  if (origin === "client" && !oldRequired && newRequired) {
-    return { reason: "new-required" };
-  }
-  if (origin === "server" && oldRequired && !newRequired) {
-    return { reason: "removed-required" };
-  }
-  return null;
-}
-function diffJSONSchema(oldSchema, newSchema, origin) {
-  if (oldSchema.type !== newSchema.type) {
-    return {
-      reason: "type-changed",
-      oldType: getReportingType(oldSchema),
-      newType: getReportingType(newSchema)
-    };
-  }
-  if (getReportingType(oldSchema) !== getReportingType(newSchema)) {
-    return {
-      reason: "type-changed",
-      oldType: getReportingType(oldSchema),
-      newType: getReportingType(newSchema)
-    };
-  }
-  if ("const" in oldSchema && "const" in newSchema && oldSchema.const !== newSchema.const) {
-    return {
-      reason: "type-changed",
-      oldType: `${getReportingType(oldSchema)}-const-${oldSchema.const}`,
-      newType: `${getReportingType(newSchema)}-const-${newSchema.const}`
-    };
-  }
-  if ("const" in oldSchema && !("const" in newSchema) && origin === "server") {
-    return {
-      reason: "type-changed",
-      oldType: `${getReportingType(oldSchema)}-const-${oldSchema.const}`,
-      newType: getReportingType(newSchema)
-    };
-  }
-  if ("const" in newSchema && !("const" in oldSchema) && origin === "client") {
-    return {
-      reason: "type-changed",
-      oldType: getReportingType(oldSchema),
-      newType: `${getReportingType(newSchema)}-const-${newSchema.const}`
-    };
-  }
-  const breakages = {};
-  if ("$ref" in newSchema) {
-    if (newSchema.$ref !== oldSchema.$ref) {
-      return {
-        reason: "type-changed",
-        oldType: getReportingType(oldSchema),
-        newType: getReportingType(newSchema)
-      };
-    }
-  } else if ("not" in newSchema) {
-    const notBreakage = diffJSONSchema(
-      oldSchema.not,
-      newSchema.not,
-      origin
-    );
-    if (notBreakage) {
-      breakages.not = notBreakage;
-    }
-  } else if ("anyOf" in newSchema) {
-    const oldAnyOfStringified = oldSchema.anyOf.map((el) => JSON.stringify(el)).sort();
-    const newAnyOfStringified = newSchema.anyOf.map((el) => JSON.stringify(el)).sort();
-    const anyOfBreakages = {};
-    for (let i = 0; i < oldAnyOfStringified.length; i++) {
-      if (newAnyOfStringified.includes(oldAnyOfStringified[i])) {
-        continue;
-      }
-      if (!newAnyOfStringified[i]) {
-        if (origin === "server") {
-          continue;
-        }
-        anyOfBreakages[`old-${i}`] = { reason: "removed-required" };
-      } else {
-        const breakage = diffJSONSchema(
-          JSON.parse(oldAnyOfStringified[i]),
-          JSON.parse(newAnyOfStringified[i]),
-          origin
-        );
-        if (breakage) {
-          anyOfBreakages[`old-${i}`] = breakage;
-        }
-      }
-    }
-    for (let i = 0; i < newAnyOfStringified.length; i++) {
-      if (oldAnyOfStringified.includes(newAnyOfStringified[i])) {
-        continue;
-      }
-      if (!oldAnyOfStringified[i]) {
-        if (origin === "client") {
-          continue;
-        }
-        anyOfBreakages[`new-${i}`] = { reason: "new-required" };
-      } else {
-        const breakage = diffJSONSchema(
-          JSON.parse(oldAnyOfStringified[i]),
-          JSON.parse(newAnyOfStringified[i]),
-          origin
-        );
-        if (breakage) {
-          anyOfBreakages[`new-${i}`] = breakage;
-        }
-      }
-    }
-    if (Object.keys(anyOfBreakages).length > 0) {
-      breakages.anyOf = {
-        reason: "field-breakage",
-        fieldBreakages: anyOfBreakages
-      };
-    }
-  } else if ("oneOf" in newSchema) {
-    throw new Error("oneOf is not supported, typebox does not emit it");
-  } else if ("allOf" in newSchema) {
-    if (newSchema.allOf.length !== oldSchema.allOf.length) {
-      breakages.allOf = {
-        reason: "type-changed",
-        oldType: `${oldSchema.allOf}`,
-        newType: `${newSchema.allOf}`
-      };
-    } else {
-      for (let i = 0; i < newSchema.allOf.length; i++) {
-        const breakage = diffJSONSchema(
-          oldSchema.allOf[i],
-          newSchema.allOf[i],
-          origin
-        );
-        if (breakage) {
-          breakages.allOf = breakage;
-          break;
-        }
-      }
-    }
-  } else if (newSchema.type === "array") {
-    const itemsBreakages = diffJSONSchema(
-      oldSchema.items,
-      newSchema.items,
-      origin
-    );
-    if (itemsBreakages) {
-      breakages.items = itemsBreakages;
-    }
-    if (oldSchema.minItems < newSchema.minItems) {
-      if (origin === "client") {
-        breakages.minItems = {
-          reason: "type-changed",
-          oldType: `${oldSchema.minItems}`,
-          newType: `${newSchema.minItems}`
-        };
-      }
-    } else if (oldSchema.minItems > newSchema.minItems) {
-      if (origin === "server") {
-        breakages.minItems = {
-          reason: "type-changed",
-          oldType: `${oldSchema.minItems}`,
-          newType: `${newSchema.minItems}`
-        };
-      }
-    }
-    if (oldSchema.maxItems < newSchema.maxItems) {
-      if (origin === "server") {
-        breakages.maxItems = {
-          reason: "type-changed",
-          oldType: `${oldSchema.maxItems}`,
-          newType: `${newSchema.maxItems}`
-        };
-      }
-    } else if (oldSchema.maxItems > newSchema.maxItems) {
-      if (origin === "client") {
-        breakages.maxItems = {
-          reason: "type-changed",
-          oldType: `${oldSchema.maxItems}`,
-          newType: `${newSchema.maxItems}`
-        };
-      }
-    }
-    if (!oldSchema.uniqueItems && newSchema.uniqueItems && origin === "client") {
-      breakages.uniqueItems = {
-        reason: "type-changed",
-        oldType: `${!!oldSchema.uniqueItems}`,
-        newType: `${!!newSchema.uniqueItems}`
-      };
-    }
-    if ("contains" in newSchema !== "contains" in oldSchema) {
-      if ("contains" in newSchema && !("contains" in oldSchema) && origin === "client") {
-        breakages.contains = {
-          reason: "type-changed",
-          oldType: "no-contains",
-          newType: "contains"
-        };
-      }
-    } else if ("contains" in newSchema) {
-      const containsBreakage = diffJSONSchema(
-        oldSchema.contains,
-        newSchema.contains,
-        origin
-      );
-      if (containsBreakage) {
-        breakages.contains = containsBreakage;
-      }
-    }
-    if (oldSchema.minContains < newSchema.minContains) {
-      if (origin === "client") {
-        breakages.minContains = {
-          reason: "type-changed",
-          oldType: `${oldSchema.minContains}`,
-          newType: `${newSchema.minContains}`
-        };
-      }
-    } else if (oldSchema.minContains > newSchema.minContains) {
-      if (origin === "server") {
-        breakages.minContains = {
-          reason: "type-changed",
-          oldType: `${oldSchema.minContains}`,
-          newType: `${newSchema.minContains}`
-        };
-      }
-    }
-    if (oldSchema.maxContains < newSchema.maxContains) {
-      if (origin === "server") {
-        breakages.maxContains = {
-          reason: "type-changed",
-          oldType: `${oldSchema.maxContains}`,
-          newType: `${newSchema.maxContains}`
-        };
-      }
-    } else if (oldSchema.maxContains > newSchema.maxContains) {
-      if (origin === "client") {
-        breakages.maxContains = {
-          reason: "type-changed",
-          oldType: `${oldSchema.maxContains}`,
-          newType: `${newSchema.maxContains}`
-        };
-      }
-    }
-  } else if (newSchema.type === "object") {
-    if ("properties" in newSchema !== "properties" in oldSchema) {
-      return {
-        reason: "type-changed",
-        oldType: "properties" in oldSchema ? "probably-object" : "probably-record",
-        newType: "properties" in newSchema ? "probably-object" : "probably-record"
-      };
-    }
-    if ("properties" in newSchema) {
-      const propertiesBreakages = diffObjectProperties(
-        oldSchema.properties,
-        newSchema.properties,
-        origin,
-        oldSchema.required,
-        newSchema.required
-      );
-      if (Object.keys(propertiesBreakages).length) {
-        breakages.properties = {
-          reason: "field-breakage",
-          fieldBreakages: propertiesBreakages
-        };
-      }
-    }
-    if ("patternProperties" in newSchema) {
-      const patternPropertiesBreakages = diffObjectProperties(
-        oldSchema.patternProperties,
-        newSchema.patternProperties,
-        origin,
-        oldSchema.required,
-        newSchema.required
-      );
-      if (Object.keys(patternPropertiesBreakages).length) {
-        breakages.patternProperties = {
-          reason: "field-breakage",
-          fieldBreakages: patternPropertiesBreakages
-        };
-      }
-    }
-    if ("additionalProperties" in newSchema || "additionalProperties" in oldSchema) {
-      throw new Error("additionalProperties is not supported");
-    }
-    if ("minProperties" in newSchema || "minProperties" in oldSchema) {
-      throw new Error("minProperties is not supported");
-    }
-    if ("maxProperties" in newSchema || "maxProperties" in oldSchema) {
-      throw new Error("maxProperties is not supported");
-    }
-  }
-  if (Object.keys(breakages).length) {
-    return {
-      reason: "field-breakage",
-      fieldBreakages: breakages
-    };
-  }
-  return null;
-}
-function diffObjectProperties(oldProperties, newProperties, origin, oldRequiredProperties = [], newRequiredProperties = []) {
-  const allProperties = /* @__PURE__ */ new Set([
-    ...Object.keys(oldProperties),
-    ...Object.keys(newProperties)
-  ]);
-  const breakages = {};
-  for (const propertyName of allProperties) {
-    const requiredBreakage = diffRequired(
-      oldProperties[propertyName],
-      newProperties[propertyName],
-      origin,
-      oldRequiredProperties.includes(propertyName),
-      newRequiredProperties.includes(propertyName)
-    );
-    if (requiredBreakage) {
-      breakages[propertyName] = requiredBreakage;
-    } else if (oldProperties[propertyName] && newProperties[propertyName]) {
-      const propertyBreakage = diffJSONSchema(
-        oldProperties[propertyName],
-        newProperties[propertyName],
-        origin
-      );
-      if (propertyBreakage) {
-        breakages[propertyName] = propertyBreakage;
-      }
-    }
-  }
-  return breakages;
-}
-function getReportingType(schema) {
-  if ("not" in schema) {
-    return "not";
-  }
-  if ("anyOf" in schema) {
-    return "anyOf";
-  }
-  if ("allOf" in schema) {
-    return "allOf";
-  }
-  if ("$ref" in schema) {
-    return "$ref";
-  }
-  if (schema.type && typeof schema.type === "string") {
-    return schema.type;
-  }
-  throw new Error(
-    "Subschema not supported, probably a conditional subschema. Check logs."
-  );
-}
-
 // router/procedures.ts
 var import_typebox2 = require("@sinclair/typebox");
 function rpc({
@@ -1187,7 +724,7 @@ function Err(error) {
 var import_api = require("@opentelemetry/api");
 
 // package.json
-var version = "0.23.15";
+var version = "0.23.18";
 
 // tracing/index.ts
 function getPropagationContext(ctx) {
@@ -1595,7 +1132,7 @@ var RiverServer = class {
     this.services = instances;
     this.contextMap = /* @__PURE__ */ new Map();
     for (const [name, service] of Object.entries(services)) {
-      const instance = service.instantiate();
+      const instance = service.instantiate(extendedContext ?? {});
       instances[name] = instance;
       this.contextMap.set(instance, {
         ...extendedContext,
@@ -2045,7 +1582,6 @@ function createServerHandshakeOptions(schema, validate) {
   createClientHandshakeOptions,
   createServer,
   createServerHandshakeOptions,
-  diffServerSchema,
   serializeSchema
 });
 //# sourceMappingURL=index.cjs.map