@replit/river 0.23.12 → 0.23.14

package/dist/chunk-WUL63FR6.js

@@ -0,0 +1,335 @@
+import {
+  ProtocolError,
+  Transport
+} from "./chunk-OTVTKAN6.js";
+import {
+  defaultServerTransportOptions
+} from "./chunk-O2AVDJCQ.js";
+import {
+  ControlMessageHandshakeRequestSchema,
+  PROTOCOL_VERSION,
+  SESSION_STATE_MISMATCH,
+  coerceErrorString,
+  handshakeResponseMessage
+} from "./chunk-GCCRVSMR.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;
+  constructor(clientId, providedOptions) {
+    super(clientId, providedOptions);
+    this.options = {
+      ...defaultServerTransportOptions,
+      ...providedOptions
+    };
+    this.sessionHandshakeMetadata = /* @__PURE__ */ new WeakMap();
+    this.log?.info(`initiated server transport`, {
+      clientId: this.clientId,
+      protocolVersion: PROTOCOL_VERSION
+    });
+  }
+  extendHandshake(options) {
+    this.handshakeExtensions = options;
+  }
+  handleConnection(conn) {
+    if (this.getStatus() !== "open")
+      return;
+    this.log?.info(`new incoming connection`, {
+      ...conn.loggingMetadata,
+      clientId: this.clientId
+    });
+    let session = void 0;
+    const client = () => session?.to ?? "unknown";
+    const handshakeTimeout = setTimeout(() => {
+      if (!session) {
+        this.log?.warn(
+          `connection to ${client()} timed out waiting for handshake, closing`,
+          {
+            ...conn.loggingMetadata,
+            clientId: this.clientId,
+            connectedTo: client()
+          }
+        );
+        conn.telemetry?.span.setStatus({
+          code: SpanStatusCode.ERROR,
+          message: "handshake timeout"
+        });
+        conn.close();
+      }
+    }, this.options.sessionDisconnectGraceMs);
+    const buffer = [];
+    let receivedHandshakeMessage = false;
+    const handshakeHandler = (data) => {
+      if (receivedHandshakeMessage) {
+        buffer.push(data);
+        return;
+      }
+      receivedHandshakeMessage = true;
+      clearTimeout(handshakeTimeout);
+      void this.receiveHandshakeRequestMessage(data, conn).then(
+        (maybeSession) => {
+          if (!maybeSession) {
+            conn.close();
+            return;
+          }
+          session = maybeSession;
+          const dataHandler = (data2) => {
+            const parsed = this.parseMsg(data2, conn);
+            if (!parsed) {
+              conn.close();
+              return;
+            }
+            this.handleMsg(parsed, conn);
+          };
+          for (const data2 of buffer) {
+            dataHandler(data2);
+          }
+          conn.removeDataListener(handshakeHandler);
+          conn.addDataListener(dataHandler);
+          buffer.length = 0;
+        }
+      );
+    };
+    conn.addDataListener(handshakeHandler);
+    conn.addCloseListener(() => {
+      if (!session)
+        return;
+      this.log?.info(`connection to ${client()} disconnected`, {
+        ...conn.loggingMetadata,
+        clientId: this.clientId
+      });
+      this.onDisconnect(conn, session);
+    });
+    conn.addErrorListener((err) => {
+      conn.telemetry?.span.setStatus({
+        code: SpanStatusCode.ERROR,
+        message: "connection error"
+      });
+      if (!session)
+        return;
+      this.log?.warn(
+        `connection to ${client()} got an error: ${coerceErrorString(err)}`,
+        { ...conn.loggingMetadata, clientId: this.clientId }
+      );
+    });
+  }
+  async validateHandshakeMetadata(conn, session, rawMetadata, from) {
+    let parsedMetadata = {};
+    if (this.handshakeExtensions) {
+      if (!Value.Check(this.handshakeExtensions.schema, rawMetadata)) {
+        conn.telemetry?.span.setStatus({
+          code: SpanStatusCode.ERROR,
+          message: "malformed handshake meta"
+        });
+        const reason = "received malformed handshake metadata";
+        const responseMsg = handshakeResponseMessage({
+          from: this.clientId,
+          to: from,
+          status: {
+            ok: false,
+            reason
+          }
+        });
+        conn.send(this.codec.toBuffer(responseMsg));
+        this.log?.warn(`received malformed handshake metadata from ${from}`, {
+          ...conn.loggingMetadata,
+          clientId: this.clientId,
+          validationErrors: [
+            ...Value.Errors(this.handshakeExtensions.schema, rawMetadata)
+          ]
+        });
+        this.protocolError(ProtocolError.HandshakeFailed, reason);
+        return false;
+      }
+      const previousParsedMetadata = session ? this.sessionHandshakeMetadata.get(session) : void 0;
+      parsedMetadata = await this.handshakeExtensions.validate(
+        rawMetadata,
+        previousParsedMetadata
+      );
+      if (parsedMetadata === false) {
+        const reason = "rejected by handshake handler";
+        conn.telemetry?.span.setStatus({
+          code: SpanStatusCode.ERROR,
+          message: reason
+        });
+        const responseMsg = handshakeResponseMessage({
+          from: this.clientId,
+          to: from,
+          status: {
+            ok: false,
+            reason
+          }
+        });
+        conn.send(this.codec.toBuffer(responseMsg));
+        this.log?.warn(`rejected handshake from ${from}`, {
+          ...conn.loggingMetadata,
+          clientId: this.clientId
+        });
+        this.protocolError(ProtocolError.HandshakeFailed, reason);
+        return false;
+      }
+    }
+    return parsedMetadata;
+  }
+  async receiveHandshakeRequestMessage(data, conn) {
+    const parsed = this.parseMsg(data, conn);
+    if (!parsed) {
+      conn.telemetry?.span.setStatus({
+        code: SpanStatusCode.ERROR,
+        message: "non-transport message"
+      });
+      this.protocolError(
+        ProtocolError.HandshakeFailed,
+        "received non-transport message"
+      );
+      return false;
+    }
+    if (!Value.Check(ControlMessageHandshakeRequestSchema, parsed.payload)) {
+      conn.telemetry?.span.setStatus({
+        code: SpanStatusCode.ERROR,
+        message: "invalid handshake request"
+      });
+      const reason = "received invalid handshake msg";
+      const responseMsg2 = handshakeResponseMessage({
+        from: this.clientId,
+        to: parsed.from,
+        status: {
+          ok: false,
+          reason
+        }
+      });
+      conn.send(this.codec.toBuffer(responseMsg2));
+      this.log?.warn(reason, {
+        ...conn.loggingMetadata,
+        clientId: this.clientId,
+        // safe to this.log metadata here as we remove the payload
+        // before passing it to user-land
+        transportMessage: parsed,
+        validationErrors: [
+          ...Value.Errors(ControlMessageHandshakeRequestSchema, parsed.payload)
+        ]
+      });
+      this.protocolError(
+        ProtocolError.HandshakeFailed,
+        "invalid handshake request"
+      );
+      return false;
+    }
+    const gotVersion = parsed.payload.protocolVersion;
+    if (gotVersion !== PROTOCOL_VERSION) {
+      conn.telemetry?.span.setStatus({
+        code: SpanStatusCode.ERROR,
+        message: "incorrect protocol version"
+      });
+      const reason = `incorrect version (got: ${gotVersion} wanted ${PROTOCOL_VERSION})`;
+      const responseMsg2 = handshakeResponseMessage({
+        from: this.clientId,
+        to: parsed.from,
+        status: {
+          ok: false,
+          reason
+        }
+      });
+      conn.send(this.codec.toBuffer(responseMsg2));
+      this.log?.warn(
+        `received handshake msg with incompatible protocol version (got: ${gotVersion}, expected: ${PROTOCOL_VERSION})`,
+        { ...conn.loggingMetadata, clientId: this.clientId }
+      );
+      this.protocolError(ProtocolError.HandshakeFailed, reason);
+      return false;
+    }
+    const oldSession = this.sessions.get(parsed.from);
+    const parsedMetadata = await this.validateHandshakeMetadata(
+      conn,
+      oldSession,
+      parsed.payload.metadata,
+      parsed.from
+    );
+    if (parsedMetadata === false) {
+      return false;
+    }
+    let session;
+    let isTransparentReconnect;
+    if (!parsed.payload.expectedSessionState) {
+      ({ session, isTransparentReconnect } = this.getOrCreateSession({
+        to: parsed.from,
+        conn,
+        sessionId: parsed.payload.sessionId,
+        propagationCtx: parsed.tracing
+      }));
+    } else if (parsed.payload.expectedSessionState.reconnect) {
+      const existingSession = this.getExistingSession({
+        to: parsed.from,
+        sessionId: parsed.payload.sessionId,
+        nextExpectedSeq: parsed.payload.expectedSessionState.nextExpectedSeq
+      });
+      if (existingSession === false) {
+        conn.telemetry?.span.setStatus({
+          code: SpanStatusCode.ERROR,
+          message: SESSION_STATE_MISMATCH
+        });
+        const reason = SESSION_STATE_MISMATCH;
+        const responseMsg2 = handshakeResponseMessage({
+          from: this.clientId,
+          to: parsed.from,
+          status: {
+            ok: false,
+            reason
+          }
+        });
+        conn.send(this.codec.toBuffer(responseMsg2));
+        this.log?.warn(
+          `'received handshake msg with incompatible existing session state: ${parsed.payload.sessionId}`,
+          { ...conn.loggingMetadata, clientId: this.clientId }
+        );
+        this.protocolError(ProtocolError.HandshakeFailed, reason);
+        return false;
+      }
+      session = existingSession;
+      isTransparentReconnect = false;
+    } else {
+      const createdSession = this.createNewSession({
+        to: parsed.from,
+        conn,
+        sessionId: parsed.payload.sessionId,
+        propagationCtx: parsed.tracing
+      });
+      session = createdSession;
+      isTransparentReconnect = false;
+    }
+    this.sessionHandshakeMetadata.set(session, parsedMetadata);
+    this.log?.debug(
+      `handshake from ${parsed.from} ok, responding with handshake success`,
+      conn.loggingMetadata
+    );
+    const responseMsg = handshakeResponseMessage({
+      from: this.clientId,
+      to: parsed.from,
+      status: {
+        ok: true,
+        sessionId: session.id
+      }
+    });
+    conn.send(this.codec.toBuffer(responseMsg));
+    this.onConnect(conn, session, isTransparentReconnect);
+    return session;
+  }
+};
+
+export {
+  ServerTransport
+};
+//# sourceMappingURL=chunk-WUL63FR6.js.map

package/dist/chunk-WUL63FR6.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.sessionDisconnectGraceMs);\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":"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","names":["data","responseMsg"]}

package/dist/{chunk-H6KTH6W6.js → chunk-YCLZWES2.js}

@@ -1,6 +1,6 @@
 import {
   Connection
-} from "./chunk-VRU4IKRT.js";
+} from "./chunk-O2AVDJCQ.js";
 
 // transport/transforms/messageFraming.ts
 import { Transform } from "node:stream";
@@ -103,4 +103,4 @@ var UdsConnection = class extends Connection {
 export {
   UdsConnection
 };
-//# sourceMappingURL=chunk-H6KTH6W6.js.map
+//# sourceMappingURL=chunk-YCLZWES2.js.map

package/dist/client-e13979ac.d.ts

@@ -0,0 +1,52 @@
+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 TransportClientId } from './index-ea74cdbb.js';
+
+declare abstract class ClientTransport<ConnType extends Connection> extends Transport<ConnType> {
+    /**
+     * The options for this transport.
+     */
+    protected options: ClientTransportOptions;
+    /**
+     * The map of reconnect promises for each client ID.
+     */
+    inflightConnectionPromises: Map<TransportClientId, Promise<ConnType>>;
+    retryBudget: LeakyBucketRateLimit;
+    /**
+     * A flag indicating whether the transport should automatically reconnect
+     * when a connection is dropped.
+     * Realistically, this should always be true for clients unless you are writing
+     * tests or a special case where you don't want to reconnect.
+     */
+    reconnectOnConnectionDrop: boolean;
+    /**
+     * Optional handshake options for this client.
+     */
+    handshakeExtensions?: ClientHandshakeOptions;
+    constructor(clientId: TransportClientId, providedOptions?: ProvidedClientTransportOptions);
+    extendHandshake(options: ClientHandshakeOptions): void;
+    protected handleConnection(conn: ConnType, to: TransportClientId): void;
+    receiveHandshakeResponseMessage(data: Uint8Array, conn: ConnType): Session<ConnType> | false;
+    /**
+     * Abstract method that creates a new {@link Connection} object.
+     * This should call {@link handleConnection} when the connection is created.
+     * The downstream client implementation needs to implement this.
+     *
+     * @param to The client ID of the node to connect to.
+     * @returns The new connection object.
+     */
+    protected abstract createNewOutgoingConnection(to: TransportClientId): Promise<ConnType>;
+    /**
+     * Manually attempts to connect to a client.
+     * @param to The client ID of the node to connect to.
+     */
+    connect(to: TransportClientId): Promise<void>;
+    protected deleteSession({ session, closeHandshakingConnection, handshakingConn, }: {
+        session: Session<ConnType>;
+        closeHandshakingConnection: boolean;
+        handshakingConn?: ConnType;
+    }): void;
+    protected sendHandshake(to: TransportClientId, conn: ConnType): Promise<boolean>;
+    close(): void;
+}
+
+export { ClientTransport as C };

package/dist/codec/index.js

@@ -1,7 +1,25 @@
 import {
-  BinaryCodec,
   NaiveJsonCodec
-} from "../chunk-3AW3IXVD.js";
+} from "../chunk-4PVU7J25.js";
+
+// codec/binary.ts
+import { decode, encode } from "@msgpack/msgpack";
+var BinaryCodec = {
+  toBuffer(obj) {
+    return encode(obj, { ignoreUndefined: true });
+  },
+  fromBuffer: (buff) => {
+    try {
+      const res = decode(buff);
+      if (typeof res !== "object") {
+        return null;
+      }
+      return res;
+    } catch {
+      return null;
+    }
+  }
+};
 export {
   BinaryCodec,
   NaiveJsonCodec

package/dist/codec/index.js.map

@@ -1 +1 @@
-{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}
+{"version":3,"sources":["../../codec/binary.ts"],"sourcesContent":["import { decode, encode } from '@msgpack/msgpack';\nimport { Codec } from './types';\n\n/**\n * Binary codec, uses [msgpack](https://www.npmjs.com/package/@msgpack/msgpack) under the hood\n * @type {Codec}\n */\nexport const BinaryCodec: Codec = {\n  toBuffer(obj) {\n    return encode(obj, { ignoreUndefined: true });\n  },\n  fromBuffer: (buff: Uint8Array) => {\n    try {\n      const res = decode(buff);\n      if (typeof res !== 'object') {\n        return null;\n      }\n\n      return res;\n    } catch {\n      return null;\n    }\n  },\n};\n"],"mappings":";;;;;AAAA,SAAS,QAAQ,cAAc;AAOxB,IAAM,cAAqB;AAAA,EAChC,SAAS,KAAK;AACZ,WAAO,OAAO,KAAK,EAAE,iBAAiB,KAAK,CAAC;AAAA,EAC9C;AAAA,EACA,YAAY,CAAC,SAAqB;AAChC,QAAI;AACF,YAAM,MAAM,OAAO,IAAI;AACvB,UAAI,OAAO,QAAQ,UAAU;AAC3B,eAAO;AAAA,MACT;AAEA,aAAO;AAAA,IACT,QAAQ;AACN,aAAO;AAAA,IACT;AAAA,EACF;AACF;","names":[]}

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

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

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

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