@replit/river 0.15.0 → 0.15.2

package/dist/transport/index.cjs

@@ -23,7 +23,7 @@ __export(transport_exports, {
   ClientTransport: () => ClientTransport,
   Connection: () => Connection,
   OpaqueTransportMessageSchema: () => OpaqueTransportMessageSchema,
-  ProtocolErrorType: () => ProtocolErrorType,
+  ProtocolError: () => ProtocolError,
   ServerTransport: () => ServerTransport,
   Session: () => Session,
   Transport: () => Transport,
@@ -131,12 +131,11 @@ function isAck(controlFlag) {
 var log;
 
 // transport/events.ts
-var ProtocolErrorType = /* @__PURE__ */ ((ProtocolErrorType2) => {
-  ProtocolErrorType2["RetriesExceeded"] = "conn_retry_exceeded";
-  ProtocolErrorType2["HandshakeFailed"] = "handshake_failed";
-  ProtocolErrorType2["UseAfterDestroy"] = "use_after_destroy";
-  return ProtocolErrorType2;
-})(ProtocolErrorType || {});
+var ProtocolError = {
+  RetriesExceeded: "conn_retry_exceeded",
+  HandshakeFailed: "handshake_failed",
+  UseAfterDestroy: "use_after_destroy"
+};
 var EventDispatcher = class {
   eventListeners = {};
   numberOfListeners(eventType) {
@@ -166,60 +165,6 @@ var EventDispatcher = class {
 
 // transport/session.ts
 var import_nanoid2 = require("nanoid");
-
-// codec/json.ts
-var encoder = new TextEncoder();
-var decoder = new TextDecoder();
-function uint8ArrayToBase64(uint8Array) {
-  let binary = "";
-  uint8Array.forEach((byte) => {
-    binary += String.fromCharCode(byte);
-  });
-  return btoa(binary);
-}
-function base64ToUint8Array(base64) {
-  const binaryString = atob(base64);
-  const uint8Array = new Uint8Array(binaryString.length);
-  for (let i = 0; i < binaryString.length; i++) {
-    uint8Array[i] = binaryString.charCodeAt(i);
-  }
-  return uint8Array;
-}
-var NaiveJsonCodec = {
-  toBuffer: (obj) => {
-    return encoder.encode(
-      JSON.stringify(obj, function replacer(key) {
-        const val = this[key];
-        if (val instanceof Uint8Array) {
-          return { $t: uint8ArrayToBase64(val) };
-        } else {
-          return val;
-        }
-      })
-    );
-  },
-  fromBuffer: (buff) => {
-    try {
-      const parsed = JSON.parse(
-        decoder.decode(buff),
-        function reviver(_key, val) {
-          if (val?.$t) {
-            return base64ToUint8Array(val.$t);
-          } else {
-            return val;
-          }
-        }
-      );
-      if (typeof parsed === "object")
-        return parsed;
-      return null;
-    } catch {
-      return null;
-    }
-  }
-};
-
-// transport/session.ts
 var nanoid2 = (0, import_nanoid2.customAlphabet)("1234567890abcdefghijklmnopqrstuvxyz", 6);
 var unsafeId = () => nanoid2();
 var Connection = class {
@@ -228,15 +173,6 @@ var Connection = class {
     this.debugId = `conn-${unsafeId()}`;
   }
 };
-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;
@@ -431,14 +367,146 @@ function coerceErrorString(err) {
   return `[coerced to error] ${String(err)}`;
 }
 
+// transport/rateLimit.ts
+var LeakyBucketRateLimit = class {
+  budgetConsumed;
+  intervalHandles;
+  options;
+  constructor(options) {
+    this.options = options;
+    this.budgetConsumed = /* @__PURE__ */ new Map();
+    this.intervalHandles = /* @__PURE__ */ new Map();
+  }
+  getBackoffMs(user) {
+    if (!this.budgetConsumed.has(user))
+      return 0;
+    const exponent = Math.max(0, this.getBudgetConsumed(user) - 1);
+    const jitter = Math.floor(Math.random() * this.options.maxJitterMs);
+    const backoffMs = Math.min(
+      this.options.baseIntervalMs * 2 ** exponent,
+      this.options.maxBackoffMs
+    );
+    return backoffMs + jitter;
+  }
+  get totalBudgetRestoreTime() {
+    return this.options.budgetRestoreIntervalMs * this.options.attemptBudgetCapacity;
+  }
+  consumeBudget(user) {
+    this.stopLeak(user);
+    this.budgetConsumed.set(user, this.getBudgetConsumed(user) + 1);
+  }
+  getBudgetConsumed(user) {
+    return this.budgetConsumed.get(user) ?? 0;
+  }
+  hasBudget(user) {
+    return this.getBudgetConsumed(user) < this.options.attemptBudgetCapacity;
+  }
+  startRestoringBudget(user) {
+    if (this.intervalHandles.has(user)) {
+      return;
+    }
+    const restoreBudgetForUser = () => {
+      const currentBudget = this.budgetConsumed.get(user);
+      if (!currentBudget) {
+        this.stopLeak(user);
+        return;
+      }
+      const newBudget = currentBudget - 1;
+      if (newBudget === 0) {
+        this.budgetConsumed.delete(user);
+        return;
+      }
+      this.budgetConsumed.set(user, newBudget);
+    };
+    restoreBudgetForUser();
+    const intervalHandle = setInterval(
+      restoreBudgetForUser,
+      this.options.budgetRestoreIntervalMs
+    );
+    this.intervalHandles.set(user, intervalHandle);
+  }
+  stopLeak(user) {
+    if (!this.intervalHandles.has(user)) {
+      return;
+    }
+    clearInterval(this.intervalHandles.get(user));
+    this.intervalHandles.delete(user);
+  }
+  close() {
+    for (const user of this.intervalHandles.keys()) {
+      this.stopLeak(user);
+    }
+  }
+};
+
+// codec/json.ts
+var encoder = new TextEncoder();
+var decoder = new TextDecoder();
+function uint8ArrayToBase64(uint8Array) {
+  let binary = "";
+  uint8Array.forEach((byte) => {
+    binary += String.fromCharCode(byte);
+  });
+  return btoa(binary);
+}
+function base64ToUint8Array(base64) {
+  const binaryString = atob(base64);
+  const uint8Array = new Uint8Array(binaryString.length);
+  for (let i = 0; i < binaryString.length; i++) {
+    uint8Array[i] = binaryString.charCodeAt(i);
+  }
+  return uint8Array;
+}
+var NaiveJsonCodec = {
+  toBuffer: (obj) => {
+    return encoder.encode(
+      JSON.stringify(obj, function replacer(key) {
+        const val = this[key];
+        if (val instanceof Uint8Array) {
+          return { $t: uint8ArrayToBase64(val) };
+        } else {
+          return val;
+        }
+      })
+    );
+  },
+  fromBuffer: (buff) => {
+    try {
+      const parsed = JSON.parse(
+        decoder.decode(buff),
+        function reviver(_key, val) {
+          if (val?.$t) {
+            return base64ToUint8Array(val.$t);
+          } else {
+            return val;
+          }
+        }
+      );
+      if (typeof parsed === "object")
+        return parsed;
+      return null;
+    } catch {
+      return null;
+    }
+  }
+};
+
 // transport/transport.ts
-var RECONNECT_JITTER_MAX_MS = 500;
-var RECONNECT_INTERVAL_MS = 250;
 var defaultTransportOptions = {
-  retryIntervalMs: RECONNECT_INTERVAL_MS,
-  retryJitterMs: RECONNECT_JITTER_MAX_MS,
-  retryAttemptsMax: 5,
-  ...defaultSessionOptions
+  heartbeatIntervalMs: 1e3,
+  heartbeatsUntilDead: 2,
+  sessionDisconnectGraceMs: 5e3,
+  codec: NaiveJsonCodec
+};
+var defaultClientTransportOptions = {
+  connectionRetryOptions: {
+    baseIntervalMs: 250,
+    maxJitterMs: 200,
+    maxBackoffMs: 32e3,
+    attemptBudgetCapacity: 15,
+    budgetRestoreIntervalMs: 200
+  },
+  ...defaultTransportOptions
 };
 var Transport = class {
   /**
@@ -653,7 +721,7 @@ var Transport = class {
     if (this.state === "destroyed") {
       const err = "transport is destroyed, cant send";
       log?.error(`${this.clientId} -- ` + err + `: ${JSON.stringify(msg)}`);
-      this.protocolError("use_after_destroy" /* UseAfterDestroy */, err);
+      this.protocolError(ProtocolError.UseAfterDestroy, err);
       return void 0;
     } else if (this.state === "closed") {
       log?.info(
@@ -713,14 +781,26 @@ var Transport = class {
   }
 };
 var ClientTransport = class extends Transport {
+  /**
+   * The options for this transport.
+   */
+  options;
   /**
    * The map of reconnect promises for each client ID.
    */
   inflightConnectionPromises;
+  retryBudget;
   tryReconnecting = true;
   constructor(clientId, providedOptions) {
     super(clientId, providedOptions);
+    this.options = {
+      ...defaultClientTransportOptions,
+      ...providedOptions
+    };
     this.inflightConnectionPromises = /* @__PURE__ */ new Map();
+    this.retryBudget = new LeakyBucketRateLimit(
+      this.options.connectionRetryOptions
+    );
   }
   handleConnection(conn, to) {
     if (this.state !== "open")
@@ -751,7 +831,10 @@ var ClientTransport = class extends Transport {
       log?.info(
         `${this.clientId} -- connection (id: ${conn.debugId}) to ${to} disconnected`
       );
-      void this.connect(to);
+      this.inflightConnectionPromises.delete(to);
+      if (this.tryReconnecting) {
+        void this.connect(to);
+      }
     });
     conn.addErrorListener((err) => {
       log?.warn(
@@ -763,7 +846,7 @@ var ClientTransport = class extends Transport {
     const parsed = this.parseMsg(data);
     if (!parsed) {
       this.protocolError(
-        "handshake_failed" /* HandshakeFailed */,
+        ProtocolError.HandshakeFailed,
         "received non-transport message"
       );
       return false;
@@ -775,7 +858,7 @@ var ClientTransport = class extends Transport {
         )}`
       );
       this.protocolError(
-        "handshake_failed" /* HandshakeFailed */,
+        ProtocolError.HandshakeFailed,
         "invalid handshake resp"
       );
       return false;
@@ -787,7 +870,7 @@ var ClientTransport = class extends Transport {
         )}`
       );
       this.protocolError(
-        "handshake_failed" /* HandshakeFailed */,
+        ProtocolError.HandshakeFailed,
         parsed.payload.status.reason
       );
       return false;
@@ -802,41 +885,64 @@ var ClientTransport = class extends Transport {
    * Manually attempts to connect to a client.
    * @param to The client ID of the node to connect to.
    */
-  async connect(to, attempt = 0) {
-    if (this.state !== "open" || !this.tryReconnecting) {
+  async connect(to) {
+    const canProceedWithConnection = () => this.state === "open";
+    if (!canProceedWithConnection()) {
       log?.info(
-        `${this.clientId} -- transport state is no longer open, not attempting connection`
+        `${this.clientId} -- transport state is no longer open, cancelling attempt to connect to ${to}`
       );
       return;
     }
     let reconnectPromise = this.inflightConnectionPromises.get(to);
     if (!reconnectPromise) {
-      reconnectPromise = this.createNewOutgoingConnection(to).then((conn) => {
+      log?.info(`${this.clientId} -- attempting connection to ${to}`);
+      const budgetConsumed = this.retryBudget.getBudgetConsumed(to);
+      if (!this.retryBudget.hasBudget(to)) {
+        const errMsg = `not attempting to connect to ${to}, retry budget exceeded (more than ${budgetConsumed} attempts in the last ${this.retryBudget.totalBudgetRestoreTime}ms)`;
+        log?.warn(`${this.clientId} -- ${errMsg}`);
+        this.protocolError(ProtocolError.RetriesExceeded, errMsg);
+        return;
+      }
+      let sleep = Promise.resolve();
+      const backoffMs = this.retryBudget.getBackoffMs(to);
+      if (backoffMs > 0) {
+        sleep = new Promise((resolve) => setTimeout(resolve, backoffMs));
+      }
+      this.retryBudget.consumeBudget(to);
+      reconnectPromise = sleep.then(() => {
+        if (!canProceedWithConnection()) {
+          throw new Error("transport state is no longer open");
+        }
+      }).then(() => this.createNewOutgoingConnection(to)).then((conn) => {
+        if (!canProceedWithConnection()) {
+          log?.info(
+            `${this.clientId} -- transport state is no longer open, closing pre-handshake connection (id: ${conn.debugId}) to ${to}`
+          );
+          conn.close();
+          throw new Error("transport state is no longer open");
+        }
+        this.retryBudget.startRestoringBudget(to);
         this.sendHandshake(to, conn);
         return conn;
       });
       this.inflightConnectionPromises.set(to, reconnectPromise);
+    } else {
+      log?.info(
+        `${this.clientId} -- attempting connection to ${to} (reusing previous attempt)`
+      );
     }
     try {
       await reconnectPromise;
     } catch (error) {
-      const errStr = coerceErrorString(error);
       this.inflightConnectionPromises.delete(to);
-      const shouldRetry = this.state === "open" && this.tryReconnecting;
-      if (!shouldRetry)
-        return;
-      if (attempt >= this.options.retryAttemptsMax) {
-        const errMsg = `connection to ${to} failed after ${attempt} attempts (${errStr}), giving up`;
-        log?.error(`${this.clientId} -- ${errMsg}`);
-        this.protocolError("conn_retry_exceeded" /* RetriesExceeded */, errMsg);
-        return;
+      const errStr = coerceErrorString(error);
+      if (!this.tryReconnecting || !canProceedWithConnection()) {
+        log?.warn(`${this.clientId} -- connection to ${to} failed (${errStr})`);
       } else {
-        const jitter = Math.floor(Math.random() * this.options.retryJitterMs);
-        const backoffMs = this.options.retryIntervalMs * 2 ** attempt + jitter;
         log?.warn(
-          `${this.clientId} -- connection to ${to} failed (${errStr}), trying again in ${backoffMs}ms`
+          `${this.clientId} -- connection to ${to} failed (${errStr}), retrying`
         );
-        setTimeout(() => void this.connect(to, attempt + 1), backoffMs);
+        return this.connect(to);
       }
     }
   }
@@ -849,9 +955,9 @@ var ClientTransport = class extends Transport {
     log?.debug(`${this.clientId} -- sending handshake request to ${to}`);
     conn.send(this.codec.toBuffer(requestMsg));
   }
-  onDisconnect(conn, session) {
-    this.inflightConnectionPromises.delete(session.to);
-    super.onDisconnect(conn, session);
+  close() {
+    this.retryBudget.close();
+    super.close();
   }
 };
 var ServerTransport = class extends Transport {
@@ -907,7 +1013,7 @@ var ServerTransport = class extends Transport {
     const parsed = this.parseMsg(data);
     if (!parsed) {
       this.protocolError(
-        "handshake_failed" /* HandshakeFailed */,
+        ProtocolError.HandshakeFailed,
         "received non-transport message"
       );
       return false;
@@ -926,7 +1032,7 @@ var ServerTransport = class extends Transport {
         )}`
       );
       this.protocolError(
-        "handshake_failed" /* HandshakeFailed */,
+        ProtocolError.HandshakeFailed,
         "invalid handshake request"
       );
       return false;
@@ -944,7 +1050,7 @@ var ServerTransport = class extends Transport {
         `${this.clientId} -- received handshake msg with incompatible protocol version (got: ${gotVersion}, expected: ${PROTOCOL_VERSION})`
       );
       this.protocolError(
-        "handshake_failed" /* HandshakeFailed */,
+        ProtocolError.HandshakeFailed,
         `incorrect version (got: ${gotVersion} wanted ${PROTOCOL_VERSION})`
       );
       return false;
@@ -968,7 +1074,7 @@ var ServerTransport = class extends Transport {
   ClientTransport,
   Connection,
   OpaqueTransportMessageSchema,
-  ProtocolErrorType,
+  ProtocolError,
   ServerTransport,
   Session,
   Transport,

package/dist/transport/index.d.cts

@@ -1,3 +1,3 @@
-export { a as ClientTransport, C as Connection, l as EventHandler, E as EventMap, k as EventTypes, O as OpaqueTransportMessage, g as OpaqueTransportMessageSchema, m as ProtocolErrorType, S as ServerTransport, d as Session, T as Transport, b as TransportClientId, h as TransportMessage, f as TransportMessageSchema, c as TransportOptions, e as TransportStatus, j as isStreamClose, i as isStreamOpen } from '../index-f922ec84.js';
+export { a as ClientTransport, c as ClientTransportOptions, C as Connection, m as EventHandler, E as EventMap, l as EventTypes, O as OpaqueTransportMessage, h as OpaqueTransportMessageSchema, n as ProtocolError, o as ProtocolErrorType, d as ServerTransporOptions, S as ServerTransport, e as Session, T as Transport, b as TransportClientId, i as TransportMessage, g as TransportMessageSchema, f as TransportStatus, k as isStreamClose, j as isStreamOpen } from '../index-bbccacef.js';
 import '../types-3e5768ec.js';
 import '@sinclair/typebox';

package/dist/transport/index.d.ts

@@ -1,3 +1,3 @@
-export { a as ClientTransport, C as Connection, l as EventHandler, E as EventMap, k as EventTypes, O as OpaqueTransportMessage, g as OpaqueTransportMessageSchema, m as ProtocolErrorType, S as ServerTransport, d as Session, T as Transport, b as TransportClientId, h as TransportMessage, f as TransportMessageSchema, c as TransportOptions, e as TransportStatus, j as isStreamClose, i as isStreamOpen } from '../index-f922ec84.js';
+export { a as ClientTransport, c as ClientTransportOptions, C as Connection, m as EventHandler, E as EventMap, l as EventTypes, O as OpaqueTransportMessage, h as OpaqueTransportMessageSchema, n as ProtocolError, o as ProtocolErrorType, d as ServerTransporOptions, S as ServerTransport, e as Session, T as Transport, b as TransportClientId, i as TransportMessage, g as TransportMessageSchema, f as TransportStatus, k as isStreamClose, j as isStreamOpen } from '../index-bbccacef.js';
 import '../types-3e5768ec.js';
 import '@sinclair/typebox';

package/dist/transport/index.js

@@ -2,11 +2,11 @@ import "../chunk-RPIDSIQG.js";
 import {
   ClientTransport,
   Connection,
-  ProtocolErrorType,
+  ProtocolError,
   ServerTransport,
   Session,
   Transport
-} from "../chunk-IVNV5HBI.js";
+} from "../chunk-B7VTDQR7.js";
 import {
   OpaqueTransportMessageSchema,
   TransportMessageSchema
@@ -17,7 +17,7 @@ export {
   ClientTransport,
   Connection,
   OpaqueTransportMessageSchema,
-  ProtocolErrorType,
+  ProtocolError,
   ServerTransport,
   Session,
   Transport,

package/dist/util/testHelpers.cjs

@@ -42,6 +42,7 @@ __export(testHelpers_exports, {
   onUdsServeReady: () => onUdsServeReady,
   onWsServerReady: () => onWsServerReady,
   payloadToTransportMessage: () => payloadToTransportMessage,
+  testingSessionOptions: () => testingSessionOptions,
   waitForMessage: () => waitForMessage
 });
 module.exports = __toCommonJS(testHelpers_exports);
@@ -53,71 +54,8 @@ var log;
 
 // transport/session.ts
 var import_nanoid = require("nanoid");
-
-// codec/json.ts
-var encoder = new TextEncoder();
-var decoder = new TextDecoder();
-function uint8ArrayToBase64(uint8Array) {
-  let binary = "";
-  uint8Array.forEach((byte) => {
-    binary += String.fromCharCode(byte);
-  });
-  return btoa(binary);
-}
-function base64ToUint8Array(base64) {
-  const binaryString = atob(base64);
-  const uint8Array = new Uint8Array(binaryString.length);
-  for (let i = 0; i < binaryString.length; i++) {
-    uint8Array[i] = binaryString.charCodeAt(i);
-  }
-  return uint8Array;
-}
-var NaiveJsonCodec = {
-  toBuffer: (obj) => {
-    return encoder.encode(
-      JSON.stringify(obj, function replacer(key) {
-        const val = this[key];
-        if (val instanceof Uint8Array) {
-          return { $t: uint8ArrayToBase64(val) };
-        } else {
-          return val;
-        }
-      })
-    );
-  },
-  fromBuffer: (buff) => {
-    try {
-      const parsed = JSON.parse(
-        decoder.decode(buff),
-        function reviver(_key, val) {
-          if (val?.$t) {
-            return base64ToUint8Array(val.$t);
-          } else {
-            return val;
-          }
-        }
-      );
-      if (typeof parsed === "object")
-        return parsed;
-      return null;
-    } catch {
-      return null;
-    }
-  }
-};
-
-// transport/session.ts
 var nanoid = (0, import_nanoid.customAlphabet)("1234567890abcdefghijklmnopqrstuvxyz", 6);
 var unsafeId = () => nanoid();
-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;
@@ -309,6 +247,58 @@ function coerceErrorString(err) {
   return `[coerced to error] ${String(err)}`;
 }
 
+// codec/json.ts
+var encoder = new TextEncoder();
+var decoder = new TextDecoder();
+function uint8ArrayToBase64(uint8Array) {
+  let binary = "";
+  uint8Array.forEach((byte) => {
+    binary += String.fromCharCode(byte);
+  });
+  return btoa(binary);
+}
+function base64ToUint8Array(base64) {
+  const binaryString = atob(base64);
+  const uint8Array = new Uint8Array(binaryString.length);
+  for (let i = 0; i < binaryString.length; i++) {
+    uint8Array[i] = binaryString.charCodeAt(i);
+  }
+  return uint8Array;
+}
+var NaiveJsonCodec = {
+  toBuffer: (obj) => {
+    return encoder.encode(
+      JSON.stringify(obj, function replacer(key) {
+        const val = this[key];
+        if (val instanceof Uint8Array) {
+          return { $t: uint8ArrayToBase64(val) };
+        } else {
+          return val;
+        }
+      })
+    );
+  },
+  fromBuffer: (buff) => {
+    try {
+      const parsed = JSON.parse(
+        decoder.decode(buff),
+        function reviver(_key, val) {
+          if (val?.$t) {
+            return base64ToUint8Array(val.$t);
+          } else {
+            return val;
+          }
+        }
+      );
+      if (typeof parsed === "object")
+        return parsed;
+      return null;
+    } catch {
+      return null;
+    }
+  }
+};
+
 // node_modules/p-defer/index.js
 function pDefer() {
   const deferred = {};
@@ -673,12 +663,18 @@ function catchProcError(err) {
     }
   };
 }
+var testingSessionOptions = {
+  heartbeatIntervalMs: 1e3,
+  heartbeatsUntilDead: 2,
+  sessionDisconnectGraceMs: 5e3,
+  codec: NaiveJsonCodec
+};
 function dummyCtx(state, extendedContext) {
   const session = new Session(
     "client",
     "SERVER",
     void 0,
-    defaultSessionOptions
+    testingSessionOptions
   );
   return {
     ...extendedContext,
@@ -750,5 +746,6 @@ var getUnixSocketPath = () => {
   onUdsServeReady,
   onWsServerReady,
   payloadToTransportMessage,
+  testingSessionOptions,
   waitForMessage
 });

package/dist/util/testHelpers.d.cts

@@ -1,11 +1,11 @@
 import * as it_pushable from 'it-pushable';
+import { C as Codec } from '../types-3e5768ec.js';
 import WebSocket from 'isomorphic-ws';
 import http from 'node:http';
-import { P as PartialTransportMessage, T as Transport, C as Connection, O as OpaqueTransportMessage } from '../index-f922ec84.js';
-import { P as PayloadType, R as RiverError, a as Procedure, S as ServiceContext, b as Result, c as RiverUncaughtSchema } from '../builder-ca6c4259.js';
+import { P as PartialTransportMessage, T as Transport, C as Connection, O as OpaqueTransportMessage } from '../index-bbccacef.js';
+import { P as PayloadType, R as RiverError, a as Procedure, S as ServiceContext, b as Result, c as RiverUncaughtSchema } from '../builder-ebd945c0.js';
 import { Static } from '@sinclair/typebox';
 import net from 'node:net';
-import '../types-3e5768ec.js';
 
 /**
  * Creates a WebSocket server instance using the provided HTTP server.
@@ -48,6 +48,12 @@ declare function createDummyTransportMessage(): PartialTransportMessage<{
  * @returns A promise that resolves with the payload of the first message that passes the filter.
  */
 declare function waitForMessage(t: Transport<Connection>, filter?: (msg: OpaqueTransportMessage) => boolean, rejectMismatch?: boolean): Promise<unknown>;
+declare const testingSessionOptions: {
+    heartbeatIntervalMs: number;
+    heartbeatsUntilDead: number;
+    sessionDisconnectGraceMs: number;
+    codec: Codec;
+};
 declare function asClientRpc<State extends object, I extends PayloadType, O extends PayloadType, E extends RiverError, Init extends PayloadType | null = null>(state: State, proc: Procedure<State, 'rpc', I, O, E, Init>, extendedContext?: Omit<ServiceContext, 'state'>): (msg: Static<I>) => Promise<Result<Static<O>, Static<E> | Static<typeof RiverUncaughtSchema>>>;
 declare function asClientStream<State extends object, I extends PayloadType, O extends PayloadType, E extends RiverError, Init extends PayloadType | null = null>(state: State, proc: Procedure<State, 'stream', I, O, E, Init>, init?: Init extends PayloadType ? Static<Init> : null, extendedContext?: Omit<ServiceContext, 'state'>): readonly [it_pushable.Pushable<Static<I>, void, unknown>, it_pushable.Pushable<Result<Static<O>, Static<E>>, void, unknown>];
 declare function asClientSubscription<State extends object, I extends PayloadType, O extends PayloadType, E extends RiverError>(state: State, proc: Procedure<State, 'subscription', I, O, E>, extendedContext?: Omit<ServiceContext, 'state'>): (msg: Static<I>) => it_pushable.Pushable<Result<Static<O>, Static<E>>, void, unknown>;
@@ -60,4 +66,4 @@ declare function asClientUpload<State extends object, I extends PayloadType, O e
 } | Result<Static<O>, Static<E>>>];
 declare const getUnixSocketPath: () => string;
 
-export { asClientRpc, asClientStream, asClientSubscription, asClientUpload, createDummyTransportMessage, createLocalWebSocketClient, createWebSocketServer, getUnixSocketPath, iterNext, onUdsServeReady, onWsServerReady, payloadToTransportMessage, waitForMessage };
+export { asClientRpc, asClientStream, asClientSubscription, asClientUpload, createDummyTransportMessage, createLocalWebSocketClient, createWebSocketServer, getUnixSocketPath, iterNext, onUdsServeReady, onWsServerReady, payloadToTransportMessage, testingSessionOptions, waitForMessage };