@replit/river 0.26.0 → 0.26.2

package/dist/router/index.d.cts

@@ -1,14 +1,14 @@
-import { A as AnyServiceSchemaMap, I as InstantiatedServiceSchemaMap, P as PayloadType, b as Result, R as RiverError } from '../services-c17f7eff.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-c17f7eff.js';
+import { A as AnyServiceSchemaMap, I as InstantiatedServiceSchemaMap, P as PayloadType, b as Result, R as RiverError } from '../services-7daa60a0.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-7daa60a0.js';
 import { Static } from '@sinclair/typebox';
 import { Pushable } from 'it-pushable';
-import { C as Connection, s as ServerHandshakeOptions, o as ServiceContext } from '../handshake-3342bb94.js';
-export { t as ParsedMetadata, u as ServiceContextWithState, v as ServiceContextWithTransportInfo, w as createClientHandshakeOptions, x as createServerHandshakeOptions } from '../handshake-3342bb94.js';
-import { S as ServerTransport } from '../server-1b695374.js';
-import '../message-1a434848.js';
+import { C as Connection, s as ServerHandshakeOptions, o as ServiceContext } from '../handshake-1a86f06d.js';
+export { t as ParsedMetadata, u as ServiceContextWithState, v as ServiceContextWithTransportInfo, w as createClientHandshakeOptions, x as createServerHandshakeOptions } from '../handshake-1a86f06d.js';
+import { S as ServerTransport } from '../server-9a6b5a8e.js';
+import '../message-57296605.js';
 import '@sinclair/typebox/value';
 import '@opentelemetry/api';
-import '../client-162c509c.js';
+import '../client-654098be.js';
 import '../types-3e5768ec.js';
 
 /**
@@ -45,6 +45,6 @@ declare function createServer<Services extends AnyServiceSchemaMap>(transport: S
     extendedContext?: Omit<ServiceContext, 'state'>;
 }>): Server<Services>;
 
-var version = "0.26.0";
+var version = "0.26.2";
 
 export { PayloadType, version as RIVER_VERSION, Result, RiverError, Server, ServiceContext, createServer };

package/dist/router/index.d.ts

@@ -1,14 +1,14 @@
-import { A as AnyServiceSchemaMap, I as InstantiatedServiceSchemaMap, P as PayloadType, b as Result, R as RiverError } from '../services-c17f7eff.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-c17f7eff.js';
+import { A as AnyServiceSchemaMap, I as InstantiatedServiceSchemaMap, P as PayloadType, b as Result, R as RiverError } from '../services-7daa60a0.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-7daa60a0.js';
 import { Static } from '@sinclair/typebox';
 import { Pushable } from 'it-pushable';
-import { C as Connection, s as ServerHandshakeOptions, o as ServiceContext } from '../handshake-3342bb94.js';
-export { t as ParsedMetadata, u as ServiceContextWithState, v as ServiceContextWithTransportInfo, w as createClientHandshakeOptions, x as createServerHandshakeOptions } from '../handshake-3342bb94.js';
-import { S as ServerTransport } from '../server-1b695374.js';
-import '../message-1a434848.js';
+import { C as Connection, s as ServerHandshakeOptions, o as ServiceContext } from '../handshake-1a86f06d.js';
+export { t as ParsedMetadata, u as ServiceContextWithState, v as ServiceContextWithTransportInfo, w as createClientHandshakeOptions, x as createServerHandshakeOptions } from '../handshake-1a86f06d.js';
+import { S as ServerTransport } from '../server-9a6b5a8e.js';
+import '../message-57296605.js';
 import '@sinclair/typebox/value';
 import '@opentelemetry/api';
-import '../client-162c509c.js';
+import '../client-654098be.js';
 import '../types-3e5768ec.js';
 
 /**
@@ -45,6 +45,6 @@ declare function createServer<Services extends AnyServiceSchemaMap>(transport: S
     extendedContext?: Omit<ServiceContext, 'state'>;
 }>): Server<Services>;
 
-var version = "0.26.0";
+var version = "0.26.2";
 
 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-BNNELZM4.js";
+} from "../chunk-MREEJE3X.js";
 import {
   version
-} from "../chunk-CCUYKR5C.js";
+} from "../chunk-M75K5TJS.js";
 export {
   Err,
   Ok,

package/dist/{server-1b695374.d.ts → server-9a6b5a8e.d.ts}

@@ -1,14 +1,22 @@
-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-3342bb94.js';
-import { M as MessageMetadata, a as TransportMessage, c as TransportClientId, P as PartialTransportMessage, b as OpaqueTransportMessage } from './message-1a434848.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-1a86f06d.js';
+import { M as MessageMetadata, a as TransportMessage, b as OpaqueTransportMessage, H as HandshakeErrorResponseCodes, c as TransportClientId, P as PartialTransportMessage } from './message-57296605.js';
+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>);
     onHandshakeData: (msg: Uint8Array) => void;

package/dist/{services-c17f7eff.d.ts → services-7daa60a0.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-3342bb94.js';
-import { c as TransportClientId } from './message-1a434848.js';
-import { C as ClientTransport } from './client-162c509c.js';
+import { C as Connection, p as ClientHandshakeOptions, v as ServiceContextWithTransportInfo, o as ServiceContext } from './handshake-1a86f06d.js';
+import { c as TransportClientId } from './message-57296605.js';
+import { C as ClientTransport } from './client-654098be.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 = {
@@ -536,9 +537,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;
@@ -571,8 +595,10 @@ var SessionConnecting = class extends IdentifiedSession {
   }
   _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 +607,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 +621,7 @@ var SessionNoConnection = class extends IdentifiedSession {
 var import_api = require("@opentelemetry/api");
 
 // package.json
-var version = "0.26.0";
+var version = "0.26.2";
 
 // tracing/index.ts
 function getPropagationContext(ctx) {
@@ -659,7 +672,10 @@ var SessionWaitingForHandshake = class extends CommonSession {
   onHandshakeData = (msg) => {
     const parsedMsg = this.parseMsg(msg);
     if (parsedMsg === null) {
-      this.listeners.onInvalidHandshake("could not parse message");
+      this.listeners.onInvalidHandshake(
+        "could not parse message",
+        "MALFORMED_HANDSHAKE"
+      );
       return;
     }
     this.listeners.onHandshake(parsedMsg);
@@ -686,7 +702,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,7 +721,10 @@ var SessionHandshaking = class extends IdentifiedSession {
   onHandshakeData = (msg) => {
     const parsedMsg = this.parseMsg(msg);
     if (parsedMsg === null) {
-      this.listeners.onInvalidHandshake("could not parse message");
+      this.listeners.onInvalidHandshake(
+        "could not parse message",
+        "MALFORMED_HANDSHAKE"
+      );
       return;
     }
     this.listeners.onHandshake(parsedMsg);
@@ -718,7 +737,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();
@@ -798,8 +820,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(
@@ -856,7 +880,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;
@@ -893,6 +917,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) => {
@@ -906,6 +936,7 @@ var SessionStateGraph = {
         to,
         seq: 0,
         ack: 0,
+        graceExpiryTime: Date.now() + options.sessionDisconnectGraceMs,
         sendBuffer,
         telemetry,
         options,
@@ -937,7 +968,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,
@@ -954,7 +985,7 @@ var SessionStateGraph = {
       return session;
     },
     BackingOffToConnecting: (oldSession, connPromise, listeners) => {
-      const carriedState = inheritSharedSession(oldSession);
+      const carriedState = inheritSharedSessionWithGrace(oldSession);
       oldSession._handleStateExit();
       const session = new SessionConnecting({
         connPromise,
@@ -971,7 +1002,7 @@ var SessionStateGraph = {
       return session;
     },
     ConnectingToHandshaking: (oldSession, conn, listeners) => {
-      const carriedState = inheritSharedSession(oldSession);
+      const carriedState = inheritSharedSessionWithGrace(oldSession);
       oldSession._handleStateExit();
       const session = new SessionHandshaking({
         conn,
@@ -1048,9 +1079,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`,
         {
@@ -1061,10 +1095,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`,
         {
@@ -1075,10 +1112,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`,
         {
@@ -1090,9 +1130,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`,
         {
@@ -1109,24 +1154,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
   }
 };
 
@@ -1195,8 +1258,8 @@ var Transport = class {
   removeEventListener(type, handler) {
     this.eventDispatcher.removeEventListener(type, handler);
   }
-  protocolError(type, message) {
-    this.eventDispatcher.dispatchEvent("protocolError", { type, message });
+  protocolError(message) {
+    this.eventDispatcher.dispatchEvent("protocolError", message);
   }
   /**
    * Default close implementation for transports. You should override this in the downstream
@@ -1322,6 +1385,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);
     }
@@ -1390,13 +1457,17 @@ var ClientTransport = class extends Transport {
         onHandshake: (msg) => {
           this.onHandshakeResponse(handshakingSession, msg);
         },
-        onInvalidHandshake: (reason) => {
+        onInvalidHandshake: (reason, code) => {
           this.log?.error(
             `invalid handshake: ${reason}`,
             handshakingSession.loggingMetadata
           );
           this.deleteSession(session);
-          this.protocolError(ProtocolError.HandshakeFailed, reason);
+          this.protocolError({
+            type: ProtocolError.HandshakeFailed,
+            code,
+            message: reason
+          });
         },
         onHandshakeTimeout: () => {
           this.log?.error(
@@ -1404,6 +1475,9 @@ var ClientTransport = class extends Transport {
             handshakingSession.loggingMetadata
           );
           this.onConnClosed(handshakingSession);
+        },
+        onSessionGracePeriodElapsed: () => {
+          this.onSessionGracePeriodElapsed(handshakingSession);
         }
       }
     );
@@ -1445,7 +1519,11 @@ var ClientTransport = class extends Transport {
         this.tryReconnecting(session.to);
       } else {
         this.deleteSession(session);
-        this.protocolError(ProtocolError.HandshakeFailed, reason);
+        this.protocolError({
+          type: ProtocolError.HandshakeFailed,
+          code: msg.payload.status.code,
+          message: reason
+        });
       }
       return;
     }
@@ -1479,7 +1557,10 @@ var ClientTransport = class extends Transport {
       onMessage: (msg2) => this.handleMsg(msg2),
       onInvalidMessage: (reason) => {
         this.deleteSession(connectedSession);
-        this.protocolError(ProtocolError.MessageOrderingViolated, reason);
+        this.protocolError({
+          type: ProtocolError.MessageOrderingViolated,
+          message: reason
+        });
       }
     });
     this.updateSession(connectedSession);
@@ -1510,7 +1591,10 @@ var ClientTransport = class extends Transport {
       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)`;
       this.log?.error(errMsg, session.loggingMetadata);
-      this.protocolError(ProtocolError.RetriesExceeded, errMsg);
+      this.protocolError({
+        type: ProtocolError.RetriesExceeded,
+        message: errMsg
+      });
       return;
     }
     const backoffMs = this.retryBudget.getBackoffMs();
@@ -1540,6 +1624,9 @@ var ClientTransport = class extends Transport {
             }
           );
           this.onBackoffFinished(backingOffSession, reconnectPromise);
+        },
+        onSessionGracePeriodElapsed: () => {
+          this.onSessionGracePeriodElapsed(backingOffSession);
         }
       }
     );
@@ -1571,6 +1658,9 @@ var ClientTransport = class extends Transport {
             connectingSession.loggingMetadata
           );
           this.onConnectingFailed(connectingSession);
+        },
+        onSessionGracePeriodElapsed: () => {
+          this.onSessionGracePeriodElapsed(connectingSession);
         }
       }
     );