@replit/river 0.23.12 → 0.23.14

package/dist/{transport-47af1c81.d.ts → handshake-5665ffd3.d.ts}

@@ -1,5 +1,5 @@
-import { a as TelemetryInfo, M as MessageMetadata, T as TransportClientId, b as PropagationContext, L as Logger, P as PartialTransportMessage, c as TransportMessage, O as OpaqueTransportMessage, g as LogFn, h as LoggingLevel } from './index-60f03cb7.js';
 import { C as Codec } from './types-3e5768ec.js';
+import { e as TelemetryInfo, M as MessageMetadata, c as TransportClientId, f as PropagationContext, L as Logger, P as PartialTransportMessage, a as TransportMessage, b as OpaqueTransportMessage, g as LogFn, h as LoggingLevel } from './index-ea74cdbb.js';
 import { TSchema, Static } from '@sinclair/typebox';
 
 /**
@@ -151,7 +151,9 @@ declare class Session<ConnType extends Connection> {
     closeHandshakingConnection(expectedHandshakingConn?: ConnType): void;
     close(): void;
     get connected(): boolean;
+    get nextExpectedAck(): number;
     get nextExpectedSeq(): number;
+    advanceAckForTesting(by: number): void;
     constructMsg<Payload>(partialMsg: PartialTransportMessage<Payload>): TransportMessage<Payload>;
     inspectSendBuffer(): ReadonlyArray<OpaqueTransportMessage>;
 }
@@ -244,95 +246,12 @@ declare class LeakyBucketRateLimit {
     close(): void;
 }
 
-/**
- * The context for services/procedures. This is used only on
- * the server.
- *
- * An important detail is that the state prop is always on
- * this interface and it shouldn't be changed, removed, or
- * extended. This prop is for the state of a service.
- *
- * You should use declaration merging to extend this interface
- * with whatever you need. For example, if you need to access
- * a database, you could do:
- *
- * ```ts
- * declare module '@replit/river' {
- *   interface ServiceContext {
- *     db: Database;
- *   }
- * }
- * ```
- */
-interface ServiceContext {
-}
-/**
- * The parsed metadata schema for a service. This is the
- * return value of the {@link ServerHandshakeOptions.validate}
- * if the handshake extension is used.
-
- * You should use declaration merging to extend this interface
- * with the sanitized metadata.
- *
- * ```ts
- * declare module '@replit/river' {
- *   interface ParsedMetadata {
- *     userId: number;
- *   }
- * }
- * ```
- */
-interface ParsedMetadata {
-}
-/**
- * The {@link ServiceContext} with state. This is what is passed to procedures.
- */
-type ServiceContextWithState<State> = ServiceContext & {
-    state: State;
-};
-type ServiceContextWithTransportInfo<State> = ServiceContext & {
-    state: State;
-    to: TransportClientId;
-    from: TransportClientId;
-    streamId: string;
-    session: Session<Connection>;
-    metadata: ParsedMetadata;
-};
-
-type ConstructHandshake<T extends TSchema> = () => Static<T> | Promise<Static<T>>;
-type ValidateHandshake<T extends TSchema> = (metadata: Static<T>, previousParsedMetadata?: ParsedMetadata) => false | ParsedMetadata | Promise<false | ParsedMetadata>;
-interface ClientHandshakeOptions<MetadataSchema extends TSchema = TSchema> {
-    /**
-     * Schema for the metadata that the client sends to the server
-     * during the handshake.
-     */
-    schema: MetadataSchema;
-    /**
-     * Gets the {@link HandshakeRequestMetadata} to send to the server.
-     */
-    construct: ConstructHandshake<MetadataSchema>;
-}
-interface ServerHandshakeOptions<MetadataSchema extends TSchema = TSchema> {
-    /**
-     * Schema for the metadata that the server receives from the client
-     * during the handshake.
-     */
-    schema: MetadataSchema;
-    /**
-     * Parses the {@link HandshakeRequestMetadata} sent by the client, transforming
-     * it into {@link ParsedHandshakeMetadata}.
-     *
-     * May return `false` if the client should be rejected.
-     *
-     * @param metadata - The metadata sent by the client.
-     * @param session - The session that the client would be associated with.
-     * @param isReconnect - Whether the client is reconnecting to the session,
-     *                      or if this is a new session.
-     */
-    validate: ValidateHandshake<MetadataSchema>;
-}
-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;
+type TransportOptions = SessionOptions;
+type ProvidedTransportOptions = Partial<TransportOptions>;
+type ClientTransportOptions = TransportOptions & ConnectionRetryOptions;
+type ProvidedClientTransportOptions = Partial<ClientTransportOptions>;
+type ServerTransportOptions = TransportOptions;
+type ProvidedServerTransportOptions = Partial<ServerTransportOptions>;
 
 /**
  * Represents the possible states of a transport.
@@ -340,12 +259,6 @@ declare function createServerHandshakeOptions<MetadataSchema extends TSchema = T
  * @property {'closed'} closed - The transport is permanently closed and cannot be reopened.
  */
 type TransportStatus = 'open' | 'closed';
-type TransportOptions = SessionOptions;
-type ProvidedTransportOptions = Partial<TransportOptions>;
-type ClientTransportOptions = TransportOptions & ConnectionRetryOptions;
-type ProvidedClientTransportOptions = Partial<ClientTransportOptions>;
-type ServerTransportOptions = TransportOptions;
-type ProvidedServerTransportOptions = Partial<ServerTransportOptions>;
 /**
  * Transports manage the lifecycle (creation/deletion) of sessions and connections. Its responsibilities include:
  *
@@ -430,6 +343,17 @@ declare abstract class Transport<ConnType extends Connection> {
      */
     protected onConnect(conn: ConnType, session: Session<ConnType>, isTransparentReconnect: boolean): void;
     protected createSession(to: TransportClientId, conn?: ConnType, propagationCtx?: PropagationContext): Session<ConnType>;
+    protected createNewSession({ to, conn, sessionId, propagationCtx, }: {
+        to: TransportClientId;
+        conn: ConnType;
+        sessionId: string;
+        propagationCtx?: PropagationContext;
+    }): Session<ConnType>;
+    protected getExistingSession({ to, sessionId, nextExpectedSeq, }: {
+        to: TransportClientId;
+        sessionId: string;
+        nextExpectedSeq: number;
+    }): false | Session<ConnType>;
     protected getOrCreateSession({ to, conn, handshakingConn, sessionId, propagationCtx, }: {
         to: TransportClientId;
         conn?: ConnType;
@@ -493,71 +417,95 @@ declare abstract class Transport<ConnType extends Connection> {
     close(): void;
     getStatus(): TransportStatus;
 }
-declare abstract class ClientTransport<ConnType extends Connection> extends Transport<ConnType> {
-    /**
-     * The options for this transport.
-     */
-    protected options: ClientTransportOptions;
-    /**
-     * The map of reconnect promises for each client ID.
-     */
-    inflightConnectionPromises: Map<TransportClientId, Promise<ConnType>>;
-    retryBudget: LeakyBucketRateLimit;
-    /**
-     * 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;
-    /**
-     * Optional handshake options for this client.
-     */
-    handshakeExtensions?: ClientHandshakeOptions;
-    constructor(clientId: TransportClientId, providedOptions?: ProvidedClientTransportOptions);
-    extendHandshake(options: ClientHandshakeOptions): void;
-    protected handleConnection(conn: ConnType, to: TransportClientId): void;
-    receiveHandshakeResponseMessage(data: Uint8Array, conn: ConnType): Session<ConnType> | false;
+
+/**
+ * The context for services/procedures. This is used only on
+ * the server.
+ *
+ * An important detail is that the state prop is always on
+ * this interface and it shouldn't be changed, removed, or
+ * extended. This prop is for the state of a service.
+ *
+ * You should use declaration merging to extend this interface
+ * with whatever you need. For example, if you need to access
+ * a database, you could do:
+ *
+ * ```ts
+ * declare module '@replit/river' {
+ *   interface ServiceContext {
+ *     db: Database;
+ *   }
+ * }
+ * ```
+ */
+interface ServiceContext {
+}
+/**
+ * The parsed metadata schema for a service. This is the
+ * return value of the {@link ServerHandshakeOptions.validate}
+ * if the handshake extension is used.
+
+ * You should use declaration merging to extend this interface
+ * with the sanitized metadata.
+ *
+ * ```ts
+ * declare module '@replit/river' {
+ *   interface ParsedMetadata {
+ *     userId: number;
+ *   }
+ * }
+ * ```
+ */
+interface ParsedMetadata {
+}
+/**
+ * The {@link ServiceContext} with state. This is what is passed to procedures.
+ */
+type ServiceContextWithState<State> = ServiceContext & {
+    state: State;
+};
+type ServiceContextWithTransportInfo<State> = ServiceContext & {
+    state: State;
+    to: TransportClientId;
+    from: TransportClientId;
+    streamId: string;
+    session: Session<Connection>;
+    metadata: ParsedMetadata;
+};
+
+type ConstructHandshake<T extends TSchema> = () => Static<T> | Promise<Static<T>>;
+type ValidateHandshake<T extends TSchema> = (metadata: Static<T>, previousParsedMetadata?: ParsedMetadata) => false | ParsedMetadata | Promise<false | ParsedMetadata>;
+interface ClientHandshakeOptions<MetadataSchema extends TSchema = TSchema> {
     /**
-     * Abstract method that creates a new {@link Connection} object.
-     * This should call {@link handleConnection} when the connection is created.
-     * The downstream client implementation needs to implement this.
-     *
-     * @param to The client ID of the node to connect to.
-     * @returns The new connection object.
+     * Schema for the metadata that the client sends to the server
+     * during the handshake.
      */
-    protected abstract createNewOutgoingConnection(to: TransportClientId): Promise<ConnType>;
+    schema: MetadataSchema;
     /**
-     * Manually attempts to connect to a client.
-     * @param to The client ID of the node to connect to.
+     * Gets the {@link HandshakeRequestMetadata} to send to the server.
      */
-    connect(to: TransportClientId): Promise<void>;
-    protected deleteSession({ session, closeHandshakingConnection, handshakingConn, }: {
-        session: Session<ConnType>;
-        closeHandshakingConnection: boolean;
-        handshakingConn?: ConnType;
-    }): void;
-    protected sendHandshake(to: TransportClientId, conn: ConnType): Promise<boolean>;
-    close(): void;
+    construct: ConstructHandshake<MetadataSchema>;
 }
-declare abstract class ServerTransport<ConnType extends Connection> extends Transport<ConnType> {
-    /**
-     * The options for this transport.
-     */
-    protected options: ServerTransportOptions;
+interface ServerHandshakeOptions<MetadataSchema extends TSchema = TSchema> {
     /**
-     * Optional handshake options for the server.
+     * Schema for the metadata that the server receives from the client
+     * during the handshake.
      */
-    handshakeExtensions?: ServerHandshakeOptions;
+    schema: MetadataSchema;
     /**
-     * A map of session handshake data for each session.
+     * Parses the {@link HandshakeRequestMetadata} sent by the client, transforming
+     * it into {@link ParsedHandshakeMetadata}.
+     *
+     * May return `false` if the client should be rejected.
+     *
+     * @param metadata - The metadata sent by the client.
+     * @param session - The session that the client would be associated with.
+     * @param isReconnect - Whether the client is reconnecting to the session,
+     *                      or if this is a new session.
      */
-    sessionHandshakeMetadata: WeakMap<Session<ConnType>, ParsedMetadata>;
-    constructor(clientId: TransportClientId, providedOptions?: ProvidedServerTransportOptions);
-    extendHandshake(options: ServerHandshakeOptions): void;
-    protected handleConnection(conn: ConnType): void;
-    private validateHandshakeMetadata;
-    receiveHandshakeRequestMessage(data: Uint8Array, conn: ConnType): Promise<Session<ConnType> | false>;
+    validate: ValidateHandshake<MetadataSchema>;
 }
+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 { Connection as C, EventMap as E, ProvidedClientTransportOptions as P, SessionOptions as S, Transport as T, Session as a, ServiceContext as b, ClientTransport as c, ServerTransport as d, ProvidedServerTransportOptions as e, ServerHandshakeOptions as f, ParsedMetadata as g, ServiceContextWithState as h, ServiceContextWithTransportInfo as i, createClientHandshakeOptions as j, createServerHandshakeOptions as k, ClientHandshakeOptions as l, ProvidedTransportOptions as m, TransportStatus as n, EventTypes as o, EventHandler as p, ProtocolError as q, ProtocolErrorType as r };
+export { 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, EventTypes as d, EventHandler as e, ProtocolError as f, ProtocolErrorType as g, SessionOptions as h, ServiceContext as i, ClientTransportOptions as j, ClientHandshakeOptions as k, ServerTransportOptions as l, ServerHandshakeOptions as m, ParsedMetadata as n, ServiceContextWithState as o, ServiceContextWithTransportInfo as p, createClientHandshakeOptions as q, createServerHandshakeOptions as r };

package/dist/{index-60f03cb7.d.ts → index-ea74cdbb.d.ts}

@@ -133,4 +133,4 @@ declare function isStreamOpen(controlFlag: number): boolean;
  */
 declare function isStreamClose(controlFlag: number): boolean;
 
-export { Logger as L, MessageMetadata as M, OpaqueTransportMessage as O, PartialTransportMessage as P, TransportClientId as T, TelemetryInfo as a, PropagationContext as b, TransportMessage as c, TransportMessageSchema as d, OpaqueTransportMessageSchema as e, isStreamClose as f, LogFn as g, LoggingLevel as h, isStreamOpen as i, coloredStringLogger as j, jsonLogger as k, stringLogger as s };
+export { 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, PropagationContext as f, LogFn as g, LoggingLevel as h, isStreamOpen as i, coloredStringLogger as j, jsonLogger as k, stringLogger as s };

package/dist/logging/index.d.cts

@@ -1,4 +1,4 @@
-export { g as LogFn, L as Logger, M as MessageMetadata, j as coloredStringLogger, k as jsonLogger, s as stringLogger } from '../index-60f03cb7.js';
+export { g as LogFn, L as Logger, M as MessageMetadata, j as coloredStringLogger, k as jsonLogger, s as stringLogger } from '../index-ea74cdbb.js';
 import '@sinclair/typebox/value';
 import '@sinclair/typebox';
 import '@opentelemetry/api';

package/dist/logging/index.d.ts

@@ -1,4 +1,4 @@
-export { g as LogFn, L as Logger, M as MessageMetadata, j as coloredStringLogger, k as jsonLogger, s as stringLogger } from '../index-60f03cb7.js';
+export { g as LogFn, L as Logger, M as MessageMetadata, j as coloredStringLogger, k as jsonLogger, s as stringLogger } from '../index-ea74cdbb.js';
 import '@sinclair/typebox/value';
 import '@sinclair/typebox';
 import '@opentelemetry/api';

package/dist/router/index.cjs

@@ -1104,6 +1104,21 @@ var ControlMessageHandshakeRequestSchema = import_typebox3.Type.Object({
   type: import_typebox3.Type.Literal("HANDSHAKE_REQ"),
   protocolVersion: import_typebox3.Type.String(),
   sessionId: import_typebox3.Type.String(),
+  /**
+   * Specifies what the server's expected session state (from the pov of the client). This can be
+   * used by the server to know whether this is a new or a reestablished connection, and whether it
+   * is compatible with what it already has.
+   */
+  expectedSessionState: import_typebox3.Type.Optional(
+    import_typebox3.Type.Object({
+      /**
+       * reconnect is set to true if the client explicitly wants to reestablish an existing
+       * connection.
+       */
+      reconnect: import_typebox3.Type.Boolean(),
+      nextExpectedSeq: import_typebox3.Type.Integer()
+    })
+  ),
   metadata: import_typebox3.Type.Optional(import_typebox3.Type.Unknown())
 });
 var ControlMessageHandshakeResponseSchema = import_typebox3.Type.Object({
@@ -1172,7 +1187,7 @@ function Err(error) {
 var import_api = require("@opentelemetry/api");
 
 // package.json
-var version = "0.23.12";
+var version = "0.23.14";
 
 // tracing/index.ts
 function getPropagationContext(ctx) {