@replit/river 0.23.12 → 0.23.14

package/dist/{chunk-3AW3IXVD.js → chunk-4PVU7J25.js}

@@ -1,22 +1,3 @@
-// codec/binary.ts
-import { decode, encode } from "@msgpack/msgpack";
-var BinaryCodec = {
-  toBuffer(obj) {
-    return encode(obj, { ignoreUndefined: true });
-  },
-  fromBuffer: (buff) => {
-    try {
-      const res = decode(buff);
-      if (typeof res !== "object") {
-        return null;
-      }
-      return res;
-    } catch {
-      return null;
-    }
-  }
-};
-
 // codec/json.ts
 var encoder = new TextEncoder();
 var decoder = new TextDecoder();
@@ -70,7 +51,6 @@ var NaiveJsonCodec = {
 };
 
 export {
-  BinaryCodec,
   NaiveJsonCodec
 };
-//# sourceMappingURL=chunk-3AW3IXVD.js.map
+//# sourceMappingURL=chunk-4PVU7J25.js.map

package/dist/chunk-4PVU7J25.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../codec/json.ts"],"sourcesContent":["import { Codec } from './types';\n\nconst encoder = new TextEncoder();\nconst decoder = new TextDecoder();\n\n// Convert Uint8Array to base64\nfunction uint8ArrayToBase64(uint8Array: Uint8Array) {\n  let binary = '';\n  uint8Array.forEach((byte) => {\n    binary += String.fromCharCode(byte);\n  });\n  return btoa(binary);\n}\n\n// Convert base64 to Uint8Array\nfunction base64ToUint8Array(base64: string) {\n  const binaryString = atob(base64);\n  const uint8Array = new Uint8Array(binaryString.length);\n  for (let i = 0; i < binaryString.length; i++) {\n    uint8Array[i] = binaryString.charCodeAt(i);\n  }\n  return uint8Array;\n}\n\ninterface Base64EncodedValue {\n  $t: string;\n}\n\n/**\n * Naive JSON codec implementation using JSON.stringify and JSON.parse.\n * @type {Codec}\n */\nexport const NaiveJsonCodec: Codec = {\n  toBuffer: (obj: object) => {\n    return encoder.encode(\n      JSON.stringify(obj, function replacer<\n        T extends object,\n      >(this: T, key: keyof T) {\n        const val = this[key];\n        if (val instanceof Uint8Array) {\n          return { $t: uint8ArrayToBase64(val) } satisfies Base64EncodedValue;\n        } else {\n          return val;\n        }\n      }),\n    );\n  },\n  fromBuffer: (buff: Uint8Array) => {\n    try {\n      const parsed = JSON.parse(\n        decoder.decode(buff),\n        function reviver(_key, val: unknown) {\n          if ((val as Base64EncodedValue | undefined)?.$t) {\n            return base64ToUint8Array((val as Base64EncodedValue).$t);\n          } else {\n            return val;\n          }\n        },\n      ) as unknown;\n\n      if (typeof parsed === 'object') return parsed;\n      return null;\n    } catch {\n      return null;\n    }\n  },\n};\n"],"mappings":";AAEA,IAAM,UAAU,IAAI,YAAY;AAChC,IAAM,UAAU,IAAI,YAAY;AAGhC,SAAS,mBAAmB,YAAwB;AAClD,MAAI,SAAS;AACb,aAAW,QAAQ,CAAC,SAAS;AAC3B,cAAU,OAAO,aAAa,IAAI;AAAA,EACpC,CAAC;AACD,SAAO,KAAK,MAAM;AACpB;AAGA,SAAS,mBAAmB,QAAgB;AAC1C,QAAM,eAAe,KAAK,MAAM;AAChC,QAAM,aAAa,IAAI,WAAW,aAAa,MAAM;AACrD,WAAS,IAAI,GAAG,IAAI,aAAa,QAAQ,KAAK;AAC5C,eAAW,CAAC,IAAI,aAAa,WAAW,CAAC;AAAA,EAC3C;AACA,SAAO;AACT;AAUO,IAAM,iBAAwB;AAAA,EACnC,UAAU,CAAC,QAAgB;AACzB,WAAO,QAAQ;AAAA,MACb,KAAK,UAAU,KAAK,SAAS,SAElB,KAAc;AACvB,cAAM,MAAM,KAAK,GAAG;AACpB,YAAI,eAAe,YAAY;AAC7B,iBAAO,EAAE,IAAI,mBAAmB,GAAG,EAAE;AAAA,QACvC,OAAO;AACL,iBAAO;AAAA,QACT;AAAA,MACF,CAAC;AAAA,IACH;AAAA,EACF;AAAA,EACA,YAAY,CAAC,SAAqB;AAChC,QAAI;AACF,YAAM,SAAS,KAAK;AAAA,QAClB,QAAQ,OAAO,IAAI;AAAA,QACnB,SAAS,QAAQ,MAAM,KAAc;AACnC,cAAK,KAAwC,IAAI;AAC/C,mBAAO,mBAAoB,IAA2B,EAAE;AAAA,UAC1D,OAAO;AACL,mBAAO;AAAA,UACT;AAAA,QACF;AAAA,MACF;AAEA,UAAI,OAAO,WAAW;AAAU,eAAO;AACvC,aAAO;AAAA,IACT,QAAQ;AACN,aAAO;AAAA,IACT;AAAA,EACF;AACF;","names":[]}

package/dist/{chunk-HDBVL7EF.js → chunk-BEALFLCB.js}

@@ -1,6 +1,6 @@
 import {
   Connection
-} from "./chunk-VRU4IKRT.js";
+} from "./chunk-O2AVDJCQ.js";
 
 // transport/impls/ws/connection.ts
 var WebSocketConnection = class extends Connection {
@@ -56,4 +56,4 @@ var WebSocketConnection = class extends Connection {
 export {
   WebSocketConnection
 };
-//# sourceMappingURL=chunk-HDBVL7EF.js.map
+//# sourceMappingURL=chunk-BEALFLCB.js.map

package/dist/chunk-D2DHRRBN.js

@@ -0,0 +1,476 @@
+import {
+  ProtocolError,
+  Transport
+} from "./chunk-OTVTKAN6.js";
+import {
+  defaultClientTransportOptions
+} from "./chunk-O2AVDJCQ.js";
+import {
+  ControlMessageHandshakeResponseSchema,
+  SESSION_STATE_MISMATCH,
+  coerceErrorString,
+  getPropagationContext,
+  handshakeRequestMessage,
+  tracing_default
+} from "./chunk-GCCRVSMR.js";
+
+// transport/client.ts
+import { SpanStatusCode } from "@opentelemetry/api";
+
+// 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);
+    };
+    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);
+    }
+  }
+};
+
+// transport/client.ts
+import { Value } from "@sinclair/typebox/value";
+var ClientTransport = class extends Transport {
+  /**
+   * The options for this transport.
+   */
+  options;
+  /**
+   * The map of reconnect promises for each client ID.
+   */
+  inflightConnectionPromises;
+  retryBudget;
+  /**
+   * 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 = true;
+  /**
+   * Optional handshake options for this client.
+   */
+  handshakeExtensions;
+  constructor(clientId, providedOptions) {
+    super(clientId, providedOptions);
+    this.options = {
+      ...defaultClientTransportOptions,
+      ...providedOptions
+    };
+    this.inflightConnectionPromises = /* @__PURE__ */ new Map();
+    this.retryBudget = new LeakyBucketRateLimit(this.options);
+  }
+  extendHandshake(options) {
+    this.handshakeExtensions = options;
+  }
+  handleConnection(conn, to) {
+    if (this.getStatus() !== "open")
+      return;
+    let session = void 0;
+    const handshakeTimeout = setTimeout(() => {
+      if (session)
+        return;
+      this.log?.warn(
+        `connection to ${to} timed out waiting for handshake, closing`,
+        { ...conn.loggingMetadata, clientId: this.clientId, connectedTo: to }
+      );
+      conn.close();
+    }, this.options.sessionDisconnectGraceMs);
+    const handshakeHandler = (data) => {
+      const maybeSession = this.receiveHandshakeResponseMessage(data, conn);
+      clearTimeout(handshakeTimeout);
+      if (!maybeSession) {
+        conn.close();
+        return;
+      } else {
+        session = maybeSession;
+      }
+      conn.removeDataListener(handshakeHandler);
+      conn.addDataListener((data2) => {
+        const parsed = this.parseMsg(data2, conn);
+        if (!parsed) {
+          conn.telemetry?.span.setStatus({
+            code: SpanStatusCode.ERROR,
+            message: "message parse failure"
+          });
+          conn.close();
+          return;
+        }
+        this.handleMsg(parsed, conn);
+      });
+    };
+    conn.addDataListener(handshakeHandler);
+    conn.addCloseListener(() => {
+      if (session) {
+        this.onDisconnect(conn, session);
+      }
+      const willReconnect = this.reconnectOnConnectionDrop && this.getStatus() === "open";
+      this.log?.info(
+        `connection to ${to} disconnected` + (willReconnect ? ", reconnecting" : ""),
+        {
+          ...conn.loggingMetadata,
+          ...session?.loggingMetadata,
+          clientId: this.clientId,
+          connectedTo: to
+        }
+      );
+      this.inflightConnectionPromises.delete(to);
+      if (this.reconnectOnConnectionDrop) {
+        void this.connect(to);
+      }
+    });
+    conn.addErrorListener((err) => {
+      conn.telemetry?.span.setStatus({
+        code: SpanStatusCode.ERROR,
+        message: "connection error"
+      });
+      this.log?.warn(
+        `error in connection to ${to}: ${coerceErrorString(err)}`,
+        {
+          ...conn.loggingMetadata,
+          ...session?.loggingMetadata,
+          clientId: this.clientId,
+          connectedTo: to
+        }
+      );
+    });
+  }
+  receiveHandshakeResponseMessage(data, conn) {
+    const parsed = this.parseMsg(data, conn);
+    if (!parsed) {
+      conn.telemetry?.span.setStatus({
+        code: SpanStatusCode.ERROR,
+        message: "non-transport message"
+      });
+      this.protocolError(
+        ProtocolError.HandshakeFailed,
+        "received non-transport message"
+      );
+      return false;
+    }
+    if (!Value.Check(ControlMessageHandshakeResponseSchema, parsed.payload)) {
+      conn.telemetry?.span.setStatus({
+        code: SpanStatusCode.ERROR,
+        message: "invalid handshake response"
+      });
+      this.log?.warn(`received invalid handshake resp`, {
+        ...conn.loggingMetadata,
+        clientId: this.clientId,
+        connectedTo: parsed.from,
+        transportMessage: parsed,
+        validationErrors: [
+          ...Value.Errors(
+            ControlMessageHandshakeResponseSchema,
+            parsed.payload
+          )
+        ]
+      });
+      this.protocolError(
+        ProtocolError.HandshakeFailed,
+        "invalid handshake resp"
+      );
+      return false;
+    }
+    const previousSession = this.sessions.get(parsed.from);
+    if (!parsed.payload.status.ok) {
+      if (parsed.payload.status.reason === SESSION_STATE_MISMATCH) {
+        if (previousSession) {
+          this.deleteSession({
+            session: previousSession,
+            closeHandshakingConnection: true
+          });
+        }
+        conn.telemetry?.span.setStatus({
+          code: SpanStatusCode.ERROR,
+          message: parsed.payload.status.reason
+        });
+      } else {
+        conn.telemetry?.span.setStatus({
+          code: SpanStatusCode.ERROR,
+          message: "handshake rejected"
+        });
+      }
+      this.log?.warn(
+        `received handshake rejection: ${parsed.payload.status.reason}`,
+        {
+          ...conn.loggingMetadata,
+          clientId: this.clientId,
+          connectedTo: parsed.from,
+          transportMessage: parsed
+        }
+      );
+      this.protocolError(
+        ProtocolError.HandshakeFailed,
+        parsed.payload.status.reason
+      );
+      return false;
+    }
+    if (previousSession?.advertisedSessionId && previousSession.advertisedSessionId !== parsed.payload.status.sessionId) {
+      this.deleteSession({
+        session: previousSession,
+        closeHandshakingConnection: true
+      });
+      conn.telemetry?.span.setStatus({
+        code: SpanStatusCode.ERROR,
+        message: "session id mismatch"
+      });
+      this.log?.warn(`handshake from ${parsed.from} session id mismatch`, {
+        ...conn.loggingMetadata,
+        clientId: this.clientId,
+        connectedTo: parsed.from,
+        transportMessage: parsed
+      });
+      this.protocolError(ProtocolError.HandshakeFailed, "session id mismatch");
+      return false;
+    }
+    this.log?.debug(`handshake from ${parsed.from} ok`, {
+      ...conn.loggingMetadata,
+      clientId: this.clientId,
+      connectedTo: parsed.from,
+      transportMessage: parsed
+    });
+    const { session, isTransparentReconnect } = this.getOrCreateSession({
+      to: parsed.from,
+      conn,
+      sessionId: parsed.payload.status.sessionId
+    });
+    this.onConnect(conn, session, isTransparentReconnect);
+    this.retryBudget.startRestoringBudget(session.to);
+    return session;
+  }
+  /**
+   * Manually attempts to connect to a client.
+   * @param to The client ID of the node to connect to.
+   */
+  async connect(to) {
+    if (this.connections.has(to)) {
+      this.log?.info(`already connected to ${to}, skipping connect attempt`, {
+        clientId: this.clientId,
+        connectedTo: to
+      });
+      return;
+    }
+    const canProceedWithConnection = () => this.getStatus() === "open";
+    if (!canProceedWithConnection()) {
+      this.log?.info(
+        `transport state is no longer open, cancelling attempt to connect to ${to}`,
+        { clientId: this.clientId, connectedTo: to }
+      );
+      return;
+    }
+    let reconnectPromise = this.inflightConnectionPromises.get(to);
+    if (!reconnectPromise) {
+      if (!this.retryBudget.hasBudget(to)) {
+        const budgetConsumed = this.retryBudget.getBudgetConsumed(to);
+        const errMsg = `tried to connect to ${to} but retry budget exceeded (more than ${budgetConsumed} attempts in the last ${this.retryBudget.totalBudgetRestoreTime}ms)`;
+        this.log?.error(errMsg, { clientId: this.clientId, connectedTo: to });
+        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.log?.info(
+        `attempting connection to ${to} (${backoffMs}ms backoff)`,
+        {
+          clientId: this.clientId,
+          connectedTo: to
+        }
+      );
+      this.retryBudget.consumeBudget(to);
+      reconnectPromise = tracing_default.startActiveSpan("connect", async (span) => {
+        try {
+          span.addEvent("backoff", { backoffMs });
+          await sleep;
+          if (!canProceedWithConnection()) {
+            throw new Error("transport state is no longer open");
+          }
+          span.addEvent("connecting");
+          const conn = await this.createNewOutgoingConnection(to);
+          if (!canProceedWithConnection()) {
+            this.log?.info(
+              `transport state is no longer open, closing pre-handshake connection to ${to}`,
+              {
+                ...conn.loggingMetadata,
+                clientId: this.clientId,
+                connectedTo: to
+              }
+            );
+            conn.close();
+            throw new Error("transport state is no longer open");
+          }
+          span.addEvent("sending handshake");
+          const ok = await this.sendHandshake(to, conn);
+          if (!ok) {
+            conn.close();
+            throw new Error("failed to send handshake");
+          }
+          return conn;
+        } catch (err) {
+          const errStr = coerceErrorString(err);
+          span.recordException(errStr);
+          span.setStatus({ code: SpanStatusCode.ERROR });
+          throw err;
+        } finally {
+          span.end();
+        }
+      });
+      this.inflightConnectionPromises.set(to, reconnectPromise);
+    } else {
+      this.log?.info(
+        `attempting connection to ${to} (reusing previous attempt)`,
+        {
+          clientId: this.clientId,
+          connectedTo: to
+        }
+      );
+    }
+    try {
+      await reconnectPromise;
+    } catch (error) {
+      this.inflightConnectionPromises.delete(to);
+      const errStr = coerceErrorString(error);
+      if (!this.reconnectOnConnectionDrop || !canProceedWithConnection()) {
+        this.log?.warn(`connection to ${to} failed (${errStr})`, {
+          clientId: this.clientId,
+          connectedTo: to
+        });
+      } else {
+        this.log?.warn(`connection to ${to} failed (${errStr}), retrying`, {
+          clientId: this.clientId,
+          connectedTo: to
+        });
+        await this.connect(to);
+      }
+    }
+  }
+  deleteSession({
+    session,
+    closeHandshakingConnection,
+    handshakingConn
+  }) {
+    this.inflightConnectionPromises.delete(session.to);
+    super.deleteSession({
+      session,
+      closeHandshakingConnection,
+      handshakingConn
+    });
+  }
+  async sendHandshake(to, conn) {
+    let metadata = void 0;
+    if (this.handshakeExtensions) {
+      metadata = await this.handshakeExtensions.construct();
+      if (!Value.Check(this.handshakeExtensions.schema, metadata)) {
+        this.log?.error(`constructed handshake metadata did not match schema`, {
+          ...conn.loggingMetadata,
+          clientId: this.clientId,
+          connectedTo: to,
+          validationErrors: [
+            ...Value.Errors(this.handshakeExtensions.schema, metadata)
+          ],
+          tags: ["invariant-violation"]
+        });
+        this.protocolError(
+          ProtocolError.HandshakeFailed,
+          "handshake metadata did not match schema"
+        );
+        conn.telemetry?.span.setStatus({
+          code: SpanStatusCode.ERROR,
+          message: "handshake meta mismatch"
+        });
+        return false;
+      }
+    }
+    const { session } = this.getOrCreateSession({ to, handshakingConn: conn });
+    const requestMsg = handshakeRequestMessage({
+      from: this.clientId,
+      to,
+      sessionId: session.id,
+      expectedSessionState: {
+        reconnect: session.advertisedSessionId !== void 0,
+        nextExpectedSeq: session.nextExpectedSeq
+      },
+      metadata,
+      tracing: getPropagationContext(session.telemetry.ctx)
+    });
+    this.log?.debug(`sending handshake request to ${to}`, {
+      ...conn.loggingMetadata,
+      clientId: this.clientId,
+      connectedTo: to,
+      transportMessage: requestMsg
+    });
+    conn.send(this.codec.toBuffer(requestMsg));
+    return true;
+  }
+  close() {
+    this.retryBudget.close();
+    super.close();
+  }
+};
+
+export {
+  ClientTransport
+};
+//# sourceMappingURL=chunk-D2DHRRBN.js.map

package/dist/chunk-D2DHRRBN.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../transport/client.ts","../transport/rateLimit.ts"],"sourcesContent":["import { SpanStatusCode } from '@opentelemetry/api';\nimport { ClientHandshakeOptions } from '../router/handshake';\nimport {\n  ControlMessageHandshakeResponseSchema,\n  SESSION_STATE_MISMATCH,\n  TransportClientId,\n  handshakeRequestMessage,\n} from './message';\nimport {\n  ClientTransportOptions,\n  ProvidedClientTransportOptions,\n  defaultClientTransportOptions,\n} from './options';\nimport { LeakyBucketRateLimit } from './rateLimit';\nimport { Connection, Session } from './session';\nimport { Transport } from './transport';\nimport { coerceErrorString } from '../util/stringify';\nimport { ProtocolError } from './events';\nimport { Value } from '@sinclair/typebox/value';\nimport tracer, { getPropagationContext } from '../tracing';\n\nexport abstract class ClientTransport<\n  ConnType extends Connection,\n> extends Transport<ConnType> {\n  /**\n   * The options for this transport.\n   */\n  protected options: ClientTransportOptions;\n\n  /**\n   * The map of reconnect promises for each client ID.\n   */\n  inflightConnectionPromises: Map<TransportClientId, Promise<ConnType>>;\n  retryBudget: LeakyBucketRateLimit;\n\n  /**\n   * A flag indicating whether the transport should automatically reconnect\n   * when a connection is dropped.\n   * Realistically, this should always be true for clients unless you are writing\n   * tests or a special case where you don't want to reconnect.\n   */\n  reconnectOnConnectionDrop = true;\n\n  /**\n   * Optional handshake options for this client.\n   */\n  handshakeExtensions?: ClientHandshakeOptions;\n\n  constructor(\n    clientId: TransportClientId,\n    providedOptions?: ProvidedClientTransportOptions,\n  ) {\n    super(clientId, providedOptions);\n    this.options = {\n      ...defaultClientTransportOptions,\n      ...providedOptions,\n    };\n    this.inflightConnectionPromises = new Map();\n    this.retryBudget = new LeakyBucketRateLimit(this.options);\n  }\n\n  extendHandshake(options: ClientHandshakeOptions) {\n    this.handshakeExtensions = options;\n  }\n\n  protected handleConnection(conn: ConnType, to: TransportClientId): void {\n    if (this.getStatus() !== 'open') return;\n    let session: Session<ConnType> | undefined = undefined;\n\n    // kill the conn after the grace period if we haven't received a handshake\n    const handshakeTimeout = setTimeout(() => {\n      if (session) return;\n      this.log?.warn(\n        `connection to ${to} timed out waiting for handshake, closing`,\n        { ...conn.loggingMetadata, clientId: this.clientId, connectedTo: to },\n      );\n      conn.close();\n    }, this.options.sessionDisconnectGraceMs);\n\n    const handshakeHandler = (data: Uint8Array) => {\n      const maybeSession = this.receiveHandshakeResponseMessage(data, conn);\n      clearTimeout(handshakeTimeout);\n      if (!maybeSession) {\n        conn.close();\n        return;\n      } else {\n        session = maybeSession;\n      }\n\n      // when we are done handshake sequence,\n      // remove handshake listener and use the normal message listener\n      conn.removeDataListener(handshakeHandler);\n      conn.addDataListener((data) => {\n        const parsed = this.parseMsg(data, conn);\n        if (!parsed) {\n          conn.telemetry?.span.setStatus({\n            code: SpanStatusCode.ERROR,\n            message: 'message parse failure',\n          });\n          conn.close();\n          return;\n        }\n\n        this.handleMsg(parsed, conn);\n      });\n    };\n\n    conn.addDataListener(handshakeHandler);\n    conn.addCloseListener(() => {\n      if (session) {\n        this.onDisconnect(conn, session);\n      }\n\n      const willReconnect =\n        this.reconnectOnConnectionDrop && this.getStatus() === 'open';\n\n      this.log?.info(\n        `connection to ${to} disconnected` +\n          (willReconnect ? ', reconnecting' : ''),\n        {\n          ...conn.loggingMetadata,\n          ...session?.loggingMetadata,\n          clientId: this.clientId,\n          connectedTo: to,\n        },\n      );\n\n      this.inflightConnectionPromises.delete(to);\n      if (this.reconnectOnConnectionDrop) {\n        void this.connect(to);\n      }\n    });\n    conn.addErrorListener((err) => {\n      conn.telemetry?.span.setStatus({\n        code: SpanStatusCode.ERROR,\n        message: 'connection error',\n      });\n      this.log?.warn(\n        `error in connection to ${to}: ${coerceErrorString(err)}`,\n        {\n          ...conn.loggingMetadata,\n          ...session?.loggingMetadata,\n          clientId: this.clientId,\n          connectedTo: to,\n        },\n      );\n    });\n  }\n\n  receiveHandshakeResponseMessage(\n    data: Uint8Array,\n    conn: ConnType,\n  ): Session<ConnType> | false {\n    const parsed = this.parseMsg(data, conn);\n    if (!parsed) {\n      conn.telemetry?.span.setStatus({\n        code: SpanStatusCode.ERROR,\n        message: 'non-transport message',\n      });\n      this.protocolError(\n        ProtocolError.HandshakeFailed,\n        'received non-transport message',\n      );\n      return false;\n    }\n\n    if (!Value.Check(ControlMessageHandshakeResponseSchema, parsed.payload)) {\n      conn.telemetry?.span.setStatus({\n        code: SpanStatusCode.ERROR,\n        message: 'invalid handshake response',\n      });\n      this.log?.warn(`received invalid handshake resp`, {\n        ...conn.loggingMetadata,\n        clientId: this.clientId,\n        connectedTo: parsed.from,\n        transportMessage: parsed,\n        validationErrors: [\n          ...Value.Errors(\n            ControlMessageHandshakeResponseSchema,\n            parsed.payload,\n          ),\n        ],\n      });\n      this.protocolError(\n        ProtocolError.HandshakeFailed,\n        'invalid handshake resp',\n      );\n      return false;\n    }\n\n    const previousSession = this.sessions.get(parsed.from);\n    if (!parsed.payload.status.ok) {\n      if (parsed.payload.status.reason === SESSION_STATE_MISMATCH) {\n        if (previousSession) {\n          // The server has told us that we cannot continue with the session because it has the\n          // wrong state. We should delete this session and start fresh.\n          this.deleteSession({\n            session: previousSession,\n            closeHandshakingConnection: true,\n          });\n        }\n\n        conn.telemetry?.span.setStatus({\n          code: SpanStatusCode.ERROR,\n          message: parsed.payload.status.reason,\n        });\n      } else {\n        conn.telemetry?.span.setStatus({\n          code: SpanStatusCode.ERROR,\n          message: 'handshake rejected',\n        });\n      }\n      this.log?.warn(\n        `received handshake rejection: ${parsed.payload.status.reason}`,\n        {\n          ...conn.loggingMetadata,\n          clientId: this.clientId,\n          connectedTo: parsed.from,\n          transportMessage: parsed,\n        },\n      );\n      this.protocolError(\n        ProtocolError.HandshakeFailed,\n        parsed.payload.status.reason,\n      );\n      return false;\n    }\n\n    // before we claim victory and we deem that the handshake is fully established, check that our\n    // session matches the remote's. if they do not match, proactively close the connection.\n    // otherwise we will end up breaking a lot of invariants.\n    //\n    // TODO: Remove this once we finish rolling out the handshake-initiated session agreement.\n    if (\n      previousSession?.advertisedSessionId &&\n      previousSession.advertisedSessionId !== parsed.payload.status.sessionId\n    ) {\n      this.deleteSession({\n        session: previousSession,\n        closeHandshakingConnection: true,\n      });\n\n      conn.telemetry?.span.setStatus({\n        code: SpanStatusCode.ERROR,\n        message: 'session id mismatch',\n      });\n      this.log?.warn(`handshake from ${parsed.from} session id mismatch`, {\n        ...conn.loggingMetadata,\n        clientId: this.clientId,\n        connectedTo: parsed.from,\n        transportMessage: parsed,\n      });\n      this.protocolError(ProtocolError.HandshakeFailed, 'session id mismatch');\n      return false;\n    }\n\n    this.log?.debug(`handshake from ${parsed.from} ok`, {\n      ...conn.loggingMetadata,\n      clientId: this.clientId,\n      connectedTo: parsed.from,\n      transportMessage: parsed,\n    });\n\n    const { session, isTransparentReconnect } = this.getOrCreateSession({\n      to: parsed.from,\n      conn,\n      sessionId: parsed.payload.status.sessionId,\n    });\n\n    this.onConnect(conn, session, isTransparentReconnect);\n\n    // After a successful connection, we start restoring the budget\n    // so that the next time we try to connect, we don't hit the client\n    // with backoff forever.\n    this.retryBudget.startRestoringBudget(session.to);\n    return session;\n  }\n\n  /**\n   * Abstract method that creates a new {@link Connection} object.\n   * This should call {@link handleConnection} when the connection is created.\n   * The downstream client implementation needs to implement this.\n   *\n   * @param to The client ID of the node to connect to.\n   * @returns The new connection object.\n   */\n  protected abstract createNewOutgoingConnection(\n    to: TransportClientId,\n  ): Promise<ConnType>;\n\n  /**\n   * Manually attempts to connect to a client.\n   * @param to The client ID of the node to connect to.\n   */\n  async connect(to: TransportClientId): Promise<void> {\n    if (this.connections.has(to)) {\n      this.log?.info(`already connected to ${to}, skipping connect attempt`, {\n        clientId: this.clientId,\n        connectedTo: to,\n      });\n      return;\n    }\n\n    const canProceedWithConnection = () => this.getStatus() === 'open';\n    if (!canProceedWithConnection()) {\n      this.log?.info(\n        `transport state is no longer open, cancelling attempt to connect to ${to}`,\n        { clientId: this.clientId, connectedTo: to },\n      );\n      return;\n    }\n\n    let reconnectPromise = this.inflightConnectionPromises.get(to);\n    if (!reconnectPromise) {\n      // check budget\n      if (!this.retryBudget.hasBudget(to)) {\n        const budgetConsumed = this.retryBudget.getBudgetConsumed(to);\n        const errMsg = `tried to connect to ${to} but retry budget exceeded (more than ${budgetConsumed} attempts in the last ${this.retryBudget.totalBudgetRestoreTime}ms)`;\n        this.log?.error(errMsg, { clientId: this.clientId, connectedTo: to });\n        this.protocolError(ProtocolError.RetriesExceeded, errMsg);\n        return;\n      }\n\n      let sleep = Promise.resolve();\n      const backoffMs = this.retryBudget.getBackoffMs(to);\n      if (backoffMs > 0) {\n        sleep = new Promise((resolve) => setTimeout(resolve, backoffMs));\n      }\n\n      this.log?.info(\n        `attempting connection to ${to} (${backoffMs}ms backoff)`,\n        {\n          clientId: this.clientId,\n          connectedTo: to,\n        },\n      );\n      this.retryBudget.consumeBudget(to);\n      reconnectPromise = tracer.startActiveSpan('connect', async (span) => {\n        try {\n          span.addEvent('backoff', { backoffMs });\n          await sleep;\n          if (!canProceedWithConnection()) {\n            throw new Error('transport state is no longer open');\n          }\n\n          span.addEvent('connecting');\n          const conn = await this.createNewOutgoingConnection(to);\n          if (!canProceedWithConnection()) {\n            this.log?.info(\n              `transport state is no longer open, closing pre-handshake connection to ${to}`,\n              {\n                ...conn.loggingMetadata,\n                clientId: this.clientId,\n                connectedTo: to,\n              },\n            );\n            conn.close();\n            throw new Error('transport state is no longer open');\n          }\n\n          span.addEvent('sending handshake');\n          const ok = await this.sendHandshake(to, conn);\n          if (!ok) {\n            conn.close();\n            throw new Error('failed to send handshake');\n          }\n\n          return conn;\n        } catch (err) {\n          // rethrow the error so that the promise is rejected\n          // as it was before we wrapped it in a span\n          const errStr = coerceErrorString(err);\n          span.recordException(errStr);\n          span.setStatus({ code: SpanStatusCode.ERROR });\n          throw err;\n        } finally {\n          span.end();\n        }\n      });\n\n      this.inflightConnectionPromises.set(to, reconnectPromise);\n    } else {\n      this.log?.info(\n        `attempting connection to ${to} (reusing previous attempt)`,\n        {\n          clientId: this.clientId,\n          connectedTo: to,\n        },\n      );\n    }\n\n    try {\n      await reconnectPromise;\n    } catch (error: unknown) {\n      this.inflightConnectionPromises.delete(to);\n      const errStr = coerceErrorString(error);\n\n      if (!this.reconnectOnConnectionDrop || !canProceedWithConnection()) {\n        this.log?.warn(`connection to ${to} failed (${errStr})`, {\n          clientId: this.clientId,\n          connectedTo: to,\n        });\n      } else {\n        this.log?.warn(`connection to ${to} failed (${errStr}), retrying`, {\n          clientId: this.clientId,\n          connectedTo: to,\n        });\n        await this.connect(to);\n      }\n    }\n  }\n\n  protected deleteSession({\n    session,\n    closeHandshakingConnection,\n    handshakingConn,\n  }: {\n    session: Session<ConnType>;\n    closeHandshakingConnection: boolean;\n    handshakingConn?: ConnType;\n  }) {\n    this.inflightConnectionPromises.delete(session.to);\n    super.deleteSession({\n      session,\n      closeHandshakingConnection,\n      handshakingConn,\n    });\n  }\n\n  protected async sendHandshake(to: TransportClientId, conn: ConnType) {\n    let metadata: unknown = undefined;\n\n    if (this.handshakeExtensions) {\n      metadata = await this.handshakeExtensions.construct();\n      if (!Value.Check(this.handshakeExtensions.schema, metadata)) {\n        this.log?.error(`constructed handshake metadata did not match schema`, {\n          ...conn.loggingMetadata,\n          clientId: this.clientId,\n          connectedTo: to,\n          validationErrors: [\n            ...Value.Errors(this.handshakeExtensions.schema, metadata),\n          ],\n          tags: ['invariant-violation'],\n        });\n        this.protocolError(\n          ProtocolError.HandshakeFailed,\n          'handshake metadata did not match schema',\n        );\n        conn.telemetry?.span.setStatus({\n          code: SpanStatusCode.ERROR,\n          message: 'handshake meta mismatch',\n        });\n        return false;\n      }\n    }\n\n    // don't pass conn here as we dont want the session to start using the conn\n    // until we have finished the handshake. Still, let the session know that\n    // it is semi-associated with the conn, and it can close it if .close() is called.\n    const { session } = this.getOrCreateSession({ to, handshakingConn: conn });\n    const requestMsg = handshakeRequestMessage({\n      from: this.clientId,\n      to,\n      sessionId: session.id,\n      expectedSessionState: {\n        reconnect: session.advertisedSessionId !== undefined,\n        nextExpectedSeq: session.nextExpectedSeq,\n      },\n      metadata,\n      tracing: getPropagationContext(session.telemetry.ctx),\n    });\n    this.log?.debug(`sending handshake request to ${to}`, {\n      ...conn.loggingMetadata,\n      clientId: this.clientId,\n      connectedTo: to,\n      transportMessage: requestMsg,\n    });\n    conn.send(this.codec.toBuffer(requestMsg));\n    return true;\n  }\n\n  close() {\n    this.retryBudget.close();\n    super.close();\n  }\n}\n","import { TransportClientId } from './message';\n\n/**\n * Options to control the backoff and retry behavior of the client transport's connection behaviour.\n *\n * River implements exponential backoff with jitter to prevent flooding the server\n * when there's an issue with connection establishment.\n *\n * The backoff is calculated via the following:\n *   backOff = min(jitter + {@link baseIntervalMs} * 2 ^ budget_consumed, {@link maxBackoffMs})\n *\n * We use a leaky bucket rate limit with a budget of {@link attemptBudgetCapacity} reconnection attempts.\n * Budget only starts to restore after a successful handshake at a rate of one budget per {@link budgetRestoreIntervalMs}.\n */\nexport interface ConnectionRetryOptions {\n  /**\n   * The base interval to wait before retrying a connection.\n   */\n  baseIntervalMs: number;\n\n  /**\n   * The maximum random jitter to add to the total backoff time.\n   */\n  maxJitterMs: number;\n\n  /**\n   * The maximum amount of time to wait before retrying a connection.\n   * This does not include the jitter.\n   */\n  maxBackoffMs: number;\n\n  /**\n   * The max number of times to attempt a connection before a successful handshake.\n   * This persists across connections but starts restoring budget after a successful handshake.\n   * The restoration interval depends on {@link budgetRestoreIntervalMs}\n   */\n  attemptBudgetCapacity: number;\n\n  /**\n   * After a successful connection attempt, how long to wait before we restore a single budget.\n   */\n  budgetRestoreIntervalMs: number;\n}\n\nexport class LeakyBucketRateLimit {\n  private budgetConsumed: Map<TransportClientId, number>;\n  private intervalHandles: Map<\n    TransportClientId,\n    ReturnType<typeof setInterval>\n  >;\n  private readonly options: ConnectionRetryOptions;\n\n  constructor(options: ConnectionRetryOptions) {\n    this.options = options;\n    this.budgetConsumed = new Map();\n    this.intervalHandles = new Map();\n  }\n\n  getBackoffMs(user: TransportClientId) {\n    if (!this.budgetConsumed.has(user)) return 0;\n\n    const exponent = Math.max(0, this.getBudgetConsumed(user) - 1);\n    const jitter = Math.floor(Math.random() * this.options.maxJitterMs);\n    const backoffMs = Math.min(\n      this.options.baseIntervalMs * 2 ** exponent,\n      this.options.maxBackoffMs,\n    );\n\n    return backoffMs + jitter;\n  }\n\n  get totalBudgetRestoreTime() {\n    return (\n      this.options.budgetRestoreIntervalMs * this.options.attemptBudgetCapacity\n    );\n  }\n\n  consumeBudget(user: TransportClientId) {\n    // If we're consuming again, let's ensure that we're not leaking\n    this.stopLeak(user);\n    this.budgetConsumed.set(user, this.getBudgetConsumed(user) + 1);\n  }\n\n  getBudgetConsumed(user: TransportClientId) {\n    return this.budgetConsumed.get(user) ?? 0;\n  }\n\n  hasBudget(user: TransportClientId) {\n    return this.getBudgetConsumed(user) < this.options.attemptBudgetCapacity;\n  }\n\n  startRestoringBudget(user: TransportClientId) {\n    if (this.intervalHandles.has(user)) {\n      return;\n    }\n\n    const restoreBudgetForUser = () => {\n      const currentBudget = this.budgetConsumed.get(user);\n      if (!currentBudget) {\n        this.stopLeak(user);\n        return;\n      }\n\n      const newBudget = currentBudget - 1;\n      if (newBudget === 0) {\n        this.budgetConsumed.delete(user);\n        return;\n      }\n\n      this.budgetConsumed.set(user, newBudget);\n    };\n\n    const intervalHandle = setInterval(\n      restoreBudgetForUser,\n      this.options.budgetRestoreIntervalMs,\n    );\n\n    this.intervalHandles.set(user, intervalHandle);\n  }\n\n  private stopLeak(user: TransportClientId) {\n    if (!this.intervalHandles.has(user)) {\n      return;\n    }\n\n    clearInterval(this.intervalHandles.get(user));\n    this.intervalHandles.delete(user);\n  }\n\n  close() {\n    for (const user of this.intervalHandles.keys()) {\n      this.stopLeak(user);\n    }\n  }\n}\n"],"mappings":"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","names":["data"]}

package/dist/{chunk-7RUKEUKE.js → chunk-GCCRVSMR.js}

@@ -30,6 +30,21 @@ var ControlMessageHandshakeRequestSchema = Type.Object({
   type: Type.Literal("HANDSHAKE_REQ"),
   protocolVersion: Type.String(),
   sessionId: 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: Type.Optional(
+    Type.Object({
+      /**
+       * reconnect is set to true if the client explicitly wants to reestablish an existing
+       * connection.
+       */
+      reconnect: Type.Boolean(),
+      nextExpectedSeq: Type.Integer()
+    })
+  ),
   metadata: Type.Optional(Type.Unknown())
 });
 var ControlMessageHandshakeResponseSchema = Type.Object({
@@ -54,7 +69,14 @@ var ControlMessagePayloadSchema = Type.Union([
 var OpaqueTransportMessageSchema = TransportMessageSchema(
   Type.Unknown()
 );
-function handshakeRequestMessage(from, to, sessionId, metadata, tracing) {
+function handshakeRequestMessage({
+  from,
+  to,
+  sessionId,
+  expectedSessionState,
+  metadata,
+  tracing
+}) {
   return {
     id: nanoid(),
     from,
@@ -68,11 +90,17 @@ function handshakeRequestMessage(from, to, sessionId, metadata, tracing) {
       type: "HANDSHAKE_REQ",
       protocolVersion: PROTOCOL_VERSION,
       sessionId,
+      expectedSessionState,
       metadata
     }
   };
 }
-function handshakeResponseMessage(from, to, status) {
+var SESSION_STATE_MISMATCH = "session state mismatch";
+function handshakeResponseMessage({
+  from,
+  to,
+  status
+}) {
   return {
     id: nanoid(),
     from,
@@ -104,7 +132,7 @@ function isStreamClose(controlFlag) {
 }
 
 // package.json
-var version = "0.23.12";
+var version = "0.23.14";
 
 // util/stringify.ts
 function coerceErrorString(err) {
@@ -222,6 +250,7 @@ export {
   ControlMessagePayloadSchema,
   OpaqueTransportMessageSchema,
   handshakeRequestMessage,
+  SESSION_STATE_MISMATCH,
   handshakeResponseMessage,
   isAck,
   isStreamOpen,
@@ -235,4 +264,4 @@ export {
   tracing_default,
   coerceErrorString
 };
-//# sourceMappingURL=chunk-7RUKEUKE.js.map
+//# sourceMappingURL=chunk-GCCRVSMR.js.map