@replit/river 0.11.0 → 0.12.1

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

@@ -34,31 +34,62 @@ 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.Union([import_typebox.Type.String(), import_typebox.Type.Null()])),
   procedureName: import_typebox.Type.Optional(import_typebox.Type.Union([import_typebox.Type.String(), import_typebox.Type.Null()])),
   streamId: import_typebox.Type.String(),
   controlFlags: import_typebox.Type.Integer(),
   payload: t
 });
-var TransportAckSchema = TransportMessageSchema(
-  import_typebox.Type.Object({
-    ack: import_typebox.Type.String()
-  })
-);
-var ControlMessagePayloadSchema = import_typebox.Type.Object({
+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";
+var ControlMessageHandshakeRequestSchema = import_typebox.Type.Object({
+  type: import_typebox.Type.Literal("HANDSHAKE_REQ"),
+  protocolVersion: import_typebox.Type.Literal(PROTOCOL_VERSION),
+  instanceId: import_typebox.Type.String()
+});
+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),
+      instanceId: import_typebox.Type.String()
+    }),
+    import_typebox.Type.Object({
+      ok: import_typebox.Type.Literal(false),
+      reason: import_typebox.Type.Union([import_typebox.Type.Literal("VERSION_MISMATCH")])
+    })
+  ])
+});
+var ControlMessagePayloadSchema = import_typebox.Type.Union([
+  ControlMessageCloseSchema,
+  ControlMessageAckSchema,
+  ControlMessageHandshakeRequestSchema,
+  ControlMessageHandshakeResponseSchema
+]);
 var OpaqueTransportMessageSchema = TransportMessageSchema(
   import_typebox.Type.Unknown()
 );
-function reply(msg, response) {
+function bootRequestMessage(from, to, instanceId) {
   return {
     id: (0, import_nanoid.nanoid)(),
-    streamId: msg.streamId,
+    from,
+    to,
+    seq: 0,
+    ack: 0,
+    streamId: (0, import_nanoid.nanoid)(),
     controlFlags: 0,
-    to: msg.from,
-    from: msg.to,
-    payload: response
+    payload: {
+      type: "HANDSHAKE_REQ",
+      protocolVersion: PROTOCOL_VERSION,
+      instanceId
+    }
   };
 }
 function isAck(controlFlag) {
@@ -96,16 +127,290 @@ var EventDispatcher = class {
   }
 };
 
-// transport/transport.ts
+// transport/session.ts
+var import_nanoid2 = require("nanoid");
+var nanoid2 = (0, import_nanoid2.customAlphabet)("1234567890abcdefghijklmnopqrstuvxyz", 6);
+var unsafeId = () => nanoid2();
 var Connection = class {
-  connectedTo;
-  transport;
-  constructor(transport, connectedTo) {
-    this.connectedTo = connectedTo;
-    this.transport = transport;
+  debugId;
+  constructor() {
+    this.debugId = `conn-${unsafeId()}`;
+  }
+};
+var HEARTBEAT_INTERVAL_MS = 1e3;
+var HEARTBEATS_TILL_DEAD = 2;
+var SESSION_DISCONNECT_GRACE_MS = 5e3;
+var Session = class {
+  codec;
+  /**
+   * The buffer of messages that have been sent but not yet acknowledged.
+   */
+  sendBuffer = [];
+  /**
+   * The active connection associated with this session
+   */
+  connection;
+  from;
+  to;
+  /**
+   * The unique ID of this session.
+   */
+  debugId;
+  /**
+   * Number of messages we've sent along this session (excluding handshake)
+   */
+  seq = 0;
+  /**
+   * Number of unique messages we've received this session (excluding handshake)
+   */
+  ack = 0;
+  /**
+   * The grace period between when the inner connection is disconnected
+   * and when we should consider the entire session disconnected.
+   */
+  disconnectionGrace;
+  /**
+   * Number of heartbeats we've sent without a response.
+   */
+  heartbeatMisses;
+  /**
+   * The interval for sending heartbeats.
+   */
+  heartbeat;
+  constructor(codec, from, connectedTo, conn) {
+    this.debugId = `sess-${unsafeId()}`;
+    this.from = from;
+    this.to = connectedTo;
+    this.connection = conn;
+    this.codec = codec;
+    this.heartbeatMisses = 0;
+    this.heartbeat = setInterval(
+      () => this.sendHeartbeat(),
+      HEARTBEAT_INTERVAL_MS
+    );
+  }
+  /**
+   * Sends a message over the session's connection.
+   * If the connection is not ready or the message fails to send, the message can be buffered for retry unless skipped.
+   *
+   * @param msg The partial message to be sent, which will be constructed into a full message.
+   * @param skipRetry Optional. If true, the message will not be buffered for retry on failure. This should only be used for
+   * ack hearbeats, which contain information that can already be found in the other buffered messages.
+   * @returns The full transport ID of the message that was attempted to be sent.
+   */
+  send(msg, skipRetry) {
+    const fullMsg = this.constructMsg(msg);
+    log?.debug(`${this.from} -- sending ${JSON.stringify(fullMsg)}`);
+    if (this.connection) {
+      const ok = this.connection.send(this.codec.toBuffer(fullMsg));
+      if (ok)
+        return fullMsg.id;
+      log?.info(
+        `${this.from} -- failed to send ${fullMsg.id} to ${fullMsg.to}, connection (id: ${this.connection.debugId}) is probably dead`
+      );
+    } else {
+      log?.info(
+        `${this.from} -- failed to send ${fullMsg.id} to ${fullMsg.to}, connection not ready yet`
+      );
+    }
+    if (skipRetry)
+      return fullMsg.id;
+    this.addToSendBuff(fullMsg);
+    log?.info(
+      `${this.from} -- buffering msg ${fullMsg.id} until connection is healthy again`
+    );
+    return fullMsg.id;
+  }
+  sendHeartbeat() {
+    if (this.heartbeatMisses >= HEARTBEATS_TILL_DEAD) {
+      if (this.connection) {
+        log?.info(
+          `${this.from} -- closing connection (id: ${this.connection.debugId}) to ${this.to} due to inactivity`
+        );
+        this.halfCloseConnection();
+      }
+      return;
+    }
+    this.send(
+      {
+        streamId: "heartbeat",
+        controlFlags: 1 /* AckBit */,
+        payload: {
+          type: "ACK"
+        }
+      },
+      true
+    );
+    this.heartbeatMisses++;
+  }
+  resetBufferedMessages() {
+    this.sendBuffer = [];
+    this.seq = 0;
+    this.ack = 0;
+  }
+  sendBufferedMessages() {
+    if (!this.connection) {
+      const msg = `${this.from} -- tried sending buffered messages without a connection (if you hit this code path something is seriously wrong)`;
+      log?.error(msg);
+      throw new Error(msg);
+    }
+    for (const msg of this.sendBuffer) {
+      log?.debug(`${this.from} -- resending ${JSON.stringify(msg)}`);
+      const ok = this.connection.send(this.codec.toBuffer(msg));
+      if (!ok) {
+        const msg2 = `${this.from} -- failed to send buffered message to ${this.to} in session (id: ${this.debugId}) (if you hit this code path something is seriously wrong)`;
+        log?.error(msg2);
+        throw new Error(msg2);
+      }
+    }
+  }
+  updateBookkeeping(ack, seq) {
+    this.sendBuffer = this.sendBuffer.filter((unacked) => unacked.seq > ack);
+    this.ack = seq + 1;
+  }
+  addToSendBuff(msg) {
+    this.sendBuffer.push(msg);
+    log?.debug(
+      `${this.from} -- send buff to ${this.to} now tracking ${this.sendBuffer.length} messages`
+    );
+  }
+  closeStaleConnection(conn) {
+    if (!this.connection || this.connection !== conn)
+      return;
+    log?.info(
+      `${this.from} -- closing old inner connection (id: ${this.connection.debugId}) from session (id: ${this.debugId}) to ${this.to}`
+    );
+    this.connection.close();
+    this.connection = void 0;
+  }
+  replaceWithNewConnection(newConn) {
+    this.closeStaleConnection(this.connection);
+    this.cancelGrace();
+    this.connection = newConn;
+  }
+  beginGrace(cb) {
+    this.disconnectionGrace = setTimeout(() => {
+      this.resetBufferedMessages();
+      clearInterval(this.heartbeat);
+      cb();
+    }, SESSION_DISCONNECT_GRACE_MS);
+  }
+  cancelGrace() {
+    this.heartbeatMisses = 0;
+    clearTimeout(this.disconnectionGrace);
+  }
+  get connected() {
+    return this.connection !== void 0;
+  }
+  get nextExpectedSeq() {
+    return this.ack;
+  }
+  constructMsg(partialMsg) {
+    const msg = {
+      ...partialMsg,
+      id: unsafeId(),
+      to: this.to,
+      from: this.from,
+      seq: this.seq,
+      ack: this.ack
+    };
+    this.seq++;
+    return msg;
+  }
+  /**
+   * Closes the out-going connection but doesn't remove the listeners
+   * for incoming messages. The connection will eventually call onClose
+   * when it is ready to be cleaned up and only then will {@link connection} be set back
+   * to undefined
+   */
+  halfCloseConnection() {
+    this.connection?.close();
+  }
+  inspectSendBuffer() {
+    return this.sendBuffer;
   }
 };
+
+// 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/transport.ts
+var import_nanoid3 = require("nanoid");
+
+// util/stringify.ts
+function coerceErrorString(err) {
+  if (err instanceof Error) {
+    return err.message;
+  }
+  return `[coerced to error] ${String(err)}`;
+}
+
+// transport/transport.ts
+var DEFAULT_RECONNECT_JITTER_MAX_MS = 500;
+var DEFAULT_RECONNECT_INTERVAL_MS = 250;
+var defaultTransportOptions = {
+  retryIntervalMs: DEFAULT_RECONNECT_INTERVAL_MS,
+  retryJitterMs: DEFAULT_RECONNECT_JITTER_MAX_MS,
+  retryAttemptsMax: 5,
+  codec: NaiveJsonCodec
+};
 var Transport = class {
+  /**
+   * Unique per instance of the transport.
+   * This allows us to distinguish reconnects to different
+   * transports.
+   */
+  instanceId = (0, import_nanoid3.nanoid)();
+  connectedInstanceIds = /* @__PURE__ */ new Map();
   /**
    * A flag indicating whether the transport has been destroyed.
    * A destroyed transport will not attempt to reconnect and cannot be used again.
@@ -120,83 +425,125 @@ var Transport = class {
    */
   clientId;
   /**
-   * An array of message IDs that are waiting to be sent over the WebSocket connection.
-   * This builds up if the WebSocket is down for a period of time.
-   */
-  sendQueue;
-  /**
-   * The buffer of messages that have been sent but not yet acknowledged.
+   * The map of {@link Session}s managed by this transport.
    */
-  sendBuffer;
+  sessions;
   /**
    * The map of {@link Connection}s managed by this transport.
    */
-  connections;
+  get connections() {
+    return new Map(
+      [...this.sessions].map(([client, session]) => [client, session.connection]).filter((entry) => entry[1] !== void 0)
+    );
+  }
   /**
    * The event dispatcher for handling events of type EventTypes.
    */
   eventDispatcher;
+  /**
+   * The options for this transport.
+   */
+  options;
   /**
    * Creates a new Transport instance.
    * This should also set up {@link onConnect}, and {@link onDisconnect} listeners.
    * @param codec The codec used to encode and decode messages.
    * @param clientId The client ID of this transport.
    */
-  constructor(codec, clientId) {
+  constructor(clientId, providedOptions) {
+    this.options = { ...defaultTransportOptions, ...providedOptions };
     this.eventDispatcher = new EventDispatcher();
-    this.sendBuffer = /* @__PURE__ */ new Map();
-    this.sendQueue = /* @__PURE__ */ new Map();
-    this.connections = /* @__PURE__ */ new Map();
-    this.codec = codec;
+    this.sessions = /* @__PURE__ */ new Map();
+    this.codec = this.options.codec;
     this.clientId = clientId;
     this.state = "open";
   }
+  sessionByClientId(clientId) {
+    const session = this.sessions.get(clientId);
+    if (!session) {
+      const err = `${this.clientId} -- (invariant violation) no existing session for ${clientId}`;
+      log?.error(err);
+      throw new Error(err);
+    }
+    return session;
+  }
   /**
-   * The downstream implementation needs to call this when a new connection is established.
+   * Called when a new connection is established
+   * and we know the identity of the connected client.
    * @param conn The connection object.
    */
-  onConnect(conn) {
-    log?.info(`${this.clientId} -- new connection to ${conn.connectedTo}`);
-    this.connections.set(conn.connectedTo, conn);
+  onConnect(conn, connectedTo, instanceId) {
     this.eventDispatcher.dispatchEvent("connectionStatus", {
       status: "connect",
       conn
     });
-    const outstanding = this.sendQueue.get(conn.connectedTo);
-    if (!outstanding) {
-      return;
+    let session = this.sessions.get(connectedTo);
+    const lastInstanceId = this.connectedInstanceIds.get(connectedTo);
+    if (session && lastInstanceId !== instanceId && lastInstanceId !== void 0) {
+      log?.debug(
+        `${this.clientId} -- handshake from ${connectedTo} has different server instance (got: ${instanceId}, last connected to: ${lastInstanceId}), starting a new session`
+      );
+      session.resetBufferedMessages();
+      session.closeStaleConnection();
+      this.deleteSession(session);
+      session = void 0;
     }
-    for (const id of outstanding) {
-      const msg = this.sendBuffer.get(id);
-      if (!msg) {
-        log?.warn(
-          `${this.clientId} -- tried to resend a message we received an ack for`
-        );
-        continue;
-      }
-      this.send(msg);
+    this.connectedInstanceIds.set(connectedTo, instanceId);
+    if (session === void 0) {
+      const newSession = this.createSession(connectedTo, conn);
+      log?.info(
+        `${this.clientId} -- new connection (id: ${conn.debugId}) for new session (id: ${newSession.debugId}) to ${connectedTo}`
+      );
+      return newSession;
     }
-    this.sendQueue.delete(conn.connectedTo);
+    log?.info(
+      `${this.clientId} -- new connection (id: ${conn.debugId}) for existing session (id: ${session.debugId}) to ${connectedTo}`
+    );
+    session.replaceWithNewConnection(conn);
+    session.sendBufferedMessages();
+    return session;
+  }
+  createSession(connectedTo, conn) {
+    const session = new Session(
+      this.codec,
+      this.clientId,
+      connectedTo,
+      conn
+    );
+    this.sessions.set(session.to, session);
+    this.eventDispatcher.dispatchEvent("sessionStatus", {
+      status: "connect",
+      session
+    });
+    return session;
+  }
+  deleteSession(session) {
+    this.sessions.delete(session.to);
+    this.eventDispatcher.dispatchEvent("sessionStatus", {
+      status: "disconnect",
+      session
+    });
+    log?.info(
+      `${this.clientId} -- session ${session.debugId} disconnect from ${session.to}`
+    );
   }
   /**
    * The downstream implementation needs to call this when a connection is closed.
    * @param conn The connection object.
    */
-  onDisconnect(conn) {
-    log?.info(`${this.clientId} -- disconnect from ${conn.connectedTo}`);
-    conn.close();
-    this.connections.delete(conn.connectedTo);
+  onDisconnect(conn, connectedTo) {
     this.eventDispatcher.dispatchEvent("connectionStatus", {
       status: "disconnect",
       conn
     });
-  }
-  /**
-   * Handles a message received by this transport. Thin wrapper around {@link handleMsg} and {@link parseMsg}.
-   * @param msg The message to handle.
-   */
-  onMessage(msg) {
-    return this.handleMsg(this.parseMsg(msg));
+    if (!connectedTo)
+      return;
+    const session = this.sessionByClientId(connectedTo);
+    log?.info(
+      `${this.clientId} -- connection (id: ${conn.debugId}) disconnect from ${connectedTo}, ${SESSION_DISCONNECT_GRACE_MS}ms until session (id: ${session.debugId}) disconnect`
+    );
+    session.closeStaleConnection(conn);
+    session.beginGrace(() => this.deleteSession(session));
   }
   /**
    * Parses a message from a Uint8Array into a {@link OpaqueTransportMessage}.
@@ -207,23 +554,24 @@ var Transport = class {
     const parsedMsg = this.codec.fromBuffer(msg);
     if (parsedMsg === null) {
       const decodedBuffer = new TextDecoder().decode(msg);
-      log?.warn(`${this.clientId} -- received malformed msg: ${decodedBuffer}`);
+      log?.error(
+        `${this.clientId} -- received malformed msg, killing conn: ${decodedBuffer}`
+      );
       return null;
     }
-    if (import_value.Value.Check(OpaqueTransportMessageSchema, parsedMsg)) {
-      return {
-        ...parsedMsg,
-        serviceName: parsedMsg.serviceName === null ? void 0 : parsedMsg.serviceName,
-        procedureName: parsedMsg.procedureName === null ? void 0 : parsedMsg.procedureName
-      };
-    } else {
-      log?.warn(
+    if (!import_value.Value.Check(OpaqueTransportMessageSchema, parsedMsg)) {
+      log?.error(
         `${this.clientId} -- received invalid msg: ${JSON.stringify(
           parsedMsg
         )}`
       );
       return null;
     }
+    return {
+      ...parsedMsg,
+      serviceName: parsedMsg.serviceName === null ? void 0 : parsedMsg.serviceName,
+      procedureName: parsedMsg.procedureName === null ? void 0 : parsedMsg.procedureName
+    };
   }
   /**
    * Called when a message is received by this transport.
@@ -231,24 +579,21 @@ var Transport = class {
    * @param msg The received message.
    */
   handleMsg(msg) {
-    if (!msg) {
+    const session = this.sessionByClientId(msg.from);
+    session.cancelGrace();
+    log?.debug(`${this.clientId} -- received msg: ${JSON.stringify(msg)}`);
+    if (msg.seq !== session.nextExpectedSeq) {
+      log?.warn(
+        `${this.clientId} -- received out-of-order msg (got: ${msg.seq}, wanted: ${session.nextExpectedSeq}), discarding: ${JSON.stringify(
+          msg
+        )}`
+      );
       return;
     }
-    if (isAck(msg.controlFlags) && import_value.Value.Check(TransportAckSchema, msg)) {
-      log?.debug(`${this.clientId} -- received ack: ${JSON.stringify(msg)}`);
-      if (this.sendBuffer.has(msg.payload.ack)) {
-        this.sendBuffer.delete(msg.payload.ack);
-      }
-    } else {
-      log?.debug(`${this.clientId} -- received msg: ${JSON.stringify(msg)}`);
+    if (!isAck(msg.controlFlags)) {
       this.eventDispatcher.dispatchEvent("message", msg);
-      if (!isAck(msg.controlFlags)) {
-        const ackMsg = reply(msg, { ack: msg.id });
-        ackMsg.controlFlags = 1 /* AckBit */;
-        ackMsg.from = this.clientId;
-        this.send(ackMsg);
-      }
     }
+    session.updateBookkeeping(msg.ack, msg.seq);
   }
   /**
    * Adds a listener to this transport.
@@ -270,9 +615,9 @@ var Transport = class {
    * Sends a message over this transport, delegating to the appropriate connection to actually
    * send the message.
    * @param msg The message to send.
-   * @returns The ID of the sent message.
+   * @returns The ID of the sent message or undefined if it wasn't sent
    */
-  send(msg) {
+  send(to, msg) {
     if (this.state === "destroyed") {
       const err = "transport is destroyed, cant send";
       log?.error(`${this.clientId} -- ` + err + `: ${JSON.stringify(msg)}`);
@@ -283,110 +628,179 @@ var Transport = class {
           msg
         )}`
       );
-      return msg.id;
+      return void 0;
     }
-    let conn = this.connections.get(msg.to);
-    if (!isAck(msg.controlFlags)) {
-      this.sendBuffer.set(msg.id, msg);
+    let session = this.sessions.get(to);
+    if (!session) {
+      session = this.createSession(to, void 0);
+      log?.info(
+        `${this.clientId} -- no session for ${to}, created a new one (id: ${session.debugId})`
+      );
     }
-    if (conn) {
-      log?.debug(`${this.clientId} -- sending ${JSON.stringify(msg)}`);
-      const ok = conn.send(this.codec.toBuffer(msg));
-      if (ok) {
-        return msg.id;
+    return session.send(msg);
+  }
+  // control helpers
+  sendCloseStream(to, streamId) {
+    return this.send(to, {
+      streamId,
+      controlFlags: 4 /* StreamClosedBit */,
+      payload: {
+        type: "CLOSE"
       }
-    }
-    log?.info(
-      `${this.clientId} -- connection to ${msg.to} not ready, attempting reconnect and queuing ${JSON.stringify(msg)}`
-    );
-    const outstanding = this.sendQueue.get(msg.to) || [];
-    outstanding.push(msg.id);
-    this.sendQueue.set(msg.to, outstanding);
-    this.createNewConnection(msg.to);
-    return msg.id;
+    });
   }
   /**
    * 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.
    */
-  async close() {
-    for (const conn of this.connections.values()) {
-      conn.close();
+  close() {
+    for (const session of this.sessions.values()) {
+      session.halfCloseConnection();
     }
-    this.connections.clear();
     this.state = "closed";
-    log?.info(`${this.clientId} -- closed transport`);
+    log?.info(`${this.clientId} -- manually closed transport`);
   }
   /**
    * Default destroy implementation for transports. You should override this in the downstream
    * implementation if you need to do any additional cleanup and call super.destroy() at the end.
    * Destroys the transport. Any messages sent while the transport is destroyed will throw an error.
    */
-  async destroy() {
-    for (const conn of this.connections.values()) {
-      conn.close();
+  destroy() {
+    for (const session of this.sessions.values()) {
+      session.closeStaleConnection(session.connection);
     }
-    this.connections.clear();
     this.state = "destroyed";
-    log?.info(`${this.clientId} -- destroyed transport`);
+    log?.info(`${this.clientId} -- manually destroyed transport`);
   }
 };
-
-// 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);
+var ClientTransport = class extends Transport {
+  /**
+   * The map of reconnect promises for each client ID.
+   */
+  inflightConnectionPromises;
+  tryReconnecting = true;
+  constructor(clientId, providedOptions) {
+    super(clientId, providedOptions);
+    this.inflightConnectionPromises = /* @__PURE__ */ new Map();
   }
-  return uint8Array;
-}
-var NaiveJsonCodec = {
-  toBuffer: (obj) => {
-    return encoder.encode(
-      JSON.stringify(obj, function replacer(key) {
-        let val = this[key];
-        if (val instanceof Uint8Array) {
-          return { $t: uint8ArrayToBase64(val) };
-        } else {
-          return val;
-        }
-      })
-    );
-  },
-  fromBuffer: (buff) => {
-    try {
-      return JSON.parse(decoder.decode(buff), function reviver(_key, val) {
-        if (val?.$t) {
-          return base64ToUint8Array(val.$t);
-        } else {
-          return val;
+  handleConnection(conn, to) {
+    const bootHandler = this.receiveWithBootSequence(conn, () => {
+      conn.removeDataListener(bootHandler);
+      conn.addDataListener((data) => {
+        const parsed = this.parseMsg(data);
+        if (!parsed) {
+          conn.close();
+          return;
         }
+        this.handleMsg(parsed);
       });
-    } catch {
-      return null;
+    });
+    conn.addDataListener(bootHandler);
+    conn.addCloseListener(() => {
+      this.onDisconnect(conn, to);
+      void this.connect(to);
+    });
+    conn.addErrorListener((err) => {
+      log?.warn(
+        `${this.clientId} -- error in connection (id: ${conn.debugId}) to ${to}: ${coerceErrorString(err)}`
+      );
+    });
+  }
+  /**
+   * Manually attempts to connect to a client.
+   * @param to The client ID of the node to connect to.
+   */
+  async connect(to, attempt = 0) {
+    if (this.state !== "open" || !this.tryReconnecting) {
+      log?.info(
+        `${this.clientId} -- transport state is no longer open, not attempting connection`
+      );
+      return;
+    }
+    let reconnectPromise = this.inflightConnectionPromises.get(to);
+    if (!reconnectPromise) {
+      reconnectPromise = this.createNewOutgoingConnection(to);
+      this.inflightConnectionPromises.set(to, reconnectPromise);
+    }
+    try {
+      const conn = await reconnectPromise;
+      this.state = "open";
+      const requestMsg = bootRequestMessage(this.clientId, to, this.instanceId);
+      log?.debug(`${this.clientId} -- sending boot handshake to ${to}`);
+      conn.send(this.codec.toBuffer(requestMsg));
+    } catch (error) {
+      const errStr = coerceErrorString(error);
+      this.inflightConnectionPromises.delete(to);
+      if (attempt >= this.options.retryAttemptsMax) {
+        const errMsg = `connection to ${to} failed after ${attempt} attempts (${errStr}), giving up`;
+        log?.error(`${this.clientId} -- ${errMsg}`);
+        throw new Error(errMsg);
+      } else {
+        const jitter = Math.floor(Math.random() * this.options.retryJitterMs);
+        const backoffMs = this.options.retryIntervalMs * 2 ** attempt + jitter;
+        log?.warn(
+          `${this.clientId} -- connection to ${to} failed (${errStr}), trying again in ${backoffMs}ms`
+        );
+        setTimeout(() => void this.connect(to, attempt + 1), backoffMs);
+      }
     }
   }
+  receiveWithBootSequence(conn, sessionCb) {
+    const bootHandler = (data) => {
+      const parsed = this.parseMsg(data);
+      if (!parsed) {
+        conn.close();
+        return;
+      }
+      if (!import_value.Value.Check(ControlMessageHandshakeResponseSchema, parsed.payload)) {
+        log?.warn(
+          `${this.clientId} -- received invalid handshake resp: ${JSON.stringify(parsed)}`
+        );
+        return;
+      }
+      if (!parsed.payload.status.ok) {
+        log?.warn(
+          `${this.clientId} -- received failed handshake resp: ${JSON.stringify(
+            parsed
+          )}`
+        );
+        return;
+      }
+      const serverInstanceId = parsed.payload.status.instanceId;
+      log?.debug(
+        `${this.clientId} -- handshake from ${parsed.from} ok (server instance: ${serverInstanceId})`
+      );
+      sessionCb(this.onConnect(conn, parsed.from, serverInstanceId));
+    };
+    return bootHandler;
+  }
+  onDisconnect(conn, connectedTo) {
+    if (connectedTo)
+      this.inflightConnectionPromises.delete(connectedTo);
+    super.onDisconnect(conn, connectedTo);
+  }
 };
 
 // transport/impls/ws/connection.ts
 var WebSocketConnection = class extends Connection {
   ws;
-  constructor(transport, connectedTo, ws) {
-    super(transport, connectedTo);
+  constructor(ws) {
+    super();
     this.ws = ws;
-    ws.binaryType = "arraybuffer";
-    this.ws.onmessage = (msg) => transport.onMessage(msg.data);
+    this.ws.binaryType = "arraybuffer";
+  }
+  addDataListener(cb) {
+    this.ws.onmessage = (msg) => cb(msg.data);
+  }
+  removeDataListener() {
+    this.ws.onmessage = null;
+  }
+  addCloseListener(cb) {
+    this.ws.onclose = cb;
+  }
+  addErrorListener(cb) {
+    this.ws.onerror = (err) => cb(new Error(err.message));
   }
   send(payload) {
     if (this.ws.readyState === this.ws.OPEN) {
@@ -396,26 +810,18 @@ var WebSocketConnection = class extends Connection {
       return false;
     }
   }
-  async close() {
+  close() {
     this.ws.close();
   }
 };
 
 // transport/impls/ws/client.ts
-var defaultOptions = {
-  retryIntervalMs: 250,
-  retryAttemptsMax: 5,
-  codec: NaiveJsonCodec
-};
-var WebSocketClientTransport = class extends Transport {
+var WebSocketClientTransport = class extends ClientTransport {
   /**
    * A function that returns a Promise that resolves to a WebSocket instance.
    */
   wsGetter;
-  options;
   serverId;
-  reconnectPromises;
-  tryReconnecting = true;
   /**
    * Creates a new WebSocketClientTransport instance.
    * @param wsGetter A function that returns a Promise that resolves to a WebSocket instance.
@@ -424,105 +830,62 @@ var WebSocketClientTransport = class extends Transport {
    * @param providedOptions An optional object containing configuration options for the transport.
    */
   constructor(wsGetter, sessionId, serverId, providedOptions) {
-    const options = { ...defaultOptions, ...providedOptions };
-    super(options.codec, sessionId);
+    super(sessionId, providedOptions);
     this.wsGetter = wsGetter;
     this.serverId = serverId;
-    this.options = options;
-    this.reconnectPromises = /* @__PURE__ */ new Map();
-    this.createNewConnection(this.serverId);
+    void this.connect(this.serverId);
   }
   reopen() {
     if (this.state === "destroyed") {
       throw new Error("cant reopen a destroyed connection");
     }
     this.state = "open";
-    this.createNewConnection(this.serverId);
+    void this.connect(this.serverId);
   }
-  async createNewConnection(to, attempt = 0) {
-    if (this.state === "destroyed") {
-      throw new Error("cant reopen a destroyed connection");
-    }
-    let reconnectPromise = this.reconnectPromises.get(to);
-    if (!reconnectPromise) {
-      if (!this.tryReconnecting) {
-        log?.info(
-          `${this.clientId} -- tryReconnecting is false, not attempting reconnect`
-        );
-        return;
-      }
-      reconnectPromise = new Promise(async (resolve) => {
-        log?.info(`${this.clientId} -- establishing a new websocket to ${to}`);
-        try {
-          const ws = await this.wsGetter(to);
-          if (ws.readyState === ws.OPEN) {
-            return resolve({ ws });
-          }
-          if (ws.readyState === ws.CLOSING || ws.readyState === ws.CLOSED) {
-            return resolve({ err: "ws is closing or closed" });
-          }
-          const onOpen = () => {
-            ws.removeEventListener("open", onOpen);
-            resolve({ ws });
-          };
-          const onClose = (evt) => {
-            ws.removeEventListener("close", onClose);
-            resolve({ err: evt.reason });
-          };
-          ws.addEventListener("open", onOpen);
-          ws.addEventListener("close", onClose);
-        } catch (e) {
-          const reason = e instanceof Error ? e.message : "unknown reason";
-          return resolve({ err: `couldn't get a new websocket: ${reason}` });
+  async createNewOutgoingConnection(to) {
+    const wsRes = await new Promise((resolve) => {
+      log?.info(`${this.clientId} -- establishing a new websocket to ${to}`);
+      this.wsGetter(to).then((ws) => {
+        if (ws.readyState === ws.OPEN) {
+          resolve({ ws });
+          return;
         }
+        if (ws.readyState === ws.CLOSING || ws.readyState === ws.CLOSED) {
+          resolve({ err: "ws is closing or closed" });
+          return;
+        }
+        const onOpen = () => {
+          ws.removeEventListener("open", onOpen);
+          resolve({ ws });
+        };
+        const onClose = (evt) => {
+          ws.removeEventListener("close", onClose);
+          resolve({ err: evt.reason });
+        };
+        const onError = (evt) => {
+          ws.removeEventListener("error", onError);
+          ws.removeEventListener("close", onClose);
+          resolve({ err: evt.message });
+        };
+        ws.addEventListener("open", onOpen);
+        ws.addEventListener("close", onClose);
+        ws.addEventListener("error", onError);
+      }).catch((e) => {
+        const reason = e instanceof Error ? e.message : "unknown reason";
+        resolve({ err: `couldn't get a new websocket: ${reason}` });
       });
-      this.reconnectPromises.set(to, reconnectPromise);
-    }
-    const res = await reconnectPromise;
-    if (this.state !== "open") {
-      this.reconnectPromises.delete(to);
-      if ("ws" in res) {
-        res.ws.close();
-      }
-      return;
-    }
-    if ("ws" in res && res.ws.readyState === res.ws.OPEN) {
-      if (res.ws === this.connections.get(to)?.ws) {
-        return;
-      }
-      log?.info(`${this.clientId} -- websocket ok`);
-      const conn = new WebSocketConnection(this, to, res.ws);
-      this.onConnect(conn);
-      res.ws.onclose = () => {
-        this.reconnectPromises.delete(to);
-        this.onDisconnect(conn);
-      };
-      this.state = "open";
-      return;
-    }
-    this.reconnectPromises.delete(to);
-    if (attempt >= this.options.retryAttemptsMax) {
-      throw new Error(
-        `${this.clientId} -- websocket to ${to} failed after ${attempt} attempts, giving up`
+    });
+    if ("ws" in wsRes) {
+      const conn = new WebSocketConnection(wsRes.ws);
+      log?.info(
+        `${this.clientId} -- websocket (id: ${conn.debugId}) to ${to} ok`
       );
+      this.handleConnection(conn, to);
+      return conn;
     } else {
-      log?.warn(
-        `${this.clientId} -- websocket to ${to} failed, trying again in ${this.options.retryIntervalMs * attempt}ms`
-      );
-      setTimeout(
-        () => this.createNewConnection(to, attempt + 1),
-        this.options.retryIntervalMs * attempt
-      );
+      throw new Error(wsRes.err);
     }
   }
-  async close() {
-    super.close();
-    this.reconnectPromises.clear();
-  }
-  async destroy() {
-    super.destroy();
-    this.reconnectPromises.clear();
-  }
 };
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {