@replit/river 0.24.3 → 0.25.1

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

@@ -1,1650 +0,0 @@
-"use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-
-// transport/impls/uds/server.ts
-var server_exports = {};
-__export(server_exports, {
-  UnixDomainSocketServerTransport: () => UnixDomainSocketServerTransport
-});
-module.exports = __toCommonJS(server_exports);
-
-// transport/transforms/messageFraming.ts
-var import_node_stream = require("stream");
-var Uint32LengthPrefixFraming = class extends import_node_stream.Transform {
-  receivedBuffer;
-  maxBufferSizeBytes;
-  constructor({ maxBufferSizeBytes, ...options }) {
-    super(options);
-    this.maxBufferSizeBytes = maxBufferSizeBytes;
-    this.receivedBuffer = Buffer.alloc(0);
-  }
-  _transform(chunk, _encoding, cb) {
-    if (this.receivedBuffer.byteLength + chunk.byteLength > this.maxBufferSizeBytes) {
-      const err = new Error(
-        `buffer overflow: ${this.receivedBuffer.byteLength}B > ${this.maxBufferSizeBytes}B`
-      );
-      this.emit("error", err);
-      cb(err);
-      return;
-    }
-    this.receivedBuffer = Buffer.concat([this.receivedBuffer, chunk]);
-    while (this.receivedBuffer.length > 4) {
-      const claimedMessageLength = this.receivedBuffer.readUInt32BE(0) + 4;
-      if (this.receivedBuffer.length >= claimedMessageLength) {
-        const message = this.receivedBuffer.subarray(4, claimedMessageLength);
-        this.push(message);
-        this.receivedBuffer = this.receivedBuffer.subarray(claimedMessageLength);
-      } else {
-        break;
-      }
-    }
-    cb();
-  }
-  _flush(cb) {
-    this.receivedBuffer = Buffer.alloc(0);
-    cb();
-  }
-  _destroy(error, callback) {
-    this.receivedBuffer = Buffer.alloc(0);
-    super._destroy(error, callback);
-  }
-};
-function createLengthEncodedStream(options) {
-  return new Uint32LengthPrefixFraming({
-    maxBufferSizeBytes: options?.maxBufferSizeBytes ?? 16 * 1024 * 1024
-    // 16MB
-  });
-}
-var MessageFramer = {
-  createFramedStream: createLengthEncodedStream,
-  write: (buf) => {
-    const lengthPrefix = Buffer.alloc(4);
-    lengthPrefix.writeUInt32BE(buf.length, 0);
-    return Buffer.concat([lengthPrefix, buf]);
-  }
-};
-
-// transport/id.ts
-var import_nanoid = require("nanoid");
-var alphabet = (0, import_nanoid.customAlphabet)(
-  "1234567890abcdefghijklmnopqrstuvxyzABCDEFGHIJKLMNOPQRSTUVXYZ"
-);
-var generateId = () => alphabet(12);
-
-// transport/connection.ts
-var Connection = class {
-  id;
-  telemetry;
-  constructor() {
-    this.id = `conn-${generateId()}`;
-  }
-  get loggingMetadata() {
-    const metadata = { connId: this.id };
-    const spanContext = this.telemetry?.span.spanContext();
-    if (this.telemetry?.span.isRecording() && spanContext) {
-      metadata.telemetry = {
-        traceId: spanContext.traceId,
-        spanId: spanContext.spanId
-      };
-    }
-    return metadata;
-  }
-  // can't use event emitter because we need this to work in both node + browser
-  _dataListeners = /* @__PURE__ */ new Set();
-  _closeListeners = /* @__PURE__ */ new Set();
-  _errorListeners = /* @__PURE__ */ new Set();
-  get dataListeners() {
-    return [...this._dataListeners];
-  }
-  get closeListeners() {
-    return [...this._closeListeners];
-  }
-  get errorListeners() {
-    return [...this._errorListeners];
-  }
-  /**
-   * Handle adding a callback for when a message is received.
-   * @param msg The message that was received.
-   */
-  addDataListener(cb) {
-    this._dataListeners.add(cb);
-  }
-  removeDataListener(cb) {
-    this._dataListeners.delete(cb);
-  }
-  /**
-   * Handle adding a callback for when the connection is closed.
-   * This should also be called if an error happens and after notifying all the error listeners.
-   * @param cb The callback to call when the connection is closed.
-   */
-  addCloseListener(cb) {
-    this._closeListeners.add(cb);
-  }
-  removeCloseListener(cb) {
-    this._closeListeners.delete(cb);
-  }
-  /**
-   * Handle adding a callback for when an error is received.
-   * This should only be used for this.logging errors, all cleanup
-   * should be delegated to addCloseListener.
-   *
-   * The implementer should take care such that the implemented
-   * connection will call both the close and error callbacks
-   * on an error.
-   *
-   * @param cb The callback to call when an error is received.
-   */
-  addErrorListener(cb) {
-    this._errorListeners.add(cb);
-  }
-  removeErrorListener(cb) {
-    this._errorListeners.delete(cb);
-  }
-};
-
-// transport/impls/uds/connection.ts
-var UdsConnection = class extends Connection {
-  sock;
-  input;
-  framer;
-  constructor(sock) {
-    super();
-    this.framer = MessageFramer.createFramedStream();
-    this.sock = sock;
-    this.input = sock.pipe(this.framer);
-    this.sock.on("close", () => {
-      for (const cb of this.closeListeners) {
-        cb();
-      }
-    });
-    this.sock.on("error", (err) => {
-      if (err instanceof Error && "code" in err && err.code === "EPIPE") {
-        return;
-      }
-      for (const cb of this.errorListeners) {
-        cb(err);
-      }
-    });
-    this.input.on("data", (msg) => {
-      for (const cb of this.dataListeners) {
-        cb(msg);
-      }
-    });
-  }
-  send(payload) {
-    if (this.framer.destroyed || !this.sock.writable || this.sock.closed) {
-      return false;
-    }
-    this.sock.write(MessageFramer.write(payload));
-    return true;
-  }
-  close() {
-    this.sock.destroy();
-    this.framer.destroy();
-  }
-};
-
-// transport/server.ts
-var import_api3 = require("@opentelemetry/api");
-
-// transport/message.ts
-var import_typebox = require("@sinclair/typebox");
-var TransportMessageSchema = (t) => import_typebox.Type.Object({
-  id: import_typebox.Type.String(),
-  from: import_typebox.Type.String(),
-  to: import_typebox.Type.String(),
-  seq: import_typebox.Type.Integer(),
-  ack: import_typebox.Type.Integer(),
-  serviceName: import_typebox.Type.Optional(import_typebox.Type.String()),
-  procedureName: import_typebox.Type.Optional(import_typebox.Type.String()),
-  streamId: import_typebox.Type.String(),
-  controlFlags: import_typebox.Type.Integer(),
-  tracing: import_typebox.Type.Optional(
-    import_typebox.Type.Object({
-      traceparent: import_typebox.Type.String(),
-      tracestate: import_typebox.Type.String()
-    })
-  ),
-  payload: t
-});
-var ControlMessageAckSchema = import_typebox.Type.Object({
-  type: import_typebox.Type.Literal("ACK")
-});
-var ControlMessageCloseSchema = import_typebox.Type.Object({
-  type: import_typebox.Type.Literal("CLOSE")
-});
-var PROTOCOL_VERSION = "v1.1";
-var ControlMessageHandshakeRequestSchema = import_typebox.Type.Object({
-  type: import_typebox.Type.Literal("HANDSHAKE_REQ"),
-  protocolVersion: import_typebox.Type.String(),
-  sessionId: import_typebox.Type.String(),
-  /**
-   * Specifies what the server's expected session state (from the pov of the client). This can be
-   * used by the server to know whether this is a new or a reestablished connection, and whether it
-   * is compatible with what it already has.
-   */
-  expectedSessionState: import_typebox.Type.Object({
-    // what the client expects the server to send next
-    nextExpectedSeq: import_typebox.Type.Integer(),
-    // TODO: remove optional once we know all servers
-    // are nextSentSeq here
-    // what the server expects the client to send next
-    nextSentSeq: import_typebox.Type.Optional(import_typebox.Type.Integer())
-  }),
-  metadata: import_typebox.Type.Optional(import_typebox.Type.Unknown())
-});
-var HandshakeErrorRetriableResponseCodes = import_typebox.Type.Union([
-  import_typebox.Type.Literal("SESSION_STATE_MISMATCH")
-]);
-var HandshakeErrorFatalResponseCodes = import_typebox.Type.Union([
-  import_typebox.Type.Literal("MALFORMED_HANDSHAKE_META"),
-  import_typebox.Type.Literal("MALFORMED_HANDSHAKE"),
-  import_typebox.Type.Literal("PROTOCOL_VERSION_MISMATCH"),
-  import_typebox.Type.Literal("REJECTED_BY_CUSTOM_HANDLER")
-]);
-var HandshakeErrorResponseCodes = import_typebox.Type.Union([
-  HandshakeErrorRetriableResponseCodes,
-  HandshakeErrorFatalResponseCodes
-]);
-var ControlMessageHandshakeResponseSchema = import_typebox.Type.Object({
-  type: import_typebox.Type.Literal("HANDSHAKE_RESP"),
-  status: import_typebox.Type.Union([
-    import_typebox.Type.Object({
-      ok: import_typebox.Type.Literal(true),
-      sessionId: import_typebox.Type.String()
-    }),
-    import_typebox.Type.Object({
-      ok: import_typebox.Type.Literal(false),
-      reason: import_typebox.Type.String(),
-      // TODO: remove optional once we know all servers
-      // are sending code here
-      code: import_typebox.Type.Optional(HandshakeErrorResponseCodes)
-    })
-  ])
-});
-var ControlMessagePayloadSchema = import_typebox.Type.Union([
-  ControlMessageCloseSchema,
-  ControlMessageAckSchema,
-  ControlMessageHandshakeRequestSchema,
-  ControlMessageHandshakeResponseSchema
-]);
-var OpaqueTransportMessageSchema = TransportMessageSchema(
-  import_typebox.Type.Unknown()
-);
-function handshakeResponseMessage({
-  from,
-  to,
-  status
-}) {
-  return {
-    id: generateId(),
-    from,
-    to,
-    seq: 0,
-    ack: 0,
-    streamId: generateId(),
-    controlFlags: 0,
-    payload: {
-      type: "HANDSHAKE_RESP",
-      status
-    }
-  };
-}
-function isAck(controlFlag) {
-  return (controlFlag & 1 /* AckBit */) === 1 /* AckBit */;
-}
-
-// codec/json.ts
-var encoder = new TextEncoder();
-var decoder = new TextDecoder();
-function uint8ArrayToBase64(uint8Array) {
-  let binary = "";
-  uint8Array.forEach((byte) => {
-    binary += String.fromCharCode(byte);
-  });
-  return btoa(binary);
-}
-function base64ToUint8Array(base64) {
-  const binaryString = atob(base64);
-  const uint8Array = new Uint8Array(binaryString.length);
-  for (let i = 0; i < binaryString.length; i++) {
-    uint8Array[i] = binaryString.charCodeAt(i);
-  }
-  return uint8Array;
-}
-var NaiveJsonCodec = {
-  toBuffer: (obj) => {
-    return encoder.encode(
-      JSON.stringify(obj, function replacer(key) {
-        const val = this[key];
-        if (val instanceof Uint8Array) {
-          return { $t: uint8ArrayToBase64(val) };
-        } else {
-          return val;
-        }
-      })
-    );
-  },
-  fromBuffer: (buff) => {
-    try {
-      const parsed = JSON.parse(
-        decoder.decode(buff),
-        function reviver(_key, val) {
-          if (val?.$t) {
-            return base64ToUint8Array(val.$t);
-          } else {
-            return val;
-          }
-        }
-      );
-      if (typeof parsed === "object")
-        return parsed;
-      return null;
-    } catch {
-      return null;
-    }
-  }
-};
-
-// transport/options.ts
-var defaultTransportOptions = {
-  heartbeatIntervalMs: 1e3,
-  heartbeatsUntilDead: 2,
-  sessionDisconnectGraceMs: 5e3,
-  connectionTimeoutMs: 2e3,
-  handshakeTimeoutMs: 1e3,
-  codec: NaiveJsonCodec
-};
-var defaultConnectionRetryOptions = {
-  baseIntervalMs: 250,
-  maxJitterMs: 200,
-  maxBackoffMs: 32e3,
-  attemptBudgetCapacity: 5,
-  budgetRestoreIntervalMs: 200
-};
-var defaultClientTransportOptions = {
-  ...defaultTransportOptions,
-  ...defaultConnectionRetryOptions
-};
-var defaultServerTransportOptions = {
-  ...defaultTransportOptions
-};
-
-// logging/log.ts
-var LoggingLevels = {
-  debug: -1,
-  info: 0,
-  warn: 1,
-  error: 2
-};
-var cleanedLogFn = (log) => {
-  return (msg, metadata) => {
-    if (!metadata?.transportMessage) {
-      log(msg, metadata);
-      return;
-    }
-    const { payload, ...rest } = metadata.transportMessage;
-    metadata.transportMessage = rest;
-    log(msg, metadata);
-  };
-};
-var BaseLogger = class {
-  minLevel;
-  output;
-  constructor(output, minLevel = "info") {
-    this.minLevel = minLevel;
-    this.output = output;
-  }
-  debug(msg, metadata) {
-    if (LoggingLevels[this.minLevel] <= LoggingLevels.debug) {
-      this.output(msg, metadata ?? {}, "debug");
-    }
-  }
-  info(msg, metadata) {
-    if (LoggingLevels[this.minLevel] <= LoggingLevels.info) {
-      this.output(msg, metadata ?? {}, "info");
-    }
-  }
-  warn(msg, metadata) {
-    if (LoggingLevels[this.minLevel] <= LoggingLevels.warn) {
-      this.output(msg, metadata ?? {}, "warn");
-    }
-  }
-  error(msg, metadata) {
-    if (LoggingLevels[this.minLevel] <= LoggingLevels.error) {
-      this.output(msg, metadata ?? {}, "error");
-    }
-  }
-};
-var createLogProxy = (log) => ({
-  debug: cleanedLogFn(log.debug.bind(log)),
-  info: cleanedLogFn(log.info.bind(log)),
-  warn: cleanedLogFn(log.warn.bind(log)),
-  error: cleanedLogFn(log.error.bind(log))
-});
-
-// transport/events.ts
-var ProtocolError = {
-  RetriesExceeded: "conn_retry_exceeded",
-  HandshakeFailed: "handshake_failed",
-  MessageOrderingViolated: "message_ordering_violated"
-};
-var EventDispatcher = class {
-  eventListeners = {};
-  removeAllListeners() {
-    this.eventListeners = {};
-  }
-  numberOfListeners(eventType) {
-    return this.eventListeners[eventType]?.size ?? 0;
-  }
-  addEventListener(eventType, handler) {
-    if (!this.eventListeners[eventType]) {
-      this.eventListeners[eventType] = /* @__PURE__ */ new Set();
-    }
-    this.eventListeners[eventType]?.add(handler);
-  }
-  removeEventListener(eventType, handler) {
-    const handlers = this.eventListeners[eventType];
-    if (handlers) {
-      this.eventListeners[eventType]?.delete(handler);
-    }
-  }
-  dispatchEvent(eventType, event) {
-    const handlers = this.eventListeners[eventType];
-    if (handlers) {
-      const copy = [...handlers];
-      for (const handler of copy) {
-        handler(event);
-      }
-    }
-  }
-};
-
-// transport/sessionStateMachine/common.ts
-var import_value = require("@sinclair/typebox/value");
-var ERR_CONSUMED = `session state has been consumed and is no longer valid`;
-var StateMachineState = class {
-  /*
-   * Whether this state has been consumed
-   * and we've moved on to another state
-   */
-  _isConsumed;
-  close() {
-    this._handleClose();
-  }
-  constructor() {
-    this._isConsumed = false;
-    return new Proxy(this, {
-      get(target, prop) {
-        if (prop === "_isConsumed" || prop === "id" || prop === "state") {
-          return Reflect.get(target, prop);
-        }
-        if (prop === "_handleStateExit") {
-          return () => {
-            target._isConsumed = true;
-            target._handleStateExit();
-          };
-        }
-        if (prop === "_handleClose") {
-          return () => {
-            target._handleStateExit();
-            target._handleClose();
-          };
-        }
-        if (target._isConsumed) {
-          throw new Error(
-            `${ERR_CONSUMED}: getting ${prop.toString()} on consumed state`
-          );
-        }
-        return Reflect.get(target, prop);
-      },
-      set(target, prop, value) {
-        if (target._isConsumed) {
-          throw new Error(
-            `${ERR_CONSUMED}: setting ${prop.toString()} on consumed state`
-          );
-        }
-        return Reflect.set(target, prop, value);
-      }
-    });
-  }
-};
-var CommonSession = class extends StateMachineState {
-  from;
-  options;
-  log;
-  constructor(from, options, log) {
-    super();
-    this.from = from;
-    this.options = options;
-    this.log = log;
-  }
-  parseMsg(msg) {
-    const parsedMsg = this.options.codec.fromBuffer(msg);
-    if (parsedMsg === null) {
-      const decodedBuffer = new TextDecoder().decode(Buffer.from(msg));
-      this.log?.error(
-        `received malformed msg: ${decodedBuffer}`,
-        this.loggingMetadata
-      );
-      return null;
-    }
-    if (!import_value.Value.Check(OpaqueTransportMessageSchema, parsedMsg)) {
-      this.log?.error(`received invalid msg: ${JSON.stringify(parsedMsg)}`, {
-        ...this.loggingMetadata,
-        validationErrors: [
-          ...import_value.Value.Errors(OpaqueTransportMessageSchema, parsedMsg)
-        ]
-      });
-      return null;
-    }
-    return parsedMsg;
-  }
-};
-var IdentifiedSession = class extends CommonSession {
-  id;
-  telemetry;
-  to;
-  /**
-   * Index of the message we will send next (excluding handshake)
-   */
-  seq;
-  /**
-   * Number of unique messages we've received this session (excluding handshake)
-   */
-  ack;
-  sendBuffer;
-  constructor(id, from, to, seq, ack, sendBuffer, telemetry, options, log) {
-    super(from, options, log);
-    this.id = id;
-    this.to = to;
-    this.seq = seq;
-    this.ack = ack;
-    this.sendBuffer = sendBuffer;
-    this.telemetry = telemetry;
-    this.log = log;
-  }
-  get loggingMetadata() {
-    const spanContext = this.telemetry.span.spanContext();
-    return {
-      clientId: this.from,
-      connectedTo: this.to,
-      sessionId: this.id,
-      telemetry: {
-        traceId: spanContext.traceId,
-        spanId: spanContext.spanId
-      }
-    };
-  }
-  constructMsg(partialMsg) {
-    const msg = {
-      ...partialMsg,
-      id: generateId(),
-      to: this.to,
-      from: this.from,
-      seq: this.seq,
-      ack: this.ack
-    };
-    this.seq++;
-    return msg;
-  }
-  nextSeq() {
-    return this.sendBuffer.length > 0 ? this.sendBuffer[0].seq : this.seq;
-  }
-  send(msg) {
-    const constructedMsg = this.constructMsg(msg);
-    this.sendBuffer.push(constructedMsg);
-    return constructedMsg.id;
-  }
-  _handleStateExit() {
-  }
-  _handleClose() {
-    this.sendBuffer.length = 0;
-    this.telemetry.span.end();
-  }
-};
-
-// transport/sessionStateMachine/SessionConnecting.ts
-var SessionConnecting = class extends IdentifiedSession {
-  state = "Connecting" /* Connecting */;
-  connPromise;
-  listeners;
-  connectionTimeout;
-  constructor(connPromise, listeners, ...args) {
-    super(...args);
-    this.connPromise = connPromise;
-    this.listeners = listeners;
-    this.connectionTimeout = setTimeout(() => {
-      listeners.onConnectionTimeout();
-    }, this.options.connectionTimeoutMs);
-    connPromise.then(
-      (conn) => {
-        if (this._isConsumed)
-          return;
-        listeners.onConnectionEstablished(conn);
-      },
-      (err) => {
-        if (this._isConsumed)
-          return;
-        listeners.onConnectionFailed(err);
-      }
-    );
-  }
-  // close a pending connection if it resolves, ignore errors if the promise
-  // ends up rejected anyways
-  bestEffortClose() {
-    void this.connPromise.then((conn) => conn.close()).catch(() => {
-    });
-  }
-  _handleStateExit() {
-    super._handleStateExit();
-    clearTimeout(this.connectionTimeout);
-    this.connectionTimeout = void 0;
-  }
-  _handleClose() {
-    this.bestEffortClose();
-    super._handleClose();
-  }
-};
-
-// transport/sessionStateMachine/SessionNoConnection.ts
-var SessionNoConnection = class extends IdentifiedSession {
-  state = "NoConnection" /* NoConnection */;
-  listeners;
-  gracePeriodTimeout;
-  constructor(listeners, ...args) {
-    super(...args);
-    this.listeners = listeners;
-    this.gracePeriodTimeout = setTimeout(() => {
-      this.listeners.onSessionGracePeriodElapsed();
-    }, this.options.sessionDisconnectGraceMs);
-  }
-  _handleClose() {
-    super._handleClose();
-  }
-  _handleStateExit() {
-    super._handleStateExit();
-    if (this.gracePeriodTimeout) {
-      clearTimeout(this.gracePeriodTimeout);
-      this.gracePeriodTimeout = void 0;
-    }
-  }
-};
-
-// tracing/index.ts
-var import_api = require("@opentelemetry/api");
-
-// package.json
-var version = "0.24.3";
-
-// tracing/index.ts
-function createSessionTelemetryInfo(sessionId, to, from, propagationCtx) {
-  const parentCtx = propagationCtx ? import_api.propagation.extract(import_api.context.active(), propagationCtx) : import_api.context.active();
-  const span = tracer.startSpan(
-    `session ${sessionId}`,
-    {
-      attributes: {
-        component: "river",
-        "river.session.id": sessionId,
-        "river.session.to": to,
-        "river.session.from": from
-      }
-    },
-    parentCtx
-  );
-  const ctx = import_api.trace.setSpan(parentCtx, span);
-  return { span, ctx };
-}
-var tracer = import_api.trace.getTracer("river", version);
-
-// transport/sessionStateMachine/SessionWaitingForHandshake.ts
-var SessionWaitingForHandshake = class extends CommonSession {
-  state = "WaitingForHandshake" /* WaitingForHandshake */;
-  conn;
-  listeners;
-  handshakeTimeout;
-  constructor(conn, listeners, ...args) {
-    super(...args);
-    this.conn = conn;
-    this.listeners = listeners;
-    this.handshakeTimeout = setTimeout(() => {
-      listeners.onHandshakeTimeout();
-    }, this.options.handshakeTimeoutMs);
-    this.conn.addDataListener(this.onHandshakeData);
-    this.conn.addErrorListener(listeners.onConnectionErrored);
-    this.conn.addCloseListener(listeners.onConnectionClosed);
-  }
-  onHandshakeData = (msg) => {
-    const parsedMsg = this.parseMsg(msg);
-    if (parsedMsg === null) {
-      this.listeners.onInvalidHandshake("could not parse message");
-      return;
-    }
-    this.listeners.onHandshake(parsedMsg);
-  };
-  get loggingMetadata() {
-    return {
-      clientId: this.from,
-      connId: this.conn.id
-    };
-  }
-  sendHandshake(msg) {
-    return this.conn.send(this.options.codec.toBuffer(msg));
-  }
-  _handleStateExit() {
-    this.conn.removeDataListener(this.onHandshakeData);
-    this.conn.removeErrorListener(this.listeners.onConnectionErrored);
-    this.conn.removeCloseListener(this.listeners.onConnectionClosed);
-    clearTimeout(this.handshakeTimeout);
-    this.handshakeTimeout = void 0;
-  }
-  _handleClose() {
-    this.conn.close();
-  }
-};
-
-// transport/sessionStateMachine/SessionHandshaking.ts
-var SessionHandshaking = class extends IdentifiedSession {
-  state = "Handshaking" /* Handshaking */;
-  conn;
-  listeners;
-  handshakeTimeout;
-  constructor(conn, listeners, ...args) {
-    super(...args);
-    this.conn = conn;
-    this.listeners = listeners;
-    this.handshakeTimeout = setTimeout(() => {
-      listeners.onHandshakeTimeout();
-    }, this.options.handshakeTimeoutMs);
-    this.conn.addDataListener(this.onHandshakeData);
-    this.conn.addErrorListener(listeners.onConnectionErrored);
-    this.conn.addCloseListener(listeners.onConnectionClosed);
-  }
-  onHandshakeData = (msg) => {
-    const parsedMsg = this.parseMsg(msg);
-    if (parsedMsg === null) {
-      this.listeners.onInvalidHandshake("could not parse message");
-      return;
-    }
-    this.listeners.onHandshake(parsedMsg);
-  };
-  sendHandshake(msg) {
-    return this.conn.send(this.options.codec.toBuffer(msg));
-  }
-  _handleStateExit() {
-    super._handleStateExit();
-    this.conn.removeDataListener(this.onHandshakeData);
-    this.conn.removeErrorListener(this.listeners.onConnectionErrored);
-    this.conn.removeCloseListener(this.listeners.onConnectionClosed);
-    clearTimeout(this.handshakeTimeout);
-  }
-  _handleClose() {
-    super._handleClose();
-    this.conn.close();
-  }
-};
-
-// transport/sessionStateMachine/SessionConnected.ts
-var import_api2 = require("@opentelemetry/api");
-var SessionConnected = class extends IdentifiedSession {
-  state = "Connected" /* Connected */;
-  conn;
-  listeners;
-  heartbeatHandle;
-  heartbeatMisses = 0;
-  get isActivelyHeartbeating() {
-    return this.heartbeatHandle !== void 0;
-  }
-  updateBookkeeping(ack, seq) {
-    this.sendBuffer = this.sendBuffer.filter((unacked) => unacked.seq >= ack);
-    this.ack = seq + 1;
-    this.heartbeatMisses = 0;
-  }
-  send(msg) {
-    const constructedMsg = this.constructMsg(msg);
-    this.sendBuffer.push(constructedMsg);
-    this.conn.send(this.options.codec.toBuffer(constructedMsg));
-    return constructedMsg.id;
-  }
-  constructor(conn, listeners, ...args) {
-    super(...args);
-    this.conn = conn;
-    this.listeners = listeners;
-    this.conn.addDataListener(this.onMessageData);
-    this.conn.addCloseListener(listeners.onConnectionClosed);
-    this.conn.addErrorListener(listeners.onConnectionErrored);
-    if (this.sendBuffer.length > 0) {
-      this.log?.debug(
-        `sending ${this.sendBuffer.length} buffered messages`,
-        this.loggingMetadata
-      );
-    }
-    for (const msg of this.sendBuffer) {
-      conn.send(this.options.codec.toBuffer(msg));
-    }
-  }
-  startActiveHeartbeat() {
-    this.heartbeatHandle = setInterval(() => {
-      const misses = this.heartbeatMisses;
-      const missDuration = misses * this.options.heartbeatIntervalMs;
-      if (misses >= this.options.heartbeatsUntilDead) {
-        this.log?.info(
-          `closing connection to ${this.to} due to inactivity (missed ${misses} heartbeats which is ${missDuration}ms)`,
-          this.loggingMetadata
-        );
-        this.telemetry.span.addEvent("closing connection due to inactivity");
-        this.conn.close();
-        clearInterval(this.heartbeatHandle);
-        this.heartbeatHandle = void 0;
-        return;
-      }
-      this.sendHeartbeat();
-      this.heartbeatMisses++;
-    }, this.options.heartbeatIntervalMs);
-  }
-  sendHeartbeat() {
-    this.send({
-      streamId: "heartbeat",
-      controlFlags: 1 /* AckBit */,
-      payload: {
-        type: "ACK"
-      }
-    });
-  }
-  onMessageData = (msg) => {
-    const parsedMsg = this.parseMsg(msg);
-    if (parsedMsg === null)
-      return;
-    if (parsedMsg.seq !== this.ack) {
-      if (parsedMsg.seq < this.ack) {
-        this.log?.debug(
-          `received duplicate msg (got seq: ${parsedMsg.seq}, wanted seq: ${this.ack}), discarding`,
-          {
-            ...this.loggingMetadata,
-            transportMessage: parsedMsg
-          }
-        );
-      } else {
-        const reason = `received out-of-order msg (got seq: ${parsedMsg.seq}, wanted seq: ${this.ack})`;
-        this.log?.error(reason, {
-          ...this.loggingMetadata,
-          transportMessage: parsedMsg,
-          tags: ["invariant-violation"]
-        });
-        this.telemetry.span.setStatus({
-          code: import_api2.SpanStatusCode.ERROR,
-          message: reason
-        });
-        this.listeners.onInvalidMessage(reason);
-      }
-      return;
-    }
-    this.log?.debug(`received msg`, {
-      ...this.loggingMetadata,
-      transportMessage: parsedMsg
-    });
-    this.updateBookkeeping(parsedMsg.ack, parsedMsg.seq);
-    if (!isAck(parsedMsg.controlFlags)) {
-      this.listeners.onMessage(parsedMsg);
-      return;
-    }
-    this.log?.debug(`discarding msg (ack bit set)`, {
-      ...this.loggingMetadata,
-      transportMessage: parsedMsg
-    });
-    if (!this.isActivelyHeartbeating) {
-      this.sendHeartbeat();
-    }
-  };
-  _handleStateExit() {
-    super._handleStateExit();
-    this.conn.removeDataListener(this.onMessageData);
-    this.conn.removeCloseListener(this.listeners.onConnectionClosed);
-    this.conn.removeErrorListener(this.listeners.onConnectionErrored);
-    clearInterval(this.heartbeatHandle);
-    this.heartbeatHandle = void 0;
-  }
-  _handleClose() {
-    super._handleClose();
-    this.conn.close();
-  }
-};
-
-// transport/sessionStateMachine/transitions.ts
-function inheritSharedSession(session) {
-  return [
-    session.id,
-    session.from,
-    session.to,
-    session.seq,
-    session.ack,
-    session.sendBuffer,
-    session.telemetry,
-    session.options,
-    session.log
-  ];
-}
-var SessionStateGraph = {
-  entrypoints: {
-    NoConnection(to, from, listeners, options, log) {
-      const id = `session-${generateId()}`;
-      const telemetry = createSessionTelemetryInfo(id, to, from);
-      const sendBuffer = [];
-      const session = new SessionNoConnection(
-        listeners,
-        id,
-        from,
-        to,
-        0,
-        0,
-        sendBuffer,
-        telemetry,
-        options,
-        log
-      );
-      session.log?.info(`session ${session.id} created in NoConnection state`, {
-        ...session.loggingMetadata,
-        tags: ["state-transition"]
-      });
-      return session;
-    },
-    WaitingForHandshake(from, conn, listeners, options, log) {
-      const session = new SessionWaitingForHandshake(
-        conn,
-        listeners,
-        from,
-        options,
-        log
-      );
-      session.log?.info(`session created in WaitingForHandshake state`, {
-        ...session.loggingMetadata,
-        tags: ["state-transition"]
-      });
-      return session;
-    }
-  },
-  // All of the transitions 'move'/'consume' the old session and return a new one.
-  // After a session is transitioned, any usage of the old session will throw.
-  transition: {
-    // happy path transitions
-    NoConnectionToConnecting(oldSession, connPromise, listeners) {
-      const carriedState = inheritSharedSession(oldSession);
-      oldSession._handleStateExit();
-      const session = new SessionConnecting(
-        connPromise,
-        listeners,
-        ...carriedState
-      );
-      session.log?.info(
-        `session ${session.id} transition from NoConnection to Connecting`,
-        {
-          ...session.loggingMetadata,
-          tags: ["state-transition"]
-        }
-      );
-      return session;
-    },
-    ConnectingToHandshaking(oldSession, conn, listeners) {
-      const carriedState = inheritSharedSession(oldSession);
-      oldSession._handleStateExit();
-      const session = new SessionHandshaking(conn, listeners, ...carriedState);
-      session.log?.info(
-        `session ${session.id} transition from Connecting to Handshaking`,
-        {
-          ...session.loggingMetadata,
-          tags: ["state-transition"]
-        }
-      );
-      return session;
-    },
-    HandshakingToConnected(oldSession, listeners) {
-      const carriedState = inheritSharedSession(oldSession);
-      const conn = oldSession.conn;
-      oldSession._handleStateExit();
-      const session = new SessionConnected(conn, listeners, ...carriedState);
-      session.log?.info(
-        `session ${session.id} transition from Handshaking to Connected`,
-        {
-          ...session.loggingMetadata,
-          tags: ["state-transition"]
-        }
-      );
-      return session;
-    },
-    WaitingForHandshakeToConnected(pendingSession, oldSession, sessionId, to, propagationCtx, listeners) {
-      const conn = pendingSession.conn;
-      const { from, options } = pendingSession;
-      const carriedState = oldSession ? (
-        // old session exists, inherit state
-        inheritSharedSession(oldSession)
-      ) : (
-        // old session does not exist, create new state
-        [
-          sessionId,
-          from,
-          to,
-          0,
-          0,
-          [],
-          createSessionTelemetryInfo(sessionId, to, from, propagationCtx),
-          options,
-          pendingSession.log
-        ]
-      );
-      pendingSession._handleStateExit();
-      oldSession?._handleStateExit();
-      const session = new SessionConnected(conn, listeners, ...carriedState);
-      session.log?.info(
-        `session ${session.id} transition from WaitingForHandshake to Connected`,
-        {
-          ...session.loggingMetadata,
-          tags: ["state-transition"]
-        }
-      );
-      return session;
-    },
-    // disconnect paths
-    ConnectingToNoConnection(oldSession, listeners) {
-      const carriedState = inheritSharedSession(oldSession);
-      oldSession.bestEffortClose();
-      oldSession._handleStateExit();
-      const session = new SessionNoConnection(listeners, ...carriedState);
-      session.log?.info(
-        `session ${session.id} transition from Connecting to NoConnection`,
-        {
-          ...session.loggingMetadata,
-          tags: ["state-transition"]
-        }
-      );
-      return session;
-    },
-    HandshakingToNoConnection(oldSession, listeners) {
-      const carriedState = inheritSharedSession(oldSession);
-      oldSession.conn.close();
-      oldSession._handleStateExit();
-      const session = new SessionNoConnection(listeners, ...carriedState);
-      session.log?.info(
-        `session ${session.id} transition from Handshaking to NoConnection`,
-        {
-          ...session.loggingMetadata,
-          tags: ["state-transition"]
-        }
-      );
-      return session;
-    },
-    ConnectedToNoConnection(oldSession, listeners) {
-      const carriedState = inheritSharedSession(oldSession);
-      oldSession.conn.close();
-      oldSession._handleStateExit();
-      const session = new SessionNoConnection(listeners, ...carriedState);
-      session.log?.info(
-        `session ${session.id} transition from Connected to NoConnection`,
-        {
-          ...session.loggingMetadata,
-          tags: ["state-transition"]
-        }
-      );
-      return session;
-    }
-  }
-};
-
-// transport/transport.ts
-var Transport = class {
-  /**
-   * The status of the transport.
-   */
-  status;
-  /**
-   * The client ID of this transport.
-   */
-  clientId;
-  /**
-   * The event dispatcher for handling events of type EventTypes.
-   */
-  eventDispatcher;
-  /**
-   * The options for this transport.
-   */
-  options;
-  log;
-  sessions;
-  /**
-   * Creates a new Transport instance.
-   * @param codec The codec used to encode and decode messages.
-   * @param clientId The client ID of this transport.
-   */
-  constructor(clientId, providedOptions) {
-    this.options = { ...defaultTransportOptions, ...providedOptions };
-    this.eventDispatcher = new EventDispatcher();
-    this.clientId = clientId;
-    this.status = "open";
-    this.sessions = /* @__PURE__ */ new Map();
-  }
-  bindLogger(fn, level) {
-    if (typeof fn === "function") {
-      this.log = createLogProxy(new BaseLogger(fn, level));
-      return;
-    }
-    this.log = createLogProxy(fn);
-  }
-  /**
-   * Called when a message is received by this transport.
-   * You generally shouldn't need to override this in downstream transport implementations.
-   * @param msg The received message.
-   */
-  handleMsg(msg) {
-    if (this.getStatus() !== "open")
-      return;
-    this.eventDispatcher.dispatchEvent("message", msg);
-  }
-  /**
-   * Adds a listener to this transport.
-   * @param the type of event to listen for
-   * @param handler The message handler to add.
-   */
-  addEventListener(type, handler) {
-    this.eventDispatcher.addEventListener(type, handler);
-  }
-  /**
-   * Removes a listener from this transport.
-   * @param the type of event to un-listen on
-   * @param handler The message handler to remove.
-   */
-  removeEventListener(type, handler) {
-    this.eventDispatcher.removeEventListener(type, handler);
-  }
-  protocolError(type, message) {
-    this.eventDispatcher.dispatchEvent("protocolError", { type, message });
-  }
-  /**
-   * Default close implementation for transports. You should override this in the downstream
-   * implementation if you need to do any additional cleanup and call super.close() at the end.
-   * Closes the transport. Any messages sent while the transport is closed will be silently discarded.
-   */
-  close() {
-    this.status = "closed";
-    for (const session of this.sessions.values()) {
-      this.deleteSession(session);
-    }
-    this.eventDispatcher.dispatchEvent("transportStatus", {
-      status: this.status
-    });
-    this.eventDispatcher.removeAllListeners();
-    this.log?.info(`manually closed transport`, { clientId: this.clientId });
-  }
-  getStatus() {
-    return this.status;
-  }
-  updateSession(session) {
-    const activeSession = this.sessions.get(session.to);
-    if (activeSession && activeSession.id !== session.id) {
-      const msg = `attempt to transition active session for ${session.to} but active session (${activeSession.id}) is different from handle (${session.id})`;
-      throw new Error(msg);
-    }
-    this.sessions.set(session.to, session);
-    if (!activeSession) {
-      this.eventDispatcher.dispatchEvent("sessionStatus", {
-        status: "connect",
-        session
-      });
-    }
-    this.eventDispatcher.dispatchEvent("sessionTransition", {
-      state: session.state,
-      session
-    });
-    return session;
-  }
-  // state transitions
-  deleteSession(session) {
-    session.log?.info(`closing session ${session.id}`, session.loggingMetadata);
-    this.eventDispatcher.dispatchEvent("sessionStatus", {
-      status: "disconnect",
-      session
-    });
-    session.close();
-    this.sessions.delete(session.to);
-  }
-  // common listeners
-  onSessionGracePeriodElapsed(session) {
-    this.log?.warn(
-      `session to ${session.to} grace period elapsed, closing`,
-      session.loggingMetadata
-    );
-    this.deleteSession(session);
-  }
-  onConnectingFailed(session) {
-    const noConnectionSession = SessionStateGraph.transition.ConnectingToNoConnection(session, {
-      onSessionGracePeriodElapsed: () => {
-        this.onSessionGracePeriodElapsed(noConnectionSession);
-      }
-    });
-    return this.updateSession(noConnectionSession);
-  }
-  onConnClosed(session) {
-    let noConnectionSession;
-    if (session.state === "Handshaking" /* Handshaking */) {
-      noConnectionSession = SessionStateGraph.transition.HandshakingToNoConnection(session, {
-        onSessionGracePeriodElapsed: () => {
-          this.onSessionGracePeriodElapsed(noConnectionSession);
-        }
-      });
-    } else {
-      noConnectionSession = SessionStateGraph.transition.ConnectedToNoConnection(session, {
-        onSessionGracePeriodElapsed: () => {
-          this.onSessionGracePeriodElapsed(noConnectionSession);
-        }
-      });
-    }
-    return this.updateSession(noConnectionSession);
-  }
-};
-
-// util/stringify.ts
-function coerceErrorString(err) {
-  if (err instanceof Error) {
-    return err.message || "unknown reason";
-  }
-  return `[coerced to error] ${String(err)}`;
-}
-
-// transport/server.ts
-var import_value2 = require("@sinclair/typebox/value");
-var ServerTransport = class extends Transport {
-  /**
-   * The options for this transport.
-   */
-  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: import_api3.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 (!import_value2.Value.Check(ControlMessageHandshakeRequestSchema, msg.payload)) {
-      this.rejectHandshakeRequest(
-        session,
-        msg.from,
-        "received invalid handshake request",
-        "MALFORMED_HANDSHAKE",
-        {
-          ...session.loggingMetadata,
-          transportMessage: msg,
-          connectedTo: msg.from,
-          validationErrors: [
-            ...import_value2.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 (!import_value2.Value.Check(this.handshakeExtensions.schema, rawMetadata)) {
-        this.rejectHandshakeRequest(
-          handshakingSession,
-          from,
-          "received malformed handshake metadata",
-          "MALFORMED_HANDSHAKE_META",
-          {
-            ...handshakingSession.loggingMetadata,
-            connectedTo: from,
-            validationErrors: [
-              ...import_value2.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;
-  }
-};
-
-// transport/impls/uds/server.ts
-var UnixDomainSocketServerTransport = class extends ServerTransport {
-  server;
-  constructor(server, clientId, providedOptions) {
-    super(clientId, providedOptions);
-    this.server = server;
-    server.addListener("connection", this.connectionHandler);
-  }
-  connectionHandler = (sock) => {
-    const conn = new UdsConnection(sock);
-    this.handleConnection(conn);
-  };
-  close() {
-    super.close();
-    this.server.removeListener("connection", this.connectionHandler);
-  }
-};
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  UnixDomainSocketServerTransport
-});
-//# sourceMappingURL=server.cjs.map