@replit/river 0.18.5 → 0.19.2

package/dist/util/testHelpers.cjs

@@ -49,420 +49,107 @@ module.exports = __toCommonJS(testHelpers_exports);
 var import_isomorphic_ws = __toESM(require("isomorphic-ws"), 1);
 var import_ws = require("ws");
 
-// transport/transport.ts
-var import_value = require("@sinclair/typebox/value");
-
-// logging/log.ts
-var log = void 0;
+// node_modules/p-defer/index.js
+function pDefer() {
+  const deferred = {};
+  deferred.promise = new Promise((resolve, reject) => {
+    deferred.resolve = resolve;
+    deferred.reject = reject;
+  });
+  return deferred;
+}
 
-// transport/session.ts
-var import_nanoid = require("nanoid");
-var nanoid = (0, import_nanoid.customAlphabet)("1234567890abcdefghijklmnopqrstuvxyz", 6);
-var unsafeId = () => nanoid();
-var Session = class {
-  codec;
-  options;
-  /**
-   * The buffer of messages that have been sent but not yet acknowledged.
-   */
-  sendBuffer = [];
-  /**
-   * The active connection associated with this session
-   */
-  connection;
-  from;
-  to;
-  /**
-   * The unique ID of this session.
-   */
-  id;
-  /**
-   * What the other side advertised as their session ID
-   * for this session.
-   */
-  advertisedSessionId;
-  /**
-   * Number of messages we've sent along this session (excluding handshake and acks)
-   */
-  seq = 0;
-  /**
-   * Number of unique messages we've received this session (excluding handshake and acks)
-   */
-  ack = 0;
-  /**
-   * The grace period between when the inner connection is disconnected
-   * and when we should consider the entire session disconnected.
-   */
-  disconnectionGrace;
-  /**
-   * Number of heartbeats we've sent without a response.
-   */
-  heartbeatMisses;
-  /**
-   * The interval for sending heartbeats.
-   */
-  heartbeat;
-  constructor(conn, from, to, options) {
-    this.id = `session-${nanoid(12)}`;
-    this.options = options;
-    this.from = from;
-    this.to = to;
-    this.connection = conn;
-    this.codec = options.codec;
-    this.heartbeatMisses = 0;
-    this.heartbeat = setInterval(
-      () => this.sendHeartbeat(),
-      options.heartbeatIntervalMs
-    );
-  }
-  get loggingMetadata() {
-    return {
-      clientId: this.from,
-      connectedTo: this.to,
-      sessionId: this.id,
-      connId: this.connection?.debugId
-    };
+// node_modules/it-pushable/dist/src/fifo.js
+var FixedFIFO = class {
+  buffer;
+  mask;
+  top;
+  btm;
+  next;
+  constructor(hwm) {
+    if (!(hwm > 0) || (hwm - 1 & hwm) !== 0) {
+      throw new Error("Max size for a FixedFIFO should be a power of two");
+    }
+    this.buffer = new Array(hwm);
+    this.mask = hwm - 1;
+    this.top = 0;
+    this.btm = 0;
+    this.next = null;
   }
-  /**
-   * 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.
-   *
-   * @param msg The partial message to be sent, which will be constructed into a full message.
-   * @param addToSendBuff Whether to add the message to the send buffer for retry.
-   * @returns The full transport ID of the message that was attempted to be sent.
-   */
-  send(msg) {
-    const fullMsg = this.constructMsg(msg);
-    log?.debug(`sending msg`, {
-      ...this.loggingMetadata,
-      fullTransportMessage: fullMsg
-    });
-    if (this.connection) {
-      const ok = this.connection.send(this.codec.toBuffer(fullMsg));
-      if (ok)
-        return fullMsg.id;
-      log?.info(
-        `failed to send msg to ${fullMsg.to}, connection is probably dead`,
-        {
-          ...this.loggingMetadata,
-          fullTransportMessage: fullMsg
-        }
-      );
-    } else {
-      log?.info(
-        `failed to send msg to ${fullMsg.to}, connection not ready yet`,
-        { ...this.loggingMetadata, fullTransportMessage: fullMsg }
-      );
+  push(data) {
+    if (this.buffer[this.top] !== void 0) {
+      return false;
     }
-    return fullMsg.id;
+    this.buffer[this.top] = data;
+    this.top = this.top + 1 & this.mask;
+    return true;
   }
-  sendHeartbeat() {
-    const misses = this.heartbeatMisses;
-    const missDuration = misses * this.options.heartbeatIntervalMs;
-    if (misses > this.options.heartbeatsUntilDead) {
-      if (this.connection) {
-        log?.info(
-          `closing connection to ${this.to} due to inactivity (missed ${misses} heartbeats which is ${missDuration}ms)`,
-          this.loggingMetadata
-        );
-        this.closeStaleConnection();
-      }
-      return;
+  shift() {
+    const last = this.buffer[this.btm];
+    if (last === void 0) {
+      return void 0;
     }
-    this.send({
-      streamId: "heartbeat",
-      controlFlags: 1 /* AckBit */,
-      payload: {
-        type: "ACK"
-      }
-    });
-    this.heartbeatMisses++;
+    this.buffer[this.btm] = void 0;
+    this.btm = this.btm + 1 & this.mask;
+    return last;
   }
-  resetBufferedMessages() {
-    this.sendBuffer = [];
-    this.seq = 0;
-    this.ack = 0;
+  isEmpty() {
+    return this.buffer[this.btm] === void 0;
+  }
+};
+var FIFO = class {
+  size;
+  hwm;
+  head;
+  tail;
+  constructor(options = {}) {
+    this.hwm = options.splitLimit ?? 16;
+    this.head = new FixedFIFO(this.hwm);
+    this.tail = this.head;
+    this.size = 0;
   }
-  sendBufferedMessages() {
-    if (!this.connection) {
-      const msg = `tried sending buffered messages without a connection (if you hit this code path something is seriously wrong)`;
-      log?.error(msg, this.loggingMetadata);
-      throw new Error(msg);
+  calculateSize(obj) {
+    if (obj?.byteLength != null) {
+      return obj.byteLength;
     }
-    log?.info(
-      `resending ${this.sendBuffer.length} buffered messages`,
-      this.loggingMetadata
-    );
-    for (const msg of this.sendBuffer) {
-      log?.debug(`resending msg`, {
-        ...this.loggingMetadata,
-        fullTransportMessage: msg
-      });
-      const ok = this.connection.send(this.codec.toBuffer(msg));
-      if (!ok) {
-        const errMsg = `failed to send buffered message to ${this.to} (if you hit this code path something is seriously wrong)`;
-        log?.error(errMsg, {
-          ...this.loggingMetadata,
-          fullTransportMessage: msg
-        });
-        throw new Error(errMsg);
-      }
+    return 1;
+  }
+  push(val) {
+    if (val?.value != null) {
+      this.size += this.calculateSize(val.value);
+    }
+    if (!this.head.push(val)) {
+      const prev = this.head;
+      this.head = prev.next = new FixedFIFO(2 * this.head.buffer.length);
+      this.head.push(val);
     }
   }
-  updateBookkeeping(ack, seq) {
-    if (seq + 1 < this.ack) {
-      log?.error(
-        `received stale seq ${seq} + 1 < ${this.ack}`,
-        this.loggingMetadata
-      );
-      return;
+  shift() {
+    let val = this.tail.shift();
+    if (val === void 0 && this.tail.next != null) {
+      const next = this.tail.next;
+      this.tail.next = null;
+      this.tail = next;
+      val = this.tail.shift();
     }
-    this.sendBuffer = this.sendBuffer.filter((unacked) => unacked.seq >= ack);
-    this.ack = seq + 1;
+    if (val?.value != null) {
+      this.size -= this.calculateSize(val.value);
+    }
+    return val;
   }
-  closeStaleConnection(conn) {
-    if (this.connection === void 0 || this.connection === conn)
-      return;
-    log?.info(
-      `closing old inner connection from session to ${this.to}`,
-      this.loggingMetadata
-    );
-    this.connection.close();
-    this.connection = void 0;
+  isEmpty() {
+    return this.head.isEmpty();
   }
-  replaceWithNewConnection(newConn) {
-    this.closeStaleConnection(newConn);
-    this.cancelGrace();
-    this.connection = newConn;
-  }
-  beginGrace(cb) {
-    log?.info(
-      `starting ${this.options.sessionDisconnectGraceMs}ms grace period until session to ${this.to} is closed`,
-      this.loggingMetadata
-    );
-    this.disconnectionGrace = setTimeout(() => {
-      this.close();
-      cb();
-    }, this.options.sessionDisconnectGraceMs);
-  }
-  // called on reconnect of the underlying session
-  cancelGrace() {
-    this.heartbeatMisses = 0;
-    clearTimeout(this.disconnectionGrace);
-    this.disconnectionGrace = void 0;
-  }
-  // closed when we want to discard the whole session
-  // (i.e. shutdown or session disconnect)
-  close() {
-    this.closeStaleConnection();
-    this.cancelGrace();
-    this.resetBufferedMessages();
-    clearInterval(this.heartbeat);
-  }
-  get connected() {
-    return this.connection !== void 0;
-  }
-  get nextExpectedSeq() {
-    return this.ack;
-  }
-  constructMsg(partialMsg) {
-    const msg = {
-      ...partialMsg,
-      id: unsafeId(),
-      to: this.to,
-      from: this.from,
-      seq: this.seq,
-      ack: this.ack
-    };
-    this.seq++;
-    this.sendBuffer.push(msg);
-    return msg;
-  }
-  inspectSendBuffer() {
-    return this.sendBuffer;
-  }
-};
-
-// util/stringify.ts
-function coerceErrorString(err) {
-  if (err instanceof Error) {
-    return err.message || "unknown reason";
-  }
-  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;
-    }
-  }
-};
-
-// transport/transport.ts
-var defaultTransportOptions = {
-  heartbeatIntervalMs: 1e3,
-  heartbeatsUntilDead: 2,
-  sessionDisconnectGraceMs: 5e3,
-  codec: NaiveJsonCodec
-};
-var defaultConnectionRetryOptions = {
-  baseIntervalMs: 250,
-  maxJitterMs: 200,
-  maxBackoffMs: 32e3,
-  attemptBudgetCapacity: 5,
-  budgetRestoreIntervalMs: 200
-};
-var defaultClientTransportOptions = {
-  ...defaultTransportOptions,
-  ...defaultConnectionRetryOptions
-};
-
-// node_modules/p-defer/index.js
-function pDefer() {
-  const deferred = {};
-  deferred.promise = new Promise((resolve, reject) => {
-    deferred.resolve = resolve;
-    deferred.reject = reject;
-  });
-  return deferred;
-}
-
-// node_modules/it-pushable/dist/src/fifo.js
-var FixedFIFO = class {
-  buffer;
-  mask;
-  top;
-  btm;
-  next;
-  constructor(hwm) {
-    if (!(hwm > 0) || (hwm - 1 & hwm) !== 0) {
-      throw new Error("Max size for a FixedFIFO should be a power of two");
-    }
-    this.buffer = new Array(hwm);
-    this.mask = hwm - 1;
-    this.top = 0;
-    this.btm = 0;
-    this.next = null;
-  }
-  push(data) {
-    if (this.buffer[this.top] !== void 0) {
-      return false;
-    }
-    this.buffer[this.top] = data;
-    this.top = this.top + 1 & this.mask;
-    return true;
-  }
-  shift() {
-    const last = this.buffer[this.btm];
-    if (last === void 0) {
-      return void 0;
-    }
-    this.buffer[this.btm] = void 0;
-    this.btm = this.btm + 1 & this.mask;
-    return last;
-  }
-  isEmpty() {
-    return this.buffer[this.btm] === void 0;
-  }
-};
-var FIFO = class {
-  size;
-  hwm;
-  head;
-  tail;
-  constructor(options = {}) {
-    this.hwm = options.splitLimit ?? 16;
-    this.head = new FixedFIFO(this.hwm);
-    this.tail = this.head;
-    this.size = 0;
-  }
-  calculateSize(obj) {
-    if (obj?.byteLength != null) {
-      return obj.byteLength;
-    }
-    return 1;
-  }
-  push(val) {
-    if (val?.value != null) {
-      this.size += this.calculateSize(val.value);
-    }
-    if (!this.head.push(val)) {
-      const prev = this.head;
-      this.head = prev.next = new FixedFIFO(2 * this.head.buffer.length);
-      this.head.push(val);
-    }
-  }
-  shift() {
-    let val = this.tail.shift();
-    if (val === void 0 && this.tail.next != null) {
-      const next = this.tail.next;
-      this.tail.next = null;
-      this.tail = next;
-      val = this.tail.shift();
-    }
-    if (val?.value != null) {
-      this.size -= this.calculateSize(val.value);
-    }
-    return val;
-  }
-  isEmpty() {
-    return this.head.isEmpty();
-  }
-};
-
-// node_modules/it-pushable/dist/src/index.js
-var AbortError = class extends Error {
-  type;
-  code;
-  constructor(message, code) {
-    super(message ?? "The operation was aborted");
-    this.type = "aborted";
-    this.code = code ?? "ABORT_ERR";
+};
+
+// node_modules/it-pushable/dist/src/index.js
+var AbortError = class extends Error {
+  type;
+  code;
+  constructor(message, code) {
+    super(message ?? "The operation was aborted");
+    this.type = "aborted";
+    this.code = code ?? "ABORT_ERR";
   }
 };
 function pushable(options = {}) {
@@ -656,8 +343,330 @@ var RiverUncaughtSchema = import_typebox.Type.Object({
   message: import_typebox.Type.String()
 });
 
+// logging/log.ts
+var log = void 0;
+
+// util/stringify.ts
+function coerceErrorString(err) {
+  if (err instanceof Error) {
+    return err.message || "unknown reason";
+  }
+  return `[coerced to error] ${String(err)}`;
+}
+
 // util/testHelpers.ts
 var import_nanoid2 = require("nanoid");
+
+// transport/session.ts
+var import_nanoid = require("nanoid");
+var nanoid = (0, import_nanoid.customAlphabet)("1234567890abcdefghijklmnopqrstuvxyz", 6);
+var unsafeId = () => nanoid();
+var Session = class {
+  codec;
+  options;
+  /**
+   * The buffer of messages that have been sent but not yet acknowledged.
+   */
+  sendBuffer = [];
+  /**
+   * The active connection associated with this session
+   */
+  connection;
+  from;
+  to;
+  /**
+   * The unique ID of this session.
+   */
+  id;
+  /**
+   * What the other side advertised as their session ID
+   * for this session.
+   */
+  advertisedSessionId;
+  /**
+   * The metadata for this session, as parsed from the handshake.
+   *
+   * Will only ever be populated on the server side.
+   */
+  metadata;
+  /**
+   * Number of messages we've sent along this session (excluding handshake and acks)
+   */
+  seq = 0;
+  /**
+   * Number of unique messages we've received this session (excluding handshake and acks)
+   */
+  ack = 0;
+  /**
+   * The grace period between when the inner connection is disconnected
+   * and when we should consider the entire session disconnected.
+   */
+  disconnectionGrace;
+  /**
+   * Number of heartbeats we've sent without a response.
+   */
+  heartbeatMisses;
+  /**
+   * The interval for sending heartbeats.
+   */
+  heartbeat;
+  constructor(conn, from, to, options) {
+    this.id = `session-${nanoid(12)}`;
+    this.options = options;
+    this.from = from;
+    this.to = to;
+    this.connection = conn;
+    this.codec = options.codec;
+    this.heartbeatMisses = 0;
+    this.heartbeat = setInterval(
+      () => this.sendHeartbeat(),
+      options.heartbeatIntervalMs
+    );
+  }
+  get loggingMetadata() {
+    return {
+      clientId: this.from,
+      connectedTo: this.to,
+      sessionId: this.id,
+      connId: this.connection?.debugId
+    };
+  }
+  /**
+   * 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.
+   *
+   * @param msg The partial message to be sent, which will be constructed into a full message.
+   * @param addToSendBuff Whether to add the message to the send buffer for retry.
+   * @returns The full transport ID of the message that was attempted to be sent.
+   */
+  send(msg) {
+    const fullMsg = this.constructMsg(msg);
+    log?.debug(`sending msg`, {
+      ...this.loggingMetadata,
+      fullTransportMessage: fullMsg
+    });
+    if (this.connection) {
+      const ok = this.connection.send(this.codec.toBuffer(fullMsg));
+      if (ok)
+        return fullMsg.id;
+      log?.info(
+        `failed to send msg to ${fullMsg.to}, connection is probably dead`,
+        {
+          ...this.loggingMetadata,
+          fullTransportMessage: fullMsg
+        }
+      );
+    } else {
+      log?.info(
+        `failed to send msg to ${fullMsg.to}, connection not ready yet`,
+        { ...this.loggingMetadata, fullTransportMessage: fullMsg }
+      );
+    }
+    return fullMsg.id;
+  }
+  sendHeartbeat() {
+    const misses = this.heartbeatMisses;
+    const missDuration = misses * this.options.heartbeatIntervalMs;
+    if (misses > this.options.heartbeatsUntilDead) {
+      if (this.connection) {
+        log?.info(
+          `closing connection to ${this.to} due to inactivity (missed ${misses} heartbeats which is ${missDuration}ms)`,
+          this.loggingMetadata
+        );
+        this.closeStaleConnection();
+      }
+      return;
+    }
+    this.send({
+      streamId: "heartbeat",
+      controlFlags: 1 /* AckBit */,
+      payload: {
+        type: "ACK"
+      }
+    });
+    this.heartbeatMisses++;
+  }
+  resetBufferedMessages() {
+    this.sendBuffer = [];
+    this.seq = 0;
+    this.ack = 0;
+  }
+  sendBufferedMessages(conn) {
+    log?.info(`resending ${this.sendBuffer.length} buffered messages`, {
+      ...this.loggingMetadata,
+      connId: conn.debugId
+    });
+    for (const msg of this.sendBuffer) {
+      log?.debug(`resending msg`, {
+        ...this.loggingMetadata,
+        fullTransportMessage: msg,
+        connId: conn.debugId
+      });
+      const ok = conn.send(this.codec.toBuffer(msg));
+      if (!ok) {
+        const errMsg = `failed to send buffered message to ${this.to} (sus, this is a fresh connection)`;
+        log?.error(errMsg, {
+          ...this.loggingMetadata,
+          fullTransportMessage: msg,
+          connId: conn.debugId
+        });
+        throw new Error(errMsg);
+      }
+    }
+  }
+  updateBookkeeping(ack, seq) {
+    if (seq + 1 < this.ack) {
+      log?.error(
+        `received stale seq ${seq} + 1 < ${this.ack}`,
+        this.loggingMetadata
+      );
+      return;
+    }
+    this.sendBuffer = this.sendBuffer.filter((unacked) => unacked.seq >= ack);
+    this.ack = seq + 1;
+  }
+  closeStaleConnection(conn) {
+    if (this.connection === void 0 || this.connection === conn)
+      return;
+    log?.info(
+      `closing old inner connection from session to ${this.to}`,
+      this.loggingMetadata
+    );
+    this.connection.close();
+    this.connection = void 0;
+  }
+  replaceWithNewConnection(newConn) {
+    this.closeStaleConnection(newConn);
+    this.cancelGrace();
+    this.connection = newConn;
+    this.sendBufferedMessages(newConn);
+  }
+  beginGrace(cb) {
+    log?.info(
+      `starting ${this.options.sessionDisconnectGraceMs}ms grace period until session to ${this.to} is closed`,
+      this.loggingMetadata
+    );
+    this.disconnectionGrace = setTimeout(() => {
+      this.close();
+      cb();
+    }, this.options.sessionDisconnectGraceMs);
+  }
+  // called on reconnect of the underlying session
+  cancelGrace() {
+    this.heartbeatMisses = 0;
+    clearTimeout(this.disconnectionGrace);
+    this.disconnectionGrace = void 0;
+  }
+  // closed when we want to discard the whole session
+  // (i.e. shutdown or session disconnect)
+  close() {
+    this.closeStaleConnection();
+    this.cancelGrace();
+    this.resetBufferedMessages();
+    clearInterval(this.heartbeat);
+  }
+  get connected() {
+    return this.connection !== void 0;
+  }
+  get nextExpectedSeq() {
+    return this.ack;
+  }
+  constructMsg(partialMsg) {
+    const msg = {
+      ...partialMsg,
+      id: unsafeId(),
+      to: this.to,
+      from: this.from,
+      seq: this.seq,
+      ack: this.ack
+    };
+    this.seq++;
+    this.sendBuffer.push(msg);
+    return msg;
+  }
+  inspectSendBuffer() {
+    return this.sendBuffer;
+  }
+};
+
+// transport/transport.ts
+var import_value = require("@sinclair/typebox/value");
+
+// 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 defaultTransportOptions = {
+  heartbeatIntervalMs: 1e3,
+  heartbeatsUntilDead: 2,
+  sessionDisconnectGraceMs: 5e3,
+  codec: NaiveJsonCodec
+};
+var defaultConnectionRetryOptions = {
+  baseIntervalMs: 250,
+  maxJitterMs: 200,
+  maxBackoffMs: 32e3,
+  attemptBudgetCapacity: 5,
+  budgetRestoreIntervalMs: 200
+};
+var defaultClientTransportOptions = {
+  ...defaultTransportOptions,
+  ...defaultConnectionRetryOptions
+};
+var defaultServerTransportOptions = {
+  ...defaultTransportOptions
+};
+
+// util/testHelpers.ts
 function createWebSocketServer(server) {
   return new import_ws.WebSocketServer({ server });
 }