@replit/river 0.23.8 → 0.23.10

package/dist/{transport-3d34f714.d.ts → transport-cf856c41.d.ts}

@@ -1,5 +1,5 @@
-import { C as Codec } from './types-3e5768ec.js';
 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 { TSchema, Static } from '@sinclair/typebox';
 
 /**
@@ -77,7 +77,7 @@ interface SessionOptions {
 declare class Session<ConnType extends Connection> {
     private codec;
     private options;
-    telemetry: TelemetryInfo;
+    readonly telemetry: TelemetryInfo;
     /**
      * The buffer of messages that have been sent but not yet acknowledged.
      */
@@ -86,12 +86,17 @@ declare class Session<ConnType extends Connection> {
      * The active connection associated with this session
      */
     connection?: ConnType;
+    /**
+     * A connection that is currently undergoing handshaking. Used to distinguish between the active
+     * connection, but still be able to close it if needed.
+     */
+    private handshakingConnection?;
     readonly from: TransportClientId;
     readonly to: TransportClientId;
     /**
      * The unique ID of this session.
      */
-    id: string;
+    readonly id: string;
     /**
      * What the other side advertised as their session ID
      * for this session.
@@ -135,10 +140,17 @@ declare class Session<ConnType extends Connection> {
     resetBufferedMessages(): void;
     sendBufferedMessages(conn: ConnType): void;
     updateBookkeeping(ack: number, seq: number): void;
-    closeStaleConnection(conn?: ConnType): void;
+    private closeStaleConnection;
     replaceWithNewConnection(newConn: ConnType): void;
+    replaceWithNewHandshakingConnection(newConn: ConnType): void;
     beginGrace(cb: () => void): void;
-    cancelGrace(): void;
+    cancelGrace({ keepHeartbeatMisses }?: {
+        keepHeartbeatMisses: boolean;
+    }): void;
+    /**
+     * Used to close the handshaking connection, if set.
+     */
+    closeHandshakingConnection(expectedHandshakingConn?: ConnType): void;
     close(): void;
     get connected(): boolean;
     get nextExpectedSeq(): number;
@@ -150,7 +162,6 @@ type ConnectionStatus = 'connect' | 'disconnect';
 declare const ProtocolError: {
     readonly RetriesExceeded: "conn_retry_exceeded";
     readonly HandshakeFailed: "handshake_failed";
-    readonly UseAfterDestroy: "use_after_destroy";
     readonly MessageOrderingViolated: "message_ordering_violated";
 };
 type ProtocolErrorType = (typeof ProtocolError)[keyof typeof ProtocolError];
@@ -168,11 +179,15 @@ interface EventMap {
         type: ProtocolErrorType;
         message: string;
     };
+    transportStatus: {
+        status: TransportStatus;
+    };
 }
 type EventTypes = keyof EventMap;
 type EventHandler<K extends EventTypes> = (event: EventMap[K]) => unknown;
 declare class EventDispatcher<T extends EventTypes> {
     private eventListeners;
+    removeAllListeners(): void;
     numberOfListeners<K extends T>(eventType: K): number;
     addEventListener<K extends T>(eventType: K, handler: EventHandler<K>): void;
     removeEventListener<K extends T>(eventType: K, handler: EventHandler<K>): void;
@@ -278,7 +293,7 @@ type ServiceContextWithState<State> = ServiceContext & {
     state: State;
 };
 type ServiceContextWithTransportInfo<State> = ServiceContext & {
-    state: Omit<State, typeof Symbol.dispose>;
+    state: State;
     to: TransportClientId;
     from: TransportClientId;
     streamId: string;
@@ -324,10 +339,9 @@ declare function createServerHandshakeOptions<MetadataSchema extends TSchema = T
 /**
  * Represents the possible states of a transport.
  * @property {'open'} open - The transport is open and operational (note that this doesn't mean it is actively connected)
- * @property {'closed'} closed - The transport is closed and not operational, but can be reopened.
- * @property {'destroyed'} destroyed - The transport is permanently destroyed and cannot be reopened.
+ * @property {'closed'} closed - The transport is permanently closed and cannot be reopened.
  */
-type TransportStatus = 'open' | 'closed' | 'destroyed';
+type TransportStatus = 'open' | 'closed';
 type TransportOptions = SessionOptions;
 type ProvidedTransportOptions = Partial<TransportOptions>;
 type ClientTransportOptions = TransportOptions & ConnectionRetryOptions;
@@ -366,10 +380,9 @@ type ProvidedServerTransportOptions = Partial<ServerTransportOptions>;
  */
 declare abstract class Transport<ConnType extends Connection> {
     /**
-     * A flag indicating whether the transport has been destroyed.
-     * A destroyed transport will not attempt to reconnect and cannot be used again.
+     * The status of the transport.
      */
-    state: TransportStatus;
+    private status;
     /**
      * The {@link Codec} used to encode and decode messages.
      */
@@ -419,11 +432,21 @@ declare abstract class Transport<ConnType extends Connection> {
      */
     protected onConnect(conn: ConnType, connectedTo: TransportClientId, session: Session<ConnType>, isReconnect: boolean): void;
     protected createSession(to: TransportClientId, conn?: ConnType, propagationCtx?: PropagationContext): Session<ConnType>;
-    protected getOrCreateSession(to: TransportClientId, conn?: ConnType, sessionId?: string, propagationCtx?: PropagationContext): {
+    protected getOrCreateSession({ to, conn, handshakingConn, sessionId, propagationCtx, }: {
+        to: TransportClientId;
+        conn?: ConnType;
+        handshakingConn?: ConnType;
+        sessionId?: string;
+        propagationCtx?: PropagationContext;
+    }): {
         session: Session<ConnType>;
         isReconnect: boolean;
     };
-    protected deleteSession(session: Session<ConnType>): void;
+    protected deleteSession({ session, closeHandshakingConnection, handshakingConn, }: {
+        session: Session<ConnType>;
+        closeHandshakingConnection: boolean;
+        handshakingConn?: ConnType;
+    }): void;
     /**
      * The downstream implementation needs to call this when a connection is closed.
      * @param conn The connection object.
@@ -460,8 +483,8 @@ declare abstract class Transport<ConnType extends Connection> {
      * @param msg The message to send.
      * @returns The ID of the sent message or undefined if it wasn't sent
      */
-    send(to: TransportClientId, msg: PartialTransportMessage): string | undefined;
-    sendCloseStream(to: TransportClientId, streamId: string): string | undefined;
+    send(to: TransportClientId, msg: PartialTransportMessage): string;
+    sendCloseStream(to: TransportClientId, streamId: string): string;
     protected protocolError(type: ProtocolErrorType, message: string): void;
     /**
      * Default close implementation for transports. You should override this in the downstream
@@ -469,12 +492,7 @@ declare abstract class Transport<ConnType extends Connection> {
      * Closes the transport. Any messages sent while the transport is closed will be silently discarded.
      */
     close(): void;
-    /**
-     * Default destroy implementation for transports. You should override this in the downstream
-     * implementation if you need to do any additional cleanup and call super.destroy() at the end.
-     * Destroys the transport. Any messages sent while the transport is destroyed will throw an error.
-     */
-    destroy(): void;
+    getStatus(): TransportStatus;
 }
 declare abstract class ClientTransport<ConnType extends Connection> extends Transport<ConnType> {
     /**
@@ -515,7 +533,11 @@ declare abstract class ClientTransport<ConnType extends Connection> extends Tran
      * @param to The client ID of the node to connect to.
      */
     connect(to: TransportClientId): Promise<void>;
-    protected deleteSession(session: Session<ConnType>): void;
+    protected deleteSession({ session, closeHandshakingConnection, handshakingConn, }: {
+        session: Session<ConnType>;
+        closeHandshakingConnection: boolean;
+        handshakingConn?: ConnType;
+    }): void;
     protected sendHandshake(to: TransportClientId, conn: ConnType): Promise<boolean>;
     close(): void;
 }

package/dist/util/testHelpers.cjs

@@ -353,7 +353,7 @@ function Err(error) {
 var import_api = require("@opentelemetry/api");
 
 // package.json
-var version = "0.23.8";
+var version = "0.23.10";
 
 // tracing/index.ts
 function createSessionTelemetryInfo(session, propagationCtx) {
@@ -403,6 +403,11 @@ var Session = class {
    * The active connection associated with this session
    */
   connection;
+  /**
+   * A connection that is currently undergoing handshaking. Used to distinguish between the active
+   * connection, but still be able to close it if needed.
+   */
+  handshakingConnection;
   from;
   to;
   /**
@@ -582,23 +587,60 @@ var Session = class {
     this.cancelGrace();
     this.sendBufferedMessages(newConn);
     this.connection = newConn;
+    this.handshakingConnection = void 0;
+  }
+  replaceWithNewHandshakingConnection(newConn) {
+    this.handshakingConnection = newConn;
   }
   beginGrace(cb) {
     this.log?.info(
       `starting ${this.options.sessionDisconnectGraceMs}ms grace period until session to ${this.to} is closed`,
       this.loggingMetadata
     );
+    this.cancelGrace({ keepHeartbeatMisses: true });
     this.disconnectionGrace = setTimeout(() => {
-      this.close();
+      if (this.connection !== void 0) {
+        this.log?.warn(
+          `grace period for ${this.to} elapsed while connected. not calling callback`,
+          {
+            ...this.loggingMetadata,
+            connId: this.connection.id,
+            tags: ["invariant-violation"]
+          }
+        );
+        return;
+      }
+      this.log?.info(
+        `grace period for ${this.to} elapsed`,
+        this.loggingMetadata
+      );
       cb();
     }, this.options.sessionDisconnectGraceMs);
   }
   // called on reconnect of the underlying session
-  cancelGrace() {
-    this.heartbeatMisses = 0;
+  cancelGrace({ keepHeartbeatMisses } = {
+    keepHeartbeatMisses: false
+  }) {
+    if (!keepHeartbeatMisses) {
+      this.heartbeatMisses = 0;
+    }
+    if (this.disconnectionGrace === void 0)
+      return;
     clearTimeout(this.disconnectionGrace);
     this.disconnectionGrace = void 0;
   }
+  /**
+   * Used to close the handshaking connection, if set.
+   */
+  closeHandshakingConnection(expectedHandshakingConn) {
+    if (this.handshakingConnection === void 0)
+      return;
+    if (expectedHandshakingConn !== void 0 && this.handshakingConnection === expectedHandshakingConn) {
+      return;
+    }
+    this.handshakingConnection.close();
+    this.handshakingConnection = void 0;
+  }
   // closed when we want to discard the whole session
   // (i.e. shutdown or session disconnect)
   close() {