@replit/river 0.12.5 → 0.13.0

package/dist/router/index.cjs

@@ -412,8 +412,8 @@ var TransportMessageSchema = (t) => import_typebox2.Type.Object({
   to: import_typebox2.Type.String(),
   seq: import_typebox2.Type.Integer(),
   ack: import_typebox2.Type.Integer(),
-  serviceName: import_typebox2.Type.Optional(import_typebox2.Type.Union([import_typebox2.Type.String(), import_typebox2.Type.Null()])),
-  procedureName: import_typebox2.Type.Optional(import_typebox2.Type.Union([import_typebox2.Type.String(), import_typebox2.Type.Null()])),
+  serviceName: import_typebox2.Type.Optional(import_typebox2.Type.String()),
+  procedureName: import_typebox2.Type.Optional(import_typebox2.Type.String()),
   streamId: import_typebox2.Type.String(),
   controlFlags: import_typebox2.Type.Integer(),
   payload: t
@@ -424,10 +424,9 @@ var ControlMessageAckSchema = import_typebox2.Type.Object({
 var ControlMessageCloseSchema = import_typebox2.Type.Object({
   type: import_typebox2.Type.Literal("CLOSE")
 });
-var PROTOCOL_VERSION = "v1";
 var ControlMessageHandshakeRequestSchema = import_typebox2.Type.Object({
   type: import_typebox2.Type.Literal("HANDSHAKE_REQ"),
-  protocolVersion: import_typebox2.Type.Literal(PROTOCOL_VERSION),
+  protocolVersion: import_typebox2.Type.String(),
   instanceId: import_typebox2.Type.String()
 });
 var ControlMessageHandshakeResponseSchema = import_typebox2.Type.Object({
@@ -513,7 +512,8 @@ function _createRecursiveProxy(callback, path) {
   });
   return proxy;
 }
-var createClient = (transport, serverId = "SERVER") => _createRecursiveProxy(async (opts) => {
+var createClient = (transport) => _createRecursiveProxy(async (opts) => {
+  const serverId = transport.connectedTo;
   const [serviceName, procName, procType] = [...opts.path];
   if (!(serviceName && procName && procType)) {
     throw new Error(
@@ -878,7 +878,13 @@ var RiverServer = class {
       );
       return;
     }
-    if (!message.serviceName || !(message.serviceName in this.services)) {
+    if (!message.procedureName || !message.serviceName) {
+      log?.warn(
+        `${this.transport.clientId} -- missing procedure or service name in stream open message`
+      );
+      return;
+    }
+    if (!(message.serviceName in this.services)) {
       log?.warn(
         `${this.transport.clientId} -- couldn't find service ${message.serviceName}`
       );
@@ -886,7 +892,7 @@ var RiverServer = class {
     }
     const service = this.services[message.serviceName];
     const serviceContext = this.getContext(service);
-    if (!message.procedureName || !(message.procedureName in service.procedures)) {
+    if (!(message.procedureName in service.procedures)) {
       log?.warn(
         `${this.transport.clientId} -- couldn't find a matching procedure for ${message.serviceName}.${message.procedureName}`
       );
@@ -932,6 +938,13 @@ var RiverServer = class {
     };
     let inputHandler;
     const procHasInitMessage = "init" in procedure;
+    const serviceContextWithTransportInfo = {
+      ...serviceContext,
+      to: message.to,
+      from: message.from,
+      streamId: message.streamId,
+      session
+    };
     switch (procedure.type) {
       case "rpc":
         inputHandler = (async () => {
@@ -941,7 +954,7 @@ var RiverServer = class {
           }
           try {
             const outputMessage = await procedure.handler(
-              serviceContext,
+              serviceContextWithTransportInfo,
               inputMessage.value
             );
             outgoing.push(outputMessage);
@@ -957,10 +970,15 @@ var RiverServer = class {
             if (initMessage.done) {
               return;
             }
-            return procedure.handler(serviceContext, initMessage.value, incoming, outgoing).catch(errorHandler);
+            return procedure.handler(
+              serviceContextWithTransportInfo,
+              initMessage.value,
+              incoming,
+              outgoing
+            ).catch(errorHandler);
           })();
         } else {
-          inputHandler = procedure.handler(serviceContext, incoming, outgoing).catch(errorHandler);
+          inputHandler = procedure.handler(serviceContextWithTransportInfo, incoming, outgoing).catch(errorHandler);
         }
         break;
       case "subscription":
@@ -971,7 +989,7 @@ var RiverServer = class {
           }
           try {
             await procedure.handler(
-              serviceContext,
+              serviceContextWithTransportInfo,
               inputMessage.value,
               outgoing
             );
@@ -989,7 +1007,7 @@ var RiverServer = class {
             }
             try {
               const outputMessage = await procedure.handler(
-                serviceContext,
+                serviceContextWithTransportInfo,
                 initMessage.value,
                 incoming
               );
@@ -1004,7 +1022,7 @@ var RiverServer = class {
           inputHandler = (async () => {
             try {
               const outputMessage = await procedure.handler(
-                serviceContext,
+                serviceContextWithTransportInfo,
                 incoming
               );
               if (!this.disconnectedSessions.has(message.from)) {

package/dist/router/index.d.cts

@@ -1,6 +1,6 @@
-import { A as AnyService, P as PayloadType, b as Result, R as RiverError, S as ServiceContext, d as ProcType, e as ProcInput, f as ProcOutput, g as ProcErrors, h as ProcHasInit, i as ProcInit } from '../builder-c593de11.js';
-export { E as Err, O as Ok, m as ProcHandler, k as ProcListing, a as Procedure, o as RiverErrorSchema, c as RiverUncaughtSchema, l as Service, j as ServiceBuilder, n as ServiceContextWithState, U as UNCAUGHT_ERROR, V as ValidProcType, s as serializeService } from '../builder-c593de11.js';
-import { T as Transport, C as Connection, b as TransportClientId } from '../index-1afc5580.js';
+import { A as AnyService, P as PayloadType, b as Result, R as RiverError, S as ServiceContext, d as ProcType, e as ProcInput, f as ProcOutput, g as ProcErrors, h as ProcHasInit, i as ProcInit } from '../builder-169fbf7f.js';
+export { E as Err, O as Ok, m as ProcHandler, k as ProcListing, a as Procedure, p as RiverErrorSchema, c as RiverUncaughtSchema, l as Service, j as ServiceBuilder, n as ServiceContextWithState, o as ServiceContextWithTransportInfo, U as UNCAUGHT_ERROR, V as ValidProcType, s as serializeService } from '../builder-169fbf7f.js';
+import { S as ServerTransport, C as Connection, a as ClientTransport } from '../index-21c1b21d.js';
 import { Pushable } from 'it-pushable';
 import { Static } from '@sinclair/typebox';
 import '../types-3e5768ec.js';
@@ -50,7 +50,7 @@ interface ProcStream {
  * @param extendedContext - An optional object containing additional context to be passed to all services.
  * @returns A promise that resolves to a server instance with the registered services.
  */
-declare function createServer<Services extends ServiceDefs>(transport: Transport<Connection>, services: Services, extendedContext?: Omit<ServiceContext, 'state'>): Server<Services>;
+declare function createServer<Services extends ServiceDefs>(transport: ServerTransport<Connection>, services: Services, extendedContext?: Omit<ServiceContext, 'state'>): Server<Services>;
 
 type AsyncIter<T> = AsyncGenerator<T, T>;
 /**
@@ -110,6 +110,6 @@ type ServerClient<Srv extends Server<ServiceDefs>> = {
  * @param {Transport} transport - The transport to use for communication.
  * @returns The client for the server.
  */
-declare const createClient: <Srv extends Server<ServiceDefs>>(transport: Transport<Connection>, serverId?: TransportClientId) => ServerClient<Srv>;
+declare const createClient: <Srv extends Server<ServiceDefs>>(transport: ClientTransport<Connection>) => ServerClient<Srv>;
 
 export { PayloadType, ProcInput, ProcOutput, ProcType, Result, RiverError, Server, ServerClient, ServiceContext, ServiceDefs, buildServiceDefs, createClient, createServer };

package/dist/router/index.d.ts

@@ -1,6 +1,6 @@
-import { A as AnyService, P as PayloadType, b as Result, R as RiverError, S as ServiceContext, d as ProcType, e as ProcInput, f as ProcOutput, g as ProcErrors, h as ProcHasInit, i as ProcInit } from '../builder-c593de11.js';
-export { E as Err, O as Ok, m as ProcHandler, k as ProcListing, a as Procedure, o as RiverErrorSchema, c as RiverUncaughtSchema, l as Service, j as ServiceBuilder, n as ServiceContextWithState, U as UNCAUGHT_ERROR, V as ValidProcType, s as serializeService } from '../builder-c593de11.js';
-import { T as Transport, C as Connection, b as TransportClientId } from '../index-1afc5580.js';
+import { A as AnyService, P as PayloadType, b as Result, R as RiverError, S as ServiceContext, d as ProcType, e as ProcInput, f as ProcOutput, g as ProcErrors, h as ProcHasInit, i as ProcInit } from '../builder-169fbf7f.js';
+export { E as Err, O as Ok, m as ProcHandler, k as ProcListing, a as Procedure, p as RiverErrorSchema, c as RiverUncaughtSchema, l as Service, j as ServiceBuilder, n as ServiceContextWithState, o as ServiceContextWithTransportInfo, U as UNCAUGHT_ERROR, V as ValidProcType, s as serializeService } from '../builder-169fbf7f.js';
+import { S as ServerTransport, C as Connection, a as ClientTransport } from '../index-21c1b21d.js';
 import { Pushable } from 'it-pushable';
 import { Static } from '@sinclair/typebox';
 import '../types-3e5768ec.js';
@@ -50,7 +50,7 @@ interface ProcStream {
  * @param extendedContext - An optional object containing additional context to be passed to all services.
  * @returns A promise that resolves to a server instance with the registered services.
  */
-declare function createServer<Services extends ServiceDefs>(transport: Transport<Connection>, services: Services, extendedContext?: Omit<ServiceContext, 'state'>): Server<Services>;
+declare function createServer<Services extends ServiceDefs>(transport: ServerTransport<Connection>, services: Services, extendedContext?: Omit<ServiceContext, 'state'>): Server<Services>;
 
 type AsyncIter<T> = AsyncGenerator<T, T>;
 /**
@@ -110,6 +110,6 @@ type ServerClient<Srv extends Server<ServiceDefs>> = {
  * @param {Transport} transport - The transport to use for communication.
  * @returns The client for the server.
  */
-declare const createClient: <Srv extends Server<ServiceDefs>>(transport: Transport<Connection>, serverId?: TransportClientId) => ServerClient<Srv>;
+declare const createClient: <Srv extends Server<ServiceDefs>>(transport: ClientTransport<Connection>) => ServerClient<Srv>;
 
 export { PayloadType, ProcInput, ProcOutput, ProcType, Result, RiverError, Server, ServerClient, ServiceContext, ServiceDefs, buildServiceDefs, createClient, createServer };

package/dist/router/index.js

@@ -8,8 +8,8 @@ import {
   createClient,
   createServer,
   serializeService
-} from "../chunk-AFLZ6INU.js";
-import "../chunk-XFFS4UOD.js";
+} from "../chunk-CBRQM65K.js";
+import "../chunk-MGGIUH5O.js";
 import "../chunk-H4BYJELI.js";
 export {
   Err,

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

@@ -40,8 +40,8 @@ var TransportMessageSchema = (t) => import_typebox.Type.Object({
   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()])),
+  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(),
   payload: t
@@ -55,7 +55,7 @@ var ControlMessageCloseSchema = import_typebox.Type.Object({
 var PROTOCOL_VERSION = "v1";
 var ControlMessageHandshakeRequestSchema = import_typebox.Type.Object({
   type: import_typebox.Type.Literal("HANDSHAKE_REQ"),
-  protocolVersion: import_typebox.Type.Literal(PROTOCOL_VERSION),
+  protocolVersion: import_typebox.Type.String(),
   instanceId: import_typebox.Type.String()
 });
 var ControlMessageHandshakeResponseSchema = import_typebox.Type.Object({
@@ -80,7 +80,7 @@ var ControlMessagePayloadSchema = import_typebox.Type.Union([
 var OpaqueTransportMessageSchema = TransportMessageSchema(
   import_typebox.Type.Unknown()
 );
-function bootRequestMessage(from, to, instanceId) {
+function handshakeRequestMessage(from, to, instanceId) {
   return {
     id: (0, import_nanoid.nanoid)(),
     from,
@@ -100,6 +100,58 @@ 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/session.ts
 var nanoid2 = (0, import_nanoid2.customAlphabet)("1234567890abcdefghijklmnopqrstuvxyz", 6);
 var unsafeId = () => nanoid2();
@@ -112,8 +164,15 @@ var Connection = class {
 var HEARTBEAT_INTERVAL_MS = 1e3;
 var HEARTBEATS_TILL_DEAD = 2;
 var SESSION_DISCONNECT_GRACE_MS = 5e3;
+var defaultSessionOptions = {
+  heartbeatIntervalMs: HEARTBEAT_INTERVAL_MS,
+  heartbeatsUntilDead: HEARTBEATS_TILL_DEAD,
+  sessionDisconnectGraceMs: SESSION_DISCONNECT_GRACE_MS,
+  codec: NaiveJsonCodec
+};
 var Session = class {
   codec;
+  options;
   /**
    * The buffer of messages that have been sent but not yet acknowledged.
    */
@@ -149,16 +208,17 @@ var Session = class {
    * The interval for sending heartbeats.
    */
   heartbeat;
-  constructor(codec, from, connectedTo, conn) {
+  constructor(from, connectedTo, conn, options) {
+    this.options = options;
     this.debugId = `sess-${unsafeId()}`;
     this.from = from;
     this.to = connectedTo;
     this.connection = conn;
-    this.codec = codec;
+    this.codec = options.codec;
     this.heartbeatMisses = 0;
     this.heartbeat = setInterval(
       () => this.sendHeartbeat(),
-      HEARTBEAT_INTERVAL_MS
+      options.heartbeatIntervalMs
     );
   }
   /**
@@ -194,7 +254,7 @@ var Session = class {
     return fullMsg.id;
   }
   sendHeartbeat() {
-    if (this.heartbeatMisses >= HEARTBEATS_TILL_DEAD) {
+    if (this.heartbeatMisses >= this.options.heartbeatsUntilDead) {
       if (this.connection) {
         log?.info(
           `${this.from} -- closing connection (id: ${this.connection.debugId}) to ${this.to} due to inactivity`
@@ -260,13 +320,11 @@ var Session = class {
     this.cancelGrace();
     this.connection = newConn;
   }
-  graceCb;
   beginGrace(cb) {
-    this.graceCb = cb;
     this.disconnectionGrace = setTimeout(() => {
       this.close();
       cb();
-    }, SESSION_DISCONNECT_GRACE_MS);
+    }, this.options.sessionDisconnectGraceMs);
   }
   // called on reconnect of the underlying session
   cancelGrace() {
@@ -278,8 +336,8 @@ var Session = class {
   close() {
     this.closeStaleConnection(this.connection);
     this.cancelGrace();
-    clearInterval(this.heartbeat);
     this.resetBufferedMessages();
+    clearInterval(this.heartbeat);
   }
   get connected() {
     return this.connection !== void 0;
@@ -428,58 +486,6 @@ var EventDispatcher = class {
   }
 };
 
-// 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");
 
@@ -492,13 +498,13 @@ function coerceErrorString(err) {
 }
 
 // transport/transport.ts
-var DEFAULT_RECONNECT_JITTER_MAX_MS = 500;
-var DEFAULT_RECONNECT_INTERVAL_MS = 250;
+var RECONNECT_JITTER_MAX_MS = 500;
+var RECONNECT_INTERVAL_MS = 250;
 var defaultTransportOptions = {
-  retryIntervalMs: DEFAULT_RECONNECT_INTERVAL_MS,
-  retryJitterMs: DEFAULT_RECONNECT_JITTER_MAX_MS,
+  retryIntervalMs: RECONNECT_INTERVAL_MS,
+  retryJitterMs: RECONNECT_JITTER_MAX_MS,
   retryAttemptsMax: 5,
-  codec: NaiveJsonCodec
+  ...defaultSessionOptions
 };
 var Transport = class {
   /**
@@ -555,15 +561,6 @@ var Transport = class {
     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;
-  }
   /**
    * Called when a new connection is established
    * and we know the identity of the connected client.
@@ -578,7 +575,7 @@ var Transport = class {
     const lastInstanceId = this.connectedInstanceIds.get(connectedTo);
     if (oldSession && lastInstanceId !== void 0 && lastInstanceId !== instanceId) {
       log?.warn(
-        `${this.clientId} -- handshake from ${connectedTo} is a different instance (got: ${instanceId}, last connected to: ${lastInstanceId}), starting a new session`
+        `${this.clientId} -- connection from ${connectedTo} is a different instance (got: ${instanceId}, last connected to: ${lastInstanceId}), starting a new session`
       );
       oldSession.close();
       this.deleteSession(oldSession);
@@ -601,10 +598,10 @@ var Transport = class {
   }
   createSession(connectedTo, conn) {
     const session = new Session(
-      this.codec,
       this.clientId,
       connectedTo,
-      conn
+      conn,
+      this.options
     );
     this.sessions.set(session.to, session);
     this.eventDispatcher.dispatchEvent("sessionStatus", {
@@ -633,13 +630,10 @@ var Transport = class {
       status: "disconnect",
       conn
     });
-    if (this.state !== "open")
+    const session = this.sessions.get(connectedTo);
+    if (!session)
       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.connection = void 0;
     session.beginGrace(() => this.deleteSession(session));
   }
   /**
@@ -650,7 +644,7 @@ var Transport = class {
   parseMsg(msg) {
     const parsedMsg = this.codec.fromBuffer(msg);
     if (parsedMsg === null) {
-      const decodedBuffer = new TextDecoder().decode(msg);
+      const decodedBuffer = new TextDecoder().decode(Buffer.from(msg));
       log?.error(
         `${this.clientId} -- received malformed msg, killing conn: ${decodedBuffer}`
       );
@@ -664,11 +658,7 @@ var Transport = class {
       );
       return null;
     }
-    return {
-      ...parsedMsg,
-      serviceName: parsedMsg.serviceName === null ? void 0 : parsedMsg.serviceName,
-      procedureName: parsedMsg.procedureName === null ? void 0 : parsedMsg.procedureName
-    };
+    return parsedMsg;
   }
   /**
    * Called when a message is received by this transport.
@@ -678,15 +668,27 @@ var Transport = class {
   handleMsg(msg) {
     if (this.state !== "open")
       return;
-    const session = this.sessionByClientId(msg.from);
+    const session = this.sessions.get(msg.from);
+    if (!session) {
+      const err = `${this.clientId} -- (invariant violation) no existing session for ${msg.from}`;
+      log?.error(err);
+      return;
+    }
     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
-        )}`
-      );
+      if (msg.seq < session.nextExpectedSeq) {
+        log?.debug(
+          `${this.clientId} -- received duplicate msg (got: ${msg.seq}, wanted: ${session.nextExpectedSeq}), discarding: ${JSON.stringify(
+            msg
+          )}`
+        );
+      } else {
+        log?.error(
+          `${this.clientId} -- received out-of-order msg (got: ${msg.seq}, wanted: ${session.nextExpectedSeq}), marking connection as dead: ${JSON.stringify(msg)}`
+        );
+        session.closeStaleConnection(session.connection);
+      }
       return;
     }
     if (!isAck(msg.controlFlags)) {
@@ -704,7 +706,7 @@ var Transport = class {
   }
   /**
    * Removes a listener from this transport.
-   * @param the type of event to unlisten on
+   * @param the type of event to un-listen on
    * @param handler The message handler to remove.
    */
   removeEventListener(type, handler) {
@@ -781,23 +783,31 @@ var ClientTransport = class extends Transport {
    */
   inflightConnectionPromises;
   tryReconnecting = true;
-  constructor(clientId, providedOptions) {
+  connectedTo;
+  constructor(clientId, connectedTo, providedOptions) {
     super(clientId, providedOptions);
+    this.connectedTo = connectedTo;
     this.inflightConnectionPromises = /* @__PURE__ */ new Map();
   }
   handleConnection(conn, to) {
-    const bootHandler = this.receiveWithBootSequence(conn, () => {
-      conn.removeDataListener(bootHandler);
-      conn.addDataListener((data) => {
-        const parsed = this.parseMsg(data);
+    const handshakeHandler = (data) => {
+      const handshake = this.receiveHandshakeResponseMessage(data);
+      if (!handshake) {
+        conn.close();
+        return;
+      }
+      this.onConnect(conn, handshake.from, handshake.instanceId);
+      conn.removeDataListener(handshakeHandler);
+      conn.addDataListener((data2) => {
+        const parsed = this.parseMsg(data2);
         if (!parsed) {
           conn.close();
           return;
         }
         this.handleMsg(parsed);
       });
-    });
-    conn.addDataListener(bootHandler);
+    };
+    conn.addDataListener(handshakeHandler);
     conn.addCloseListener(() => {
       this.onDisconnect(conn, to);
       void this.connect(to);
@@ -808,6 +818,32 @@ var ClientTransport = class extends Transport {
       );
     });
   }
+  receiveHandshakeResponseMessage(data) {
+    const parsed = this.parseMsg(data);
+    if (!parsed)
+      return false;
+    if (!import_value.Value.Check(ControlMessageHandshakeResponseSchema, parsed.payload)) {
+      log?.warn(
+        `${this.clientId} -- received invalid handshake resp: ${JSON.stringify(
+          parsed
+        )}`
+      );
+      return false;
+    }
+    if (!parsed.payload.status.ok) {
+      log?.warn(
+        `${this.clientId} -- received failed handshake resp: ${JSON.stringify(
+          parsed
+        )}`
+      );
+      return false;
+    }
+    const instanceId = parsed.payload.status.instanceId;
+    log?.debug(
+      `${this.clientId} -- handshake from ${parsed.from} ok (instance: ${instanceId})`
+    );
+    return { instanceId, from: parsed.from };
+  }
   /**
    * Manually attempts to connect to a client.
    * @param to The client ID of the node to connect to.
@@ -826,10 +862,7 @@ var ClientTransport = class extends Transport {
     }
     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));
+      this.sendHandshake(to, conn);
     } catch (error) {
       const errStr = coerceErrorString(error);
       this.inflightConnectionPromises.delete(to);
@@ -847,34 +880,14 @@ var ClientTransport = class extends Transport {
       }
     }
   }
-  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;
+  sendHandshake(to, conn) {
+    const requestMsg = handshakeRequestMessage(
+      this.clientId,
+      to,
+      this.instanceId
+    );
+    log?.debug(`${this.clientId} -- sending handshake request to ${to}`);
+    conn.send(this.codec.toBuffer(requestMsg));
   }
   onDisconnect(conn, connectedTo) {
     this.inflightConnectionPromises.delete(connectedTo);
@@ -887,7 +900,7 @@ var UnixDomainSocketClientTransport = class extends ClientTransport {
   path;
   serverId;
   constructor(socketPath, clientId, serverId, providedOptions) {
-    super(clientId, providedOptions);
+    super(clientId, serverId, providedOptions);
     this.path = socketPath;
     this.serverId = serverId;
     void this.connect(serverId);

package/dist/transport/impls/uds/client.d.cts

@@ -1,9 +1,8 @@
-import { a as ClientTransport, b as TransportClientId, c as TransportOptions } from '../../../index-1afc5580.js';
-import { U as UdsConnection } from '../../../connection-a6cc48e8.js';
+import { a as ClientTransport, b as TransportClientId, c as TransportOptions } from '../../../index-21c1b21d.js';
+import { U as UdsConnection } from '../../../connection-dd789651.js';
 import '../../../types-3e5768ec.js';
 import '@sinclair/typebox';
 import 'node:net';
-import '../../../messageFraming-b200ef25.js';
 import 'node:stream';
 
 declare class UnixDomainSocketClientTransport extends ClientTransport<UdsConnection> {