@replit/river 0.26.0 → 0.26.2

package/dist/{handshake-3342bb94.d.ts → handshake-1a86f06d.d.ts}

@@ -1,5 +1,5 @@
-import { e as TelemetryInfo, M as MessageMetadata, c as TransportClientId, L as Logger, b as OpaqueTransportMessage, P as PartialTransportMessage, a as TransportMessage, f as LogFn, g as LoggingLevel, H as HandshakeErrorCustomHandlerFatalResponseCodes } from './message-1a434848.js';
-import { TSchema, Static } from '@sinclair/typebox';
+import { e as TelemetryInfo, M as MessageMetadata, c as TransportClientId, L as Logger, b as OpaqueTransportMessage, P as PartialTransportMessage, a as TransportMessage, H as HandshakeErrorResponseCodes, f as LogFn, g as LoggingLevel, h as HandshakeErrorCustomHandlerFatalResponseCodes } from './message-57296605.js';
+import { Static, TSchema } from '@sinclair/typebox';
 import { C as Codec } from './types-3e5768ec.js';
 
 /**
@@ -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) => 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>;
@@ -273,7 +287,11 @@ interface EventMap {
         state: SessionState.NoConnection;
     };
     protocolError: {
-        type: ProtocolErrorType;
+        type: (typeof ProtocolError)['HandshakeFailed'];
+        code: Static<typeof HandshakeErrorResponseCodes>;
+        message: string;
+    } | {
+        type: Omit<ProtocolErrorType, (typeof ProtocolError)['HandshakeFailed']>;
         message: string;
     };
     transportStatus: {
@@ -428,7 +446,7 @@ declare abstract class Transport<ConnType extends Connection> {
      * @returns The ID of the sent message or undefined if it wasn't sent
      */
     abstract send(to: TransportClientId, msg: PartialTransportMessage): string;
-    protected protocolError(type: ProtocolErrorType, message: string): void;
+    protected protocolError(message: EventMap['protocolError']): void;
     /**
      * Default close implementation for transports. You should override this in the downstream
      * implementation if you need to do any additional cleanup and call super.close() at the end.
@@ -438,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;
 }
@@ -481,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.
@@ -533,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/logging/index.d.cts

@@ -1,4 +1,4 @@
-export { f as LogFn, L as Logger, M as MessageMetadata, h as coloredStringLogger, j as jsonLogger, s as stringLogger } from '../message-1a434848.js';
+export { f as LogFn, L as Logger, M as MessageMetadata, j as coloredStringLogger, k as jsonLogger, s as stringLogger } from '../message-57296605.js';
 import '@sinclair/typebox/value';
 import '@sinclair/typebox';
 import '@opentelemetry/api';

package/dist/logging/index.d.ts

@@ -1,4 +1,4 @@
-export { f as LogFn, L as Logger, M as MessageMetadata, h as coloredStringLogger, j as jsonLogger, s as stringLogger } from '../message-1a434848.js';
+export { f as LogFn, L as Logger, M as MessageMetadata, j as coloredStringLogger, k as jsonLogger, s as stringLogger } from '../message-57296605.js';
 import '@sinclair/typebox/value';
 import '@sinclair/typebox';
 import '@opentelemetry/api';

package/dist/{message-1a434848.d.ts → message-57296605.d.ts}

@@ -65,6 +65,7 @@ declare const TransportMessageSchema: <T extends TSchema>(t: T) => _sinclair_typ
     payload: T;
 }>;
 declare const HandshakeErrorCustomHandlerFatalResponseCodes: _sinclair_typebox.TUnion<[_sinclair_typebox.TLiteral<"REJECTED_UNSUPPORTED_CLIENT">, _sinclair_typebox.TLiteral<"REJECTED_BY_CUSTOM_HANDLER">]>;
+declare const HandshakeErrorResponseCodes: _sinclair_typebox.TUnion<[_sinclair_typebox.TLiteral<"SESSION_STATE_MISMATCH">, _sinclair_typebox.TUnion<[_sinclair_typebox.TUnion<[_sinclair_typebox.TLiteral<"REJECTED_UNSUPPORTED_CLIENT">, _sinclair_typebox.TLiteral<"REJECTED_BY_CUSTOM_HANDLER">]>, _sinclair_typebox.TLiteral<"MALFORMED_HANDSHAKE_META">, _sinclair_typebox.TLiteral<"MALFORMED_HANDSHAKE">, _sinclair_typebox.TLiteral<"PROTOCOL_VERSION_MISMATCH">]>]>;
 /**
  * Defines the schema for an opaque transport message that is agnostic to any
  * procedure/service.
@@ -134,4 +135,4 @@ declare function isStreamOpen(controlFlag: number): boolean;
  */
 declare function isStreamClose(controlFlag: number): boolean;
 
-export { HandshakeErrorCustomHandlerFatalResponseCodes as H, Logger as L, MessageMetadata as M, OpaqueTransportMessageSchema as O, PartialTransportMessage as P, TransportMessageSchema as T, TransportMessage as a, OpaqueTransportMessage as b, TransportClientId as c, isStreamClose as d, TelemetryInfo as e, LogFn as f, LoggingLevel as g, coloredStringLogger as h, isStreamOpen as i, jsonLogger as j, stringLogger as s };
+export { HandshakeErrorResponseCodes as H, Logger as L, MessageMetadata as M, OpaqueTransportMessageSchema as O, PartialTransportMessage as P, TransportMessageSchema as T, TransportMessage as a, OpaqueTransportMessage as b, TransportClientId as c, isStreamClose as d, TelemetryInfo as e, LogFn as f, LoggingLevel as g, HandshakeErrorCustomHandlerFatalResponseCodes as h, isStreamOpen as i, coloredStringLogger as j, jsonLogger as k, stringLogger as s };

package/dist/router/index.cjs

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