@finalai/websockets 0.1.0

package/dist/modules/index.mjs

@@ -0,0 +1,1432 @@
+import {
+  compareWebsocketGatewayCursors,
+  websocketGatewayDataSchema,
+  websocketGatewayProtocolVersion,
+  websocketGatewayServerFrameSchema
+} from "@finalai/websocket-gateway-protocol";
+import { WebSocket as PartySocketWebSocket } from "partysocket";
+const openReadyState = 1;
+const defaultAckTimeoutMs = 3e4;
+const defaultMaxQueuedFrames = 256;
+const randomId = () => typeof globalThis.crypto?.randomUUID === "function" ? globalThis.crypto.randomUUID() : `${Date.now().toString(36)}-${Math.random().toString(36).slice(2)}`;
+const bytesToBase64 = (bytes) => {
+  let binary = "";
+  const chunkSize = 32768;
+  for (let offset = 0; offset < bytes.length; offset += chunkSize) {
+    const chunk = bytes.subarray(offset, offset + chunkSize);
+    binary += String.fromCharCode(...chunk);
+  }
+  return btoa(binary);
+};
+const base64ToArrayBuffer = (data) => {
+  const binary = atob(data);
+  const bytes = new Uint8Array(binary.length);
+  for (let index = 0; index < binary.length; index += 1) {
+    bytes[index] = binary.charCodeAt(index);
+  }
+  return bytes.buffer;
+};
+const encodeProxyPayload = (data) => {
+  if (typeof data === "string") return data;
+  const bytes = data instanceof ArrayBuffer ? new Uint8Array(data) : new Uint8Array(data.buffer, data.byteOffset, data.byteLength);
+  return { encoding: "base64", data: bytesToBase64(bytes) };
+};
+const decodeProxyPayload = (data) => typeof data === "string" ? data : base64ToArrayBuffer(data.data);
+const resolveAuth = async (auth) => typeof auth === "function" ? auth() : auth;
+const compareCursors = compareWebsocketGatewayCursors;
+const utf8ByteLength = (value) => {
+  let bytes = 0;
+  for (let index = 0; index < value.length; index += 1) {
+    const codePoint = value.charCodeAt(index);
+    if (codePoint < 128) {
+      bytes += 1;
+    } else if (codePoint < 2048) {
+      bytes += 2;
+    } else if (codePoint >= 55296 && codePoint <= 56319 && index + 1 < value.length) {
+      const trailing = value.charCodeAt(index + 1);
+      if (trailing >= 56320 && trailing <= 57343) {
+        bytes += 4;
+        index += 1;
+      } else {
+        bytes += 3;
+      }
+    } else {
+      bytes += 3;
+    }
+  }
+  return bytes;
+};
+const maxBufferedChannelFrames = 1e4;
+class WebsocketsConnection {
+  constructor(options) {
+    this.options = options;
+  }
+  options;
+  socket = null;
+  handlers = /* @__PURE__ */ new Set();
+  replayRegistrations = /* @__PURE__ */ new Map();
+  heartbeatTimer = null;
+  channelSubscriptions = /* @__PURE__ */ new Map();
+  realtimeSubscriptions = /* @__PURE__ */ new Map();
+  realtimeSubscribeQueue = /* @__PURE__ */ new Set();
+  realtimeSubscribeQueued = false;
+  realtimeUnsubscribeQueue = /* @__PURE__ */ new Set();
+  realtimeUnsubscribeQueued = false;
+  socketAuthToken = null;
+  authenticated = false;
+  queuedFrames = [];
+  queuedBytes = 0;
+  manuallyClosed = false;
+  hasAuthenticated = false;
+  diagnostics = {
+    bufferedBytes: 0,
+    bufferedBytesHighWater: 0,
+    bufferedFrames: 0,
+    bufferedFramesHighWater: 0,
+    bufferLimitFlushes: 0,
+    channelMessageBytes: 0,
+    channelMessageFrames: 0,
+    channelStreams: [],
+    channelSubscriptions: 0,
+    gapFillErrors: 0,
+    gapFillRequests: 0,
+    gapFillResponses: 0,
+    gapFillSendErrors: 0,
+    gapFillTimeouts: 0,
+    frameHandlers: 0,
+    frameHandlersHighWater: 0,
+    lastCloseCode: null,
+    lastCloseReason: null,
+    pendingGapFills: 0,
+    pendingSubscribeAcks: 0,
+    queuedBytes: 0,
+    queuedFrames: 0,
+    realtimeMessageBytes: 0,
+    realtimeMessageFrames: 0,
+    realtimeSubscriptions: 0,
+    receivedBytes: 0,
+    receivedFrames: 0,
+    reconnects: 0,
+    rpcCallBytes: 0,
+    rpcCallFrames: 0,
+    sentBytes: 0,
+    sentFrames: 0,
+    socketBufferedBytes: 0,
+    socketBufferedBytesHighWater: 0,
+    socketCloses: 0,
+    socketOpens: 0,
+    subscribeAcks: 0,
+    subscribeErrors: 0,
+    subscribeRequests: 0,
+    subscribeSuperseded: 0,
+    subscribeTimeouts: 0
+  };
+  async connect() {
+    this.manuallyClosed = false;
+    await this.openSocket();
+  }
+  async openSocket() {
+    const WebSocketCtor = this.options.WebSocketCtor ?? globalThis.WebSocket;
+    if (WebSocketCtor == null) {
+      throw new Error("WebSocket is not available in this runtime");
+    }
+    const socket = new PartySocketWebSocket(() => this.resolveSocketUrlAndAuth(), void 0, {
+      WebSocket: WebSocketCtor,
+      minReconnectionDelay: 500,
+      maxReconnectionDelay: 15e3,
+      reconnectionDelayGrowFactor: 2,
+      maxRetries: this.options.reconnect === false ? 0 : Infinity
+    });
+    this.socket = socket;
+    socket.addEventListener("message", (event) => {
+      const rawText = String(event.data);
+      let raw;
+      try {
+        raw = JSON.parse(rawText);
+      } catch {
+        return;
+      }
+      const parsed = websocketGatewayServerFrameSchema.safeParse(raw);
+      if (!parsed.success) return;
+      const frameByteLength = utf8ByteLength(rawText);
+      this.diagnostics.receivedFrames += 1;
+      this.diagnostics.receivedBytes += frameByteLength;
+      if (parsed.data.type === "channel.message") {
+        this.diagnostics.channelMessageFrames += 1;
+        this.diagnostics.channelMessageBytes += frameByteLength;
+      }
+      if (parsed.data.type === "realtime.message") {
+        this.diagnostics.realtimeMessageFrames += 1;
+        this.diagnostics.realtimeMessageBytes += frameByteLength;
+      }
+      for (const frame of this.routeIncomingFrame(parsed.data, frameByteLength)) {
+        for (const handler of this.handlers) handler(frame);
+      }
+    });
+    socket.addEventListener("close", (event) => {
+      this.clearHeartbeat();
+      this.authenticated = false;
+      this.diagnostics.socketCloses += 1;
+      this.diagnostics.lastCloseCode = event.code;
+      this.diagnostics.lastCloseReason = event.reason;
+    });
+    await new Promise((resolve, reject) => {
+      let settled = false;
+      socket.addEventListener("open", () => {
+        this.diagnostics.socketOpens += 1;
+        this.authenticated = false;
+        void this.authenticateInitialSocket().then(() => {
+          this.authenticated = true;
+          this.startHeartbeat();
+          this.resubscribeChannels();
+          this.resubscribeRealtimeTopics();
+          this.replayRegistrations.forEach((replay) => replay());
+          this.flushQueuedFrames();
+          if (this.hasAuthenticated) {
+            this.diagnostics.reconnects += 1;
+            this.options.onReconnect?.();
+          }
+          this.hasAuthenticated = true;
+          if (!settled) {
+            settled = true;
+            resolve();
+          }
+        }).catch((cause) => {
+          this.clearHeartbeat();
+          this.authenticated = false;
+          if (!settled && this.socket === socket) {
+            this.socket = null;
+          }
+          if (!settled) {
+            socket.close(4001, "websockets auth failed");
+            settled = true;
+            reject(cause instanceof Error ? cause : new Error("Websockets auth failed"));
+          } else {
+            socket.reconnect(4001, "websockets auth failed");
+          }
+        });
+      });
+      socket.addEventListener("error", () => {
+        if (!settled) {
+          settled = true;
+          reject(new Error("Websockets open failed"));
+        }
+      });
+    });
+  }
+  async resolveSocketUrlAndAuth() {
+    this.socketAuthToken = await resolveAuth(this.options.auth);
+    const url = new URL(this.options.url);
+    url.searchParams.set("protocolVersion", String(websocketGatewayProtocolVersion));
+    return url.toString();
+  }
+  authenticateInitialSocket() {
+    const token = this.socketAuthToken;
+    this.socketAuthToken = null;
+    if (token == null) {
+      return Promise.reject(new Error("Websockets auth token was not resolved"));
+    }
+    return this.auth.authorize({ token });
+  }
+  startHeartbeat() {
+    this.clearHeartbeat();
+    const intervalMs = this.options.heartbeatIntervalMs;
+    if (intervalMs == null || intervalMs <= 0) return;
+    this.heartbeatTimer = setInterval(() => {
+      if (this.socket == null || this.socket.readyState !== openReadyState) return;
+      this.send({ type: "ping", nonce: randomId() });
+    }, intervalMs);
+  }
+  clearHeartbeat() {
+    if (this.heartbeatTimer == null) return;
+    clearInterval(this.heartbeatTimer);
+    this.heartbeatTimer = null;
+  }
+  // Per-channel frame routing: dedupes replay/live overlap by cursor, buffers
+  // live frames until the subscribe ack so replay dispatches first, and
+  // gap-fills skipped messages when a frame's prevCursor doesn't chain.
+  routeIncomingFrame(frame, frameByteLength) {
+    if (frame.type === "realtime.subscribed") {
+      const state = this.realtimeSubscriptions.get(frame.topic);
+      if (state != null) {
+        state.pendingSubscribe = false;
+        if (frame.resyncRequired) state.lastCursor = void 0;
+        if (frame.cursor != null) state.lastCursor = frame.cursor;
+        if (frame.resyncRequired) state.onResyncRequired?.();
+        state.onSubscribed?.();
+        const buffered = this.settleSubscriptionBuffer(state, []);
+        queueMicrotask(() => {
+          if (this.realtimeSubscriptions.get(frame.topic) !== state) return;
+          this.dispatchRealtimeDeliveries(state, buffered);
+        });
+      }
+      return [frame];
+    }
+    if (frame.type === "realtime.error") {
+      this.realtimeSubscriptions.get(frame.topic)?.onError?.({
+        code: frame.code,
+        message: frame.message,
+        retryable: frame.retryable
+      });
+      return [frame];
+    }
+    if (frame.type === "realtime.history") {
+      const state = this.realtimeSubscriptions.get(frame.topic);
+      if (state != null && state.gapFillRequestId === frame.requestId) {
+        this.diagnostics.gapFillResponses += 1;
+        this.clearSubscriptionGapFill(state);
+        this.dispatchRealtimeDeliveries(
+          state,
+          this.settleSubscriptionBuffer(
+            state,
+            frame.messages.map((message) => ({ message }))
+          )
+        );
+      }
+      return [frame];
+    }
+    if (frame.type === "realtime.presence.event") return [frame];
+    if (frame.type === "realtime.message") {
+      const state = this.realtimeSubscriptions.get(frame.topic);
+      if (state == null) return [frame];
+      if (state.pendingSubscribe || state.gapFillRequestId != null) {
+        this.bufferSubscriptionDelivery(state, frame, frameByteLength);
+        if (state.buffered.length >= maxBufferedChannelFrames) {
+          this.diagnostics.bufferLimitFlushes += 1;
+          state.pendingSubscribe = false;
+          state.onResyncRequired?.();
+          this.dispatchRealtimeDeliveries(state, this.settleSubscriptionBuffer(state, []));
+        }
+        return [];
+      }
+      const cursor = frame.message.cursor;
+      if (frame.prevCursor != null && state.lastCursor != null && cursor != null && frame.prevCursor !== state.lastCursor && compareCursors(frame.prevCursor, state.lastCursor) > 0) {
+        this.beginRealtimeGapFill(state, frame, frameByteLength);
+        return [];
+      }
+      const dispatchable = this.dispatchableSubscriptionDeliveries(state, [frame]);
+      this.dispatchRealtimeDeliveries(state, dispatchable);
+      return dispatchable.length === 0 ? [] : [frame];
+    }
+    if (frame.type === "channel.message") {
+      const state = this.channelSubscriptions.get(frame.message.channel);
+      if (state == null) return [frame];
+      state.receivedFrames += 1;
+      state.receivedBytes += frameByteLength;
+      if (state.pendingAckId != null || state.gapFillRequestId != null) {
+        this.bufferSubscriptionDelivery(state, frame, frameByteLength);
+        if (state.buffered.length >= maxBufferedChannelFrames) {
+          this.diagnostics.bufferLimitFlushes += 1;
+          return this.channelFrames(this.settleSubscriptionBuffer(state, []));
+        }
+        return [];
+      }
+      if (frame.prevCursor != null && state.lastCursor != null && frame.message.cursor != null && frame.prevCursor !== state.lastCursor && compareCursors(frame.prevCursor, state.lastCursor) > 0) {
+        this.beginChannelGapFill(frame.message.channel, state, frame, frameByteLength);
+        return [];
+      }
+      return this.channelFrames(this.dispatchableSubscriptionDeliveries(state, [frame]));
+    }
+    if (frame.type === "ack" || frame.type === "error") {
+      const state = [...this.channelSubscriptions.values()].find(
+        (candidate) => candidate.pendingAckId != null && candidate.pendingAckId === frame.requestId
+      );
+      if (state != null) {
+        if (frame.type === "error") {
+          this.diagnostics.subscribeErrors += 1;
+        } else {
+          this.diagnostics.subscribeAcks += 1;
+        }
+        state.pendingAckId = null;
+        if (state.pendingAckTimer != null) {
+          clearTimeout(state.pendingAckTimer);
+          state.pendingAckTimer = null;
+        }
+        const settled = this.channelFrames(this.settleSubscriptionBuffer(state, []));
+        if (frame.type === "ack" && frame.cursor != null && state.lastCursor == null) {
+          state.lastCursor = frame.cursor;
+        }
+        if (frame.type === "error") {
+          state.onError?.(frame);
+        } else {
+          state.onSubscribed?.();
+        }
+        return [...settled, frame];
+      }
+      if (frame.type === "error") {
+        const realtimeGapFillState = [...this.realtimeSubscriptions.values()].find(
+          (candidate) => candidate.gapFillRequestId === frame.requestId
+        );
+        if (realtimeGapFillState != null) {
+          this.diagnostics.gapFillErrors += 1;
+          this.clearSubscriptionGapFill(realtimeGapFillState);
+          this.dispatchRealtimeDeliveries(
+            realtimeGapFillState,
+            this.settleSubscriptionBuffer(realtimeGapFillState, [])
+          );
+          realtimeGapFillState.onError?.({
+            code: frame.code,
+            message: frame.message,
+            retryable: true
+          });
+          return [frame];
+        }
+        const gapFillState = [...this.channelSubscriptions.values()].find(
+          (candidate) => candidate.gapFillRequestId != null && candidate.gapFillRequestId === frame.requestId
+        );
+        if (gapFillState != null) {
+          this.diagnostics.gapFillErrors += 1;
+          this.clearSubscriptionGapFill(gapFillState);
+          const settled = this.channelFrames(this.settleSubscriptionBuffer(gapFillState, []));
+          gapFillState.onError?.(frame);
+          return [...settled, frame];
+        }
+      }
+      return [frame];
+    }
+    if (frame.type === "channel.history") {
+      const state = [...this.channelSubscriptions.values()].find(
+        (candidate) => candidate.gapFillRequestId != null && candidate.gapFillRequestId === frame.requestId
+      );
+      if (state == null) return [frame];
+      this.diagnostics.gapFillResponses += 1;
+      this.clearSubscriptionGapFill(state);
+      return this.channelFrames(
+        this.settleSubscriptionBuffer(
+          state,
+          frame.messages.map((message) => ({ message }))
+        )
+      );
+    }
+    return [frame];
+  }
+  dispatchableSubscriptionDeliveries(state, deliveries) {
+    const dispatchable = [];
+    for (const delivery of deliveries) {
+      const cursor = delivery.message.cursor;
+      if (cursor != null) {
+        if (state.lastCursor != null && compareCursors(cursor, state.lastCursor) <= 0) continue;
+        state.lastCursor = cursor;
+      }
+      dispatchable.push(delivery);
+    }
+    return dispatchable;
+  }
+  settleSubscriptionBuffer(state, fetched) {
+    const buffered = state.buffered;
+    state.buffered = [];
+    state.bufferedBytes = 0;
+    const retained = [
+      ...fetched.filter((delivery) => delivery.message.cursor != null),
+      ...buffered.filter((delivery) => delivery.message.cursor != null)
+    ].sort(
+      (left, right) => compareCursors(left.message.cursor ?? "0-0", right.message.cursor ?? "0-0")
+    );
+    const ephemeral = buffered.filter((delivery) => delivery.message.cursor == null);
+    return this.dispatchableSubscriptionDeliveries(state, [...retained, ...ephemeral]);
+  }
+  bufferSubscriptionDelivery(state, delivery, byteLength) {
+    state.buffered.push(delivery);
+    state.bufferedBytes += byteLength;
+    state.bufferedFramesHighWater = Math.max(state.bufferedFramesHighWater, state.buffered.length);
+    state.bufferedBytesHighWater = Math.max(state.bufferedBytesHighWater, state.bufferedBytes);
+    const diagnostics = this.currentBufferDiagnostics();
+    this.diagnostics.bufferedFramesHighWater = Math.max(
+      this.diagnostics.bufferedFramesHighWater,
+      diagnostics.frames
+    );
+    this.diagnostics.bufferedBytesHighWater = Math.max(
+      this.diagnostics.bufferedBytesHighWater,
+      diagnostics.bytes
+    );
+  }
+  currentBufferDiagnostics() {
+    let bytes = 0;
+    let frames = 0;
+    for (const state of this.channelSubscriptions.values()) {
+      bytes += state.bufferedBytes;
+      frames += state.buffered.length;
+    }
+    for (const state of this.realtimeSubscriptions.values()) {
+      bytes += state.bufferedBytes;
+      frames += state.buffered.length;
+    }
+    return { bytes, frames };
+  }
+  clearSubscriptionGapFill(state) {
+    state.gapFillRequestId = null;
+    if (state.gapFillTimer != null) clearTimeout(state.gapFillTimer);
+    state.gapFillTimer = null;
+  }
+  beginSubscriptionGapFill(state, delivery, deliveryByteLength, sendHistory, onUnavailable) {
+    const requestId = randomId();
+    this.diagnostics.gapFillRequests += 1;
+    state.gapFillRequestId = requestId;
+    this.bufferSubscriptionDelivery(state, delivery, deliveryByteLength);
+    const recoverWithoutHistory = () => {
+      if (state.gapFillRequestId !== requestId) return;
+      this.clearSubscriptionGapFill(state);
+      onUnavailable(this.settleSubscriptionBuffer(state, []));
+    };
+    state.gapFillTimer = setTimeout(() => {
+      this.diagnostics.gapFillTimeouts += 1;
+      recoverWithoutHistory();
+    }, this.options.ackTimeoutMs ?? defaultAckTimeoutMs);
+    try {
+      sendHistory(requestId);
+    } catch {
+      this.diagnostics.gapFillSendErrors += 1;
+      recoverWithoutHistory();
+    }
+  }
+  channelFrames(deliveries) {
+    return deliveries.map((delivery) => ({ type: "channel.message", ...delivery }));
+  }
+  dispatchRealtimeDeliveries(state, deliveries) {
+    for (const delivery of deliveries) state.handler(delivery.message);
+  }
+  beginRealtimeGapFill(state, frame, frameByteLength) {
+    this.beginSubscriptionGapFill(
+      state,
+      frame,
+      frameByteLength,
+      (requestId) => {
+        this.send({
+          type: "realtime.history",
+          id: requestId,
+          topic: state.topic,
+          afterCursor: state.lastCursor,
+          limit: 1e3
+        });
+      },
+      (deliveries) => {
+        this.dispatchRealtimeDeliveries(state, deliveries);
+        state.onResyncRequired?.();
+      }
+    );
+  }
+  beginChannelGapFill(channel, state, frame, frameByteLength) {
+    this.beginSubscriptionGapFill(
+      state,
+      frame,
+      frameByteLength,
+      (requestId) => {
+        this.send({
+          type: "channel.history",
+          id: requestId,
+          channel,
+          afterCursor: state.lastCursor,
+          limit: 1e3
+        });
+      },
+      (deliveries) => {
+        for (const flushed of this.channelFrames(deliveries)) {
+          for (const handler of this.handlers) handler(flushed);
+        }
+      }
+    );
+  }
+  resubscribeChannels() {
+    for (const [channel, subscription] of this.channelSubscriptions) {
+      this.sendSubscribeFrame(channel, subscription);
+    }
+  }
+  resubscribeRealtimeTopics() {
+    this.realtimeSubscribeQueue.clear();
+    this.realtimeSubscribeQueued = false;
+    this.realtimeUnsubscribeQueue.clear();
+    this.realtimeUnsubscribeQueued = false;
+    this.queuedFrames = this.queuedFrames.filter(
+      (queued) => queued.frame.type !== "realtime.subscribe" && queued.frame.type !== "realtime.unsubscribe"
+    );
+    this.queuedBytes = this.queuedFrames.reduce((total, queued) => total + queued.sizeBytes, 0);
+    this.sendRealtimeSubscribeBatches([...this.realtimeSubscriptions.values()]);
+  }
+  queueRealtimeSubscribe(topic) {
+    this.realtimeSubscribeQueue.add(topic);
+    if (this.realtimeSubscribeQueued) return;
+    this.realtimeSubscribeQueued = true;
+    queueMicrotask(() => {
+      this.realtimeSubscribeQueued = false;
+      const states = [...this.realtimeSubscribeQueue].flatMap((queuedTopic) => {
+        const state = this.realtimeSubscriptions.get(queuedTopic);
+        return state == null ? [] : [state];
+      });
+      this.realtimeSubscribeQueue.clear();
+      if (states.length > 0 && !this.manuallyClosed) this.sendRealtimeSubscribeBatches(states);
+    });
+  }
+  sendRealtimeSubscribeBatches(states) {
+    for (let offset = 0; offset < states.length; offset += 64) {
+      const batch = states.slice(offset, offset + 64);
+      for (const state of batch) state.pendingSubscribe = true;
+      this.send({
+        type: "realtime.subscribe",
+        id: randomId(),
+        subscriptions: batch.map((state) => ({
+          topic: state.topic,
+          afterCursor: state.lastCursor ?? state.afterCursor ?? "$"
+        }))
+      });
+    }
+  }
+  queueRealtimeUnsubscribe(topic) {
+    this.realtimeUnsubscribeQueue.add(topic);
+    if (this.realtimeUnsubscribeQueued) return;
+    this.realtimeUnsubscribeQueued = true;
+    queueMicrotask(() => {
+      this.realtimeUnsubscribeQueued = false;
+      const topics = [...this.realtimeUnsubscribeQueue];
+      this.realtimeUnsubscribeQueue.clear();
+      if (this.manuallyClosed) return;
+      for (let offset = 0; offset < topics.length; offset += 64) {
+        this.send({ type: "realtime.unsubscribe", topics: topics.slice(offset, offset + 64) });
+      }
+    });
+  }
+  sendSubscribeFrame(channel, subscription) {
+    const requestId = randomId();
+    this.diagnostics.subscribeRequests += 1;
+    if (subscription.pendingAckId != null) this.diagnostics.subscribeSuperseded += 1;
+    subscription.pendingAckId = requestId;
+    if (subscription.pendingAckTimer != null) clearTimeout(subscription.pendingAckTimer);
+    subscription.pendingAckTimer = setTimeout(() => {
+      if (subscription.pendingAckId !== requestId) return;
+      this.diagnostics.subscribeTimeouts += 1;
+      subscription.pendingAckId = null;
+      subscription.pendingAckTimer = null;
+      for (const flushed of this.channelFrames(this.settleSubscriptionBuffer(subscription, []))) {
+        for (const handler of this.handlers) handler(flushed);
+      }
+    }, this.options.ackTimeoutMs ?? defaultAckTimeoutMs);
+    this.send({
+      type: "channel.subscribe",
+      id: requestId,
+      channel,
+      afterCursor: subscription.lastCursor ?? subscription.afterCursor ?? "$"
+    });
+  }
+  auth = {
+    authorize: (args) => {
+      const requestId = randomId();
+      const result = this.waitForAck(requestId, "auth");
+      this.sendAuthFrame({ id: requestId, type: "auth", token: args.token });
+      return result;
+    }
+  };
+  onFrame(handler) {
+    this.handlers.add(handler);
+    this.diagnostics.frameHandlersHighWater = Math.max(
+      this.diagnostics.frameHandlersHighWater,
+      this.handlers.size
+    );
+    return () => this.handlers.delete(handler);
+  }
+  registerReplay(key, replay) {
+    this.replayRegistrations.set(key, replay);
+    return () => this.replayRegistrations.delete(key);
+  }
+  waitForAck(requestId, operation) {
+    return new Promise((resolve, reject) => {
+      const timeout = setTimeout(() => {
+        unsubscribe();
+        reject(new Error(`Websockets ${operation} acknowledgement timed out`));
+      }, this.options.ackTimeoutMs ?? defaultAckTimeoutMs);
+      const unsubscribe = this.onFrame((frame) => {
+        if (frame.type === "ack" && frame.requestId === requestId && frame.operation === operation) {
+          unsubscribe();
+          clearTimeout(timeout);
+          resolve();
+        }
+        if (frame.type === "error" && frame.requestId === requestId) {
+          unsubscribe();
+          clearTimeout(timeout);
+          reject(new Error(frame.message));
+        }
+      });
+    });
+  }
+  channel(name) {
+    return new WebsocketsChannel(this, name);
+  }
+  realtime(topic) {
+    return new WebsocketsRealtimeTopic(this, topic);
+  }
+  registerRealtimeSubscription(args) {
+    this.realtimeUnsubscribeQueue.delete(args.topic);
+    const state = {
+      topic: args.topic,
+      pendingSubscribe: true,
+      afterCursor: args.options?.afterCursor,
+      gapFillRequestId: null,
+      gapFillTimer: null,
+      buffered: [],
+      bufferedBytes: 0,
+      bufferedBytesHighWater: 0,
+      bufferedFramesHighWater: 0,
+      handler: args.handler,
+      onError: args.options?.onError ?? null,
+      onResyncRequired: args.options?.onResyncRequired ?? null,
+      onSubscribed: args.options?.onSubscribed ?? null
+    };
+    this.realtimeSubscriptions.set(args.topic, state);
+    this.queueRealtimeSubscribe(args.topic);
+    return () => {
+      if (this.realtimeSubscriptions.get(args.topic) !== state) return;
+      this.clearSubscriptionGapFill(state);
+      this.realtimeSubscriptions.delete(args.topic);
+      this.realtimeSubscribeQueue.delete(args.topic);
+      this.queueRealtimeUnsubscribe(args.topic);
+    };
+  }
+  registerChannelSubscription(args) {
+    const subscription = {
+      afterCursor: args.afterCursor,
+      pendingAckId: null,
+      pendingAckTimer: null,
+      gapFillRequestId: null,
+      gapFillTimer: null,
+      buffered: [],
+      bufferedBytes: 0,
+      bufferedBytesHighWater: 0,
+      bufferedFramesHighWater: 0,
+      onError: args.onError ?? null,
+      onSubscribed: args.onSubscribed ?? null,
+      receivedBytes: 0,
+      receivedFrames: 0
+    };
+    this.channelSubscriptions.set(args.channel, subscription);
+    this.sendSubscribeFrame(args.channel, subscription);
+    return () => {
+      if (subscription.pendingAckTimer != null) clearTimeout(subscription.pendingAckTimer);
+      this.clearSubscriptionGapFill(subscription);
+      this.channelSubscriptions.delete(args.channel);
+      this.send({ type: "channel.unsubscribe", channel: args.channel });
+    };
+  }
+  rpc(name) {
+    return new WebsocketsRpc(this, name);
+  }
+  bridge(name) {
+    return new WebsocketsBridge(this, name);
+  }
+  proxy(upstream) {
+    return new WebsocketsProxy(this, upstream);
+  }
+  send(frame) {
+    if (this.socket == null) {
+      throw new Error("Websockets connection is not open");
+    }
+    if (this.manuallyClosed) {
+      throw new Error("Websockets connection is not open");
+    }
+    const encoded = JSON.stringify(frame);
+    const sizeBytes = utf8ByteLength(encoded);
+    if (!this.authenticated && frame.type !== "auth") {
+      if (this.socket.readyState !== openReadyState && this.options.reconnect === false) {
+        throw new Error("Websockets connection is not open");
+      }
+      if (this.queuedFrames.length >= (this.options.maxQueuedFrames ?? defaultMaxQueuedFrames)) {
+        throw new Error("Websockets queued frame limit exceeded");
+      }
+      this.queuedFrames.push({ encoded, frame, sizeBytes });
+      this.queuedBytes += sizeBytes;
+      return;
+    }
+    if (this.socket.readyState !== openReadyState) {
+      throw new Error("Websockets connection is not open");
+    }
+    this.sendEncodedFrame(frame, encoded, sizeBytes);
+  }
+  getDiagnostics() {
+    const buffers = this.currentBufferDiagnostics();
+    let pendingGapFills = 0;
+    let pendingSubscribeAcks = 0;
+    for (const state of this.channelSubscriptions.values()) {
+      if (state.gapFillRequestId != null) pendingGapFills += 1;
+      if (state.pendingAckId != null) pendingSubscribeAcks += 1;
+    }
+    for (const state of this.realtimeSubscriptions.values()) {
+      if (state.gapFillRequestId != null) pendingGapFills += 1;
+    }
+    return {
+      ...this.diagnostics,
+      bufferedBytes: buffers.bytes,
+      bufferedFrames: buffers.frames,
+      channelStreams: [...this.channelSubscriptions.entries()].map(([channel, state]) => ({
+        bufferedBytes: state.bufferedBytes,
+        bufferedBytesHighWater: state.bufferedBytesHighWater,
+        bufferedFrames: state.buffered.length,
+        bufferedFramesHighWater: state.bufferedFramesHighWater,
+        channel,
+        pendingGapFill: state.gapFillRequestId != null,
+        pendingSubscribeAck: state.pendingAckId != null,
+        receivedBytes: state.receivedBytes,
+        receivedFrames: state.receivedFrames
+      })),
+      channelSubscriptions: this.channelSubscriptions.size,
+      frameHandlers: this.handlers.size,
+      pendingGapFills,
+      pendingSubscribeAcks,
+      queuedBytes: this.queuedBytes,
+      queuedFrames: this.queuedFrames.length,
+      realtimeSubscriptions: this.realtimeSubscriptions.size,
+      socketBufferedBytes: this.socket?.bufferedAmount ?? 0
+    };
+  }
+  sendAuthFrame(frame) {
+    if (this.socket == null || this.socket.readyState !== openReadyState) {
+      throw new Error("Websockets connection is not open");
+    }
+    const encoded = JSON.stringify(frame);
+    this.sendEncodedFrame(frame, encoded, utf8ByteLength(encoded));
+  }
+  sendEncodedFrame(frame, encoded, sizeBytes) {
+    if (this.socket == null || this.socket.readyState !== openReadyState) {
+      throw new Error("Websockets connection is not open");
+    }
+    this.socket.send(encoded);
+    this.diagnostics.sentFrames += 1;
+    this.diagnostics.sentBytes += sizeBytes;
+    if (frame.type === "rpc.call") {
+      this.diagnostics.rpcCallFrames += 1;
+      this.diagnostics.rpcCallBytes += sizeBytes;
+    }
+    const socketBufferedBytes = this.socket.bufferedAmount;
+    this.diagnostics.socketBufferedBytesHighWater = Math.max(
+      this.diagnostics.socketBufferedBytesHighWater,
+      socketBufferedBytes
+    );
+  }
+  flushQueuedFrames() {
+    if (this.socket == null || this.socket.readyState !== openReadyState || !this.authenticated) {
+      return;
+    }
+    const frames = this.queuedFrames;
+    this.queuedFrames = [];
+    this.queuedBytes = 0;
+    for (const queued of frames) {
+      this.sendEncodedFrame(queued.frame, queued.encoded, queued.sizeBytes);
+    }
+  }
+  ping(nonce = randomId()) {
+    this.send({ type: "ping", nonce });
+  }
+  close(code, reason) {
+    this.manuallyClosed = true;
+    this.queuedFrames = [];
+    this.queuedBytes = 0;
+    this.realtimeSubscribeQueue.clear();
+    this.realtimeSubscribeQueued = false;
+    this.realtimeUnsubscribeQueue.clear();
+    this.realtimeUnsubscribeQueued = false;
+    this.clearHeartbeat();
+    this.socket?.close(code, reason);
+  }
+}
+class WebsocketsChannel {
+  constructor(connection, name) {
+    this.connection = connection;
+    this.name = name;
+  }
+  connection;
+  name;
+  subscribe(handler, options) {
+    const unsubscribe = this.connection.onFrame((frame) => {
+      if (frame.type === "channel.message" && frame.message.channel === this.name) {
+        handler(frame.message);
+      }
+    });
+    const unregisterSubscription = this.connection.registerChannelSubscription({
+      channel: this.name,
+      afterCursor: typeof options === "string" ? options : options?.afterCursor,
+      onError: typeof options === "string" ? void 0 : options?.onError,
+      onSubscribed: typeof options === "string" ? void 0 : options?.onSubscribed
+    });
+    return () => {
+      unsubscribe();
+      unregisterSubscription();
+    };
+  }
+  publish(data, options = {}) {
+    const publishOptions = typeof options === "string" ? { name: options } : options;
+    this.connection.send({
+      type: "channel.publish",
+      channel: this.name,
+      name: publishOptions.name ?? "message",
+      data,
+      idempotencyKey: publishOptions.idempotencyKey,
+      retain: publishOptions.retain
+    });
+  }
+  history(args = {}) {
+    const requestId = randomId();
+    this.connection.send({
+      type: "channel.history",
+      id: requestId,
+      channel: this.name,
+      afterCursor: args.afterCursor,
+      limit: args.limit ?? 100
+    });
+    return new Promise((resolve, reject) => {
+      const unsubscribe = this.connection.onFrame((frame) => {
+        if (frame.type === "channel.history" && frame.requestId === requestId) {
+          unsubscribe();
+          resolve(frame.messages);
+        }
+        if (frame.type === "error" && frame.requestId === requestId) {
+          unsubscribe();
+          reject(new Error(frame.message));
+        }
+      });
+    });
+  }
+  presence() {
+    return new WebsocketsPresence(this.connection, this.name);
+  }
+}
+class WebsocketsRealtimeTopic {
+  constructor(connection, topic) {
+    this.connection = connection;
+    this.topic = topic;
+  }
+  connection;
+  topic;
+  subscribe(handler, options) {
+    return this.connection.registerRealtimeSubscription({ topic: this.topic, handler, options });
+  }
+  presence() {
+    let data;
+    let unregisterReplay = null;
+    return {
+      enter: (nextData) => {
+        data = nextData;
+        unregisterReplay?.();
+        unregisterReplay = this.connection.registerReplay(`realtime-presence:${this.topic}`, () => {
+          this.connection.send({
+            type: "realtime.presence.enter",
+            topic: this.topic,
+            data
+          });
+        });
+        this.connection.send({
+          type: "realtime.presence.enter",
+          topic: this.topic,
+          data: nextData
+        });
+      },
+      update: (nextData) => {
+        data = nextData;
+        this.connection.send({
+          type: "realtime.presence.update",
+          topic: this.topic,
+          data: nextData
+        });
+      },
+      leave: () => {
+        unregisterReplay?.();
+        unregisterReplay = null;
+        this.connection.send({ type: "realtime.presence.leave", topic: this.topic });
+      },
+      get: (options = {}) => {
+        const requestId = randomId();
+        return new Promise((resolve, reject) => {
+          let unsubscribe = () => void 0;
+          const cleanup = () => {
+            unsubscribe();
+            options.signal?.removeEventListener("abort", handleAbort);
+          };
+          const handleAbort = () => {
+            cleanup();
+            reject(options.signal?.reason ?? new Error("Presence snapshot request aborted"));
+          };
+          if (options.signal?.aborted === true) {
+            handleAbort();
+            return;
+          }
+          unsubscribe = this.connection.onFrame((frame) => {
+            if (frame.type === "realtime.presence.snapshot" && frame.requestId === requestId && frame.topic === this.topic) {
+              cleanup();
+              resolve(frame.members);
+            }
+            if (frame.type === "realtime.error" && frame.requestId === requestId && frame.topic === this.topic) {
+              cleanup();
+              reject(new Error(frame.message));
+            }
+          });
+          options.signal?.addEventListener("abort", handleAbort, { once: true });
+          try {
+            this.connection.send({
+              id: requestId,
+              type: "realtime.presence.get",
+              topic: this.topic
+            });
+          } catch (error) {
+            cleanup();
+            reject(error);
+          }
+        });
+      },
+      subscribe: (handler) => this.connection.onFrame((frame) => {
+        if (frame.type !== "realtime.presence.event" || frame.topic !== this.topic) return;
+        handler(frame);
+      })
+    };
+  }
+}
+class WebsocketsPresence {
+  constructor(connection, channel) {
+    this.connection = connection;
+    this.channel = channel;
+  }
+  connection;
+  channel;
+  unregisterPresenceReplay = null;
+  data;
+  enter(data) {
+    this.data = data;
+    this.unregisterPresenceReplay?.();
+    this.unregisterPresenceReplay = this.connection.registerReplay(
+      `presence:${this.channel}`,
+      () => {
+        this.connection.send({ type: "presence.enter", channel: this.channel, data: this.data });
+      }
+    );
+    this.connection.send({ type: "presence.enter", channel: this.channel, data });
+  }
+  update(data) {
+    this.data = data;
+    this.connection.send({ type: "presence.update", channel: this.channel, data });
+  }
+  leave() {
+    this.unregisterPresenceReplay?.();
+    this.unregisterPresenceReplay = null;
+    this.connection.send({ type: "presence.leave", channel: this.channel });
+  }
+  get(options = {}) {
+    const requestId = randomId();
+    return new Promise((resolve, reject) => {
+      let unsubscribe = () => void 0;
+      const cleanup = () => {
+        unsubscribe();
+        options.signal?.removeEventListener("abort", handleAbort);
+      };
+      const handleAbort = () => {
+        cleanup();
+        reject(options.signal?.reason ?? new Error("Presence snapshot request aborted"));
+      };
+      if (options.signal?.aborted === true) {
+        handleAbort();
+        return;
+      }
+      unsubscribe = this.connection.onFrame((frame) => {
+        if (frame.type === "presence.snapshot" && frame.requestId === requestId) {
+          cleanup();
+          resolve(frame.members);
+        }
+        if (frame.type === "error" && frame.requestId === requestId) {
+          cleanup();
+          reject(new Error(frame.message));
+        }
+      });
+      options.signal?.addEventListener("abort", handleAbort, { once: true });
+      try {
+        this.connection.send({
+          type: "presence.get",
+          id: requestId,
+          channel: this.channel
+        });
+      } catch (error) {
+        cleanup();
+        reject(error);
+      }
+    });
+  }
+  subscribe(handler) {
+    return this.connection.onFrame((frame) => {
+      if (frame.type === "presence.event" && frame.channel === this.channel) {
+        handler({ channel: frame.channel, action: frame.action, member: frame.member });
+      }
+    });
+  }
+}
+class WebsocketsRpc {
+  constructor(connection, name) {
+    this.connection = connection;
+    this.name = name;
+  }
+  connection;
+  name;
+  connect(handler) {
+    this.connection.send({ type: "rpc.register", name: this.name });
+    const unregisterReplay = this.connection.registerReplay(`rpc:${this.name}`, () => {
+      this.connection.send({ type: "rpc.register", name: this.name });
+    });
+    const unsubscribe = this.connection.onFrame((frame) => {
+      if (frame.type !== "rpc.call" || frame.name !== this.name) return;
+      Promise.resolve(handler(websocketGatewayDataSchema.parse(frame.data))).then((data) => {
+        this.connection.send({ type: "rpc.respond", correlationId: frame.correlationId, data });
+      }).catch((cause) => {
+        this.connection.send({
+          type: "rpc.respond",
+          correlationId: frame.correlationId,
+          error: {
+            code: "handler_failed",
+            message: cause instanceof Error ? cause.message : String(cause)
+          }
+        });
+      });
+    });
+    return () => {
+      unsubscribe();
+      unregisterReplay();
+    };
+  }
+  call(data, timeoutMs = 3e4, signal) {
+    const correlationId = randomId();
+    return new Promise((resolve, reject) => {
+      if (signal?.aborted === true) {
+        reject(signal.reason);
+        return;
+      }
+      const cleanup = () => {
+        clearTimeout(timer);
+        unsubscribe();
+        signal?.removeEventListener("abort", abort);
+      };
+      const abort = () => {
+        cleanup();
+        reject(signal?.reason ?? new Error("Websockets RPC aborted"));
+      };
+      const timer = setTimeout(() => {
+        cleanup();
+        reject(new Error("Websockets RPC timed out"));
+      }, timeoutMs);
+      const unsubscribe = this.connection.onFrame((frame) => {
+        if (frame.type !== "rpc.response" || frame.correlationId !== correlationId) return;
+        cleanup();
+        if (frame.error != null) reject(new Error(frame.error.message));
+        else
+          resolve(
+            frame.data === void 0 ? void 0 : websocketGatewayDataSchema.parse(frame.data)
+          );
+      });
+      signal?.addEventListener("abort", abort, { once: true });
+      try {
+        this.connection.send({ type: "rpc.call", name: this.name, correlationId, data, timeoutMs });
+      } catch (cause) {
+        cleanup();
+        reject(cause);
+      }
+    });
+  }
+}
+class WebsocketsBridge {
+  constructor(connection, name) {
+    this.connection = connection;
+    this.name = name;
+  }
+  connection;
+  name;
+  join(role, handler) {
+    this.connection.send({ type: "bridge.join", bridge: this.name, role });
+    const unregisterReplay = this.connection.registerReplay(`bridge:${this.name}`, () => {
+      this.connection.send({ type: "bridge.join", bridge: this.name, role });
+    });
+    const unsubscribe = this.connection.onFrame((frame) => {
+      if (frame.type === "bridge.message" && frame.bridge === this.name) {
+        handler?.(websocketGatewayDataSchema.parse(frame.data));
+      }
+    });
+    return () => {
+      unsubscribe();
+      unregisterReplay();
+      this.connection.send({ type: "bridge.leave", bridge: this.name });
+    };
+  }
+  async joinReady(role, handler) {
+    const requestId = randomId();
+    const acknowledged = this.connection.waitForAck(requestId, "bridge.join");
+    const unsubscribe = this.connection.onFrame((frame) => {
+      if (frame.type === "bridge.message" && frame.bridge === this.name) {
+        handler?.(websocketGatewayDataSchema.parse(frame.data));
+      }
+    });
+    const unregisterReplay = this.connection.registerReplay(`bridge:${this.name}`, () => {
+      this.connection.send({ type: "bridge.join", bridge: this.name, role });
+    });
+    this.connection.send({
+      id: requestId,
+      type: "bridge.join",
+      bridge: this.name,
+      role
+    });
+    try {
+      await acknowledged;
+    } catch (error) {
+      unsubscribe();
+      unregisterReplay();
+      throw error;
+    }
+    return () => {
+      unsubscribe();
+      unregisterReplay();
+      this.connection.send({ type: "bridge.leave", bridge: this.name });
+    };
+  }
+  send(data) {
+    this.connection.send({ type: "bridge.send", bridge: this.name, data });
+  }
+}
+class WebsocketsProxy {
+  constructor(connection, upstream) {
+    this.connection = connection;
+    this.upstreamId = typeof upstream === "string" ? upstream : upstream.id;
+  }
+  connection;
+  upstreamId;
+  connect(handlers = {}) {
+    const unsubscribe = this.connection.onFrame((frame) => {
+      switch (frame.type) {
+        case "proxy.open":
+          if (frame.upstreamId === this.upstreamId) {
+            handlers.onOpen?.(frame.upstreamId);
+          }
+          return;
+        case "proxy.message":
+          handlers.onMessage?.(decodeProxyPayload(frame.data));
+          return;
+        case "proxy.closed":
+          handlers.onClose?.({ code: frame.code, reason: frame.reason });
+          return;
+      }
+    });
+    this.connection.send({ type: "proxy.connect", upstreamId: this.upstreamId });
+    return unsubscribe;
+  }
+  send(data) {
+    this.connection.send({ type: "proxy.send", data: encodeProxyPayload(data) });
+  }
+  close(code, reason) {
+    this.connection.send({ type: "proxy.close", code, reason });
+  }
+}
+class WebsocketsWorker {
+  constructor(connection) {
+    this.connection = connection;
+  }
+  connection;
+  helloArgs = null;
+  inFlightLeases = /* @__PURE__ */ new Map();
+  pendingTerminalLeaseOperations = /* @__PURE__ */ new Map();
+  unregisterHelloReplay = null;
+  unregisterTerminalOperationReplay = null;
+  hello(args) {
+    this.helloArgs = {
+      workerId: args.workerId,
+      namespace: args.namespace,
+      appVersion: args.appVersion,
+      queues: args.queues,
+      maxConcurrency: args.maxConcurrency ?? 1,
+      inFlightLeaseIds: args.inFlightLeaseIds ?? []
+    };
+    this.inFlightLeases.clear();
+    for (const lease of args.inFlightLeases ?? []) {
+      this.inFlightLeases.set(lease.leaseId, lease.queue);
+    }
+    if ((args.inFlightLeases == null || args.inFlightLeases.length === 0) && args.queues.length === 1) {
+      for (const leaseId of args.inFlightLeaseIds ?? []) {
+        this.inFlightLeases.set(leaseId, args.queues[0]);
+      }
+    }
+    this.unregisterHelloReplay?.();
+    this.unregisterHelloReplay = this.connection.registerReplay(`worker:${args.workerId}`, () => {
+      this.sendHello();
+    });
+    this.unregisterTerminalOperationReplay?.();
+    this.unregisterTerminalOperationReplay = this.connection.registerReplay(
+      `worker:${args.workerId}:terminal-lease-operations`,
+      () => {
+        this.replayPendingTerminalLeaseOperations();
+      }
+    );
+    this.sendHello();
+  }
+  sendHello() {
+    if (this.helloArgs == null) return;
+    this.connection.send({
+      type: "worker.hello",
+      workerId: this.helloArgs.workerId,
+      namespace: this.helloArgs.namespace,
+      appVersion: this.helloArgs.appVersion,
+      queues: this.helloArgs.queues,
+      ...(() => {
+        if (!(this.helloArgs.maxConcurrency === 1))
+          return { maxConcurrency: this.helloArgs.maxConcurrency };
+        return {};
+      })(),
+      inFlightLeaseIds: this.helloArgs.inFlightLeaseIds,
+      inFlightLeases: [...this.inFlightLeases.entries()].map(([leaseId, queue]) => ({
+        leaseId,
+        queue
+      }))
+    });
+  }
+  onOffer(handler) {
+    return this.connection.onFrame((frame) => {
+      if (frame.type !== "work.offer") return;
+      this.inFlightLeases.set(frame.leaseId, frame.queue);
+      handler({
+        queue: frame.queue,
+        leaseId: frame.leaseId,
+        payload: websocketGatewayDataSchema.parse(frame.payload)
+      });
+    });
+  }
+  accept(leaseId) {
+    return this.sendLeaseOperation("work.accept", leaseId);
+  }
+  heartbeat(leaseId) {
+    return this.sendLeaseOperation("work.heartbeat", leaseId);
+  }
+  complete(leaseId, result) {
+    return this.sendTerminalLeaseOperation("work.complete", leaseId, { result }).then(() => {
+      this.inFlightLeases.delete(leaseId);
+    });
+  }
+  fail(leaseId, error) {
+    return this.sendTerminalLeaseOperation("work.fail", leaseId, { error }).then(() => {
+      this.inFlightLeases.delete(leaseId);
+    });
+  }
+  drain(reason) {
+    const requestId = randomId();
+    const result = this.connection.waitForAck(requestId, "work.drain");
+    this.connection.send({ id: requestId, type: "work.drain", reason });
+    return result;
+  }
+  close(code, reason) {
+    this.unregisterHelloReplay?.();
+    this.unregisterTerminalOperationReplay?.();
+    this.connection.close(code, reason);
+  }
+  sendTerminalLeaseOperation(operation, leaseId, extra = {}) {
+    this.pendingTerminalLeaseOperations.get(leaseId)?.unsubscribe();
+    const requestId = randomId();
+    const unsubscribe = this.connection.onFrame((frame) => {
+      if (frame.type === "ack" && frame.requestId === requestId && frame.operation === operation) {
+        this.clearPendingTerminalLeaseOperation(leaseId);
+        this.inFlightLeases.delete(leaseId);
+      }
+      if (frame.type === "error" && frame.requestId === requestId) {
+        this.clearPendingTerminalLeaseOperation(leaseId);
+        this.inFlightLeases.delete(leaseId);
+      }
+    });
+    this.pendingTerminalLeaseOperations.set(leaseId, {
+      operation,
+      requestId,
+      result: extra.result,
+      error: extra.error,
+      unsubscribe
+    });
+    const result = this.connection.waitForAck(requestId, operation).then(() => {
+      this.clearPendingTerminalLeaseOperation(leaseId);
+    });
+    this.sendTerminalLeaseOperationFrame(leaseId);
+    return result;
+  }
+  clearPendingTerminalLeaseOperation(leaseId) {
+    const pending = this.pendingTerminalLeaseOperations.get(leaseId);
+    pending?.unsubscribe();
+    this.pendingTerminalLeaseOperations.delete(leaseId);
+  }
+  replayPendingTerminalLeaseOperations() {
+    for (const leaseId of this.pendingTerminalLeaseOperations.keys()) {
+      this.sendTerminalLeaseOperationFrame(leaseId);
+    }
+  }
+  sendTerminalLeaseOperationFrame(leaseId) {
+    const pending = this.pendingTerminalLeaseOperations.get(leaseId);
+    if (pending == null) return;
+    switch (pending.operation) {
+      case "work.complete":
+        this.connection.send({
+          id: pending.requestId,
+          type: "work.complete",
+          leaseId,
+          result: pending.result
+        });
+        break;
+      case "work.fail":
+        this.connection.send({
+          id: pending.requestId,
+          type: "work.fail",
+          leaseId,
+          error: pending.error ?? "Worker failed"
+        });
+        break;
+    }
+  }
+  sendLeaseOperation(operation, leaseId, extra = {}) {
+    const requestId = randomId();
+    const result = this.connection.waitForAck(requestId, operation);
+    switch (operation) {
+      case "work.accept":
+        this.connection.send({ id: requestId, type: "work.accept", leaseId });
+        break;
+      case "work.heartbeat":
+        this.connection.send({ id: requestId, type: "work.heartbeat", leaseId });
+        break;
+      case "work.complete":
+        this.connection.send({
+          id: requestId,
+          type: "work.complete",
+          leaseId,
+          result: extra.result
+        });
+        break;
+      case "work.fail":
+        this.connection.send({
+          id: requestId,
+          type: "work.fail",
+          leaseId,
+          error: extra.error ?? "Worker failed"
+        });
+        break;
+    }
+    return result;
+  }
+}
+const client = {
+  connect: async (options) => {
+    const connection = new WebsocketsConnection(options);
+    await connection.connect();
+    return connection;
+  }
+};
+const worker = {
+  connect: async (options) => {
+    const connection = new WebsocketsConnection(options);
+    await connection.connect();
+    return new WebsocketsWorker(connection);
+  }
+};
+const capability = (channels, actions) => ({
+  channels,
+  actions
+});
+export {
+  WebsocketsBridge,
+  WebsocketsChannel,
+  WebsocketsConnection,
+  WebsocketsPresence,
+  WebsocketsProxy,
+  WebsocketsRealtimeTopic,
+  WebsocketsRpc,
+  WebsocketsWorker,
+  capability,
+  client,
+  worker
+};
+//# sourceMappingURL=index.mjs.map