@replit/river 0.12.6 → 0.13.0

package/dist/{chunk-4SDJ5VN4.js → chunk-R2IMXRVU.js}

@@ -1,19 +1,19 @@
-import {
-  NaiveJsonCodec
-} from "./chunk-GZ7HCLLM.js";
 import {
   ControlMessageHandshakeRequestSchema,
   ControlMessageHandshakeResponseSchema,
   OpaqueTransportMessageSchema,
   PROTOCOL_VERSION,
-  bootRequestMessage,
-  bootResponseMessage,
   coerceErrorString,
+  handshakeRequestMessage,
+  handshakeResponseMessage,
   isAck
-} from "./chunk-XFFS4UOD.js";
+} from "./chunk-MGGIUH5O.js";
 import {
   log
 } from "./chunk-H4BYJELI.js";
+import {
+  NaiveJsonCodec
+} from "./chunk-GZ7HCLLM.js";
 
 // transport/events.ts
 var EventDispatcher = class {
@@ -56,8 +56,15 @@ var Connection = class {
 var HEARTBEAT_INTERVAL_MS = 1e3;
 var HEARTBEATS_TILL_DEAD = 2;
 var SESSION_DISCONNECT_GRACE_MS = 5e3;
+var defaultSessionOptions = {
+  heartbeatIntervalMs: HEARTBEAT_INTERVAL_MS,
+  heartbeatsUntilDead: HEARTBEATS_TILL_DEAD,
+  sessionDisconnectGraceMs: SESSION_DISCONNECT_GRACE_MS,
+  codec: NaiveJsonCodec
+};
 var Session = class {
   codec;
+  options;
   /**
    * The buffer of messages that have been sent but not yet acknowledged.
    */
@@ -93,16 +100,17 @@ var Session = class {
    * The interval for sending heartbeats.
    */
   heartbeat;
-  constructor(codec, from, connectedTo, conn) {
+  constructor(from, connectedTo, conn, options) {
+    this.options = options;
     this.debugId = `sess-${unsafeId()}`;
     this.from = from;
     this.to = connectedTo;
     this.connection = conn;
-    this.codec = codec;
+    this.codec = options.codec;
     this.heartbeatMisses = 0;
     this.heartbeat = setInterval(
       () => this.sendHeartbeat(),
-      HEARTBEAT_INTERVAL_MS
+      options.heartbeatIntervalMs
     );
   }
   /**
@@ -138,7 +146,7 @@ var Session = class {
     return fullMsg.id;
   }
   sendHeartbeat() {
-    if (this.heartbeatMisses >= HEARTBEATS_TILL_DEAD) {
+    if (this.heartbeatMisses >= this.options.heartbeatsUntilDead) {
       if (this.connection) {
         log?.info(
           `${this.from} -- closing connection (id: ${this.connection.debugId}) to ${this.to} due to inactivity`
@@ -208,7 +216,7 @@ var Session = class {
     this.disconnectionGrace = setTimeout(() => {
       this.close();
       cb();
-    }, SESSION_DISCONNECT_GRACE_MS);
+    }, this.options.sessionDisconnectGraceMs);
   }
   // called on reconnect of the underlying session
   cancelGrace() {
@@ -249,13 +257,13 @@ var Session = class {
 // transport/transport.ts
 import { Value } from "@sinclair/typebox/value";
 import { nanoid as nanoid2 } from "nanoid";
-var DEFAULT_RECONNECT_JITTER_MAX_MS = 500;
-var DEFAULT_RECONNECT_INTERVAL_MS = 250;
+var RECONNECT_JITTER_MAX_MS = 500;
+var RECONNECT_INTERVAL_MS = 250;
 var defaultTransportOptions = {
-  retryIntervalMs: DEFAULT_RECONNECT_INTERVAL_MS,
-  retryJitterMs: DEFAULT_RECONNECT_JITTER_MAX_MS,
+  retryIntervalMs: RECONNECT_INTERVAL_MS,
+  retryJitterMs: RECONNECT_JITTER_MAX_MS,
   retryAttemptsMax: 5,
-  codec: NaiveJsonCodec
+  ...defaultSessionOptions
 };
 var Transport = class {
   /**
@@ -326,7 +334,7 @@ var Transport = class {
     const lastInstanceId = this.connectedInstanceIds.get(connectedTo);
     if (oldSession && lastInstanceId !== void 0 && lastInstanceId !== instanceId) {
       log?.warn(
-        `${this.clientId} -- handshake from ${connectedTo} is a different instance (got: ${instanceId}, last connected to: ${lastInstanceId}), starting a new session`
+        `${this.clientId} -- connection from ${connectedTo} is a different instance (got: ${instanceId}, last connected to: ${lastInstanceId}), starting a new session`
       );
       oldSession.close();
       this.deleteSession(oldSession);
@@ -349,10 +357,10 @@ var Transport = class {
   }
   createSession(connectedTo, conn) {
     const session = new Session(
-      this.codec,
       this.clientId,
       connectedTo,
-      conn
+      conn,
+      this.options
     );
     this.sessions.set(session.to, session);
     this.eventDispatcher.dispatchEvent("sessionStatus", {
@@ -395,7 +403,7 @@ var Transport = class {
   parseMsg(msg) {
     const parsedMsg = this.codec.fromBuffer(msg);
     if (parsedMsg === null) {
-      const decodedBuffer = new TextDecoder().decode(msg);
+      const decodedBuffer = new TextDecoder().decode(Buffer.from(msg));
       log?.error(
         `${this.clientId} -- received malformed msg, killing conn: ${decodedBuffer}`
       );
@@ -409,11 +417,7 @@ var Transport = class {
       );
       return null;
     }
-    return {
-      ...parsedMsg,
-      serviceName: parsedMsg.serviceName === null ? void 0 : parsedMsg.serviceName,
-      procedureName: parsedMsg.procedureName === null ? void 0 : parsedMsg.procedureName
-    };
+    return parsedMsg;
   }
   /**
    * Called when a message is received by this transport.
@@ -432,11 +436,18 @@ var Transport = class {
     session.cancelGrace();
     log?.debug(`${this.clientId} -- received msg: ${JSON.stringify(msg)}`);
     if (msg.seq !== session.nextExpectedSeq) {
-      log?.warn(
-        `${this.clientId} -- received out-of-order msg (got: ${msg.seq}, wanted: ${session.nextExpectedSeq}), discarding: ${JSON.stringify(
-          msg
-        )}`
-      );
+      if (msg.seq < session.nextExpectedSeq) {
+        log?.debug(
+          `${this.clientId} -- received duplicate msg (got: ${msg.seq}, wanted: ${session.nextExpectedSeq}), discarding: ${JSON.stringify(
+            msg
+          )}`
+        );
+      } else {
+        log?.error(
+          `${this.clientId} -- received out-of-order msg (got: ${msg.seq}, wanted: ${session.nextExpectedSeq}), marking connection as dead: ${JSON.stringify(msg)}`
+        );
+        session.closeStaleConnection(session.connection);
+      }
       return;
     }
     if (!isAck(msg.controlFlags)) {
@@ -454,7 +465,7 @@ var Transport = class {
   }
   /**
    * Removes a listener from this transport.
-   * @param the type of event to unlisten on
+   * @param the type of event to un-listen on
    * @param handler The message handler to remove.
    */
   removeEventListener(type, handler) {
@@ -531,23 +542,31 @@ var ClientTransport = class extends Transport {
    */
   inflightConnectionPromises;
   tryReconnecting = true;
-  constructor(clientId, providedOptions) {
+  connectedTo;
+  constructor(clientId, connectedTo, providedOptions) {
     super(clientId, providedOptions);
+    this.connectedTo = connectedTo;
     this.inflightConnectionPromises = /* @__PURE__ */ new Map();
   }
   handleConnection(conn, to) {
-    const bootHandler = this.receiveWithBootSequence(conn, () => {
-      conn.removeDataListener(bootHandler);
-      conn.addDataListener((data) => {
-        const parsed = this.parseMsg(data);
+    const handshakeHandler = (data) => {
+      const handshake = this.receiveHandshakeResponseMessage(data);
+      if (!handshake) {
+        conn.close();
+        return;
+      }
+      this.onConnect(conn, handshake.from, handshake.instanceId);
+      conn.removeDataListener(handshakeHandler);
+      conn.addDataListener((data2) => {
+        const parsed = this.parseMsg(data2);
         if (!parsed) {
           conn.close();
           return;
         }
         this.handleMsg(parsed);
       });
-    });
-    conn.addDataListener(bootHandler);
+    };
+    conn.addDataListener(handshakeHandler);
     conn.addCloseListener(() => {
       this.onDisconnect(conn, to);
       void this.connect(to);
@@ -558,6 +577,32 @@ var ClientTransport = class extends Transport {
       );
     });
   }
+  receiveHandshakeResponseMessage(data) {
+    const parsed = this.parseMsg(data);
+    if (!parsed)
+      return false;
+    if (!Value.Check(ControlMessageHandshakeResponseSchema, parsed.payload)) {
+      log?.warn(
+        `${this.clientId} -- received invalid handshake resp: ${JSON.stringify(
+          parsed
+        )}`
+      );
+      return false;
+    }
+    if (!parsed.payload.status.ok) {
+      log?.warn(
+        `${this.clientId} -- received failed handshake resp: ${JSON.stringify(
+          parsed
+        )}`
+      );
+      return false;
+    }
+    const instanceId = parsed.payload.status.instanceId;
+    log?.debug(
+      `${this.clientId} -- handshake from ${parsed.from} ok (instance: ${instanceId})`
+    );
+    return { instanceId, from: parsed.from };
+  }
   /**
    * Manually attempts to connect to a client.
    * @param to The client ID of the node to connect to.
@@ -576,10 +621,7 @@ var ClientTransport = class extends Transport {
     }
     try {
       const conn = await reconnectPromise;
-      this.state = "open";
-      const requestMsg = bootRequestMessage(this.clientId, to, this.instanceId);
-      log?.debug(`${this.clientId} -- sending boot handshake to ${to}`);
-      conn.send(this.codec.toBuffer(requestMsg));
+      this.sendHandshake(to, conn);
     } catch (error) {
       const errStr = coerceErrorString(error);
       this.inflightConnectionPromises.delete(to);
@@ -597,34 +639,14 @@ var ClientTransport = class extends Transport {
       }
     }
   }
-  receiveWithBootSequence(conn, sessionCb) {
-    const bootHandler = (data) => {
-      const parsed = this.parseMsg(data);
-      if (!parsed) {
-        conn.close();
-        return;
-      }
-      if (!Value.Check(ControlMessageHandshakeResponseSchema, parsed.payload)) {
-        log?.warn(
-          `${this.clientId} -- received invalid handshake resp: ${JSON.stringify(parsed)}`
-        );
-        return;
-      }
-      if (!parsed.payload.status.ok) {
-        log?.warn(
-          `${this.clientId} -- received failed handshake resp: ${JSON.stringify(
-            parsed
-          )}`
-        );
-        return;
-      }
-      const serverInstanceId = parsed.payload.status.instanceId;
-      log?.debug(
-        `${this.clientId} -- handshake from ${parsed.from} ok (server instance: ${serverInstanceId})`
-      );
-      sessionCb(this.onConnect(conn, parsed.from, serverInstanceId));
-    };
-    return bootHandler;
+  sendHandshake(to, conn) {
+    const requestMsg = handshakeRequestMessage(
+      this.clientId,
+      to,
+      this.instanceId
+    );
+    log?.debug(`${this.clientId} -- sending handshake request to ${to}`);
+    conn.send(this.codec.toBuffer(requestMsg));
   }
   onDisconnect(conn, connectedTo) {
     this.inflightConnectionPromises.delete(connectedTo);
@@ -641,22 +663,24 @@ var ServerTransport = class extends Transport {
   handleConnection(conn) {
     let session = void 0;
     const client = () => session?.to ?? "unknown";
-    const bootHandler = this.receiveWithBootSequence(
-      conn,
-      (establishedSession) => {
-        session = establishedSession;
-        conn.removeDataListener(bootHandler);
-        conn.addDataListener((data) => {
-          const parsed = this.parseMsg(data);
-          if (!parsed) {
-            conn.close();
-            return;
-          }
-          this.handleMsg(parsed);
-        });
+    const handshakeHandler = (data) => {
+      const handshake = this.receiveHandshakeRequestMessage(data, conn);
+      if (!handshake) {
+        conn.close();
+        return;
       }
-    );
-    conn.addDataListener(bootHandler);
+      session = this.onConnect(conn, handshake.from, handshake.instanceId);
+      conn.removeDataListener(handshakeHandler);
+      conn.addDataListener((data2) => {
+        const parsed = this.parseMsg(data2);
+        if (!parsed) {
+          conn.close();
+          return;
+        }
+        this.handleMsg(parsed);
+      });
+    };
+    conn.addDataListener(handshakeHandler);
     conn.addCloseListener(() => {
       if (!session)
         return;
@@ -673,47 +697,57 @@ var ServerTransport = class extends Transport {
       );
     });
   }
-  receiveWithBootSequence(conn, sessionCb) {
-    const bootHandler = (data) => {
-      const parsed = this.parseMsg(data);
-      if (!parsed) {
-        conn.close();
-        return;
-      }
-      if (!Value.Check(ControlMessageHandshakeRequestSchema, parsed.payload)) {
-        const responseMsg2 = bootResponseMessage(
-          this.clientId,
-          this.instanceId,
-          parsed.from,
-          false
-        );
-        conn.send(this.codec.toBuffer(responseMsg2));
-        log?.warn(
-          `${this.clientId} -- received invalid handshake msg: ${JSON.stringify(
-            parsed
-          )}`
-        );
-        return;
-      }
-      const instanceId = parsed.payload.instanceId;
-      log?.debug(
-        `${this.clientId} -- handshake from ${parsed.from} ok (instance id: ${instanceId}), responding with handshake success`
+  receiveHandshakeRequestMessage(data, conn) {
+    const parsed = this.parseMsg(data);
+    if (!parsed)
+      return false;
+    if (!Value.Check(ControlMessageHandshakeRequestSchema, parsed.payload)) {
+      const responseMsg2 = handshakeResponseMessage(
+        this.clientId,
+        this.instanceId,
+        parsed.from,
+        false
+      );
+      conn.send(this.codec.toBuffer(responseMsg2));
+      log?.warn(
+        `${this.clientId} -- received invalid handshake msg: ${JSON.stringify(
+          parsed
+        )}`
       );
-      const responseMsg = bootResponseMessage(
+      return false;
+    }
+    const gotVersion = parsed.payload.protocolVersion;
+    if (gotVersion !== PROTOCOL_VERSION) {
+      const responseMsg2 = handshakeResponseMessage(
         this.clientId,
         this.instanceId,
         parsed.from,
-        true
+        false
       );
-      conn.send(this.codec.toBuffer(responseMsg));
-      sessionCb(this.onConnect(conn, parsed.from, instanceId));
-    };
-    return bootHandler;
+      conn.send(this.codec.toBuffer(responseMsg2));
+      log?.warn(
+        `${this.clientId} -- received handshake msg with incompatible protocol version (got: ${gotVersion}, expected: ${PROTOCOL_VERSION})`
+      );
+      return false;
+    }
+    const instanceId = parsed.payload.instanceId;
+    log?.debug(
+      `${this.clientId} -- handshake from ${parsed.from} ok (instance id: ${instanceId}), responding with handshake success`
+    );
+    const responseMsg = handshakeResponseMessage(
+      this.clientId,
+      this.instanceId,
+      parsed.from,
+      true
+    );
+    conn.send(this.codec.toBuffer(responseMsg));
+    return { instanceId, from: parsed.from };
   }
 };
 
 export {
   Connection,
+  defaultSessionOptions,
   Session,
   Transport,
   ClientTransport,

package/dist/{connection-ba37d174.d.ts → connection-ab681c08.d.ts}

@@ -1,5 +1,5 @@
 import WebSocket from 'isomorphic-ws';
-import { C as Connection } from './index-54e0f99c.js';
+import { C as Connection } from './index-21c1b21d.js';
 
 declare class WebSocketConnection extends Connection {
     ws: WebSocket;

package/dist/{messageFraming-b200ef25.d.ts → connection-dd789651.d.ts}

@@ -1,4 +1,6 @@
-import { Transform, TransformCallback, TransformOptions } from 'node:stream';
+import { C as Connection } from './index-21c1b21d.js';
+import { Socket } from 'node:net';
+import stream, { Transform, TransformCallback, TransformOptions } from 'node:stream';
 
 interface LengthEncodedOptions extends TransformOptions {
     /** Maximum in-memory buffer size before we throw */
@@ -17,4 +19,17 @@ declare class Uint32LengthPrefixFraming extends Transform {
     _destroy(error: Error | null, callback: (error: Error | null) => void): void;
 }
 
-export { Uint32LengthPrefixFraming as U };
+declare class UdsConnection extends Connection {
+    sock: Socket;
+    input: stream.Readable;
+    framer: Uint32LengthPrefixFraming;
+    constructor(sock: Socket);
+    addDataListener(cb: (msg: Uint8Array) => void): void;
+    removeDataListener(cb: (msg: Uint8Array) => void): void;
+    addCloseListener(cb: () => void): void;
+    addErrorListener(cb: (err: Error) => void): void;
+    send(payload: Uint8Array): boolean;
+    close(): void;
+}
+
+export { UdsConnection as U };

package/dist/{index-54e0f99c.d.ts → index-21c1b21d.d.ts}

@@ -14,8 +14,8 @@ declare const TransportMessageSchema: <T extends TSchema>(t: T) => _sinclair_typ
     to: _sinclair_typebox.TString;
     seq: _sinclair_typebox.TInteger;
     ack: _sinclair_typebox.TInteger;
-    serviceName: _sinclair_typebox.TOptional<_sinclair_typebox.TUnion<[_sinclair_typebox.TString, _sinclair_typebox.TNull]>>;
-    procedureName: _sinclair_typebox.TOptional<_sinclair_typebox.TUnion<[_sinclair_typebox.TString, _sinclair_typebox.TNull]>>;
+    serviceName: _sinclair_typebox.TOptional<_sinclair_typebox.TString>;
+    procedureName: _sinclair_typebox.TOptional<_sinclair_typebox.TString>;
     streamId: _sinclair_typebox.TString;
     controlFlags: _sinclair_typebox.TInteger;
     payload: T;
@@ -31,8 +31,8 @@ declare const OpaqueTransportMessageSchema: _sinclair_typebox.TObject<{
     to: _sinclair_typebox.TString;
     seq: _sinclair_typebox.TInteger;
     ack: _sinclair_typebox.TInteger;
-    serviceName: _sinclair_typebox.TOptional<_sinclair_typebox.TUnion<[_sinclair_typebox.TString, _sinclair_typebox.TNull]>>;
-    procedureName: _sinclair_typebox.TOptional<_sinclair_typebox.TUnion<[_sinclair_typebox.TString, _sinclair_typebox.TNull]>>;
+    serviceName: _sinclair_typebox.TOptional<_sinclair_typebox.TString>;
+    procedureName: _sinclair_typebox.TOptional<_sinclair_typebox.TString>;
     streamId: _sinclair_typebox.TString;
     controlFlags: _sinclair_typebox.TInteger;
     payload: _sinclair_typebox.TUnknown;
@@ -48,6 +48,8 @@ declare const OpaqueTransportMessageSchema: _sinclair_typebox.TObject<{
  * * If `controlFlags & StreamOpenBit == StreamOpenBit`, `serviceName` and `procedureName` must be set.
  * * If `controlFlags & StreamClosedBit == StreamClosedBit` and the kind is `stream` or `subscription`,
  *   `payload` should be discarded (usually contains a control message).
+ * * If `controlFlags & AckBit == AckBit`, the message is an explicit acknowledgement message and doesn't
+ *   contain any payload that is relevant to the application so should not be delivered.
  * @template Payload The type of the payload.
  */
 interface TransportMessage<Payload = Record<string, unknown>> {
@@ -126,6 +128,12 @@ declare abstract class Connection {
      */
     abstract close(): void;
 }
+interface SessionOptions {
+    heartbeatIntervalMs: number;
+    heartbeatsUntilDead: number;
+    sessionDisconnectGraceMs: number;
+    codec: Codec;
+}
 /**
  * A session is a higher-level abstraction that operates over the span of potentially multiple transport-level connections
  * - It’s responsible for tracking any metadata for a particular client that might need to be persisted across connections (i.e. the sendBuffer, ack, seq)
@@ -161,6 +169,7 @@ declare abstract class Connection {
  */
 declare class Session<ConnType extends Connection> {
     private codec;
+    private options;
     /**
      * The buffer of messages that have been sent but not yet acknowledged.
      */
@@ -196,7 +205,7 @@ declare class Session<ConnType extends Connection> {
      * The interval for sending heartbeats.
      */
     private heartbeat?;
-    constructor(codec: Codec, from: TransportClientId, connectedTo: TransportClientId, conn: ConnType | undefined);
+    constructor(from: TransportClientId, connectedTo: TransportClientId, conn: ConnType | undefined, options: SessionOptions);
     /**
      * Sends a message over the session's connection.
      * If the connection is not ready or the message fails to send, the message can be buffered for retry unless skipped.
@@ -252,12 +261,11 @@ declare class EventDispatcher<T extends EventTypes> {
  * @property {'destroyed'} destroyed - The transport is permanently destroyed and cannot be reopened.
  */
 type TransportStatus = 'open' | 'closed' | 'destroyed';
-interface TransportOptions {
+type TransportOptions = {
     retryIntervalMs: number;
     retryJitterMs: number;
     retryAttemptsMax: number;
-    codec: Codec;
-}
+} & SessionOptions;
 /**
  * Transports manage the lifecycle (creation/deletion) of sessions and connections. Its responsibilities include:
  *
@@ -324,7 +332,7 @@ declare abstract class Transport<ConnType extends Connection> {
     /**
      * The options for this transport.
      */
-    options: TransportOptions;
+    protected options: TransportOptions;
     /**
      * Creates a new Transport instance.
      * This should also set up {@link onConnect}, and {@link onDisconnect} listeners.
@@ -375,7 +383,7 @@ declare abstract class Transport<ConnType extends Connection> {
     addEventListener<K extends EventTypes, T extends EventHandler<K>>(type: K, handler: T): void;
     /**
      * Removes a listener from this transport.
-     * @param the type of event to unlisten on
+     * @param the type of event to un-listen on
      * @param handler The message handler to remove.
      */
     removeEventListener<K extends EventTypes, T extends EventHandler<K>>(type: K, handler: T): void;
@@ -406,8 +414,13 @@ declare abstract class ClientTransport<ConnType extends Connection> extends Tran
      */
     inflightConnectionPromises: Map<TransportClientId, Promise<ConnType>>;
     tryReconnecting: boolean;
-    constructor(clientId: TransportClientId, providedOptions?: Partial<TransportOptions>);
+    connectedTo: TransportClientId;
+    constructor(clientId: TransportClientId, connectedTo: TransportClientId, providedOptions?: Partial<TransportOptions>);
     protected handleConnection(conn: ConnType, to: TransportClientId): void;
+    receiveHandshakeResponseMessage(data: Uint8Array): false | {
+        instanceId: string;
+        from: string;
+    };
     /**
      * Abstract method that creates a new {@link Connection} object.
      * This should call {@link handleConnection} when the connection is created.
@@ -422,13 +435,16 @@ declare abstract class ClientTransport<ConnType extends Connection> extends Tran
      * @param to The client ID of the node to connect to.
      */
     connect(to: TransportClientId, attempt?: number): Promise<void>;
-    private receiveWithBootSequence;
+    protected sendHandshake(to: TransportClientId, conn: ConnType): void;
     protected onDisconnect(conn: ConnType, connectedTo: string): void;
 }
 declare abstract class ServerTransport<ConnType extends Connection> extends Transport<ConnType> {
     constructor(clientId: TransportClientId, providedOptions?: Partial<TransportOptions>);
     protected handleConnection(conn: ConnType): void;
-    protected receiveWithBootSequence(conn: ConnType, sessionCb: (sess: Session<ConnType>) => void): (data: Uint8Array) => void;
+    receiveHandshakeRequestMessage(data: Uint8Array, conn: ConnType): false | {
+        instanceId: string;
+        from: string;
+    };
 }
 
 export { Connection as C, EventMap as E, OpaqueTransportMessage as O, PartialTransportMessage as P, ServerTransport as S, Transport as T, ClientTransport as a, TransportClientId as b, TransportOptions as c, Session as d, TransportMessageSchema as e, OpaqueTransportMessageSchema as f, TransportMessage as g, isStreamClose as h, isStreamOpen as i, EventTypes as j, EventHandler as k };