@replit/river 0.21.0 → 0.22.0

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

@@ -1,9 +1,7 @@
 "use strict";
-var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __export = (target, all) => {
   for (var name in all)
@@ -17,14 +15,6 @@ var __copyProps = (to, from, except, desc) => {
   }
   return to;
 };
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
 // transport/impls/ws/server.ts
@@ -36,7 +26,6 @@ module.exports = __toCommonJS(server_exports);
 
 // transport/transport.ts
 var import_value = require("@sinclair/typebox/value");
-var import_api2 = require("@opentelemetry/api");
 
 // transport/message.ts
 var import_typebox = require("@sinclair/typebox");
@@ -152,17 +141,62 @@ var EventDispatcher = class {
 
 // transport/session.ts
 var import_nanoid2 = require("nanoid");
+
+// tracing/index.ts
+var import_api = require("@opentelemetry/api");
+
+// package.json
+var version = "0.22.0";
+
+// tracing/index.ts
+function createSessionTelemetryInfo(session, propagationCtx) {
+  const ctx = propagationCtx ? import_api.propagation.extract(import_api.context.active(), propagationCtx) : import_api.context.active();
+  const span = tracer.startSpan(
+    `session ${session.id}`,
+    {
+      attributes: {
+        component: "river",
+        "river.session.id": session.id,
+        "river.session.to": session.to,
+        "river.session.from": session.from
+      }
+    },
+    ctx
+  );
+  return { span, ctx };
+}
+function createConnectionTelemetryInfo(connection, sessionSpan) {
+  const ctx = import_api.trace.setSpan(import_api.context.active(), sessionSpan);
+  const span = tracer.startSpan(
+    `connection ${connection.id}`,
+    {
+      attributes: {
+        component: "river",
+        "river.connection.id": connection.id
+      },
+      links: [{ context: sessionSpan.spanContext() }]
+    },
+    ctx
+  );
+  return { span, ctx };
+}
+var tracer = import_api.trace.getTracer("river", version);
+
+// transport/session.ts
+var import_api2 = require("@opentelemetry/api");
 var nanoid2 = (0, import_nanoid2.customAlphabet)("1234567890abcdefghijklmnopqrstuvxyz", 6);
 var unsafeId = () => nanoid2();
 var Connection = class {
-  debugId;
+  id;
+  telemetry;
   constructor() {
-    this.debugId = `conn-${unsafeId()}`;
+    this.id = `conn-${nanoid2(12)}`;
   }
 };
 var Session = class {
   codec;
   options;
+  telemetry;
   /**
    * The buffer of messages that have been sent but not yet acknowledged.
    */
@@ -209,7 +243,7 @@ var Session = class {
    * The interval for sending heartbeats.
    */
   heartbeat;
-  constructor(conn, from, to, options) {
+  constructor(conn, from, to, options, propagationCtx) {
     this.id = `session-${nanoid2(12)}`;
     this.options = options;
     this.from = from;
@@ -221,13 +255,14 @@ var Session = class {
       () => this.sendHeartbeat(),
       options.heartbeatIntervalMs
     );
+    this.telemetry = createSessionTelemetryInfo(this, propagationCtx);
   }
   get loggingMetadata() {
     return {
       clientId: this.from,
       connectedTo: this.to,
       sessionId: this.id,
-      connId: this.connection?.debugId
+      connId: this.connection?.id
     };
   }
   /**
@@ -272,6 +307,7 @@ var Session = class {
           `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.closeStaleConnection();
       }
       return;
@@ -293,32 +329,38 @@ var Session = class {
   sendBufferedMessages(conn) {
     log?.info(`resending ${this.sendBuffer.length} buffered messages`, {
       ...this.loggingMetadata,
-      connId: conn.debugId
+      connId: conn.id
     });
     for (const msg of this.sendBuffer) {
       log?.debug(`resending msg`, {
         ...this.loggingMetadata,
         fullTransportMessage: msg,
-        connId: conn.debugId
+        connId: conn.id
       });
       const ok = conn.send(this.codec.toBuffer(msg));
       if (!ok) {
         const errMsg = `failed to send buffered message to ${this.to} (sus, this is a fresh connection)`;
+        conn.telemetry?.span.setStatus({
+          code: import_api2.SpanStatusCode.ERROR,
+          message: errMsg
+        });
         log?.error(errMsg, {
           ...this.loggingMetadata,
           fullTransportMessage: msg,
-          connId: conn.debugId
+          connId: conn.id,
+          tags: ["invariant-violation"]
         });
-        throw new Error(errMsg);
+        conn.close();
+        return;
       }
     }
   }
   updateBookkeeping(ack, seq) {
     if (seq + 1 < this.ack) {
-      log?.error(
-        `received stale seq ${seq} + 1 < ${this.ack}`,
-        this.loggingMetadata
-      );
+      log?.error(`received stale seq ${seq} + 1 < ${this.ack}`, {
+        ...this.loggingMetadata,
+        tags: ["invariant-violation"]
+      });
       return;
     }
     this.sendBuffer = this.sendBuffer.filter((unacked) => unacked.seq >= ack);
@@ -388,11 +430,6 @@ var Session = class {
   }
 };
 
-// tracing/index.ts
-var import_api = require("@opentelemetry/api");
-var tracer = import_api.trace.getTracer("river");
-var tracing_default = tracer;
-
 // util/stringify.ts
 function coerceErrorString(err) {
   if (err instanceof Error) {
@@ -454,6 +491,7 @@ var NaiveJsonCodec = {
 };
 
 // transport/transport.ts
+var import_api3 = require("@opentelemetry/api");
 var defaultTransportOptions = {
   heartbeatIntervalMs: 1e3,
   heartbeatsUntilDead: 2,
@@ -532,17 +570,22 @@ var Transport = class {
       status: "connect",
       conn
     });
+    conn.telemetry = createConnectionTelemetryInfo(
+      conn,
+      session.telemetry.span
+    );
     if (isReconnect) {
       session.replaceWithNewConnection(conn);
       log?.info(`reconnected to ${connectedTo}`, session.loggingMetadata);
     }
   }
-  createSession(to, conn) {
+  createSession(to, conn, propagationCtx) {
     const session = new Session(
       conn,
       this.clientId,
       to,
-      this.options
+      this.options,
+      propagationCtx
     );
     this.sessions.set(session.to, session);
     this.eventDispatcher.dispatchEvent("sessionStatus", {
@@ -551,11 +594,11 @@ var Transport = class {
     });
     return session;
   }
-  getOrCreateSession(to, conn, sessionId) {
+  getOrCreateSession(to, conn, sessionId, propagationCtx) {
     let session = this.sessions.get(to);
     let isReconnect = session !== void 0;
     if (session?.advertisedSessionId !== void 0 && sessionId !== void 0 && session.advertisedSessionId !== sessionId) {
-      log?.warn(
+      log?.info(
         `session for ${to} already exists but has a different session id (expected: ${session.advertisedSessionId}, got: ${sessionId}), creating a new one`,
         session.loggingMetadata
       );
@@ -564,7 +607,7 @@ var Transport = class {
       session = void 0;
     }
     if (!session) {
-      session = this.createSession(to, conn);
+      session = this.createSession(to, conn, propagationCtx);
       log?.info(
         `no session for ${to}, created a new one`,
         session.loggingMetadata
@@ -577,6 +620,7 @@ var Transport = class {
   }
   deleteSession(session) {
     session.close();
+    session.telemetry.span.end();
     this.sessions.delete(session.to);
     log?.info(
       `session ${session.id} disconnect from ${session.to}`,
@@ -593,12 +637,16 @@ var Transport = class {
    * @param connectedTo The peer we are connected to.
    */
   onDisconnect(conn, session) {
+    conn.telemetry?.span.end();
     this.eventDispatcher.dispatchEvent("connectionStatus", {
       status: "disconnect",
       conn
     });
     session.connection = void 0;
-    session.beginGrace(() => this.deleteSession(session));
+    session.beginGrace(() => {
+      session.telemetry.span.addEvent("session grace period expired");
+      this.deleteSession(session);
+    });
   }
   /**
    * Parses a message from a Uint8Array into a {@link OpaqueTransportMessage}.
@@ -632,9 +680,10 @@ var Transport = class {
       return;
     const session = this.sessions.get(msg.from);
     if (!session) {
-      log?.error(`(invariant violation) no existing session for ${msg.from}`, {
+      log?.error(`no existing session for ${msg.from}`, {
         clientId: this.clientId,
-        fullTransportMessage: msg
+        fullTransportMessage: msg,
+        tags: ["invariant-violation"]
       });
       return;
     }
@@ -653,9 +702,14 @@ var Transport = class {
         const errMsg = `received out-of-order msg (got seq: ${msg.seq}, wanted seq: ${session.nextExpectedSeq})`;
         log?.error(`${errMsg}, marking connection as dead`, {
           clientId: this.clientId,
-          fullTransportMessage: msg
+          fullTransportMessage: msg,
+          tags: ["invariant-violation"]
         });
         this.protocolError(ProtocolError.MessageOrderingViolated, errMsg);
+        session.telemetry.span.setStatus({
+          code: import_api3.SpanStatusCode.ERROR,
+          message: "message order violated"
+        });
         session.close();
       }
       return;
@@ -697,7 +751,8 @@ var Transport = class {
       const err = "transport is destroyed, cant send";
       log?.error(err, {
         clientId: this.clientId,
-        partialTransportMessage: msg
+        partialTransportMessage: msg,
+        tags: ["invariant-violation"]
       });
       this.protocolError(ProtocolError.UseAfterDestroy, err);
       return void 0;
@@ -765,278 +820,262 @@ var ServerTransport = class extends Transport {
     });
   }
   handleConnection(conn) {
-    tracing_default.startActiveSpan(
-      "handleConnection",
-      {
-        attributes: {
-          component: "river",
-          "span.kind": "server"
-        },
-        kind: import_api2.SpanKind.SERVER
-      },
-      (span) => {
-        if (this.state !== "open")
-          return;
-        log?.info(`new incoming connection`, {
-          clientId: this.clientId,
-          connId: conn.debugId
+    if (this.state !== "open")
+      return;
+    log?.info(`new incoming connection`, {
+      clientId: this.clientId,
+      connId: conn.id
+    });
+    let session = void 0;
+    const client = () => session?.to ?? "unknown";
+    const handshakeTimeout = setTimeout(() => {
+      if (!session) {
+        log?.warn(
+          `connection to ${client()} timed out waiting for handshake, closing`,
+          {
+            clientId: this.clientId,
+            connectedTo: client(),
+            connId: conn.id
+          }
+        );
+        conn.telemetry?.span.setStatus({
+          code: import_api3.SpanStatusCode.ERROR,
+          message: "handshake timeout"
         });
-        let session = void 0;
-        const client = () => session?.to ?? "unknown";
-        const handshakeTimeout = setTimeout(() => {
-          if (!session) {
-            log?.warn(
-              `connection to ${client()} timed out waiting for handshake, closing`,
-              {
-                clientId: this.clientId,
-                connectedTo: client(),
-                connId: conn.debugId
-              }
-            );
-            span.setStatus({ code: import_api2.SpanStatusCode.ERROR });
-            span.end();
+        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();
-          }
-        }, 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) {
-                span.setStatus({ code: import_api2.SpanStatusCode.ERROR });
-                span.end();
-                conn.close();
-                return;
-              }
-              session = maybeSession;
-              const dataHandler = (data2) => {
-                const parsed = this.parseMsg(data2);
-                if (!parsed) {
-                  conn.close();
-                  return;
-                }
-                this.handleMsg(parsed);
-              };
-              conn.removeDataListener(handshakeHandler);
-              conn.addDataListener(dataHandler);
-              for (const data2 of buffer) {
-                dataHandler(data2);
-              }
-              buffer.length = 0;
+          session = maybeSession;
+          const dataHandler = (data2) => {
+            const parsed = this.parseMsg(data2);
+            if (!parsed) {
+              conn.close();
+              return;
             }
-          );
-        };
-        conn.addDataListener(handshakeHandler);
-        conn.addCloseListener(() => {
-          if (session) {
-            log?.info(`connection to ${client()} disconnected`, {
-              clientId: this.clientId,
-              connId: conn.debugId
-            });
-            this.onDisconnect(conn, session);
+            this.handleMsg(parsed);
+          };
+          for (const data2 of buffer) {
+            dataHandler(data2);
           }
-          span.setStatus({ code: import_api2.SpanStatusCode.OK });
-          span.end();
-        });
-        conn.addErrorListener((err) => {
-          if (session) {
-            log?.warn(
-              `connection to ${client()} got an error: ${coerceErrorString(
-                err
-              )}`,
-              { clientId: this.clientId, connId: conn.debugId }
-            );
-          }
-          span.setStatus({ code: import_api2.SpanStatusCode.ERROR });
-          span.end();
-        });
-      }
-    );
+          conn.removeDataListener(handshakeHandler);
+          conn.addDataListener(dataHandler);
+          buffer.length = 0;
+        }
+      );
+    };
+    conn.addDataListener(handshakeHandler);
+    conn.addCloseListener(() => {
+      if (!session)
+        return;
+      log?.info(`connection to ${client()} disconnected`, {
+        clientId: this.clientId,
+        connId: conn.id
+      });
+      this.onDisconnect(conn, session);
+    });
+    conn.addErrorListener((err) => {
+      conn.telemetry?.span.setStatus({
+        code: import_api3.SpanStatusCode.ERROR,
+        message: "connection error"
+      });
+      if (!session)
+        return;
+      log?.warn(
+        `connection to ${client()} got an error: ${coerceErrorString(err)}`,
+        { clientId: this.clientId, connId: conn.id }
+      );
+    });
   }
   async receiveHandshakeRequestMessage(data, conn) {
     const parsed = this.parseMsg(data);
     if (!parsed) {
+      conn.telemetry?.span.setStatus({
+        code: import_api3.SpanStatusCode.ERROR,
+        message: "non-transport message"
+      });
       this.protocolError(
         ProtocolError.HandshakeFailed,
         "received non-transport message"
       );
       return false;
     }
-    let activeContext = import_api2.context.active();
-    if (parsed.tracing) {
-      activeContext = import_api2.propagation.extract(activeContext, parsed.tracing);
+    if (!import_value.Value.Check(ControlMessageHandshakeRequestSchema, parsed.payload)) {
+      conn.telemetry?.span.setStatus({
+        code: import_api3.SpanStatusCode.ERROR,
+        message: "invalid handshake request"
+      });
+      const reason = "received invalid handshake msg";
+      const responseMsg2 = handshakeResponseMessage(this.clientId, parsed.from, {
+        ok: false,
+        reason
+      });
+      conn.send(this.codec.toBuffer(responseMsg2));
+      const logData = { ...parsed.payload ?? {}, metadata: "redacted" };
+      log?.warn(reason, {
+        clientId: this.clientId,
+        connId: conn.id,
+        partialTransportMessage: { ...parsed, payload: logData }
+      });
+      this.protocolError(
+        ProtocolError.HandshakeFailed,
+        "invalid handshake request"
+      );
+      return false;
     }
-    return tracing_default.startActiveSpan(
-      "receiveHandshakeRequestMessage",
-      {
-        attributes: {
-          component: "river",
-          "span.kind": "server"
-        },
-        kind: import_api2.SpanKind.SERVER
-      },
-      activeContext,
-      async (span) => {
-        if (!import_value.Value.Check(ControlMessageHandshakeRequestSchema, parsed.payload)) {
-          const reason = "received invalid handshake msg";
-          const responseMsg2 = handshakeResponseMessage(
-            this.clientId,
-            parsed.from,
-            {
-              ok: false,
-              reason
-            }
-          );
-          conn.send(this.codec.toBuffer(responseMsg2));
-          const logData = typeof parsed.payload === "object" ? {
-            ...parsed,
-            payload: { ...parsed.payload, metadata: "redacted" }
-          } : { ...parsed };
-          log?.warn(`${reason}: ${JSON.stringify(logData)}`, {
-            clientId: this.clientId,
-            connId: conn.debugId
-          });
-          this.protocolError(
-            ProtocolError.HandshakeFailed,
-            "invalid handshake request"
-          );
-          span.setStatus({ code: import_api2.SpanStatusCode.ERROR });
-          span.end();
-          return false;
-        }
-        const gotVersion = parsed.payload.protocolVersion;
-        if (gotVersion !== PROTOCOL_VERSION) {
-          const reason = `incorrect version (got: ${gotVersion} wanted ${PROTOCOL_VERSION})`;
-          const responseMsg2 = handshakeResponseMessage(
-            this.clientId,
-            parsed.from,
-            {
-              ok: false,
-              reason
-            }
-          );
-          conn.send(this.codec.toBuffer(responseMsg2));
-          log?.warn(
-            `received handshake msg with incompatible protocol version (got: ${gotVersion}, expected: ${PROTOCOL_VERSION})`,
-            { clientId: this.clientId, connId: conn.debugId }
-          );
-          this.protocolError(ProtocolError.HandshakeFailed, reason);
-          span.setStatus({ code: import_api2.SpanStatusCode.ERROR });
-          span.end();
-          return false;
-        }
-        const { session, isReconnect } = this.getOrCreateSession(
+    const gotVersion = parsed.payload.protocolVersion;
+    if (gotVersion !== PROTOCOL_VERSION) {
+      conn.telemetry?.span.setStatus({
+        code: import_api3.SpanStatusCode.ERROR,
+        message: "incorrect protocol version"
+      });
+      const reason = `incorrect version (got: ${gotVersion} wanted ${PROTOCOL_VERSION})`;
+      const responseMsg2 = handshakeResponseMessage(this.clientId, parsed.from, {
+        ok: false,
+        reason
+      });
+      conn.send(this.codec.toBuffer(responseMsg2));
+      log?.warn(
+        `received handshake msg with incompatible protocol version (got: ${gotVersion}, expected: ${PROTOCOL_VERSION})`,
+        { clientId: this.clientId, connId: conn.id }
+      );
+      this.protocolError(ProtocolError.HandshakeFailed, reason);
+      return false;
+    }
+    const { session, isReconnect } = this.getOrCreateSession(
+      parsed.from,
+      conn,
+      parsed.payload.sessionId,
+      parsed.tracing
+    );
+    let handshakeMetadata;
+    if (this.options.handshake) {
+      if (!import_value.Value.Check(
+        this.options.handshake.requestSchema,
+        parsed.payload.metadata
+      )) {
+        conn.telemetry?.span.setStatus({
+          code: import_api3.SpanStatusCode.ERROR,
+          message: "malformed handshake meta"
+        });
+        const reason = "received malformed handshake metadata";
+        const responseMsg2 = handshakeResponseMessage(
+          this.clientId,
           parsed.from,
-          conn,
-          parsed.payload.sessionId
+          { ok: false, reason }
         );
-        let handshakeMetadata;
-        if (this.options.handshake) {
-          if (!import_value.Value.Check(
-            this.options.handshake.requestSchema,
-            parsed.payload.metadata
-          )) {
-            const reason = "received malformed handshake metadata";
-            const responseMsg2 = handshakeResponseMessage(
-              this.clientId,
-              parsed.from,
-              { ok: false, reason }
-            );
-            conn.send(this.codec.toBuffer(responseMsg2));
-            log?.warn(
-              `received malformed handshake metadata from ${parsed.from}`,
-              {
-                clientId: this.clientId,
-                connId: conn.debugId
-              }
-            );
-            this.protocolError(ProtocolError.HandshakeFailed, reason);
-            this.deleteSession(session);
-            span.setStatus({ code: import_api2.SpanStatusCode.ERROR });
-            span.end();
-            return false;
-          }
-          const parsedMetadata = await this.options.handshake.parse(
-            parsed.payload.metadata,
-            session,
-            isReconnect
-          );
-          if (parsedMetadata === false) {
-            const reason = "rejected by server";
-            const responseMsg2 = handshakeResponseMessage(
-              this.clientId,
-              parsed.from,
-              { ok: false, reason }
-            );
-            conn.send(this.codec.toBuffer(responseMsg2));
-            log?.warn(`rejected handshake from ${parsed.from}`, {
-              clientId: this.clientId,
-              connId: conn.debugId
-            });
-            this.protocolError(ProtocolError.HandshakeFailed, reason);
-            this.deleteSession(session);
-            span.setStatus({ code: import_api2.SpanStatusCode.ERROR });
-            span.end();
-            return false;
-          }
-          if (!import_value.Value.Check(this.options.handshake.parsedSchema, parsedMetadata)) {
-            const reason = "failed to parse handshake metadata";
-            const responseMsg2 = handshakeResponseMessage(
-              this.clientId,
-              parsed.from,
-              { ok: false, reason }
-            );
-            conn.send(this.codec.toBuffer(responseMsg2));
-            log?.error(`failed to parse handshake metadata`, {
-              clientId: this.clientId,
-              connId: conn.debugId
-            });
-            this.protocolError(ProtocolError.HandshakeFailed, reason);
-            this.deleteSession(session);
-            span.setStatus({ code: import_api2.SpanStatusCode.ERROR });
-            span.end();
-            return false;
-          }
-          handshakeMetadata = parsedMetadata;
-        }
-        handshakeMetadata ??= {};
-        session.metadata = handshakeMetadata;
-        log?.debug(
-          `handshake from ${parsed.from} ok, responding with handshake success`,
-          { clientId: this.clientId, connId: conn.debugId }
+        conn.send(this.codec.toBuffer(responseMsg2));
+        log?.warn(`received malformed handshake metadata from ${parsed.from}`, {
+          clientId: this.clientId,
+          connId: conn.id
+        });
+        this.protocolError(ProtocolError.HandshakeFailed, reason);
+        this.deleteSession(session);
+        return false;
+      }
+      const parsedMetadata = await this.options.handshake.parse(
+        parsed.payload.metadata,
+        session,
+        isReconnect
+      );
+      if (parsedMetadata === false) {
+        conn.telemetry?.span.setStatus({
+          code: import_api3.SpanStatusCode.ERROR,
+          message: "rejected by handshake handler"
+        });
+        const reason = "rejected by handshake handler";
+        const responseMsg2 = handshakeResponseMessage(
+          this.clientId,
+          parsed.from,
+          { ok: false, reason }
         );
-        const responseMsg = handshakeResponseMessage(
+        conn.send(this.codec.toBuffer(responseMsg2));
+        log?.warn(`rejected handshake from ${parsed.from}`, {
+          clientId: this.clientId,
+          connId: conn.id
+        });
+        this.protocolError(ProtocolError.HandshakeFailed, reason);
+        this.deleteSession(session);
+        return false;
+      }
+      if (!import_value.Value.Check(this.options.handshake.parsedSchema, parsedMetadata)) {
+        conn.telemetry?.span.setStatus({
+          code: import_api3.SpanStatusCode.ERROR,
+          message: "malformed handshake meta"
+        });
+        const reason = "failed to parse handshake metadata";
+        const responseMsg2 = handshakeResponseMessage(
           this.clientId,
           parsed.from,
-          {
-            ok: true,
-            sessionId: session.id
-          }
+          { ok: false, reason }
         );
-        conn.send(this.codec.toBuffer(responseMsg));
-        this.onConnect(conn, parsed.from, session, isReconnect);
-        span.end();
-        return session;
+        conn.send(this.codec.toBuffer(responseMsg2));
+        log?.error(`failed to parse handshake metadata`, {
+          clientId: this.clientId,
+          connId: conn.id
+        });
+        this.protocolError(ProtocolError.HandshakeFailed, reason);
+        this.deleteSession(session);
+        return false;
       }
+      handshakeMetadata = parsedMetadata;
+    }
+    handshakeMetadata ??= {};
+    session.metadata = handshakeMetadata;
+    log?.debug(
+      `handshake from ${parsed.from} ok, responding with handshake success`,
+      { clientId: this.clientId, connId: conn.id }
     );
+    const responseMsg = handshakeResponseMessage(this.clientId, parsed.from, {
+      ok: true,
+      sessionId: session.id
+    });
+    conn.send(this.codec.toBuffer(responseMsg));
+    this.onConnect(conn, parsed.from, session, isReconnect);
+    return session;
   }
 };
 
 // transport/impls/ws/connection.ts
-var import_agnostic_ws = __toESM(require("agnostic-ws"), 1);
 var WebSocketConnection = class extends Connection {
+  errorCb = null;
+  closeCb = null;
   ws;
   constructor(ws) {
     super();
     this.ws = ws;
     this.ws.binaryType = "arraybuffer";
+    let didError = false;
+    this.ws.onerror = () => {
+      didError = true;
+    };
+    this.ws.onclose = ({ code, reason }) => {
+      if (didError && this.errorCb) {
+        this.errorCb(
+          new Error(
+            `websocket closed with code and reason: ${code} - ${reason}`
+          )
+        );
+        return;
+      }
+      if (this.closeCb) {
+        this.closeCb();
+      }
+    };
   }
   addDataListener(cb) {
     this.ws.onmessage = (msg) => cb(msg.data);
@@ -1045,13 +1084,13 @@ var WebSocketConnection = class extends Connection {
     this.ws.onmessage = null;
   }
   addCloseListener(cb) {
-    this.ws.onclose = cb;
+    this.closeCb = cb;
   }
   addErrorListener(cb) {
-    this.ws.onerror = (err) => cb(err.error);
+    this.errorCb = cb;
   }
   send(payload) {
-    if (this.ws.readyState === import_agnostic_ws.default.OPEN) {
+    if (this.ws.readyState === this.ws.OPEN) {
       this.ws.send(payload);
       return true;
     } else {