@replit/river 0.26.1 → 0.26.2

package/dist/{handshake-8752f79e.d.ts → handshake-1a86f06d.d.ts}

@@ -84,7 +84,11 @@ interface SessionOptions {
      */
     heartbeatsUntilDead: number;
     /**
-     * Duration to wait between connection disconnect and actual session disconnect
+     * Max duration that a session can be without a connection before we consider
+     * it dead. This deadline is carried between states and is used to determine
+     * when to consider the session a lost cause and delete it entirely.
+     * Generally, this should be strictly greater than the sum of
+     * {@link connectionTimeoutMs} and {@link handshakeTimeoutMs}.
      */
     sessionDisconnectGraceMs: number;
     /**
@@ -95,6 +99,10 @@ interface SessionOptions {
      * Handshake timeout in milliseconds
      */
     handshakeTimeoutMs: number;
+    /**
+     * Whether to enable transparent session reconnects
+     */
+    enableTransparentSessionReconnects: boolean;
     /**
      * The codec to use for encoding/decoding messages over the wire
      */
@@ -143,40 +151,32 @@ declare abstract class IdentifiedSession extends CommonSession {
     _handleStateExit(): void;
     _handleClose(): void;
 }
-
-interface SessionHandshakingListeners {
-    onConnectionErrored: (err: unknown) => void;
-    onConnectionClosed: () => void;
-    onHandshake: (msg: OpaqueTransportMessage) => void;
-    onInvalidHandshake: (reason: string, code: Static<typeof HandshakeErrorResponseCodes>) => void;
-    onHandshakeTimeout: () => void;
+interface IdentifiedSessionWithGracePeriodListeners {
+    onSessionGracePeriodElapsed: () => void;
 }
-interface SessionHandshakingProps<ConnType extends Connection> extends IdentifiedSessionProps {
-    conn: ConnType;
-    listeners: SessionHandshakingListeners;
+interface IdentifiedSessionWithGracePeriodProps extends IdentifiedSessionProps {
+    graceExpiryTime: number;
+    listeners: IdentifiedSessionWithGracePeriodListeners;
 }
-declare class SessionHandshaking<ConnType extends Connection> extends IdentifiedSession {
-    readonly state: SessionState.Handshaking;
-    conn: ConnType;
-    listeners: SessionHandshakingListeners;
-    handshakeTimeout: ReturnType<typeof setTimeout>;
-    constructor(props: SessionHandshakingProps<ConnType>);
-    onHandshakeData: (msg: Uint8Array) => void;
-    sendHandshake(msg: TransportMessage): boolean;
+declare abstract class IdentifiedSessionWithGracePeriod extends IdentifiedSession {
+    graceExpiryTime: number;
+    protected gracePeriodTimeout?: ReturnType<typeof setTimeout>;
+    listeners: IdentifiedSessionWithGracePeriodListeners;
+    constructor(props: IdentifiedSessionWithGracePeriodProps);
     _handleStateExit(): void;
     _handleClose(): void;
 }
 
-interface SessionConnectingListeners {
+interface SessionConnectingListeners extends IdentifiedSessionWithGracePeriodListeners {
     onConnectionEstablished: (conn: Connection) => void;
     onConnectionFailed: (err: unknown) => void;
     onConnectionTimeout: () => void;
 }
-interface SessionConnectingProps<ConnType extends Connection> extends IdentifiedSessionProps {
+interface SessionConnectingProps<ConnType extends Connection> extends IdentifiedSessionWithGracePeriodProps {
     connPromise: Promise<ConnType>;
     listeners: SessionConnectingListeners;
 }
-declare class SessionConnecting<ConnType extends Connection> extends IdentifiedSession {
+declare class SessionConnecting<ConnType extends Connection> extends IdentifiedSessionWithGracePeriod {
     readonly state: SessionState.Connecting;
     connPromise: Promise<ConnType>;
     listeners: SessionConnectingListeners;
@@ -187,21 +187,35 @@ declare class SessionConnecting<ConnType extends Connection> extends IdentifiedS
     _handleClose(): void;
 }
 
-interface SessionNoConnectionListeners {
-    onSessionGracePeriodElapsed: () => void;
-}
-interface SessionNoConnectionProps extends IdentifiedSessionProps {
-    listeners: SessionNoConnectionListeners;
-}
-declare class SessionNoConnection extends IdentifiedSession {
+declare class SessionNoConnection extends IdentifiedSessionWithGracePeriod {
     readonly state: SessionState.NoConnection;
-    listeners: SessionNoConnectionListeners;
-    gracePeriodTimeout?: ReturnType<typeof setTimeout>;
-    constructor(props: SessionNoConnectionProps);
     _handleClose(): void;
     _handleStateExit(): void;
 }
 
+interface SessionHandshakingListeners extends IdentifiedSessionWithGracePeriodListeners {
+    onConnectionErrored: (err: unknown) => void;
+    onConnectionClosed: () => void;
+    onHandshake: (msg: OpaqueTransportMessage) => void;
+    onInvalidHandshake: (reason: string, code: Static<typeof HandshakeErrorResponseCodes>) => void;
+    onHandshakeTimeout: () => void;
+}
+interface SessionHandshakingProps<ConnType extends Connection> extends IdentifiedSessionWithGracePeriodProps {
+    conn: ConnType;
+    listeners: SessionHandshakingListeners;
+}
+declare class SessionHandshaking<ConnType extends Connection> extends IdentifiedSessionWithGracePeriod {
+    readonly state: SessionState.Handshaking;
+    conn: ConnType;
+    listeners: SessionHandshakingListeners;
+    handshakeTimeout?: ReturnType<typeof setTimeout>;
+    constructor(props: SessionHandshakingProps<ConnType>);
+    onHandshakeData: (msg: Uint8Array) => void;
+    sendHandshake(msg: TransportMessage): boolean;
+    _handleStateExit(): void;
+    _handleClose(): void;
+}
+
 interface SessionConnectedListeners {
     onConnectionErrored: (err: unknown) => void;
     onConnectionClosed: () => void;
@@ -229,14 +243,14 @@ declare class SessionConnected<ConnType extends Connection> extends IdentifiedSe
     _handleClose(): void;
 }
 
-interface SessionBackingOffListeners {
+interface SessionBackingOffListeners extends IdentifiedSessionWithGracePeriodListeners {
     onBackoffFinished: () => void;
 }
-interface SessionBackingOffProps extends IdentifiedSessionProps {
+interface SessionBackingOffProps extends IdentifiedSessionWithGracePeriodProps {
     backoffMs: number;
     listeners: SessionBackingOffListeners;
 }
-declare class SessionBackingOff extends IdentifiedSession {
+declare class SessionBackingOff extends IdentifiedSessionWithGracePeriod {
     readonly state: SessionState.BackingOff;
     listeners: SessionBackingOffListeners;
     backoffTimeout?: ReturnType<typeof setTimeout>;
@@ -442,7 +456,7 @@ declare abstract class Transport<ConnType extends Connection> {
     getStatus(): TransportStatus;
     protected updateSession<S extends Session<ConnType>>(session: S): S;
     protected deleteSession(session: Session<ConnType>): void;
-    protected onSessionGracePeriodElapsed(session: SessionNoConnection): void;
+    protected onSessionGracePeriodElapsed(session: Session<ConnType>): void;
     protected onConnectingFailed(session: SessionConnecting<ConnType>): SessionNoConnection;
     protected onConnClosed(session: SessionHandshaking<ConnType> | SessionConnected<ConnType>): SessionNoConnection;
 }
@@ -485,7 +499,7 @@ interface ServiceContext {
  * }
  * ```
  */
-interface ParsedMetadata {
+interface ParsedMetadata extends Record<string, unknown> {
 }
 /**
  * The {@link ServiceContext} with state. This is what is passed to procedures.
@@ -537,4 +551,4 @@ interface ServerHandshakeOptions<MetadataSchema extends TSchema = TSchema> {
 declare function createClientHandshakeOptions<MetadataSchema extends TSchema = TSchema>(schema: MetadataSchema, construct: ConstructHandshake<MetadataSchema>): ClientHandshakeOptions;
 declare function createServerHandshakeOptions<MetadataSchema extends TSchema = TSchema>(schema: MetadataSchema, validate: ValidateHandshake<MetadataSchema>): ServerHandshakeOptions;
 
-export { CommonSessionProps as A, ServerTransportOptions as B, Connection as C, ServerSession as D, EventMap as E, LeakyBucketRateLimit as L, ProvidedTransportOptions as P, Session as S, Transport as T, TransportStatus as a, ProvidedClientTransportOptions as b, ProvidedServerTransportOptions as c, SessionState as d, SessionNoConnection as e, SessionConnecting as f, SessionHandshaking as g, SessionConnected as h, EventTypes as i, EventHandler as j, ProtocolError as k, ProtocolErrorType as l, SessionOptions as m, ClientTransportOptions as n, ServiceContext as o, ClientHandshakeOptions as p, ClientSession as q, SessionBackingOff as r, ServerHandshakeOptions as s, ParsedMetadata as t, ServiceContextWithState as u, ServiceContextWithTransportInfo as v, createClientHandshakeOptions as w, createServerHandshakeOptions as x, CommonSession as y, SessionHandshakingListeners as z };
+export { ServerTransportOptions as A, ServerSession as B, Connection as C, EventMap as E, LeakyBucketRateLimit as L, ProvidedTransportOptions as P, Session as S, Transport as T, TransportStatus as a, ProvidedClientTransportOptions as b, ProvidedServerTransportOptions as c, SessionState as d, SessionNoConnection as e, SessionConnecting as f, SessionHandshaking as g, SessionConnected as h, EventTypes as i, EventHandler as j, ProtocolError as k, ProtocolErrorType as l, SessionOptions as m, ClientTransportOptions as n, ServiceContext as o, ClientHandshakeOptions as p, ClientSession as q, SessionBackingOff as r, ServerHandshakeOptions as s, ParsedMetadata as t, ServiceContextWithState as u, ServiceContextWithTransportInfo as v, createClientHandshakeOptions as w, createServerHandshakeOptions as x, CommonSession as y, CommonSessionProps as z };

package/dist/router/index.cjs

@@ -761,7 +761,7 @@ function Err(error) {
 var import_api = require("@opentelemetry/api");
 
 // package.json
-var version = "0.26.1";
+var version = "0.26.2";
 
 // tracing/index.ts
 function getPropagationContext(ctx) {