@replit/river 0.16.1 → 0.17.0

package/dist/{index-2e402bb8.d.ts → index-8df0bdfb.d.ts}

@@ -170,7 +170,12 @@ declare class Session<ConnType extends Connection> {
     /**
      * The unique ID of this session.
      */
-    debugId: string;
+    id: string;
+    /**
+     * What the other side advertised as their session ID
+     * for this session.
+     */
+    advertisedSessionId?: string;
     /**
      * Number of messages we've sent along this session (excluding handshake and acks)
      */
@@ -191,8 +196,8 @@ declare class Session<ConnType extends Connection> {
     /**
      * The interval for sending heartbeats.
      */
-    private heartbeat?;
-    constructor(from: TransportClientId, connectedTo: TransportClientId, conn: ConnType | undefined, options: SessionOptions);
+    private heartbeat;
+    constructor(conn: ConnType | undefined, from: TransportClientId, to: TransportClientId, options: SessionOptions);
     /**
      * 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.
@@ -222,6 +227,7 @@ declare const ProtocolError: {
     readonly RetriesExceeded: "conn_retry_exceeded";
     readonly HandshakeFailed: "handshake_failed";
     readonly UseAfterDestroy: "use_after_destroy";
+    readonly MessageOrderingViolated: "message_ordering_violated";
 };
 type ProtocolErrorType = (typeof ProtocolError)[keyof typeof ProtocolError];
 interface EventMap {
@@ -308,14 +314,10 @@ declare class LeakyBucketRateLimit {
  * @property {'destroyed'} destroyed - The transport is permanently destroyed and cannot be reopened.
  */
 type TransportStatus = 'open' | 'closed' | 'destroyed';
-type ProvidedTransportOptions = Partial<SessionOptions>;
-type TransportOptions = Required<ProvidedTransportOptions>;
-type ProvidedClientTransportOptions = {
-    connectionRetryOptions?: Partial<ConnectionRetryOptions>;
-} & ProvidedTransportOptions;
-type ClientTransportOptions = SessionOptions & {
-    connectionRetryOptions: ConnectionRetryOptions;
-};
+type TransportOptions = SessionOptions;
+type ProvidedTransportOptions = Partial<TransportOptions>;
+type ProvidedClientTransportOptions = Partial<ClientTransportOptions>;
+type ClientTransportOptions = SessionOptions & ConnectionRetryOptions;
 /**
  * Transports manage the lifecycle (creation/deletion) of sessions and connections. Its responsibilities include:
  *
@@ -347,13 +349,6 @@ type ClientTransportOptions = SessionOptions & {
  * @abstract
  */
 declare abstract class Transport<ConnType extends Connection> {
-    /**
-     * Unique per instance of the transport.
-     * This allows us to distinguish reconnects to different
-     * transports.
-     */
-    instanceId: string;
-    connectedInstanceIds: Map<string, string>;
     /**
      * A flag indicating whether the transport has been destroyed.
      * A destroyed transport will not attempt to reconnect and cannot be used again.
@@ -404,8 +399,9 @@ declare abstract class Transport<ConnType extends Connection> {
      * and we know the identity of the connected client.
      * @param conn The connection object.
      */
-    protected onConnect(conn: ConnType, connectedTo: TransportClientId, instanceId: string): Session<ConnType>;
-    private createSession;
+    protected onConnect(conn: ConnType, connectedTo: TransportClientId, advertisedSessionId: string): Session<ConnType>;
+    protected createSession(to: TransportClientId, conn?: ConnType): Session<ConnType>;
+    protected getOrCreateSession(to: TransportClientId, conn?: ConnType): Session<ConnType>;
     protected deleteSession(session: Session<ConnType>): void;
     /**
      * The downstream implementation needs to call this when a connection is closed.
@@ -469,13 +465,16 @@ declare abstract class ClientTransport<ConnType extends Connection> extends Tran
      */
     inflightConnectionPromises: Map<TransportClientId, Promise<ConnType>>;
     retryBudget: LeakyBucketRateLimit;
-    tryReconnecting: boolean;
-    constructor(clientId: TransportClientId, providedOptions?: ProvidedTransportOptions);
+    /**
+     * A flag indicating whether the transport should automatically reconnect
+     * when a connection is dropped.
+     * Realistically, this should always be true for clients unless you are writing
+     * tests or a special case where you don't want to reconnect.
+     */
+    reconnectOnConnectionDrop: boolean;
+    constructor(clientId: TransportClientId, providedOptions?: ProvidedClientTransportOptions);
     protected handleConnection(conn: ConnType, to: TransportClientId): void;
-    receiveHandshakeResponseMessage(data: Uint8Array): false | {
-        instanceId: string;
-        from: string;
-    };
+    receiveHandshakeResponseMessage(data: Uint8Array, conn: ConnType): Session<ConnType> | false;
     /**
      * Abstract method that creates a new {@link Connection} object.
      * This should call {@link handleConnection} when the connection is created.
@@ -496,10 +495,7 @@ declare abstract class ClientTransport<ConnType extends Connection> extends Tran
 declare abstract class ServerTransport<ConnType extends Connection> extends Transport<ConnType> {
     constructor(clientId: TransportClientId, providedOptions?: ProvidedTransportOptions);
     protected handleConnection(conn: ConnType): void;
-    receiveHandshakeRequestMessage(data: Uint8Array, conn: ConnType): false | {
-        instanceId: string;
-        from: string;
-    };
+    receiveHandshakeRequestMessage(data: Uint8Array, conn: ConnType): Session<ConnType> | false;
 }
 
-export { Connection as C, EventMap as E, OpaqueTransportMessage as O, PartialTransportMessage as P, ServerTransport as S, Transport as T, ClientTransport as a, TransportClientId as b, ProvidedClientTransportOptions as c, ProvidedTransportOptions as d, Session as e, TransportStatus as f, TransportMessageSchema as g, OpaqueTransportMessageSchema as h, TransportMessage as i, isStreamOpen as j, isStreamClose as k, EventTypes as l, EventHandler as m, ProtocolError as n, ProtocolErrorType as o };
+export { Connection as C, EventMap as E, OpaqueTransportMessage as O, PartialTransportMessage as P, SessionOptions as S, Transport as T, ClientTransport as a, TransportClientId as b, ProvidedClientTransportOptions as c, ServerTransport as d, ProvidedTransportOptions as e, Session as f, TransportStatus as g, TransportMessageSchema as h, OpaqueTransportMessageSchema as i, TransportMessage as j, isStreamOpen as k, isStreamClose as l, EventTypes as m, EventHandler as n, ProtocolError as o, ProtocolErrorType as p };

package/dist/{procedures-f0226890.d.ts → procedures-b5ddb54d.d.ts}

@@ -1,6 +1,6 @@
 import { TObject, TUnion, TString, TSchema, TNever, TLiteral, Static } from '@sinclair/typebox';
 import { Pushable } from 'it-pushable';
-import { b as TransportClientId, e as Session, C as Connection } from './index-2e402bb8.js';
+import { b as TransportClientId, f as Session, C as Connection } from './index-8df0bdfb.js';
 
 type TLiteralString = TLiteral<string>;
 type RiverErrorSchema = TObject<{

package/dist/router/index.cjs

@@ -567,14 +567,14 @@ var ControlMessageCloseSchema = import_typebox3.Type.Object({
 var ControlMessageHandshakeRequestSchema = import_typebox3.Type.Object({
   type: import_typebox3.Type.Literal("HANDSHAKE_REQ"),
   protocolVersion: import_typebox3.Type.String(),
-  instanceId: import_typebox3.Type.String()
+  sessionId: import_typebox3.Type.String()
 });
 var ControlMessageHandshakeResponseSchema = import_typebox3.Type.Object({
   type: import_typebox3.Type.Literal("HANDSHAKE_RESP"),
   status: import_typebox3.Type.Union([
     import_typebox3.Type.Object({
       ok: import_typebox3.Type.Literal(true),
-      instanceId: import_typebox3.Type.String()
+      sessionId: import_typebox3.Type.String()
     }),
     import_typebox3.Type.Object({
       ok: import_typebox3.Type.Literal(false),
@@ -655,8 +655,13 @@ function _createRecursiveProxy(callback, path) {
   });
   return proxy;
 }
-var createClient = (transport, serverId, eagerlyConnect = true) => {
-  if (eagerlyConnect) {
+var defaultClientOptions = {
+  connectOnInvoke: true,
+  eagerlyConnect: true
+};
+var createClient = (transport, serverId, providedClientOptions = {}) => {
+  const options = { ...defaultClientOptions, ...providedClientOptions };
+  if (options.eagerlyConnect) {
     void transport.connect(serverId);
   }
   return _createRecursiveProxy(async (opts) => {
@@ -672,6 +677,9 @@ var createClient = (transport, serverId, eagerlyConnect = true) => {
         input
       )}`
     );
+    if (options.connectOnInvoke && !transport.connections.has(serverId)) {
+      void transport.connect(serverId);
+    }
     if (procType === "rpc") {
       return handleRpc(
         transport,

package/dist/router/index.d.cts

@@ -1,7 +1,7 @@
 import { TObject, TUnion, Static } from '@sinclair/typebox';
-import { e as ProcedureMap, c as RiverUncaughtSchema, U as Unbranded, B as Branded, A as AnyProcedure, P as PayloadType, b as Result, R as RiverError, S as ServiceContext } from '../procedures-f0226890.js';
-export { E as Err, O as Ok, a as Procedure, d as ProcedureResult, f as RPCProcedure, m as RiverErrorSchema, j as ServiceContextWithState, k as ServiceContextWithTransportInfo, i as StreamProcedure, h as SubscriptionProcedure, l as UNCAUGHT_ERROR, g as UploadProcedure, V as ValidProcType } from '../procedures-f0226890.js';
-import { S as ServerTransport, C as Connection, a as ClientTransport, b as TransportClientId } from '../index-2e402bb8.js';
+import { e as ProcedureMap, c as RiverUncaughtSchema, U as Unbranded, B as Branded, A as AnyProcedure, P as PayloadType, b as Result, R as RiverError, S as ServiceContext } from '../procedures-b5ddb54d.js';
+export { E as Err, O as Ok, a as Procedure, d as ProcedureResult, f as RPCProcedure, m as RiverErrorSchema, j as ServiceContextWithState, k as ServiceContextWithTransportInfo, i as StreamProcedure, h as SubscriptionProcedure, l as UNCAUGHT_ERROR, g as UploadProcedure, V as ValidProcType } from '../procedures-b5ddb54d.js';
+import { d as ServerTransport, C as Connection, a as ClientTransport, b as TransportClientId } from '../index-8df0bdfb.js';
 import { Pushable } from 'it-pushable';
 import '../types-3e5768ec.js';
 
@@ -381,6 +381,10 @@ type ServiceClient<Router extends AnyService> = {
 type ServerClient<Srv extends Server<ServiceSchemaMap>> = {
     [SvcName in keyof Srv['services']]: ServiceClient<Srv['services'][SvcName]>;
 };
+interface ClientOptions {
+    connectOnInvoke: boolean;
+    eagerlyConnect: boolean;
+}
 /**
  * Creates a client for a given server using the provided transport.
  * Note that the client only needs the type of the server, not the actual
@@ -394,6 +398,6 @@ type ServerClient<Srv extends Server<ServiceSchemaMap>> = {
  * @param {Transport} transport - The transport to use for communication.
  * @returns The client for the server.
  */
-declare const createClient: <Srv extends Server<ServiceSchemaMap>>(transport: ClientTransport<Connection>, serverId: TransportClientId, eagerlyConnect?: boolean) => ServerClient<Srv>;
+declare const createClient: <Srv extends Server<ServiceSchemaMap>>(transport: ClientTransport<Connection>, serverId: TransportClientId, providedClientOptions?: Partial<ClientOptions>) => ServerClient<Srv>;
 
 export { PayloadType, ProcErrors, ProcHandler, ProcInit, ProcInput, ProcOutput, ProcType, ProcedureMap, Result, RiverError, RiverUncaughtSchema, Server, ServerClient, Service, ServiceConfiguration, ServiceContext, ServiceSchema, createClient, createServer };

package/dist/router/index.d.ts

@@ -1,7 +1,7 @@
 import { TObject, TUnion, Static } from '@sinclair/typebox';
-import { e as ProcedureMap, c as RiverUncaughtSchema, U as Unbranded, B as Branded, A as AnyProcedure, P as PayloadType, b as Result, R as RiverError, S as ServiceContext } from '../procedures-f0226890.js';
-export { E as Err, O as Ok, a as Procedure, d as ProcedureResult, f as RPCProcedure, m as RiverErrorSchema, j as ServiceContextWithState, k as ServiceContextWithTransportInfo, i as StreamProcedure, h as SubscriptionProcedure, l as UNCAUGHT_ERROR, g as UploadProcedure, V as ValidProcType } from '../procedures-f0226890.js';
-import { S as ServerTransport, C as Connection, a as ClientTransport, b as TransportClientId } from '../index-2e402bb8.js';
+import { e as ProcedureMap, c as RiverUncaughtSchema, U as Unbranded, B as Branded, A as AnyProcedure, P as PayloadType, b as Result, R as RiverError, S as ServiceContext } from '../procedures-b5ddb54d.js';
+export { E as Err, O as Ok, a as Procedure, d as ProcedureResult, f as RPCProcedure, m as RiverErrorSchema, j as ServiceContextWithState, k as ServiceContextWithTransportInfo, i as StreamProcedure, h as SubscriptionProcedure, l as UNCAUGHT_ERROR, g as UploadProcedure, V as ValidProcType } from '../procedures-b5ddb54d.js';
+import { d as ServerTransport, C as Connection, a as ClientTransport, b as TransportClientId } from '../index-8df0bdfb.js';
 import { Pushable } from 'it-pushable';
 import '../types-3e5768ec.js';
 
@@ -381,6 +381,10 @@ type ServiceClient<Router extends AnyService> = {
 type ServerClient<Srv extends Server<ServiceSchemaMap>> = {
     [SvcName in keyof Srv['services']]: ServiceClient<Srv['services'][SvcName]>;
 };
+interface ClientOptions {
+    connectOnInvoke: boolean;
+    eagerlyConnect: boolean;
+}
 /**
  * Creates a client for a given server using the provided transport.
  * Note that the client only needs the type of the server, not the actual
@@ -394,6 +398,6 @@ type ServerClient<Srv extends Server<ServiceSchemaMap>> = {
  * @param {Transport} transport - The transport to use for communication.
  * @returns The client for the server.
  */
-declare const createClient: <Srv extends Server<ServiceSchemaMap>>(transport: ClientTransport<Connection>, serverId: TransportClientId, eagerlyConnect?: boolean) => ServerClient<Srv>;
+declare const createClient: <Srv extends Server<ServiceSchemaMap>>(transport: ClientTransport<Connection>, serverId: TransportClientId, providedClientOptions?: Partial<ClientOptions>) => ServerClient<Srv>;
 
 export { PayloadType, ProcErrors, ProcHandler, ProcInit, ProcInput, ProcOutput, ProcType, ProcedureMap, Result, RiverError, RiverUncaughtSchema, Server, ServerClient, Service, ServiceConfiguration, ServiceContext, ServiceSchema, createClient, createServer };

package/dist/router/index.js

@@ -7,8 +7,8 @@ import {
   UNCAUGHT_ERROR,
   createClient,
   createServer
-} from "../chunk-Q6WPGM3K.js";
-import "../chunk-GFRAOY75.js";
+} from "../chunk-7IQO434V.js";
+import "../chunk-VH3NGOXQ.js";
 import "../chunk-H4BYJELI.js";
 export {
   Err,

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

@@ -52,18 +52,18 @@ var ControlMessageAckSchema = import_typebox.Type.Object({
 var ControlMessageCloseSchema = import_typebox.Type.Object({
   type: import_typebox.Type.Literal("CLOSE")
 });
-var PROTOCOL_VERSION = "v1";
+var PROTOCOL_VERSION = "v1.1";
 var ControlMessageHandshakeRequestSchema = import_typebox.Type.Object({
   type: import_typebox.Type.Literal("HANDSHAKE_REQ"),
   protocolVersion: import_typebox.Type.String(),
-  instanceId: import_typebox.Type.String()
+  sessionId: 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()
+      sessionId: import_typebox.Type.String()
     }),
     import_typebox.Type.Object({
       ok: import_typebox.Type.Literal(false),
@@ -80,7 +80,7 @@ var ControlMessagePayloadSchema = import_typebox.Type.Union([
 var OpaqueTransportMessageSchema = TransportMessageSchema(
   import_typebox.Type.Unknown()
 );
-function handshakeRequestMessage(from, to, instanceId) {
+function handshakeRequestMessage(from, to, sessionId) {
   return {
     id: (0, import_nanoid.nanoid)(),
     from,
@@ -92,7 +92,7 @@ function handshakeRequestMessage(from, to, instanceId) {
     payload: {
       type: "HANDSHAKE_REQ",
       protocolVersion: PROTOCOL_VERSION,
-      instanceId
+      sessionId
     }
   };
 }
@@ -125,7 +125,12 @@ var Session = class {
   /**
    * The unique ID of this session.
    */
-  debugId;
+  id;
+  /**
+   * What the other side advertised as their session ID
+   * for this session.
+   */
+  advertisedSessionId;
   /**
    * Number of messages we've sent along this session (excluding handshake and acks)
    */
@@ -147,11 +152,11 @@ var Session = class {
    * The interval for sending heartbeats.
    */
   heartbeat;
-  constructor(from, connectedTo, conn, options) {
+  constructor(conn, from, to, options) {
+    this.id = `session-${nanoid2(12)}`;
     this.options = options;
-    this.debugId = `sess-${unsafeId()}`;
     this.from = from;
-    this.to = connectedTo;
+    this.to = to;
     this.connection = conn;
     this.codec = options.codec;
     this.heartbeatMisses = 0;
@@ -191,7 +196,7 @@ var Session = class {
         log?.info(
           `${this.from} -- closing connection (id: ${this.connection.debugId}) to ${this.to} due to inactivity`
         );
-        this.closeStaleConnection(this.connection);
+        this.closeStaleConnection();
       }
       return;
     }
@@ -222,33 +227,37 @@ var Session = class {
       log?.debug(`${this.from} -- resending ${msg.id} (seq: ${msg.seq})`);
       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)`;
+        const msg2 = `${this.from} -- failed to send buffered message to ${this.to} in session (id: ${this.id}) (if you hit this code path something is seriously wrong)`;
         log?.error(msg2);
         throw new Error(msg2);
       }
     }
   }
   updateBookkeeping(ack, seq) {
+    if (seq + 1 < this.ack) {
+      log?.error(`${this.from} -- received stale seq ${seq} + 1 < ${this.ack}`);
+      return;
+    }
     this.sendBuffer = this.sendBuffer.filter((unacked) => unacked.seq > ack);
     this.ack = seq + 1;
   }
   closeStaleConnection(conn) {
-    if (!this.connection || this.connection !== conn)
+    if (this.connection === void 0 || 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.from} -- closing old inner connection (id: ${this.connection.debugId}) from session (id: ${this.id}) to ${this.to}`
     );
     this.connection.close();
     this.connection = void 0;
   }
   replaceWithNewConnection(newConn) {
-    this.closeStaleConnection(this.connection);
+    this.closeStaleConnection(newConn);
     this.cancelGrace();
     this.connection = newConn;
   }
   beginGrace(cb) {
     log?.info(
-      `${this.from} -- starting ${this.options.sessionDisconnectGraceMs}ms grace period until session (id: ${this.debugId}) to ${this.to} is closed`
+      `${this.from} -- starting ${this.options.sessionDisconnectGraceMs}ms grace period until session (id: ${this.id}) to ${this.to} is closed`
     );
     this.disconnectionGrace = setTimeout(() => {
       this.close();
@@ -259,11 +268,12 @@ var Session = class {
   cancelGrace() {
     this.heartbeatMisses = 0;
     clearTimeout(this.disconnectionGrace);
+    this.disconnectionGrace = void 0;
   }
   // closed when we want to discard the whole session
   // (i.e. shutdown or session disconnect)
   close() {
-    this.closeStaleConnection(this.connection);
+    this.closeStaleConnection();
     this.cancelGrace();
     this.resetBufferedMessages();
     clearInterval(this.heartbeat);
@@ -392,7 +402,8 @@ var import_value = require("@sinclair/typebox/value");
 var ProtocolError = {
   RetriesExceeded: "conn_retry_exceeded",
   HandshakeFailed: "handshake_failed",
-  UseAfterDestroy: "use_after_destroy"
+  UseAfterDestroy: "use_after_destroy",
+  MessageOrderingViolated: "message_ordering_violated"
 };
 var EventDispatcher = class {
   eventListeners = {};
@@ -421,9 +432,6 @@ var EventDispatcher = class {
   }
 };
 
-// transport/transport.ts
-var import_nanoid3 = require("nanoid");
-
 // util/stringify.ts
 function coerceErrorString(err) {
   if (err instanceof Error) {
@@ -570,17 +578,10 @@ var defaultConnectionRetryOptions = {
   budgetRestoreIntervalMs: 200
 };
 var defaultClientTransportOptions = {
-  connectionRetryOptions: defaultConnectionRetryOptions,
-  ...defaultTransportOptions
+  ...defaultTransportOptions,
+  ...defaultConnectionRetryOptions
 };
 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.
@@ -633,41 +634,41 @@ var Transport = class {
    * and we know the identity of the connected client.
    * @param conn The connection object.
    */
-  onConnect(conn, connectedTo, instanceId) {
+  onConnect(conn, connectedTo, advertisedSessionId) {
     this.eventDispatcher.dispatchEvent("connectionStatus", {
       status: "connect",
       conn
     });
     let oldSession = this.sessions.get(connectedTo);
-    const lastInstanceId = this.connectedInstanceIds.get(connectedTo);
-    if (oldSession && lastInstanceId !== void 0 && lastInstanceId !== instanceId) {
+    if (oldSession?.advertisedSessionId && oldSession.advertisedSessionId !== advertisedSessionId) {
       log?.warn(
-        `${this.clientId} -- connection from ${connectedTo} is a different instance (got: ${instanceId}, last connected to: ${lastInstanceId}), starting a new session`
+        `${this.clientId} -- connection from ${connectedTo} is a different session (id: ${advertisedSessionId}, last connected to: ${oldSession.advertisedSessionId}), starting a new session`
       );
       oldSession.close();
       this.deleteSession(oldSession);
       oldSession = void 0;
     }
-    this.connectedInstanceIds.set(connectedTo, instanceId);
     if (oldSession === void 0) {
       const newSession = this.createSession(connectedTo, conn);
+      newSession.advertisedSessionId = advertisedSessionId;
       log?.info(
-        `${this.clientId} -- new connection (id: ${conn.debugId}) for new session (id: ${newSession.debugId}) to ${connectedTo}`
+        `${this.clientId} -- new connection (id: ${conn.debugId}) for new session (id: ${newSession.id}) to ${connectedTo}`
       );
       return newSession;
     }
     log?.info(
-      `${this.clientId} -- new connection (id: ${conn.debugId}) for existing session (id: ${oldSession.debugId}) to ${connectedTo}`
+      `${this.clientId} -- new connection (id: ${conn.debugId}) for existing session (id: ${oldSession.id}) to ${connectedTo}`
     );
     oldSession.replaceWithNewConnection(conn);
     oldSession.sendBufferedMessages();
+    oldSession.advertisedSessionId = advertisedSessionId;
     return oldSession;
   }
-  createSession(connectedTo, conn) {
+  createSession(to, conn) {
     const session = new Session(
-      this.clientId,
-      connectedTo,
       conn,
+      this.clientId,
+      to,
       this.options
     );
     this.sessions.set(session.to, session);
@@ -677,10 +678,20 @@ var Transport = class {
     });
     return session;
   }
+  getOrCreateSession(to, conn) {
+    let session = this.sessions.get(to);
+    if (!session) {
+      session = this.createSession(to, conn);
+      log?.info(
+        `${this.clientId} -- no session for ${to}, created a new one (id: ${session.id})`
+      );
+    }
+    return session;
+  }
   deleteSession(session) {
     this.sessions.delete(session.to);
     log?.info(
-      `${this.clientId} -- session ${session.debugId} disconnect from ${session.to}`
+      `${this.clientId} -- session ${session.id} disconnect from ${session.to}`
     );
     this.eventDispatcher.dispatchEvent("sessionStatus", {
       status: "disconnect",
@@ -748,11 +759,14 @@ var Transport = class {
           )}`
         );
       } else {
+        const errMsg = `received out-of-order msg (got seq: ${msg.seq}, wanted seq: ${session.nextExpectedSeq})`;
         log?.error(
-          `${this.clientId} -- received out-of-order msg (got: ${msg.seq}, wanted: ${session.nextExpectedSeq}), marking connection as dead: ${JSON.stringify(msg)}`
+          `${this.clientId} -- fatal: ${errMsg}, marking connection as dead: ${JSON.stringify(
+            msg
+          )}`
         );
+        this.protocolError(ProtocolError.MessageOrderingViolated, errMsg);
         session.close();
-        this.deleteSession(session);
       }
       return;
     }
@@ -799,14 +813,7 @@ var Transport = class {
       );
       return void 0;
     }
-    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})`
-      );
-    }
-    return session.send(msg);
+    return this.getOrCreateSession(to).send(msg);
   }
   // control helpers
   sendCloseStream(to, streamId) {
@@ -858,7 +865,13 @@ var ClientTransport = class extends Transport {
    */
   inflightConnectionPromises;
   retryBudget;
-  tryReconnecting = true;
+  /**
+   * A flag indicating whether the transport should automatically reconnect
+   * when a connection is dropped.
+   * Realistically, this should always be true for clients unless you are writing
+   * tests or a special case where you don't want to reconnect.
+   */
+  reconnectOnConnectionDrop = true;
   constructor(clientId, providedOptions) {
     super(clientId, providedOptions);
     this.options = {
@@ -866,21 +879,20 @@ var ClientTransport = class extends Transport {
       ...providedOptions
     };
     this.inflightConnectionPromises = /* @__PURE__ */ new Map();
-    this.retryBudget = new LeakyBucketRateLimit(
-      this.options.connectionRetryOptions
-    );
+    this.retryBudget = new LeakyBucketRateLimit(this.options);
   }
   handleConnection(conn, to) {
     if (this.state !== "open")
       return;
     let session = void 0;
     const handshakeHandler = (data) => {
-      const handshake = this.receiveHandshakeResponseMessage(data);
-      if (!handshake) {
+      const maybeSession = this.receiveHandshakeResponseMessage(data, conn);
+      if (!maybeSession) {
         conn.close();
         return;
+      } else {
+        session = maybeSession;
       }
-      session = this.onConnect(conn, handshake.from, handshake.instanceId);
       conn.removeDataListener(handshakeHandler);
       conn.addDataListener((data2) => {
         const parsed = this.parseMsg(data2);
@@ -900,7 +912,7 @@ var ClientTransport = class extends Transport {
         `${this.clientId} -- connection (id: ${conn.debugId}) to ${to} disconnected`
       );
       this.inflightConnectionPromises.delete(to);
-      if (this.tryReconnecting) {
+      if (this.reconnectOnConnectionDrop) {
         void this.connect(to);
       }
     });
@@ -910,7 +922,7 @@ var ClientTransport = class extends Transport {
       );
     });
   }
-  receiveHandshakeResponseMessage(data) {
+  receiveHandshakeResponseMessage(data, conn) {
     const parsed = this.parseMsg(data);
     if (!parsed) {
       this.protocolError(
@@ -943,12 +955,14 @@ var ClientTransport = class extends Transport {
       );
       return false;
     }
-    const instanceId = parsed.payload.status.instanceId;
-    log?.debug(
-      `${this.clientId} -- handshake from ${parsed.from} ok (instance: ${instanceId})`
+    log?.debug(`${this.clientId} -- handshake from ${parsed.from} ok`);
+    const session = this.onConnect(
+      conn,
+      parsed.from,
+      parsed.payload.status.sessionId
     );
     this.retryBudget.startRestoringBudget(parsed.from);
-    return { instanceId, from: parsed.from };
+    return session;
   }
   /**
    * Manually attempts to connect to a client.
@@ -1006,7 +1020,7 @@ var ClientTransport = class extends Transport {
     } catch (error) {
       this.inflightConnectionPromises.delete(to);
       const errStr = coerceErrorString(error);
-      if (!this.tryReconnecting || !canProceedWithConnection()) {
+      if (!this.reconnectOnConnectionDrop || !canProceedWithConnection()) {
         log?.warn(`${this.clientId} -- connection to ${to} failed (${errStr})`);
       } else {
         log?.warn(
@@ -1017,11 +1031,8 @@ var ClientTransport = class extends Transport {
     }
   }
   sendHandshake(to, conn) {
-    const requestMsg = handshakeRequestMessage(
-      this.clientId,
-      to,
-      this.instanceId
-    );
+    const session = this.getOrCreateSession(to, conn);
+    const requestMsg = handshakeRequestMessage(this.clientId, to, session.id);
     log?.debug(`${this.clientId} -- sending handshake request to ${to}`);
     conn.send(this.codec.toBuffer(requestMsg));
   }

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

@@ -1,5 +1,5 @@
-import { a as ClientTransport, c as ProvidedClientTransportOptions, b as TransportClientId } from '../../../index-2e402bb8.js';
-import { U as UdsConnection } from '../../../connection-94896f3b.js';
+import { a as ClientTransport, c as ProvidedClientTransportOptions, b as TransportClientId } from '../../../index-8df0bdfb.js';
+import { U as UdsConnection } from '../../../connection-0767dc6b.js';
 import '../../../types-3e5768ec.js';
 import '@sinclair/typebox';
 import 'node:net';

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

@@ -1,5 +1,5 @@
-import { a as ClientTransport, c as ProvidedClientTransportOptions, b as TransportClientId } from '../../../index-2e402bb8.js';
-import { U as UdsConnection } from '../../../connection-94896f3b.js';
+import { a as ClientTransport, c as ProvidedClientTransportOptions, b as TransportClientId } from '../../../index-8df0bdfb.js';
+import { U as UdsConnection } from '../../../connection-0767dc6b.js';
 import '../../../types-3e5768ec.js';
 import '@sinclair/typebox';
 import 'node:net';

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

@@ -1,10 +1,10 @@
 import {
   UdsConnection
-} from "../../../chunk-L65XWBX2.js";
+} from "../../../chunk-VJRLJ3JU.js";
 import {
   ClientTransport
-} from "../../../chunk-7SPCAA6Q.js";
-import "../../../chunk-GFRAOY75.js";
+} from "../../../chunk-LQMPJI3S.js";
+import "../../../chunk-VH3NGOXQ.js";
 import {
   log
 } from "../../../chunk-H4BYJELI.js";