@replit/river 0.26.1 → 0.26.3

package/dist/router/index.d.cts

@@ -1,14 +1,15 @@
-import { A as AnyServiceSchemaMap, I as InstantiatedServiceSchemaMap, P as PayloadType, b as Result, R as RiverError } from '../services-fc99aae1.js';
-export { C as Client, E as Err, O as Ok, z as Output, j as ProcErrors, f as ProcHandler, g as ProcInit, h as ProcInput, i as ProcOutput, k as ProcType, a as Procedure, p as ProcedureMap, d as ProcedureResult, q as RPCProcedure, y as ResultUnwrapErr, x as ResultUnwrapOk, w as RiverErrorSchema, c as RiverUncaughtSchema, o as SerializedProcedureSchema, m as SerializedServerSchema, n as SerializedServiceSchema, S as Service, e as ServiceConfiguration, l as ServiceSchema, t as StreamProcedure, r as SubscriptionProcedure, v as UNCAUGHT_ERROR, U as UploadProcedure, V as ValidProcType, u as createClient, s as serializeSchema } from '../services-fc99aae1.js';
+import { A as AnyServiceSchemaMap, I as InstantiatedServiceSchemaMap, P as PayloadType, b as Result, R as RiverError } from '../services-491d8c32.js';
+export { C as Client, E as Err, O as Ok, z as Output, j as ProcErrors, f as ProcHandler, g as ProcInit, h as ProcInput, i as ProcOutput, k as ProcType, a as Procedure, p as ProcedureMap, d as ProcedureResult, q as RPCProcedure, y as ResultUnwrapErr, x as ResultUnwrapOk, w as RiverErrorSchema, c as RiverUncaughtSchema, o as SerializedProcedureSchema, m as SerializedServerSchema, n as SerializedServiceSchema, S as Service, e as ServiceConfiguration, l as ServiceSchema, t as StreamProcedure, r as SubscriptionProcedure, v as UNCAUGHT_ERROR, U as UploadProcedure, V as ValidProcType, u as createClient, s as serializeSchema } from '../services-491d8c32.js';
 import { Static } from '@sinclair/typebox';
 import { Pushable } from 'it-pushable';
-import { C as Connection, s as ServerHandshakeOptions, o as ServiceContext } from '../handshake-8752f79e.js';
-export { t as ParsedMetadata, u as ServiceContextWithState, v as ServiceContextWithTransportInfo, w as createClientHandshakeOptions, x as createServerHandshakeOptions } from '../handshake-8752f79e.js';
-import { S as ServerTransport } from '../server-e304daec.js';
-import '../message-57296605.js';
+import { C as Connection, s as ServerHandshakeOptions, o as ServiceContext } from '../handshake-154a0bb2.js';
+export { t as ParsedMetadata, u as ServiceContextWithState, v as ServiceContextWithTransportInfo, w as createClientHandshakeOptions, x as createServerHandshakeOptions } from '../handshake-154a0bb2.js';
+import { S as ServerTransport } from '../server-1f5eb427.js';
+import '../message-ff78a233.js';
 import '@sinclair/typebox/value';
 import '@opentelemetry/api';
-import '../client-0f636b3a.js';
+import '../client-1894a9c9.js';
+import '@sinclair/typebox/errors';
 import '../types-3e5768ec.js';
 
 /**
@@ -45,6 +46,6 @@ declare function createServer<Services extends AnyServiceSchemaMap>(transport: S
     extendedContext?: Omit<ServiceContext, 'state'>;
 }>): Server<Services>;
 
-var version = "0.26.1";
+var version = "0.26.3";
 
 export { PayloadType, version as RIVER_VERSION, Result, RiverError, Server, ServiceContext, createServer };

package/dist/router/index.d.ts

@@ -1,14 +1,15 @@
-import { A as AnyServiceSchemaMap, I as InstantiatedServiceSchemaMap, P as PayloadType, b as Result, R as RiverError } from '../services-fc99aae1.js';
-export { C as Client, E as Err, O as Ok, z as Output, j as ProcErrors, f as ProcHandler, g as ProcInit, h as ProcInput, i as ProcOutput, k as ProcType, a as Procedure, p as ProcedureMap, d as ProcedureResult, q as RPCProcedure, y as ResultUnwrapErr, x as ResultUnwrapOk, w as RiverErrorSchema, c as RiverUncaughtSchema, o as SerializedProcedureSchema, m as SerializedServerSchema, n as SerializedServiceSchema, S as Service, e as ServiceConfiguration, l as ServiceSchema, t as StreamProcedure, r as SubscriptionProcedure, v as UNCAUGHT_ERROR, U as UploadProcedure, V as ValidProcType, u as createClient, s as serializeSchema } from '../services-fc99aae1.js';
+import { A as AnyServiceSchemaMap, I as InstantiatedServiceSchemaMap, P as PayloadType, b as Result, R as RiverError } from '../services-491d8c32.js';
+export { C as Client, E as Err, O as Ok, z as Output, j as ProcErrors, f as ProcHandler, g as ProcInit, h as ProcInput, i as ProcOutput, k as ProcType, a as Procedure, p as ProcedureMap, d as ProcedureResult, q as RPCProcedure, y as ResultUnwrapErr, x as ResultUnwrapOk, w as RiverErrorSchema, c as RiverUncaughtSchema, o as SerializedProcedureSchema, m as SerializedServerSchema, n as SerializedServiceSchema, S as Service, e as ServiceConfiguration, l as ServiceSchema, t as StreamProcedure, r as SubscriptionProcedure, v as UNCAUGHT_ERROR, U as UploadProcedure, V as ValidProcType, u as createClient, s as serializeSchema } from '../services-491d8c32.js';
 import { Static } from '@sinclair/typebox';
 import { Pushable } from 'it-pushable';
-import { C as Connection, s as ServerHandshakeOptions, o as ServiceContext } from '../handshake-8752f79e.js';
-export { t as ParsedMetadata, u as ServiceContextWithState, v as ServiceContextWithTransportInfo, w as createClientHandshakeOptions, x as createServerHandshakeOptions } from '../handshake-8752f79e.js';
-import { S as ServerTransport } from '../server-e304daec.js';
-import '../message-57296605.js';
+import { C as Connection, s as ServerHandshakeOptions, o as ServiceContext } from '../handshake-154a0bb2.js';
+export { t as ParsedMetadata, u as ServiceContextWithState, v as ServiceContextWithTransportInfo, w as createClientHandshakeOptions, x as createServerHandshakeOptions } from '../handshake-154a0bb2.js';
+import { S as ServerTransport } from '../server-1f5eb427.js';
+import '../message-ff78a233.js';
 import '@sinclair/typebox/value';
 import '@opentelemetry/api';
-import '../client-0f636b3a.js';
+import '../client-1894a9c9.js';
+import '@sinclair/typebox/errors';
 import '../types-3e5768ec.js';
 
 /**
@@ -45,6 +46,6 @@ declare function createServer<Services extends AnyServiceSchemaMap>(transport: S
     extendedContext?: Omit<ServiceContext, 'state'>;
 }>): Server<Services>;
 
-var version = "0.26.1";
+var version = "0.26.3";
 
 export { PayloadType, version as RIVER_VERSION, Result, RiverError, Server, ServiceContext, createServer };

package/dist/router/index.js

@@ -10,10 +10,10 @@ import {
   createServer,
   createServerHandshakeOptions,
   serializeSchema
-} from "../chunk-4W5LENT2.js";
+} from "../chunk-3JCZNGF7.js";
 import {
   version
-} from "../chunk-UQOD22AN.js";
+} from "../chunk-MZELCWJK.js";
 export {
   Err,
   Ok,

package/dist/{server-e304daec.d.ts → server-1f5eb427.d.ts}

@@ -1,18 +1,40 @@
-import { C as Connection, y as CommonSession, d as SessionState, z as SessionHandshakingListeners, A as CommonSessionProps, T as Transport, B as ServerTransportOptions, s as ServerHandshakeOptions, t as ParsedMetadata, D as ServerSession, c as ProvidedServerTransportOptions } from './handshake-8752f79e.js';
-import { M as MessageMetadata, a as TransportMessage, c as TransportClientId, P as PartialTransportMessage, b as OpaqueTransportMessage } from './message-57296605.js';
+import { C as Connection, y as CommonSession, d as SessionState, z as CommonSessionProps, T as Transport, A as ServerTransportOptions, s as ServerHandshakeOptions, t as ParsedMetadata, B as ServerSession, c as ProvidedServerTransportOptions } from './handshake-154a0bb2.js';
+import { b as OpaqueTransportMessage, e as Tags, a as TransportMessage, H as HandshakeErrorResponseCodes, c as TransportClientId, P as PartialTransportMessage } from './message-ff78a233.js';
+import * as _sinclair_typebox_errors from '@sinclair/typebox/errors';
+import { Static } from '@sinclair/typebox';
 
+interface SessionWaitingForHandshakeListeners {
+    onConnectionErrored: (err: unknown) => void;
+    onConnectionClosed: () => void;
+    onHandshake: (msg: OpaqueTransportMessage) => void;
+    onInvalidHandshake: (reason: string, code: Static<typeof HandshakeErrorResponseCodes>) => void;
+    onHandshakeTimeout: () => void;
+}
 interface SessionWaitingForHandshakeProps<ConnType extends Connection> extends CommonSessionProps {
     conn: ConnType;
-    listeners: SessionHandshakingListeners;
+    listeners: SessionWaitingForHandshakeListeners;
 }
 declare class SessionWaitingForHandshake<ConnType extends Connection> extends CommonSession {
     readonly state: SessionState.WaitingForHandshake;
     conn: ConnType;
-    listeners: SessionHandshakingListeners;
+    listeners: SessionWaitingForHandshakeListeners;
     handshakeTimeout?: ReturnType<typeof setTimeout>;
     constructor(props: SessionWaitingForHandshakeProps<ConnType>);
+    get loggingMetadata(): {
+        protocolVersion?: string | undefined;
+        clientId: string;
+        connectedTo?: string | undefined;
+        sessionId?: string | undefined;
+        connId: string;
+        transportMessage?: Partial<OpaqueTransportMessage> | undefined;
+        validationErrors?: _sinclair_typebox_errors.ValueError[] | undefined;
+        tags?: Tags[] | undefined;
+        telemetry?: {
+            traceId: string;
+            spanId: string;
+        } | undefined;
+    };
     onHandshakeData: (msg: Uint8Array) => void;
-    get loggingMetadata(): MessageMetadata;
     sendHandshake(msg: TransportMessage): boolean;
     _handleStateExit(): void;
     _handleClose(): void;
@@ -41,7 +63,6 @@ declare abstract class ServerTransport<ConnType extends Connection> extends Tran
     protected handleConnection(conn: ConnType): void;
     private rejectHandshakeRequest;
     protected onHandshakeRequest(session: SessionWaitingForHandshake<ConnType>, msg: OpaqueTransportMessage): Promise<void>;
-    private validateHandshakeMetadata;
 }
 
 export { ServerTransport as S, SessionWaitingForHandshake as a };

package/dist/{services-fc99aae1.d.ts → services-491d8c32.d.ts}

@@ -1,8 +1,8 @@
 import { Static, TObject, TUnion, TString, TSchema, TNever, TLiteral } from '@sinclair/typebox';
 import { Pushable } from 'it-pushable';
-import { C as Connection, p as ClientHandshakeOptions, v as ServiceContextWithTransportInfo, o as ServiceContext } from './handshake-8752f79e.js';
-import { c as TransportClientId } from './message-57296605.js';
-import { C as ClientTransport } from './client-0f636b3a.js';
+import { C as Connection, p as ClientHandshakeOptions, v as ServiceContextWithTransportInfo, o as ServiceContext } from './handshake-154a0bb2.js';
+import { c as TransportClientId } from './message-ff78a233.js';
+import { C as ClientTransport } from './client-1894a9c9.js';
 
 type AsyncIter<T> = AsyncGenerator<T, T>;
 /**

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

@@ -218,6 +218,7 @@ var defaultTransportOptions = {
   sessionDisconnectGraceMs: 5e3,
   connectionTimeoutMs: 2e3,
   handshakeTimeoutMs: 1e3,
+  enableTransparentSessionReconnects: true,
   codec: NaiveJsonCodec
 };
 var defaultConnectionRetryOptions = {
@@ -419,6 +420,7 @@ var StateMachineState = class {
         }
         if (prop === "_handleClose") {
           return () => {
+            target._isConsumed = true;
             target._handleStateExit();
             target._handleClose();
           };
@@ -499,15 +501,18 @@ var IdentifiedSession = class extends CommonSession {
   }
   get loggingMetadata() {
     const spanContext = this.telemetry.span.spanContext();
-    return {
+    const metadata = {
       clientId: this.from,
       connectedTo: this.to,
-      sessionId: this.id,
-      telemetry: {
+      sessionId: this.id
+    };
+    if (this.telemetry.span.isRecording()) {
+      metadata.telemetry = {
         traceId: spanContext.traceId,
         spanId: spanContext.spanId
-      }
-    };
+      };
+    }
+    return metadata;
   }
   constructMsg(partialMsg) {
     const msg = {
@@ -536,9 +541,32 @@ var IdentifiedSession = class extends CommonSession {
     this.telemetry.span.end();
   }
 };
+var IdentifiedSessionWithGracePeriod = class extends IdentifiedSession {
+  graceExpiryTime;
+  gracePeriodTimeout;
+  listeners;
+  constructor(props) {
+    super(props);
+    this.listeners = props.listeners;
+    this.graceExpiryTime = props.graceExpiryTime;
+    this.gracePeriodTimeout = setTimeout(() => {
+      this.listeners.onSessionGracePeriodElapsed();
+    }, this.graceExpiryTime - Date.now());
+  }
+  _handleStateExit() {
+    super._handleStateExit();
+    if (this.gracePeriodTimeout) {
+      clearTimeout(this.gracePeriodTimeout);
+      this.gracePeriodTimeout = void 0;
+    }
+  }
+  _handleClose() {
+    super._handleClose();
+  }
+};
 
 // transport/sessionStateMachine/SessionConnecting.ts
-var SessionConnecting = class extends IdentifiedSession {
+var SessionConnecting = class extends IdentifiedSessionWithGracePeriod {
   state = "Connecting" /* Connecting */;
   connPromise;
   listeners;
@@ -566,13 +594,24 @@ var SessionConnecting = class extends IdentifiedSession {
   // close a pending connection if it resolves, ignore errors if the promise
   // ends up rejected anyways
   bestEffortClose() {
-    void this.connPromise.then((conn) => conn.close()).catch(() => {
+    void this.connPromise.then((conn) => {
+      conn.close();
+      this.log?.info(
+        "connection eventually resolved but session has transitioned, closed connection",
+        {
+          ...this.loggingMetadata,
+          ...conn.loggingMetadata
+        }
+      );
+    }).catch(() => {
     });
   }
   _handleStateExit() {
     super._handleStateExit();
-    clearTimeout(this.connectionTimeout);
-    this.connectionTimeout = void 0;
+    if (this.connectionTimeout) {
+      clearTimeout(this.connectionTimeout);
+      this.connectionTimeout = void 0;
+    }
   }
   _handleClose() {
     this.bestEffortClose();
@@ -581,26 +620,13 @@ var SessionConnecting = class extends IdentifiedSession {
 };
 
 // transport/sessionStateMachine/SessionNoConnection.ts
-var SessionNoConnection = class extends IdentifiedSession {
+var SessionNoConnection = class extends IdentifiedSessionWithGracePeriod {
   state = "NoConnection" /* NoConnection */;
-  listeners;
-  gracePeriodTimeout;
-  constructor(props) {
-    super(props);
-    this.listeners = props.listeners;
-    this.gracePeriodTimeout = setTimeout(() => {
-      this.listeners.onSessionGracePeriodElapsed();
-    }, this.options.sessionDisconnectGraceMs);
-  }
   _handleClose() {
     super._handleClose();
   }
   _handleStateExit() {
     super._handleStateExit();
-    if (this.gracePeriodTimeout) {
-      clearTimeout(this.gracePeriodTimeout);
-      this.gracePeriodTimeout = void 0;
-    }
   }
 };
 
@@ -608,7 +634,7 @@ var SessionNoConnection = class extends IdentifiedSession {
 var import_api = require("@opentelemetry/api");
 
 // package.json
-var version = "0.26.1";
+var version = "0.26.3";
 
 // tracing/index.ts
 function getPropagationContext(ctx) {
@@ -656,6 +682,13 @@ var SessionWaitingForHandshake = class extends CommonSession {
     this.conn.addErrorListener(this.listeners.onConnectionErrored);
     this.conn.addCloseListener(this.listeners.onConnectionClosed);
   }
+  get loggingMetadata() {
+    return {
+      clientId: this.from,
+      connId: this.conn.id,
+      ...this.conn.loggingMetadata
+    };
+  }
   onHandshakeData = (msg) => {
     const parsedMsg = this.parseMsg(msg);
     if (parsedMsg === null) {
@@ -667,12 +700,6 @@ var SessionWaitingForHandshake = class extends CommonSession {
     }
     this.listeners.onHandshake(parsedMsg);
   };
-  get loggingMetadata() {
-    return {
-      clientId: this.from,
-      connId: this.conn.id
-    };
-  }
   sendHandshake(msg) {
     return this.conn.send(this.options.codec.toBuffer(msg));
   }
@@ -689,7 +716,7 @@ var SessionWaitingForHandshake = class extends CommonSession {
 };
 
 // transport/sessionStateMachine/SessionHandshaking.ts
-var SessionHandshaking = class extends IdentifiedSession {
+var SessionHandshaking = class extends IdentifiedSessionWithGracePeriod {
   state = "Handshaking" /* Handshaking */;
   conn;
   listeners;
@@ -705,6 +732,12 @@ var SessionHandshaking = class extends IdentifiedSession {
     this.conn.addErrorListener(this.listeners.onConnectionErrored);
     this.conn.addCloseListener(this.listeners.onConnectionClosed);
   }
+  get loggingMetadata() {
+    return {
+      ...super.loggingMetadata,
+      ...this.conn.loggingMetadata
+    };
+  }
   onHandshakeData = (msg) => {
     const parsedMsg = this.parseMsg(msg);
     if (parsedMsg === null) {
@@ -724,7 +757,10 @@ var SessionHandshaking = class extends IdentifiedSession {
     this.conn.removeDataListener(this.onHandshakeData);
     this.conn.removeErrorListener(this.listeners.onConnectionErrored);
     this.conn.removeCloseListener(this.listeners.onConnectionClosed);
-    clearTimeout(this.handshakeTimeout);
+    if (this.handshakeTimeout) {
+      clearTimeout(this.handshakeTimeout);
+      this.handshakeTimeout = void 0;
+    }
   }
   _handleClose() {
     super._handleClose();
@@ -789,6 +825,12 @@ var SessionConnected = class extends IdentifiedSession {
       this.heartbeatMisses++;
     }, this.options.heartbeatIntervalMs);
   }
+  get loggingMetadata() {
+    return {
+      ...super.loggingMetadata,
+      ...this.conn.loggingMetadata
+    };
+  }
   startActiveHeartbeat() {
     this.isActivelyHeartbeating = true;
   }
@@ -804,8 +846,10 @@ var SessionConnected = class extends IdentifiedSession {
   }
   onMessageData = (msg) => {
     const parsedMsg = this.parseMsg(msg);
-    if (parsedMsg === null)
+    if (parsedMsg === null) {
+      this.listeners.onInvalidMessage("could not parse message");
       return;
+    }
     if (parsedMsg.seq !== this.ack) {
       if (parsedMsg.seq < this.ack) {
         this.log?.debug(
@@ -862,7 +906,7 @@ var SessionConnected = class extends IdentifiedSession {
 };
 
 // transport/sessionStateMachine/SessionBackingOff.ts
-var SessionBackingOff = class extends IdentifiedSession {
+var SessionBackingOff = class extends IdentifiedSessionWithGracePeriod {
   state = "BackingOff" /* BackingOff */;
   listeners;
   backoffTimeout;
@@ -899,6 +943,12 @@ function inheritSharedSession(session) {
     log: session.log
   };
 }
+function inheritSharedSessionWithGrace(session) {
+  return {
+    ...inheritSharedSession(session),
+    graceExpiryTime: session.graceExpiryTime
+  };
+}
 var SessionStateGraph = {
   entrypoints: {
     NoConnection: (to, from, listeners, options, log) => {
@@ -912,6 +962,7 @@ var SessionStateGraph = {
         to,
         seq: 0,
         ack: 0,
+        graceExpiryTime: Date.now() + options.sessionDisconnectGraceMs,
         sendBuffer,
         telemetry,
         options,
@@ -943,7 +994,7 @@ var SessionStateGraph = {
   transition: {
     // happy path transitions
     NoConnectionToBackingOff: (oldSession, backoffMs, listeners) => {
-      const carriedState = inheritSharedSession(oldSession);
+      const carriedState = inheritSharedSessionWithGrace(oldSession);
       oldSession._handleStateExit();
       const session = new SessionBackingOff({
         backoffMs,
@@ -960,7 +1011,7 @@ var SessionStateGraph = {
       return session;
     },
     BackingOffToConnecting: (oldSession, connPromise, listeners) => {
-      const carriedState = inheritSharedSession(oldSession);
+      const carriedState = inheritSharedSessionWithGrace(oldSession);
       oldSession._handleStateExit();
       const session = new SessionConnecting({
         connPromise,
@@ -977,7 +1028,7 @@ var SessionStateGraph = {
       return session;
     },
     ConnectingToHandshaking: (oldSession, conn, listeners) => {
-      const carriedState = inheritSharedSession(oldSession);
+      const carriedState = inheritSharedSessionWithGrace(oldSession);
       oldSession._handleStateExit();
       const session = new SessionHandshaking({
         conn,
@@ -1054,9 +1105,12 @@ var SessionStateGraph = {
     },
     // disconnect paths
     BackingOffToNoConnection: (oldSession, listeners) => {
-      const carriedState = inheritSharedSession(oldSession);
+      const carriedState = inheritSharedSessionWithGrace(oldSession);
       oldSession._handleStateExit();
-      const session = new SessionNoConnection({ listeners, ...carriedState });
+      const session = new SessionNoConnection({
+        listeners,
+        ...carriedState
+      });
       session.log?.info(
         `session ${session.id} transition from BackingOff to NoConnection`,
         {
@@ -1067,10 +1121,13 @@ var SessionStateGraph = {
       return session;
     },
     ConnectingToNoConnection: (oldSession, listeners) => {
-      const carriedState = inheritSharedSession(oldSession);
+      const carriedState = inheritSharedSessionWithGrace(oldSession);
       oldSession.bestEffortClose();
       oldSession._handleStateExit();
-      const session = new SessionNoConnection({ listeners, ...carriedState });
+      const session = new SessionNoConnection({
+        listeners,
+        ...carriedState
+      });
       session.log?.info(
         `session ${session.id} transition from Connecting to NoConnection`,
         {
@@ -1081,10 +1138,13 @@ var SessionStateGraph = {
       return session;
     },
     HandshakingToNoConnection: (oldSession, listeners) => {
-      const carriedState = inheritSharedSession(oldSession);
+      const carriedState = inheritSharedSessionWithGrace(oldSession);
       oldSession.conn.close();
       oldSession._handleStateExit();
-      const session = new SessionNoConnection({ listeners, ...carriedState });
+      const session = new SessionNoConnection({
+        listeners,
+        ...carriedState
+      });
       session.log?.info(
         `session ${session.id} transition from Handshaking to NoConnection`,
         {
@@ -1096,9 +1156,14 @@ var SessionStateGraph = {
     },
     ConnectedToNoConnection: (oldSession, listeners) => {
       const carriedState = inheritSharedSession(oldSession);
+      const graceExpiryTime = Date.now() + oldSession.options.sessionDisconnectGraceMs;
       oldSession.conn.close();
       oldSession._handleStateExit();
-      const session = new SessionNoConnection({ listeners, ...carriedState });
+      const session = new SessionNoConnection({
+        listeners,
+        graceExpiryTime,
+        ...carriedState
+      });
       session.log?.info(
         `session ${session.id} transition from Connected to NoConnection`,
         {
@@ -1115,24 +1180,42 @@ var ClientSessionStateGraph = {
   entrypoint: SessionStateGraph.entrypoints.NoConnection,
   transition: {
     // happy paths
+    // NoConnection -> BackingOff: attempt to connect
     NoConnectionToBackingOff: transitions.NoConnectionToBackingOff,
+    // BackingOff -> Connecting: backoff period elapsed, start connection
     BackingOffToConnecting: transitions.BackingOffToConnecting,
+    // Connecting -> Handshaking: connection established, start handshake
     ConnectingToHandshaking: transitions.ConnectingToHandshaking,
+    // Handshaking -> Connected: handshake complete, session ready
     HandshakingToConnected: transitions.HandshakingToConnected,
     // disconnect paths
+    // BackingOff -> NoConnection: unused
     BackingOffToNoConnection: transitions.BackingOffToNoConnection,
+    // Connecting -> NoConnection: connection failed or connection timeout
     ConnectingToNoConnection: transitions.ConnectingToNoConnection,
+    // Handshaking -> NoConnection: connection closed or handshake timeout
     HandshakingToNoConnection: transitions.HandshakingToNoConnection,
+    // Connected -> NoConnection: connection closed
     ConnectedToNoConnection: transitions.ConnectedToNoConnection
+    // destroy/close paths
+    // NoConnection -> x: grace period elapsed
+    // BackingOff -> x: grace period elapsed
+    // Connecting -> x: grace period elapsed
+    // Handshaking -> x: grace period elapsed or invalid handshake message or handshake rejection
+    // Connected -> x: grace period elapsed or invalid message
   }
 };
 var ServerSessionStateGraph = {
   entrypoint: SessionStateGraph.entrypoints.WaitingForHandshake,
   transition: {
     // happy paths
+    // WaitingForHandshake -> Connected: handshake complete, session ready
     WaitingForHandshakeToConnected: transitions.WaitingForHandshakeToConnected,
     // disconnect paths
+    // Connected -> NoConnection: connection closed
     ConnectedToNoConnection: transitions.ConnectedToNoConnection
+    // destroy/close paths
+    // WaitingForHandshake -> x: handshake timeout elapsed or invalid handshake message or handshake rejection or connection closed
   }
 };
 
@@ -1249,8 +1332,9 @@ var Transport = class {
       status: "disconnect",
       session
     });
+    const to = session.to;
     session.close();
-    this.sessions.delete(session.to);
+    this.sessions.delete(to);
   }
   // common listeners
   onSessionGracePeriodElapsed(session) {
@@ -1328,6 +1412,10 @@ var ClientTransport = class extends Transport {
     this.handshakeExtensions = options;
   }
   tryReconnecting(to) {
+    const oldSession = this.sessions.get(to);
+    if (!this.options.enableTransparentSessionReconnects && oldSession) {
+      this.deleteSession(oldSession);
+    }
     if (this.reconnectOnConnectionDrop && this.getStatus() === "open") {
       this.connect(to);
     }
@@ -1414,6 +1502,9 @@ var ClientTransport = class extends Transport {
             handshakingSession.loggingMetadata
           );
           this.onConnClosed(handshakingSession);
+        },
+        onSessionGracePeriodElapsed: () => {
+          this.onSessionGracePeriodElapsed(handshakingSession);
         }
       }
     );
@@ -1447,14 +1538,14 @@ var ClientTransport = class extends Transport {
         msg.payload.status.code
       ) : false;
       const reason = `handshake failed: ${msg.payload.status.reason}`;
+      const to = session.to;
       this.rejectHandshakeResponse(session, reason, {
         ...session.loggingMetadata,
         transportMessage: msg
       });
       if (retriable) {
-        this.tryReconnecting(session.to);
+        this.tryReconnecting(to);
       } else {
-        this.deleteSession(session);
         this.protocolError({
           type: ProtocolError.HandshakeFailed,
           code: msg.payload.status.code,
@@ -1507,6 +1598,12 @@ var ClientTransport = class extends Transport {
    * @param to The client ID of the node to connect to.
    */
   connect(to) {
+    if (this.getStatus() !== "open") {
+      this.log?.info(
+        `transport state is no longer open, cancelling attempt to connect to ${to}`
+      );
+      return;
+    }
     let session = this.sessions.get(to);
     session ??= this.createUnconnectedSession(to);
     if (session.state !== "NoConnection" /* NoConnection */) {
@@ -1516,13 +1613,6 @@ var ClientTransport = class extends Transport {
       );
       return;
     }
-    if (this.getStatus() !== "open") {
-      this.log?.info(
-        `transport state is no longer open, cancelling attempt to connect to ${to}`,
-        session.loggingMetadata
-      );
-      return;
-    }
     if (!this.retryBudget.hasBudget()) {
       const budgetConsumed = this.retryBudget.getBudgetConsumed();
       const errMsg = `tried to connect to ${to} but retry budget exceeded (more than ${budgetConsumed} attempts in the last ${this.retryBudget.totalBudgetRestoreTime}ms)`;
@@ -1560,6 +1650,9 @@ var ClientTransport = class extends Transport {
             }
           );
           this.onBackoffFinished(backingOffSession, reconnectPromise);
+        },
+        onSessionGracePeriodElapsed: () => {
+          this.onSessionGracePeriodElapsed(backingOffSession);
         }
       }
     );
@@ -1591,6 +1684,9 @@ var ClientTransport = class extends Transport {
             connectingSession.loggingMetadata
           );
           this.onConnectingFailed(connectingSession);
+        },
+        onSessionGracePeriodElapsed: () => {
+          this.onSessionGracePeriodElapsed(connectingSession);
         }
       }
     );
@@ -1780,9 +1876,10 @@ var WebSocketClientTransport = class extends ClientTransport {
       };
     });
     const conn = new WebSocketConnection(ws);
-    this.log?.info(`raw websocket to ${to} ok, starting handshake`, {
+    this.log?.info(`raw websocket to ${to} ok`, {
       clientId: this.clientId,
-      connectedTo: to
+      connectedTo: to,
+      ...conn.loggingMetadata
     });
     return conn;
   }