velocious 1.0.431 → 1.0.433

package/build/src/http-server/client/websocket-session.js

@@ -1,60 +1,51 @@
 // @ts-check
-
-import {randomUUID} from "node:crypto"
-
-import EventEmitter from "../../utils/event-emitter.js"
-import Logger from "../../logger.js"
-import RequestRunner from "./request-runner.js"
-import WebsocketRequest from "./websocket-request.js"
-import WebsocketChannel from "../websocket-channel.js"
-import {websocketEventLogStoreForConfiguration} from "../websocket-event-log-store.js"
-
-const WEBSOCKET_FINAL_FRAME = 0x80
-const WEBSOCKET_OPCODE_CONTINUATION = 0x0
-const WEBSOCKET_OPCODE_TEXT = 0x1
-const WEBSOCKET_OPCODE_BINARY = 0x2
-const WEBSOCKET_OPCODE_CLOSE = 0x8
-const WEBSOCKET_OPCODE_PING = 0x9
-const WEBSOCKET_OPCODE_PONG = 0xA
-
+import { randomUUID } from "node:crypto";
+import EventEmitter from "../../utils/event-emitter.js";
+import Logger from "../../logger.js";
+import RequestRunner from "./request-runner.js";
+import WebsocketRequest from "./websocket-request.js";
+import WebsocketChannel from "../websocket-channel.js";
+import { websocketEventLogStoreForConfiguration } from "../websocket-event-log-store.js";
+const WEBSOCKET_FINAL_FRAME = 0x80;
+const WEBSOCKET_OPCODE_CONTINUATION = 0x0;
+const WEBSOCKET_OPCODE_TEXT = 0x1;
+const WEBSOCKET_OPCODE_BINARY = 0x2;
+const WEBSOCKET_OPCODE_CLOSE = 0x8;
+const WEBSOCKET_OPCODE_PING = 0x9;
+const WEBSOCKET_OPCODE_PONG = 0xA;
 /** Cap on the paused outbound queue; oldest frames drop on overflow. */
-const WEBSOCKET_PAUSED_QUEUE_CAP = 1000
-
+const WEBSOCKET_PAUSED_QUEUE_CAP = 1000;
 /** Cap on total bytes buffered for a single fragmented message. */
-const WEBSOCKET_MAX_FRAGMENTED_MESSAGE_BYTES = 16 * 1024 * 1024
-
+const WEBSOCKET_MAX_FRAGMENTED_MESSAGE_BYTES = 16 * 1024 * 1024;
 /** Cap on fragment count for a single fragmented message. */
-const WEBSOCKET_MAX_FRAGMENTED_MESSAGE_FRAGMENTS = 1024
-
+const WEBSOCKET_MAX_FRAGMENTED_MESSAGE_FRAGMENTS = 1024;
 /**
  * Defines this typedef.
  * @typedef {{type: "subscribe", channel: string, lastEventId?: string, params?: Record<string, ?>} | {type: "metadata", data?: Record<string, ?>} | {type?: "request", body?: ?, headers?: Record<string, ?>, id?: string | number | null, method: string, path: string} | Record<string, ?>} WebsocketSessionMessage
  */
-
 /**
  * Runs subscribe message.
  * @param {WebsocketSessionMessage} message - Raw websocket message.
  * @returns {{type: "subscribe", channel: string, lastEventId?: string, params?: Record<string, ?>} | null} - Subscribe message when matched.
  */
 function subscribeMessage(message) {
-  return message.type === "subscribe"
-    ? /**
-       * Narrows the runtime value to the documented type.
-        @type {{type: "subscribe", channel: string, lastEventId?: string, params?: Record<string, ?>}} */ (message)
-    : null
+    return message.type === "subscribe"
+        ? /**
+           * Narrows the runtime value to the documented type.
+            @type {{type: "subscribe", channel: string, lastEventId?: string, params?: Record<string, ?>}} */
+            (message)
+        : null;
 }
-
 /**
  * Runs request message.
  * @param {WebsocketSessionMessage} message - Raw websocket message.
  * @returns {{type?: "request", body?: ?, headers?: Record<string, ?>, id?: string | number | null, method: string, path: string} | null} - Request message when matched.
  */
 function requestMessage(message) {
-  if (message.type && message.type !== "request") return null
-
-  return /** Narrows the runtime value to the documented type. @type {{type?: "request", body?: ?, headers?: Record<string, ?>, id?: string | number | null, method: string, path: string}} */ (message)
+    if (message.type && message.type !== "request")
+        return null;
+    return /** Narrows the runtime value to the documented type. @type {{type?: "request", body?: ?, headers?: Record<string, ?>, id?: string | number | null, method: string, path: string}} */ (message);
 }
-
 /**
  * Compares two identity values from `getWebsocketSessionIdentityResolver`.
  * Nullish values compare equal to each other but not to a real identity.
@@ -65,1691 +56,1495 @@ function requestMessage(message) {
  * @returns {boolean} - True when the two identities are considered the same caller.
  */
 function identitiesMatch(a, b) {
-  if (a === b) return true
-  if (a == null || b == null) return false
-  if (typeof a !== "object" || typeof b !== "object") return false
-
-  try {
-    return JSON.stringify(a) === JSON.stringify(b)
-  } catch {
-    return false
-  }
+    if (a === b)
+        return true;
+    if (a == null || b == null)
+        return false;
+    if (typeof a !== "object" || typeof b !== "object")
+        return false;
+    try {
+        return JSON.stringify(a) === JSON.stringify(b);
+    }
+    catch {
+        return false;
+    }
 }
-
 export default class VelociousHttpServerClientWebsocketSession {
-  events = new EventEmitter()
-  subscriptions = new Set()
-  channels = new Set()
-  subscriptionHandlers = new Map()
-  handlerSubscriptions = new Map()
-  channelTenants = new Map()
-  channelReplayStates = new Map()
-  /**
-   * Message queue.
-    @type {WebsocketSessionMessage[]} */
-  messageQueue = []
-
-  /**
-   * Runs constructor.
-   * @param {object} args - Options object.
-   * @param {import("../../configuration.js").default} args.configuration - Configuration instance.
-   * @param {import("./index.js").default} args.client - Client instance.
-   * @param {import("./request.js").default | import("./websocket-request.js").default} [args.upgradeRequest] - Initial websocket upgrade request.
-   * @param {import("../../configuration-types.js").WebsocketMessageHandler} [args.messageHandler] - Optional raw message handler.
-   * @param {Promise<import("../../configuration-types.js").WebsocketMessageHandler | void>} [args.messageHandlerPromise] - Optional raw message handler promise.
-   */
-  constructor({client, configuration, upgradeRequest, messageHandler, messageHandlerPromise}) {
-    this.buffer = Buffer.alloc(0)
-    this.client = client
-    this.configuration = configuration
-    this.upgradeRequest = upgradeRequest
-    this.messageHandler = messageHandler
-    this.messageHandlerPromise = messageHandlerPromise
-    this.pendingMessageHandler = Boolean(messageHandlerPromise)
-    this.logger = new Logger(this)
-
+    events = new EventEmitter();
+    subscriptions = new Set();
+    channels = new Set();
+    subscriptionHandlers = new Map();
+    handlerSubscriptions = new Map();
+    channelTenants = new Map();
+    channelReplayStates = new Map();
     /**
-     * Narrows the runtime value to the documented type.
-      @type {Record<string, ?>} */
-    this._metadata = {}
-
+     * Message queue.
+      @type {WebsocketSessionMessage[]} */
+    messageQueue = [];
     /**
-     * Long-lived per-session state bag. Stable across reconnects once
-     * grace-period resumption lands in Phase 2; today it just lives
-     * for the duration of the underlying socket.
-     * @type {Record<string, ?>}
+     * Runs constructor.
+     * @param {object} args - Options object.
+     * @param {import("../../configuration.js").default} args.configuration - Configuration instance.
+     * @param {import("./index.js").default} args.client - Client instance.
+     * @param {import("./request.js").default | import("./websocket-request.js").default} [args.upgradeRequest] - Initial websocket upgrade request.
+     * @param {import("../../configuration-types.js").WebsocketMessageHandler} [args.messageHandler] - Optional raw message handler.
+     * @param {Promise<import("../../configuration-types.js").WebsocketMessageHandler | void>} [args.messageHandlerPromise] - Optional raw message handler promise.
      */
-    this.data = {}
-
-    /**
-     * Narrows the runtime value to the documented type.
-      @type {Map<string, import("../websocket-connection.js").default>} */
-    this._connections = new Map()
-
-    /**
-     * Narrows the runtime value to the documented type.
-      @type {Map<string, {channelType: string, subscription: import("../websocket-channel.js").default}>} */
-    this._channelSubscriptions = new Map()
-
+    constructor({ client, configuration, upgradeRequest, messageHandler, messageHandlerPromise }) {
+        this.buffer = Buffer.alloc(0);
+        this.client = client;
+        this.configuration = configuration;
+        this.upgradeRequest = upgradeRequest;
+        this.messageHandler = messageHandler;
+        this.messageHandlerPromise = messageHandlerPromise;
+        this.pendingMessageHandler = Boolean(messageHandlerPromise);
+        this.logger = new Logger(this);
+        /**
+         * Narrows the runtime value to the documented type.
+          @type {Record<string, ?>} */
+        this._metadata = {};
+        /**
+         * Long-lived per-session state bag. Stable across reconnects once
+         * grace-period resumption lands in Phase 2; today it just lives
+         * for the duration of the underlying socket.
+         * @type {Record<string, ?>}
+         */
+        this.data = {};
+        /**
+         * Narrows the runtime value to the documented type.
+          @type {Map<string, import("../websocket-connection.js").default>} */
+        this._connections = new Map();
+        /**
+         * Narrows the runtime value to the documented type.
+          @type {Map<string, {channelType: string, subscription: import("../websocket-channel.js").default}>} */
+        this._channelSubscriptions = new Map();
+        /**
+         * Unique id assigned to this session on first connect. Sent to the
+         * client via `session-established`; the client echoes it back via
+         * `session-resume` after a WS drop to reattach to this session
+         * within the grace period.
+         * @type {string}
+         */
+        this.sessionId = randomUUID();
+        /**
+         * Narrows the runtime value to the documented type.
+         * @type {boolean} - true after `_handleClose` pauses instead of tearing down.
+         */
+        this._paused = false;
+        /**
+         * Narrows the runtime value to the documented type.
+         * @type {Array<?>} - frames produced while paused; flushed on resume.
+         */
+        this._outboundQueue = [];
+        /**
+         * Narrows the runtime value to the documented type.
+          @type {import("./index.js").default | null} */
+        this.socket = null;
+        /**
+         * Tail of a per-session promise chain that serializes message
+         * handling. Prevents races where message B reads `session.data`
+         * before message A's handler finishes writing it (e.g. a
+         * connection-message setting the locale vs. a subsequent request
+         * whose aroundRequest wrapper reads it).
+         * @type {Promise<void>}
+         */
+        this._messageChain = Promise.resolve();
+        /**
+         * Promise that resolves to the auth identity captured at pause
+         * time by `getWebsocketSessionIdentityResolver`. Awaited at resume
+         * time to compare against the fresh caller's identity. Undefined
+         * on a live (non-paused) session.
+         * @type {Promise<?> | undefined}
+         */
+        this._resumeIdentityPromise = undefined;
+        /**
+         * Accumulates payloads for a fragmented websocket message per
+         * RFC 6455. Non-null while mid-fragment; cleared when the frame
+         * with FIN=1 completes and the message is dispatched.
+         * @type {Buffer[] | null}
+         */
+        this._fragmentedPayloads = null;
+        /**
+         * Opcode (TEXT/BINARY) captured from the first frame of a
+         * fragmented message. Continuation frames (opcode 0) inherit it
+         * at reassembly time.
+         * @type {number | null}
+         */
+        this._fragmentedOpcode = null;
+        /**
+         * Running byte total for `_fragmentedPayloads`. Used to enforce
+         * `WEBSOCKET_MAX_FRAGMENTED_MESSAGE_BYTES` so a peer cannot
+         * exhaust memory by streaming non-final fragments indefinitely.
+         * @type {number}
+         */
+        this._fragmentedBytes = 0;
+        this.configuration._websocketSessions.add(this);
+    }
     /**
-     * Unique id assigned to this session on first connect. Sent to the
-     * client via `session-established`; the client echoes it back via
-     * `session-resume` after a WS drop to reattach to this session
-     * within the grace period.
-     * @type {string}
+     * Sends the client its sessionId + grace window. Called by
+     * `VelociousHttpServerClient` after the WS upgrade completes.
+     * @returns {void}
      */
-    this.sessionId = randomUUID()
-
+    sendSessionEstablished() {
+        this.sendJson({
+            type: "session-established",
+            sessionId: this.sessionId,
+            graceSeconds: this.configuration.getWebsocketSessionGraceSeconds?.() || 300
+        });
+    }
     /**
-     * Narrows the runtime value to the documented type.
-     * @type {boolean} - true after `_handleClose` pauses instead of tearing down.
+     * Removes a closed connection from the session registry. Called by
+     * `VelociousWebsocketConnection.close()` after it sends the final
+     * `connection-closed` frame.
+     * @param {string} connectionId
+     * @returns {void}
      */
-    this._paused = false
-
+    _removeConnection(connectionId) {
+        this._connections.delete(connectionId);
+    }
     /**
-     * Narrows the runtime value to the documented type.
-     * @type {Array<?>} - frames produced while paused; flushed on resume.
+     * Runs get metadata.
+     * @returns {Record<string, ?>} - Client-provided metadata (defensive copy).
      */
-    this._outboundQueue = []
-
-    /**
-     * Narrows the runtime value to the documented type.
-      @type {import("./index.js").default | null} */
-    this.socket = null
-
+    getMetadata() {
+        return { ...this._metadata };
+    }
     /**
-     * Tail of a per-session promise chain that serializes message
-     * handling. Prevents races where message B reads `session.data`
-     * before message A's handler finishes writing it (e.g. a
-     * connection-message setting the locale vs. a subsequent request
-     * whose aroundRequest wrapper reads it).
-     * @type {Promise<void>}
+     * Runs is paused.
+     * @returns {boolean} - true while the session is in the paused/grace registry.
      */
-    this._messageChain = Promise.resolve()
-
+    isPaused() {
+        return this._paused;
+    }
     /**
-     * Promise that resolves to the auth identity captured at pause
-     * time by `getWebsocketSessionIdentityResolver`. Awaited at resume
-     * time to compare against the fresh caller's identity. Undefined
-     * on a live (non-paused) session.
-     * @type {Promise<?> | undefined}
+     * Runs add subscription.
+     * @param {string} channel - Channel name.
+     * @returns {void} - No return value.
      */
-    this._resumeIdentityPromise = undefined
-
+    addSubscription(channel) {
+        this.subscriptions.add(channel);
+    }
+    destroy() {
+        this.configuration._websocketSessions.delete(this);
+        this._paused = false;
+        void this._teardownChannel();
+        void this._teardownConnections("session_destroyed");
+        void this._teardownChannelSubscriptions();
+        this.events.removeAllListeners();
+    }
     /**
-     * Accumulates payloads for a fragmented websocket message per
-     * RFC 6455. Non-null while mid-fragment; cleared when the frame
-     * with FIN=1 completes and the message is dispatched.
-     * @type {Buffer[] | null}
+     * Runs has subscription.
+     * @param {string} channel - Channel name.
+     * @returns {boolean} - Whether it has subscription.
      */
-    this._fragmentedPayloads = null
-
+    hasSubscription(channel) {
+        return this.subscriptions.has(channel);
+    }
     /**
-     * Opcode (TEXT/BINARY) captured from the first frame of a
-     * fragmented message. Continuation frames (opcode 0) inherit it
-     * at reassembly time.
-     * @type {number | null}
+     * Runs on data.
+     * @param {Buffer} data - Data payload.
+     * @returns {void} - No return value.
      */
-    this._fragmentedOpcode = null
-
+    onData(data) {
+        this.buffer = Buffer.concat([this.buffer, data]);
+        this._processBuffer();
+    }
     /**
-     * Running byte total for `_fragmentedPayloads`. Used to enforce
-     * `WEBSOCKET_MAX_FRAGMENTED_MESSAGE_BYTES` so a peer cannot
-     * exhaust memory by streaming non-final fragments indefinitely.
-     * @type {number}
+     * Runs send event.
+     * @param {string} channel - Channel name.
+     * @param {?} payload - Payload data.
+     * @param {{createdAt?: string, eventId?: string, replayed?: boolean, sequence?: number}} [options] - Event metadata.
+     * @returns {Promise<void>} - Resolves when complete.
      */
-    this._fragmentedBytes = 0
-
-    this.configuration._websocketSessions.add(this)
-  }
-
-  /**
-   * Sends the client its sessionId + grace window. Called by
-   * `VelociousHttpServerClient` after the WS upgrade completes.
-   * @returns {void}
-   */
-  sendSessionEstablished() {
-    this.sendJson({
-      type: "session-established",
-      sessionId: this.sessionId,
-      graceSeconds: this.configuration.getWebsocketSessionGraceSeconds?.() || 300
-    })
-  }
-
-  /**
-   * Removes a closed connection from the session registry. Called by
-   * `VelociousWebsocketConnection.close()` after it sends the final
-   * `connection-closed` frame.
-   * @param {string} connectionId
-   * @returns {void}
-   */
-  _removeConnection(connectionId) {
-    this._connections.delete(connectionId)
-  }
-
-  /**
-   * Runs get metadata.
-   * @returns {Record<string, ?>} - Client-provided metadata (defensive copy).
-   */
-  getMetadata() {
-    return {...this._metadata}
-  }
-
-  /**
-   * Runs is paused.
-   * @returns {boolean} - true while the session is in the paused/grace registry.
-   */
-  isPaused() {
-    return this._paused
-  }
-
-  /**
-   * Runs add subscription.
-   * @param {string} channel - Channel name.
-   * @returns {void} - No return value.
-   */
-  addSubscription(channel) {
-    this.subscriptions.add(channel)
-  }
-
-  destroy() {
-    this.configuration._websocketSessions.delete(this)
-    this._paused = false
-    void this._teardownChannel()
-    void this._teardownConnections("session_destroyed")
-    void this._teardownChannelSubscriptions()
-    this.events.removeAllListeners()
-  }
-
-  /**
-   * Runs has subscription.
-   * @param {string} channel - Channel name.
-   * @returns {boolean} - Whether it has subscription.
-   */
-  hasSubscription(channel) {
-    return this.subscriptions.has(channel)
-  }
-
-  /**
-   * Runs on data.
-   * @param {Buffer} data - Data payload.
-   * @returns {void} - No return value.
-   */
-  onData(data) {
-    this.buffer = Buffer.concat([this.buffer, data])
-    this._processBuffer()
-  }
-
-  /**
-   * Runs send event.
-   * @param {string} channel - Channel name.
-   * @param {?} payload - Payload data.
-   * @param {{createdAt?: string, eventId?: string, replayed?: boolean, sequence?: number}} [options] - Event metadata.
-   * @returns {Promise<void>} - Resolves when complete.
-   */
-  async sendEvent(channel, payload, options = {}) {
-    const channelHandlers = this.subscriptionHandlers.get(channel)
-    const hasChannelHandlers = Boolean(channelHandlers && channelHandlers.size > 0)
-    const replayState = this.channelReplayStates.get(channel)
-
-    if (replayState?.replaying && !options.replayed) {
-      replayState.buffered = true
-      return
-    }
-
-    if (!this.hasSubscription(channel) && !hasChannelHandlers) return
-
-    if (hasChannelHandlers) {
-      await Promise.all(Array.from(channelHandlers).map(async (handler) => {
-        const tenant = this.channelTenants.get(handler)
-
-        await this.configuration.runWithTenant(tenant, async () => {
-          await this._withConnections(async () => {
-            await handler.receivedBroadcast({
-              channel,
-              createdAt: options.createdAt,
-              eventId: options.eventId,
-              payload,
-              replayed: options.replayed,
-              sequence: options.sequence
-            })
-          })
-        })
-      }))
-      return
-    }
-
-    this.sendJson({
-      channel,
-      createdAt: options.createdAt,
-      eventId: options.eventId,
-      payload,
-      replayed: options.replayed,
-      sequence: options.sequence,
-      type: "event"
-    })
-  }
-
-  /**
-   * Runs initialize channel.
-   * @returns {Promise<void>} - Resolves when complete.
-   */
-  async initializeChannel() {
-    if (this.messageHandlerPromise) {
-      await this._resolveMessageHandlerPromise()
-
-      if (this.messageHandler) return
-    }
-
-    if (this.messageHandler) {
-      await this._runMessageHandlerOpen()
-      return
-    }
-
-    const resolver = this.configuration.getWebsocketChannelResolver?.()
-
-    if (!resolver) return
-
-    try {
-      const tenant = await this._resolveTenant({})
-      const resolved = await this.configuration.runWithTenant(tenant, async () => {
-        return await resolver({
-          client: this.client,
-          configuration: this.configuration,
-          request: this.upgradeRequest,
-          websocketSession: this
-        })
-      })
-
-      if (!resolved) return
-
-      const channel = typeof resolved === "function"
-        ? new resolved({client: this.client, configuration: this.configuration, request: this.upgradeRequest, websocketSession: this})
-        : resolved
-
-      if (channel && !(channel instanceof WebsocketChannel)) {
-        throw new Error("Resolved websocket channel must extend WebsocketChannel")
-      }
-
-      await this._registerChannel(channel, tenant)
-    } catch (error) {
-      this.logger.error(() => ["Failed to initialize websocket channel", error])
-    }
-  }
-
-  /**
-   * Runs send goodbye.
-   * @param {import("./index.js").default} client - Client instance.
-   * @returns {void} - No return value.
-   */
-  sendGoodbye(client) {
-    const frame = Buffer.from([WEBSOCKET_FINAL_FRAME | WEBSOCKET_OPCODE_CLOSE, 0x00])
-
-    client.events.emit("output", frame)
-  }
-
-  /**
-   * Runs handle message.
-   * @param {WebsocketSessionMessage} message - Message text.
-   * @returns {Promise<void>} - Resolves when complete.
-   */
-  async _handleMessage(message) {
-    // Serialize per-session: chain onto `_messageChain` so messages
-    // are processed one at a time. Without this, fire-and-forget
-    // dispatch from `_processBuffer` lets message B read
-    // `session.data` before A has finished writing it.
-    const previous = this._messageChain
-    const next = previous.then(() => this._dispatchMessage(message))
-
-    this._messageChain = next.catch(() => {})
-    await next
-  }
-
-  /**
-   * Runs dispatch message.
-   * @param {WebsocketSessionMessage} message - Message text.
-   * @returns {Promise<void>} - Resolves when complete.
-   */
-  async _dispatchMessage(message) {
-    const wrapper = this.configuration.getWebsocketAroundRequest?.()
-
-    if (wrapper) {
-      await wrapper(this, () => this._handleMessageInner(message))
-      return
-    }
-
-    await this._handleMessageInner(message)
-  }
-
-  /**
-   * The actual message dispatch, extracted so
-   * `configuration.getWebsocketAroundRequest()` can wrap it in any
-   * per-request context (AsyncLocalStorage, tracing, etc.).
-   * @param {WebsocketSessionMessage} message
-   * @returns {Promise<void>}
-   */
-  async _handleMessageInner(message) {
-    if (this.pendingMessageHandler) {
-      this.messageQueue.push(message)
-      return
-    }
-
-    // The messageHandler short-circuits default routing only when the
-    // app actually declared an `onMessage` hook. Apps that only want
-    // session-lifecycle tracking (`onOpen`/`onClose`) still need the
-    // built-in subscribe/connection/channel-subscribe routing below,
-    // otherwise every incoming message is silently dropped.
-    if (this.messageHandler && typeof this.messageHandler.onMessage === "function") {
-      await this._runMessageHandlerMessage(message)
-      return
-    }
-
-    const subscribePayload = subscribeMessage(message)
-
-    if (subscribePayload) {
-      const {channel, lastEventId, params} = subscribePayload
-
-      if (!channel) throw new Error("channel is required for subscribe")
-      const resolver = this.configuration.getWebsocketChannelResolver?.()
-
-      if (resolver) {
-        await this._handleChannelSubscription({channel, lastEventId, params})
-      } else {
-        await this.subscribeToChannel(channel, {acknowledge: true, lastEventId, params})
-      }
-
-      return
-    }
-
-    if (message.type === "metadata") {
-      const metadataPayload = /**
-                               * Narrows the runtime value to the documented type.
-                                @type {{data?: Record<string, ?>}} */ (message)
-
-      this._metadata = metadataPayload.data && typeof metadataPayload.data === "object" ? {...metadataPayload.data} : {}
-
-      for (const {subscription} of this._channelSubscriptions.values()) {
-        if (typeof subscription.onMetadataChanged === "function") {
-          await this._withConnections(async () => {
-            await subscription.onMetadataChanged(this._metadata)
-          })
-        }
-      }
-
-      return
-    }
-
-    if (message.type === "session-resume") {
-      await this._handleSessionResume(message)
-      return
-    }
-
-    if (message.type === "connection-open") {
-      await this._handleConnectionOpen(message)
-      return
-    }
-
-    if (message.type === "connection-message") {
-      await this._handleConnectionMessage(message)
-      return
-    }
-
-    if (message.type === "connection-close") {
-      await this._handleConnectionClose(message)
-      return
-    }
-
-    if (message.type === "channel-subscribe") {
-      await this._handleChannelSubscribe(message)
-      return
-    }
-
-    if (message.type === "channel-unsubscribe") {
-      await this._handleChannelUnsubscribe(message)
-      return
-    }
-
-    if (message.type && message.type !== "request") {
-      this.sendJson({error: `Unknown message type: ${message.type}`, type: "error"})
-      return
-    }
-
-    const requestPayload = requestMessage(message)
-
-    if (!requestPayload) {
-      this.sendJson({error: `Unknown message type: ${message.type}`, type: "error"})
-      return
-    }
-
-    const {body, headers, id, method, path} = requestPayload
-
-    if (!method) throw new Error("method is required")
-    if (!path) throw new Error("path is required")
-
-    const request = new WebsocketRequest({
-      body,
-      headers,
-      metadata: this.getMetadata(),
-      method,
-      path,
-      remoteAddress: this.remoteAddress()
-    })
-    const requestRunner = new RequestRunner({
-      configuration: this.configuration,
-      request
-    })
-
-    requestRunner.events.on("done", () => {
-      const response = requestRunner.response
-      const body = response.getBody()
-      const headers = response.headers
-
-      this.sendJson({
-        body,
-        headers,
-        id,
-        statusCode: response.getStatusCode(),
-        statusMessage: response.getStatusMessage(),
-        type: "response"
-      })
-      void requestRunner.logCompletedRequest().catch((error) => {
-        this.logger.warn("Failed to log completed request", error)
-      })
-    })
-
-    await requestRunner.run()
-  }
-
-  /**
-   * Runs process buffer.
-   * @returns {void} - No return value.
-   */
-  _processBuffer() {
-    while (this.buffer.length >= 2) {
-      const firstByte = this.buffer[0]
-      const secondByte = this.buffer[1]
-      const isFinal = (firstByte & WEBSOCKET_FINAL_FRAME) === WEBSOCKET_FINAL_FRAME
-      const opcode = firstByte & 0x0F
-      const isMasked = (secondByte & 0x80) === 0x80
-      let payloadLength = secondByte & 0x7F
-      let offset = 2
-
-      if (payloadLength === 126) {
-        if (this.buffer.length < offset + 2) return
-        payloadLength = this.buffer.readUInt16BE(offset)
-        offset += 2
-      } else if (payloadLength === 127) {
-        if (this.buffer.length < offset + 8) return
-        const bigLength = this.buffer.readBigUInt64BE(offset)
-
-        payloadLength = Number(bigLength)
-        offset += 8
-      }
-
-      const maskLength = isMasked ? 4 : 0
-
-      if (this.buffer.length < offset + maskLength + payloadLength) return
-
-      /** Payload. @type {Buffer} */
-      let payload = this.buffer.slice(offset + maskLength, offset + maskLength + payloadLength)
-
-      if (isMasked) {
-        const mask = this.buffer.slice(offset, offset + maskLength)
-        payload = this._unmaskPayload(payload, mask)
-      }
-
-      this.buffer = this.buffer.slice(offset + maskLength + payloadLength)
-
-      // Control frames (opcode >= 0x8) must not be fragmented per
-      // RFC 6455 and can arrive interleaved with a fragmented data
-      // message. Handle them first without touching the fragment
-      // accumulator.
-      if (opcode === WEBSOCKET_OPCODE_PING) {
-        this._sendControlFrame(WEBSOCKET_OPCODE_PONG, payload)
-        continue
-      }
-
-      if (opcode === WEBSOCKET_OPCODE_CLOSE) {
-        this.sendGoodbye(this.client)
-        this._handleClose()
-        continue
-      }
-
-      if (opcode >= 0x8) {
-        this.logger.warn(`Unsupported websocket control opcode: ${opcode}`)
-        continue
-      }
-
-      // Data frame (TEXT/BINARY/CONTINUATION). Reassemble fragments
-      // before dispatching. Browsers (Chrome) legitimately fragment
-      // longer client→server text frames; a prior version dropped
-      // every fragmented message silently, so any payload large
-      // enough to hit the browser's fragmentation threshold
-      // (e.g. a channel-subscribe with an auth token) never reached
-      // the handler.
-      if (opcode === WEBSOCKET_OPCODE_CONTINUATION) {
-        if (this._fragmentedPayloads === null) {
-          this.logger.warn("Received continuation frame with no fragmented message in progress")
-          continue
-        }
-
-        if (!this._appendFragment(payload)) return
-
-        if (!isFinal) continue
-      } else if (opcode === WEBSOCKET_OPCODE_TEXT || opcode === WEBSOCKET_OPCODE_BINARY) {
-        if (this._fragmentedPayloads !== null) {
-          this.logger.warn("Received new data frame while a fragmented message was in progress; discarding prior fragments")
-          this._resetFragmentBuffer()
-        }
-
-        if (!isFinal) {
-          this._fragmentedPayloads = [payload]
-          this._fragmentedOpcode = opcode
-          this._fragmentedBytes = payload.length
-
-          if (!this._enforceFragmentLimits()) return
-
-          continue
-        }
-      } else {
-        this.logger.warn(`Unsupported websocket data opcode: ${opcode}`)
-        continue
-      }
-
-      /**
-       * Defines finalPayload.
-        @type {Buffer} */
-      let finalPayload
-      /**
-       * Defines finalOpcode.
-        @type {number} */
-      let finalOpcode
-
-      if (this._fragmentedPayloads !== null) {
-        if (opcode === WEBSOCKET_OPCODE_CONTINUATION) {
-          finalPayload = Buffer.concat(this._fragmentedPayloads)
-          finalOpcode = this._fragmentedOpcode ?? WEBSOCKET_OPCODE_TEXT
-        } else {
-          finalPayload = payload
-          finalOpcode = opcode
-        }
-        this._resetFragmentBuffer()
-      } else {
-        finalPayload = payload
-        finalOpcode = opcode
-      }
-
-      if (finalOpcode !== WEBSOCKET_OPCODE_TEXT) {
-        this.logger.warn(`Unsupported websocket data opcode after reassembly: ${finalOpcode}`)
-        continue
-      }
-
-      try {
-        const message = JSON.parse(finalPayload.toString("utf-8"))
-
-        this._handleMessage(message).catch((error) => {
-          this.logger.error(() => ["Websocket message handler failed", error])
-          this.sendJson({error: error.message, type: "error"})
-        })
-      } catch (error) {
-        this.logger.error(() => ["Failed to parse websocket message", error])
-        this.sendJson({error: "Invalid websocket message", type: "error"})
-      }
-    }
-  }
-
-  /**
-   * Appends a continuation-frame payload to the in-progress
-   * fragmented message. Returns true when the fragment was accepted
-   * and false when the per-message cap was hit and the socket has
-   * been closed.
-   * @param {Buffer} payload
-   * @returns {boolean}
-   */
-  _appendFragment(payload) {
-    // Guard pushing first so `_enforceFragmentLimits` sees the final
-    // state; on overflow the reset inside the enforcer drops the
-    // buffered fragments.
-    this._fragmentedPayloads?.push(payload)
-    this._fragmentedBytes += payload.length
-
-    return this._enforceFragmentLimits()
-  }
-
-  /**
-   * Verifies the fragmented message has not exceeded the byte or
-   * fragment-count caps. On overflow, clears the buffer, sends a
-   * close frame, and tears the session down. Returns true when the
-   * caller can continue processing, false when the session is being
-   * closed.
-   * @returns {boolean}
-   */
-  _enforceFragmentLimits() {
-    if (this._fragmentedPayloads === null) return true
-
-    const fragmentCount = this._fragmentedPayloads.length
-    const overBytes = this._fragmentedBytes > WEBSOCKET_MAX_FRAGMENTED_MESSAGE_BYTES
-    const overFragments = fragmentCount > WEBSOCKET_MAX_FRAGMENTED_MESSAGE_FRAGMENTS
-
-    if (!overBytes && !overFragments) return true
-
-    this.logger.warn(() => [
-      "Fragmented websocket message exceeded caps; closing connection",
-      {
-        fragmentBytes: this._fragmentedBytes,
-        fragmentCount,
-        maxBytes: WEBSOCKET_MAX_FRAGMENTED_MESSAGE_BYTES,
-        maxFragments: WEBSOCKET_MAX_FRAGMENTED_MESSAGE_FRAGMENTS
-      }
-    ])
-
-    this._resetFragmentBuffer()
-    this.buffer = Buffer.alloc(0)
-    this.sendGoodbye(this.client)
-    this._handleClose()
-
-    return false
-  }
-
-  /**
-   * Runs reset fragment buffer.
-    @returns {void} */
-  _resetFragmentBuffer() {
-    this._fragmentedPayloads = null
-    this._fragmentedOpcode = null
-    this._fragmentedBytes = 0
-  }
-
-  /**
-   * Runs send control frame.
-   * @param {number} opcode - Opcode.
-   * @param {Buffer} payload - Payload data.
-   * @returns {void} - No return value.
-   */
-  _sendControlFrame(opcode, payload) {
-    const header = Buffer.alloc(2)
-
-    header[0] = WEBSOCKET_FINAL_FRAME | opcode
-    header[1] = payload.length
-
-    this.client.events.emit("output", Buffer.concat([header, payload]))
-  }
-
-  /**
-   * Runs send json.
-   * @param {object} body - Request body.
-   * @returns {void} - No return value.
-   */
-  sendJson(body) {
-    // While paused (waiting for a resume), stash frames in an
-    // outbound queue and flush them in order on resume. Capped to
-    // prevent runaway memory use while the client is offline.
-    if (this._paused) {
-      this._outboundQueue ||= []
-
-      if (this._outboundQueue.length >= WEBSOCKET_PAUSED_QUEUE_CAP) {
-        // Drop oldest so the most recent activity wins on resume.
-        this._outboundQueue.shift()
-      }
-
-      this._outboundQueue.push(body)
-      return
-    }
-
-    if (!this.client?.events) return
-
-    const json = JSON.stringify(body)
-    const payload = Buffer.from(json, "utf-8")
-    let header
-
-    if (payload.length < 126) {
-      header = Buffer.alloc(2)
-      header[1] = payload.length
-    } else if (payload.length < 65536) {
-      header = Buffer.alloc(4)
-      header[1] = 126
-      header.writeUInt16BE(payload.length, 2)
-    } else {
-      header = Buffer.alloc(10)
-      header[1] = 127
-      header.writeBigUInt64BE(BigInt(payload.length), 2)
-    }
-
-    header[0] = WEBSOCKET_FINAL_FRAME | WEBSOCKET_OPCODE_TEXT
-
-    this.client.events.emit("output", Buffer.concat([header, payload]))
-  }
-
-  /**
-   * Flushes the paused outbound queue over the current socket.
-   * Called during resume after `session-resumed` has been sent on
-   * the NEW session's socket (not this session's).
-   * @returns {void}
-   */
-  _flushOutboundQueue() {
-    const queue = this._outboundQueue || []
-
-    this._outboundQueue = []
-
-    for (const body of queue) {
-      this.sendJson(body)
-    }
-  }
-
-  /**
-   * Runs subscribe to channel.
-   * @param {string} channel - Channel name.
-   * @param {{acknowledge?: boolean, channelHandler?: import("../websocket-channel.js").default, lastEventId?: string, params?: Record<string, ?>, subscriptionChannel?: string}} [options] - Subscribe options.
-   * @returns {Promise<boolean>} - Whether the subscription was added.
-   */
-  async subscribeToChannel(channel, {acknowledge = true, channelHandler, lastEventId, params, subscriptionChannel} = {}) {
-    await websocketEventLogStoreForConfiguration(this.configuration).markChannelInterested(channel)
-
-    const replayState = await this._prepareReplayState({
-      channel,
-      lastEventId,
-      subscriptionChannel: subscriptionChannel || channel,
-      subscriptionParams: params
-    })
-
-    if (replayState === false) return false
-    if (replayState) {
-      this.channelReplayStates.set(channel, replayState)
-    }
-
-    this.addSubscription(channel)
-
-    if (channelHandler) {
-      if (!this.subscriptionHandlers.has(channel)) {
-        this.subscriptionHandlers.set(channel, new Set())
-      }
-
-      this.subscriptionHandlers.get(channel)?.add(channelHandler)
-
-      if (!this.handlerSubscriptions.has(channelHandler)) {
-        this.handlerSubscriptions.set(channelHandler, new Set())
-      }
-
-      this.handlerSubscriptions.get(channelHandler)?.add(channel)
-    }
-
-    if (replayState) {
-      try {
-        await this._replayChannelEvents({channel, replayState})
-      } finally {
-        await this._finishReplayState(channel, replayState)
-      }
-    }
-
-    if (acknowledge) {
-      this.sendJson({channel, type: "subscribed"})
+    async sendEvent(channel, payload, options = {}) {
+        const channelHandlers = this.subscriptionHandlers.get(channel);
+        const hasChannelHandlers = Boolean(channelHandlers && channelHandlers.size > 0);
+        const replayState = this.channelReplayStates.get(channel);
+        if (replayState?.replaying && !options.replayed) {
+            replayState.buffered = true;
+            return;
+        }
+        if (!this.hasSubscription(channel) && !hasChannelHandlers)
+            return;
+        if (hasChannelHandlers) {
+            await Promise.all(Array.from(channelHandlers).map(async (handler) => {
+                const tenant = this.channelTenants.get(handler);
+                await this.configuration.runWithTenant(tenant, async () => {
+                    await this._withConnections(async () => {
+                        await handler.receivedBroadcast({
+                            channel,
+                            createdAt: options.createdAt,
+                            eventId: options.eventId,
+                            payload,
+                            replayed: options.replayed,
+                            sequence: options.sequence
+                        });
+                    });
+                });
+            }));
+            return;
+        }
+        this.sendJson({
+            channel,
+            createdAt: options.createdAt,
+            eventId: options.eventId,
+            payload,
+            replayed: options.replayed,
+            sequence: options.sequence,
+            type: "event"
+        });
     }
-    return true
-  }
-
-  _handleClose() {
-    // If the session has resumable state (live Connection or
-    // ChannelV2 subscription), move it into the paused registry
-    // instead of tearing down; a new socket presenting the sessionId
-    // via `session-resume` within the grace window will reattach.
-    const hasResumableState = this._connections.size > 0 || this._channelSubscriptions.size > 0
-
-    if (hasResumableState && !this._paused) {
-      this._paused = true
-      this.socket = null
-      // Kick off auth-identity capture for resume verification. Runs
-      // in the background — `_handleSessionResume` awaits
-      // `_resumeIdentityPromise` before comparing. Pause registration
-      // is synchronous so a resume arriving immediately still finds
-      // the session.
-      this._resumeIdentityPromise = this._captureResumeIdentity()
-      void this._fireOnDisconnect()
-      this.configuration._pauseWebsocketSession(this)
-      this.events.emit("close")
-      return
+    /**
+     * Runs initialize channel.
+     * @returns {Promise<void>} - Resolves when complete.
+     */
+    async initializeChannel() {
+        if (this.messageHandlerPromise) {
+            await this._resolveMessageHandlerPromise();
+            if (this.messageHandler)
+                return;
+        }
+        if (this.messageHandler) {
+            await this._runMessageHandlerOpen();
+            return;
+        }
+        const resolver = this.configuration.getWebsocketChannelResolver?.();
+        if (!resolver)
+            return;
+        try {
+            const tenant = await this._resolveTenant({});
+            const resolved = await this.configuration.runWithTenant(tenant, async () => {
+                return await resolver({
+                    client: this.client,
+                    configuration: this.configuration,
+                    request: this.upgradeRequest,
+                    websocketSession: this
+                });
+            });
+            if (!resolved)
+                return;
+            const channel = typeof resolved === "function"
+                ? new resolved({ client: this.client, configuration: this.configuration, request: this.upgradeRequest, websocketSession: this })
+                : resolved;
+            if (channel && !(channel instanceof WebsocketChannel)) {
+                throw new Error("Resolved websocket channel must extend WebsocketChannel");
+            }
+            await this._registerChannel(channel, tenant);
+        }
+        catch (error) {
+            this.logger.error(() => ["Failed to initialize websocket channel", error]);
+        }
     }
-
-    void this._runMessageHandlerClose()
-    void this._teardownChannel()
-    void this._teardownConnections("session_destroyed")
-    void this._teardownChannelSubscriptions()
-    this.events.emit("close")
-  }
-
-  /**
-   * Called by the grace timer when the paused period expires without
-   * a resume. Tears down all live Connections + Channel subs and
-   * drops the session.
-   * @returns {void}
-   */
-  _finalizeGraceExpiry() {
-    void this._runMessageHandlerClose()
-    void this._teardownChannel()
-    void this._teardownConnections("grace_expired")
-    void this._teardownChannelSubscriptions()
-    this.events.emit("close")
-  }
-
-  /**
-   * Runs the configured identity resolver against this session.
-   * The returned promise is stored at pause time and awaited at
-   * resume time so we can reject resume attempts from a different
-   * authenticated caller (signed out, swapped user, expired cookie).
-   * @returns {Promise<?>}
-   */
-  async _captureResumeIdentity() {
-    const resolver = this.configuration.getWebsocketSessionIdentityResolver?.()
-
-    if (typeof resolver !== "function") return undefined
-
-    try {
-      return await resolver(this)
-    } catch (error) {
-      this.logger.error(() => ["Websocket session identity resolver failed at pause", error])
-      return undefined
+    /**
+     * Runs send goodbye.
+     * @param {import("./index.js").default} client - Client instance.
+     * @returns {void} - No return value.
+     */
+    sendGoodbye(client) {
+        const frame = Buffer.from([WEBSOCKET_FINAL_FRAME | WEBSOCKET_OPCODE_CLOSE, 0x00]);
+        client.events.emit("output", frame);
     }
-  }
-
-  /**
-   * Fires `onDisconnect` on every live Connection and Channel sub so
-   * apps can pause per-instance work while the session is paused.
-   * Errors are logged, not rethrown — one broken handler must not
-   * block the rest.
-   * @returns {Promise<void>}
-   */
-  async _fireOnDisconnect() {
-    await this._fireLifecycleCallback("onDisconnect")
-  }
-
-  /**
-   * Fires `onResume` on every live Connection and Channel sub after
-   * a successful `session-resume` handoff.
-   * @returns {Promise<void>}
-   */
-  async _fireOnResume() {
-    await this._fireLifecycleCallback("onResume")
-  }
-
-  /**
-   * Runs fire lifecycle callback.
-   * @param {"onDisconnect" | "onResume"} callbackName Lifecycle callback to fire.
-   * @returns {Promise<void>} Resolves when every live handler has been attempted.
-   */
-  async _fireLifecycleCallback(callbackName) {
-    for (const connection of this._connections.values()) {
-      try {
-        await connection[callbackName]?.()
-      } catch (error) {
-        this.logger.error(() => [`${callbackName} failed for ${connection.connectionId}`, error])
-      }
+    /**
+     * Runs handle message.
+     * @param {WebsocketSessionMessage} message - Message text.
+     * @returns {Promise<void>} - Resolves when complete.
+     */
+    async _handleMessage(message) {
+        // Serialize per-session: chain onto `_messageChain` so messages
+        // are processed one at a time. Without this, fire-and-forget
+        // dispatch from `_processBuffer` lets message B read
+        // `session.data` before A has finished writing it.
+        const previous = this._messageChain;
+        const next = previous.then(() => this._dispatchMessage(message));
+        this._messageChain = next.catch(() => { });
+        await next;
     }
-
-    for (const {subscription} of this._channelSubscriptions.values()) {
-      try {
-        await subscription[callbackName]?.()
-      } catch (error) {
-        this.logger.error(() => [`${callbackName} failed for channel sub ${subscription.subscriptionId}`, error])
-      }
+    /**
+     * Runs dispatch message.
+     * @param {WebsocketSessionMessage} message - Message text.
+     * @returns {Promise<void>} - Resolves when complete.
+     */
+    async _dispatchMessage(message) {
+        const wrapper = this.configuration.getWebsocketAroundRequest?.();
+        if (wrapper) {
+            await wrapper(this, () => this._handleMessageInner(message));
+            return;
+        }
+        await this._handleMessageInner(message);
     }
-  }
-
-  /**
-   * Handles `{type: "session-resume"}`. This session (the newly-
-   * created one whose socket just connected) transfers state from
-   * the paused session and instructs the client via
-   * `session-resumed` or `session-gone`.
-   * @param {Record<string, ?>} message
-   * @returns {Promise<void>}
-   */
-  async _handleSessionResume(message) {
-    const resumeSessionId = message.sessionId
-
-    if (typeof resumeSessionId !== "string" || !resumeSessionId) {
-      this.sendJson({type: "session-gone"})
-      return
+    /**
+     * The actual message dispatch, extracted so
+     * `configuration.getWebsocketAroundRequest()` can wrap it in any
+     * per-request context (AsyncLocalStorage, tracing, etc.).
+     * @param {WebsocketSessionMessage} message
+     * @returns {Promise<void>}
+     */
+    async _handleMessageInner(message) {
+        if (this.pendingMessageHandler) {
+            this.messageQueue.push(message);
+            return;
+        }
+        // The messageHandler short-circuits default routing only when the
+        // app actually declared an `onMessage` hook. Apps that only want
+        // session-lifecycle tracking (`onOpen`/`onClose`) still need the
+        // built-in subscribe/connection/channel-subscribe routing below,
+        // otherwise every incoming message is silently dropped.
+        if (this.messageHandler && typeof this.messageHandler.onMessage === "function") {
+            await this._runMessageHandlerMessage(message);
+            return;
+        }
+        const subscribePayload = subscribeMessage(message);
+        if (subscribePayload) {
+            const { channel, lastEventId, params } = subscribePayload;
+            if (!channel)
+                throw new Error("channel is required for subscribe");
+            const resolver = this.configuration.getWebsocketChannelResolver?.();
+            if (resolver) {
+                await this._handleChannelSubscription({ channel, lastEventId, params });
+            }
+            else {
+                await this.subscribeToChannel(channel, { acknowledge: true, lastEventId, params });
+            }
+            return;
+        }
+        if (message.type === "metadata") {
+            const metadataPayload = /**
+                                     * Narrows the runtime value to the documented type.
+                                      @type {{data?: Record<string, ?>}} */ (message);
+            this._metadata = metadataPayload.data && typeof metadataPayload.data === "object" ? { ...metadataPayload.data } : {};
+            for (const { subscription } of this._channelSubscriptions.values()) {
+                if (typeof subscription.onMetadataChanged === "function") {
+                    await this._withConnections(async () => {
+                        await subscription.onMetadataChanged(this._metadata);
+                    });
+                }
+            }
+            return;
+        }
+        if (message.type === "session-resume") {
+            await this._handleSessionResume(message);
+            return;
+        }
+        if (message.type === "connection-open") {
+            await this._handleConnectionOpen(message);
+            return;
+        }
+        if (message.type === "connection-message") {
+            await this._handleConnectionMessage(message);
+            return;
+        }
+        if (message.type === "connection-close") {
+            await this._handleConnectionClose(message);
+            return;
+        }
+        if (message.type === "channel-subscribe") {
+            await this._handleChannelSubscribe(message);
+            return;
+        }
+        if (message.type === "channel-unsubscribe") {
+            await this._handleChannelUnsubscribe(message);
+            return;
+        }
+        if (message.type && message.type !== "request") {
+            this.sendJson({ error: `Unknown message type: ${message.type}`, type: "error" });
+            return;
+        }
+        const requestPayload = requestMessage(message);
+        if (!requestPayload) {
+            this.sendJson({ error: `Unknown message type: ${message.type}`, type: "error" });
+            return;
+        }
+        const { body, headers, id, method, path } = requestPayload;
+        if (!method)
+            throw new Error("method is required");
+        if (!path)
+            throw new Error("path is required");
+        const request = new WebsocketRequest({
+            body,
+            headers,
+            metadata: this.getMetadata(),
+            method,
+            path,
+            remoteAddress: this.remoteAddress()
+        });
+        const requestRunner = new RequestRunner({
+            configuration: this.configuration,
+            request
+        });
+        requestRunner.events.on("done", () => {
+            const response = requestRunner.response;
+            const body = response.getBody();
+            const headers = response.headers;
+            this.sendJson({
+                body,
+                headers,
+                id,
+                statusCode: response.getStatusCode(),
+                statusMessage: response.getStatusMessage(),
+                type: "response"
+            });
+            void requestRunner.logCompletedRequest().catch((error) => {
+                this.logger.warn("Failed to log completed request", error);
+            });
+        });
+        await requestRunner.run();
     }
-
-    const paused = this.configuration._findPausedWebsocketSession(resumeSessionId)
-
-    if (!paused) {
-      this.sendJson({type: "session-gone"})
-      return
+    /**
+     * Runs process buffer.
+     * @returns {void} - No return value.
+     */
+    _processBuffer() {
+        while (this.buffer.length >= 2) {
+            const firstByte = this.buffer[0];
+            const secondByte = this.buffer[1];
+            const isFinal = (firstByte & WEBSOCKET_FINAL_FRAME) === WEBSOCKET_FINAL_FRAME;
+            const opcode = firstByte & 0x0F;
+            const isMasked = (secondByte & 0x80) === 0x80;
+            let payloadLength = secondByte & 0x7F;
+            let offset = 2;
+            if (payloadLength === 126) {
+                if (this.buffer.length < offset + 2)
+                    return;
+                payloadLength = this.buffer.readUInt16BE(offset);
+                offset += 2;
+            }
+            else if (payloadLength === 127) {
+                if (this.buffer.length < offset + 8)
+                    return;
+                const bigLength = this.buffer.readBigUInt64BE(offset);
+                payloadLength = Number(bigLength);
+                offset += 8;
+            }
+            const maskLength = isMasked ? 4 : 0;
+            if (this.buffer.length < offset + maskLength + payloadLength)
+                return;
+            /** Payload. @type {Buffer} */
+            let payload = this.buffer.slice(offset + maskLength, offset + maskLength + payloadLength);
+            if (isMasked) {
+                const mask = this.buffer.slice(offset, offset + maskLength);
+                payload = this._unmaskPayload(payload, mask);
+            }
+            this.buffer = this.buffer.slice(offset + maskLength + payloadLength);
+            // Control frames (opcode >= 0x8) must not be fragmented per
+            // RFC 6455 and can arrive interleaved with a fragmented data
+            // message. Handle them first without touching the fragment
+            // accumulator.
+            if (opcode === WEBSOCKET_OPCODE_PING) {
+                this._sendControlFrame(WEBSOCKET_OPCODE_PONG, payload);
+                continue;
+            }
+            if (opcode === WEBSOCKET_OPCODE_CLOSE) {
+                this.sendGoodbye(this.client);
+                this._handleClose();
+                continue;
+            }
+            if (opcode >= 0x8) {
+                this.logger.warn(`Unsupported websocket control opcode: ${opcode}`);
+                continue;
+            }
+            // Data frame (TEXT/BINARY/CONTINUATION). Reassemble fragments
+            // before dispatching. Browsers (Chrome) legitimately fragment
+            // longer client→server text frames; a prior version dropped
+            // every fragmented message silently, so any payload large
+            // enough to hit the browser's fragmentation threshold
+            // (e.g. a channel-subscribe with an auth token) never reached
+            // the handler.
+            if (opcode === WEBSOCKET_OPCODE_CONTINUATION) {
+                if (this._fragmentedPayloads === null) {
+                    this.logger.warn("Received continuation frame with no fragmented message in progress");
+                    continue;
+                }
+                if (!this._appendFragment(payload))
+                    return;
+                if (!isFinal)
+                    continue;
+            }
+            else if (opcode === WEBSOCKET_OPCODE_TEXT || opcode === WEBSOCKET_OPCODE_BINARY) {
+                if (this._fragmentedPayloads !== null) {
+                    this.logger.warn("Received new data frame while a fragmented message was in progress; discarding prior fragments");
+                    this._resetFragmentBuffer();
+                }
+                if (!isFinal) {
+                    this._fragmentedPayloads = [payload];
+                    this._fragmentedOpcode = opcode;
+                    this._fragmentedBytes = payload.length;
+                    if (!this._enforceFragmentLimits())
+                        return;
+                    continue;
+                }
+            }
+            else {
+                this.logger.warn(`Unsupported websocket data opcode: ${opcode}`);
+                continue;
+            }
+            /**
+             * Defines finalPayload.
+              @type {Buffer} */
+            let finalPayload;
+            /**
+             * Defines finalOpcode.
+              @type {number} */
+            let finalOpcode;
+            if (this._fragmentedPayloads !== null) {
+                if (opcode === WEBSOCKET_OPCODE_CONTINUATION) {
+                    finalPayload = Buffer.concat(this._fragmentedPayloads);
+                    finalOpcode = this._fragmentedOpcode ?? WEBSOCKET_OPCODE_TEXT;
+                }
+                else {
+                    finalPayload = payload;
+                    finalOpcode = opcode;
+                }
+                this._resetFragmentBuffer();
+            }
+            else {
+                finalPayload = payload;
+                finalOpcode = opcode;
+            }
+            if (finalOpcode !== WEBSOCKET_OPCODE_TEXT) {
+                this.logger.warn(`Unsupported websocket data opcode after reassembly: ${finalOpcode}`);
+                continue;
+            }
+            try {
+                const message = JSON.parse(finalPayload.toString("utf-8"));
+                this._handleMessage(message).catch((error) => {
+                    this.logger.error(() => ["Websocket message handler failed", error]);
+                    this.sendJson({ error: error.message, type: "error" });
+                });
+            }
+            catch (error) {
+                this.logger.error(() => ["Failed to parse websocket message", error]);
+                this.sendJson({ error: "Invalid websocket message", type: "error" });
+            }
+        }
     }
-
-    // Auth re-verify: compare the fresh caller's identity against the
-    // one captured at pause. Mismatch means a different user (or a
-    // signed-out session) is trying to reclaim state that isn't
-    // theirs — destroy the paused session outright.
-    const resolver = this.configuration.getWebsocketSessionIdentityResolver?.()
-
-    if (typeof resolver === "function") {
-      const pausedIdentity = await paused._resumeIdentityPromise
-      let freshIdentity
-
-      try {
-        freshIdentity = await resolver(this)
-      } catch (error) {
-        this.logger.error(() => ["Websocket session identity resolver failed at resume", error])
-        freshIdentity = undefined
-      }
-
-      if (!identitiesMatch(pausedIdentity, freshIdentity)) {
-        this.configuration._clearPausedWebsocketSession(resumeSessionId)
-        paused._finalizeGraceExpiry()
-        this.sendJson({type: "session-gone"})
-        return
-      }
+    /**
+     * Appends a continuation-frame payload to the in-progress
+     * fragmented message. Returns true when the fragment was accepted
+     * and false when the per-message cap was hit and the socket has
+     * been closed.
+     * @param {Buffer} payload
+     * @returns {boolean}
+     */
+    _appendFragment(payload) {
+        // Guard pushing first so `_enforceFragmentLimits` sees the final
+        // state; on overflow the reset inside the enforcer drops the
+        // buffered fragments.
+        this._fragmentedPayloads?.push(payload);
+        this._fragmentedBytes += payload.length;
+        return this._enforceFragmentLimits();
     }
-
-    this.configuration._clearPausedWebsocketSession(resumeSessionId)
-
-    // Transfer resumable state onto this (live) session. The paused
-    // session shell is discarded after the transfer.
-    for (const [connectionId, connection] of paused._connections) {
-      connection.session = this
-      this._connections.set(connectionId, connection)
+    /**
+     * Verifies the fragmented message has not exceeded the byte or
+     * fragment-count caps. On overflow, clears the buffer, sends a
+     * close frame, and tears the session down. Returns true when the
+     * caller can continue processing, false when the session is being
+     * closed.
+     * @returns {boolean}
+     */
+    _enforceFragmentLimits() {
+        if (this._fragmentedPayloads === null)
+            return true;
+        const fragmentCount = this._fragmentedPayloads.length;
+        const overBytes = this._fragmentedBytes > WEBSOCKET_MAX_FRAGMENTED_MESSAGE_BYTES;
+        const overFragments = fragmentCount > WEBSOCKET_MAX_FRAGMENTED_MESSAGE_FRAGMENTS;
+        if (!overBytes && !overFragments)
+            return true;
+        this.logger.warn(() => [
+            "Fragmented websocket message exceeded caps; closing connection",
+            {
+                fragmentBytes: this._fragmentedBytes,
+                fragmentCount,
+                maxBytes: WEBSOCKET_MAX_FRAGMENTED_MESSAGE_BYTES,
+                maxFragments: WEBSOCKET_MAX_FRAGMENTED_MESSAGE_FRAGMENTS
+            }
+        ]);
+        this._resetFragmentBuffer();
+        this.buffer = Buffer.alloc(0);
+        this.sendGoodbye(this.client);
+        this._handleClose();
+        return false;
     }
-
-    for (const [subId, entry] of paused._channelSubscriptions) {
-      entry.subscription.session = this
-      this._channelSubscriptions.set(subId, entry)
+    /**
+     * Runs reset fragment buffer.
+      @returns {void} */
+    _resetFragmentBuffer() {
+        this._fragmentedPayloads = null;
+        this._fragmentedOpcode = null;
+        this._fragmentedBytes = 0;
     }
-
-    this._metadata = {...paused._metadata}
-    this.data = paused.data
-    this.sessionId = resumeSessionId
-
-    // Transfer any frames queued while the paused session had no
-    // socket. They flush AFTER session-resumed so the client knows
-    // which session they belong to.
-    const queued = paused._outboundQueue || []
-
-    paused._outboundQueue = []
-    paused._connections.clear()
-    paused._channelSubscriptions.clear()
-    paused._paused = false
-    paused.destroy()
-
-    this.sendJson({type: "session-resumed", sessionId: resumeSessionId})
-    for (const body of queued) this.sendJson(body)
-    await this._fireOnResume()
-  }
-
-  /**
-   * Fires `onClose(reason)` on every live app-defined connection, then
-   * drops them from the registry. No network frame is sent — the
-   * socket is already going away.
-   * @param {"session_destroyed" | "grace_expired" | "error"} reason
-   * @returns {Promise<void>}
-   */
-  async _teardownConnections(reason) {
-    const connections = [...this._connections.values()]
-
-    this._connections.clear()
-
-    for (const connection of connections) {
-      connection._closed = true
-
-      try {
-        await this._withConnections(async () => {
-          await connection.onClose(reason)
-        })
-      } catch (error) {
-        this.logger.error(() => [`Failed to tear down connection ${connection.connectionId}`, error])
-      }
+    /**
+     * Runs send control frame.
+     * @param {number} opcode - Opcode.
+     * @param {Buffer} payload - Payload data.
+     * @returns {void} - No return value.
+     */
+    _sendControlFrame(opcode, payload) {
+        const header = Buffer.alloc(2);
+        header[0] = WEBSOCKET_FINAL_FRAME | opcode;
+        header[1] = payload.length;
+        this.client.events.emit("output", Buffer.concat([header, payload]));
     }
-  }
-
-  /**
-   * Handles a `{type: "connection-open"}` message — instantiates the
-   * registered connection class, stores it on `_connections`, and
-   * fires `onConnect()`. Sends `connection-opened` on success or
-   * `connection-error` on failure.
-   * @param {Record<string, ?>} message
-   * @returns {Promise<void>}
-   */
-  async _handleConnectionOpen(message) {
-    const connectionId = message.connectionId
-    const connectionType = message.connectionType
-    const params = message.params || {}
-
-    if (typeof connectionId !== "string" || !connectionId) {
-      this.sendJson({type: "error", error: "connection-open requires connectionId"})
-      return
+    /**
+     * Runs send json.
+     * @param {object} body - Request body.
+     * @returns {void} - No return value.
+     */
+    sendJson(body) {
+        // While paused (waiting for a resume), stash frames in an
+        // outbound queue and flush them in order on resume. Capped to
+        // prevent runaway memory use while the client is offline.
+        if (this._paused) {
+            this._outboundQueue ||= [];
+            if (this._outboundQueue.length >= WEBSOCKET_PAUSED_QUEUE_CAP) {
+                // Drop oldest so the most recent activity wins on resume.
+                this._outboundQueue.shift();
+            }
+            this._outboundQueue.push(body);
+            return;
+        }
+        if (!this.client?.events)
+            return;
+        const json = JSON.stringify(body);
+        const payload = Buffer.from(json, "utf-8");
+        let header;
+        if (payload.length < 126) {
+            header = Buffer.alloc(2);
+            header[1] = payload.length;
+        }
+        else if (payload.length < 65536) {
+            header = Buffer.alloc(4);
+            header[1] = 126;
+            header.writeUInt16BE(payload.length, 2);
+        }
+        else {
+            header = Buffer.alloc(10);
+            header[1] = 127;
+            header.writeBigUInt64BE(BigInt(payload.length), 2);
+        }
+        header[0] = WEBSOCKET_FINAL_FRAME | WEBSOCKET_OPCODE_TEXT;
+        this.client.events.emit("output", Buffer.concat([header, payload]));
     }
-
-    if (typeof connectionType !== "string" || !connectionType) {
-      this.sendJson({type: "connection-error", connectionId, message: "connectionType is required"})
-      return
+    /**
+     * Flushes the paused outbound queue over the current socket.
+     * Called during resume after `session-resumed` has been sent on
+     * the NEW session's socket (not this session's).
+     * @returns {void}
+     */
+    _flushOutboundQueue() {
+        const queue = this._outboundQueue || [];
+        this._outboundQueue = [];
+        for (const body of queue) {
+            this.sendJson(body);
+        }
     }
-
-    if (this._connections.has(connectionId)) {
-      this.sendJson({type: "connection-error", connectionId, message: "Connection id already in use"})
-      return
+    /**
+     * Runs subscribe to channel.
+     * @param {string} channel - Channel name.
+     * @param {{acknowledge?: boolean, channelHandler?: import("../websocket-channel.js").default, lastEventId?: string, params?: Record<string, ?>, subscriptionChannel?: string}} [options] - Subscribe options.
+     * @returns {Promise<boolean>} - Whether the subscription was added.
+     */
+    async subscribeToChannel(channel, { acknowledge = true, channelHandler, lastEventId, params, subscriptionChannel } = {}) {
+        await websocketEventLogStoreForConfiguration(this.configuration).markChannelInterested(channel);
+        const replayState = await this._prepareReplayState({
+            channel,
+            lastEventId,
+            subscriptionChannel: subscriptionChannel || channel,
+            subscriptionParams: params
+        });
+        if (replayState === false)
+            return false;
+        if (replayState) {
+            this.channelReplayStates.set(channel, replayState);
+        }
+        this.addSubscription(channel);
+        if (channelHandler) {
+            if (!this.subscriptionHandlers.has(channel)) {
+                this.subscriptionHandlers.set(channel, new Set());
+            }
+            this.subscriptionHandlers.get(channel)?.add(channelHandler);
+            if (!this.handlerSubscriptions.has(channelHandler)) {
+                this.handlerSubscriptions.set(channelHandler, new Set());
+            }
+            this.handlerSubscriptions.get(channelHandler)?.add(channel);
+        }
+        if (replayState) {
+            try {
+                await this._replayChannelEvents({ channel, replayState });
+            }
+            finally {
+                await this._finishReplayState(channel, replayState);
+            }
+        }
+        if (acknowledge) {
+            this.sendJson({ channel, type: "subscribed" });
+        }
+        return true;
+    }
+    _handleClose() {
+        // If the session has resumable state (live Connection or
+        // ChannelV2 subscription), move it into the paused registry
+        // instead of tearing down; a new socket presenting the sessionId
+        // via `session-resume` within the grace window will reattach.
+        const hasResumableState = this._connections.size > 0 || this._channelSubscriptions.size > 0;
+        if (hasResumableState && !this._paused) {
+            this._paused = true;
+            this.socket = null;
+            // Kick off auth-identity capture for resume verification. Runs
+            // in the background — `_handleSessionResume` awaits
+            // `_resumeIdentityPromise` before comparing. Pause registration
+            // is synchronous so a resume arriving immediately still finds
+            // the session.
+            this._resumeIdentityPromise = this._captureResumeIdentity();
+            void this._fireOnDisconnect();
+            this.configuration._pauseWebsocketSession(this);
+            this.events.emit("close");
+            return;
+        }
+        void this._runMessageHandlerClose();
+        void this._teardownChannel();
+        void this._teardownConnections("session_destroyed");
+        void this._teardownChannelSubscriptions();
+        this.events.emit("close");
     }
-
-    const ConnectionClass = this.configuration.getWebsocketConnectionClass?.(connectionType)
-
-    if (!ConnectionClass) {
-      this.sendJson({type: "connection-error", connectionId, message: `Unknown connection type: ${connectionType}`})
-      return
+    /**
+     * Called by the grace timer when the paused period expires without
+     * a resume. Tears down all live Connections + Channel subs and
+     * drops the session.
+     * @returns {void}
+     */
+    _finalizeGraceExpiry() {
+        void this._runMessageHandlerClose();
+        void this._teardownChannel();
+        void this._teardownConnections("grace_expired");
+        void this._teardownChannelSubscriptions();
+        this.events.emit("close");
     }
-
-    const connection = new ConnectionClass({connectionId, params, session: this})
-
-    try {
-      await this._withConnections(async () => {
-        await connection.onConnect()
-      })
-      // Register only after onConnect resolves so a connection-message
-      // can never be routed to a partially initialized connection.
-      this._connections.set(connectionId, connection)
-      this.sendJson({type: "connection-opened", connectionId})
-    } catch (error) {
-      this.logger.error(() => [`Failed to open connection ${connectionType}:${connectionId}`, error])
-      this.sendJson({type: "connection-error", connectionId, message: /**
-                                                                       * Narrows the runtime value to the documented type.
-                                                                        @type {Error} */ (error).message || "Failed to open connection"})
+    /**
+     * Runs the configured identity resolver against this session.
+     * The returned promise is stored at pause time and awaited at
+     * resume time so we can reject resume attempts from a different
+     * authenticated caller (signed out, swapped user, expired cookie).
+     * @returns {Promise<?>}
+     */
+    async _captureResumeIdentity() {
+        const resolver = this.configuration.getWebsocketSessionIdentityResolver?.();
+        if (typeof resolver !== "function")
+            return undefined;
+        try {
+            return await resolver(this);
+        }
+        catch (error) {
+            this.logger.error(() => ["Websocket session identity resolver failed at pause", error]);
+            return undefined;
+        }
     }
-  }
-
-  /**
-   * Handles a `{type: "connection-message"}` from the client.
-   * @param {Record<string, ?>} message
-   * @returns {Promise<void>}
-   */
-  async _handleConnectionMessage(message) {
-    const connectionId = message.connectionId
-    const connection = typeof connectionId === "string" ? this._connections.get(connectionId) : null
-
-    if (!connection) {
-      this.sendJson({type: "connection-error", connectionId, message: "Unknown connection id"})
-      return
+    /**
+     * Fires `onDisconnect` on every live Connection and Channel sub so
+     * apps can pause per-instance work while the session is paused.
+     * Errors are logged, not rethrown — one broken handler must not
+     * block the rest.
+     * @returns {Promise<void>}
+     */
+    async _fireOnDisconnect() {
+        await this._fireLifecycleCallback("onDisconnect");
     }
-
-    try {
-      await this._withConnections(async () => {
-        await connection.onMessage(message.body)
-      })
-    } catch (error) {
-      this.logger.error(() => [`Failed to handle connection-message for ${connectionId}`, error])
-      this.sendJson({type: "connection-error", connectionId, message: /**
-                                                                       * Narrows the runtime value to the documented type.
-                                                                        @type {Error} */ (error).message || "Failed to handle message"})
+    /**
+     * Fires `onResume` on every live Connection and Channel sub after
+     * a successful `session-resume` handoff.
+     * @returns {Promise<void>}
+     */
+    async _fireOnResume() {
+        await this._fireLifecycleCallback("onResume");
     }
-  }
-
-  /**
-   * Handles a `{type: "connection-close"}` from the client — fires
-   * `onClose("client_close")` and confirms with `connection-closed`.
-   * @param {Record<string, ?>} message
-   * @returns {Promise<void>}
-   */
-  async _handleConnectionClose(message) {
-    const connectionId = message.connectionId
-    const connection = typeof connectionId === "string" ? this._connections.get(connectionId) : null
-
-    if (!connection) return
-
-    this._connections.delete(connectionId)
-    // Mark closed before firing onClose so app code holding the
-    // handle sees `isClosed() === true` and can't re-enter sendMessage.
-    connection._closed = true
-
-    try {
-      await this._withConnections(async () => {
-        await connection.onClose("client_close")
-      })
-    } catch (error) {
-      this.logger.error(() => [`Failed to tear down connection ${connectionId}`, error])
+    /**
+     * Runs fire lifecycle callback.
+     * @param {"onDisconnect" | "onResume"} callbackName Lifecycle callback to fire.
+     * @returns {Promise<void>} Resolves when every live handler has been attempted.
+     */
+    async _fireLifecycleCallback(callbackName) {
+        for (const connection of this._connections.values()) {
+            try {
+                await connection[callbackName]?.();
+            }
+            catch (error) {
+                this.logger.error(() => [`${callbackName} failed for ${connection.connectionId}`, error]);
+            }
+        }
+        for (const { subscription } of this._channelSubscriptions.values()) {
+            try {
+                await subscription[callbackName]?.();
+            }
+            catch (error) {
+                this.logger.error(() => [`${callbackName} failed for channel sub ${subscription.subscriptionId}`, error]);
+            }
+        }
     }
-
-    this.sendJson({type: "connection-closed", connectionId, reason: "client_close"})
-  }
-
-  /**
-   * Handles `{type: "channel-subscribe"}` — runs `canSubscribe()`,
-   * registers with the Configuration's global routing registry on
-   * success, and sends `channel-subscribed` or `channel-error`.
-   * @param {Record<string, ?>} message
-   * @returns {Promise<void>}
-   */
-  async _handleChannelSubscribe(message) {
-    const subscriptionId = message.subscriptionId
-    const channelType = message.channelType
-    const params = message.params || {}
-    const lastEventId = message.lastEventId
-
-    if (typeof subscriptionId !== "string" || !subscriptionId) {
-      this.sendJson({type: "error", error: "channel-subscribe requires subscriptionId"})
-      return
+    /**
+     * Handles `{type: "session-resume"}`. This session (the newly-
+     * created one whose socket just connected) transfers state from
+     * the paused session and instructs the client via
+     * `session-resumed` or `session-gone`.
+     * @param {Record<string, ?>} message
+     * @returns {Promise<void>}
+     */
+    async _handleSessionResume(message) {
+        const resumeSessionId = message.sessionId;
+        if (typeof resumeSessionId !== "string" || !resumeSessionId) {
+            this.sendJson({ type: "session-gone" });
+            return;
+        }
+        const paused = this.configuration._findPausedWebsocketSession(resumeSessionId);
+        if (!paused) {
+            this.sendJson({ type: "session-gone" });
+            return;
+        }
+        // Auth re-verify: compare the fresh caller's identity against the
+        // one captured at pause. Mismatch means a different user (or a
+        // signed-out session) is trying to reclaim state that isn't
+        // theirs — destroy the paused session outright.
+        const resolver = this.configuration.getWebsocketSessionIdentityResolver?.();
+        if (typeof resolver === "function") {
+            const pausedIdentity = await paused._resumeIdentityPromise;
+            let freshIdentity;
+            try {
+                freshIdentity = await resolver(this);
+            }
+            catch (error) {
+                this.logger.error(() => ["Websocket session identity resolver failed at resume", error]);
+                freshIdentity = undefined;
+            }
+            if (!identitiesMatch(pausedIdentity, freshIdentity)) {
+                this.configuration._clearPausedWebsocketSession(resumeSessionId);
+                paused._finalizeGraceExpiry();
+                this.sendJson({ type: "session-gone" });
+                return;
+            }
+        }
+        this.configuration._clearPausedWebsocketSession(resumeSessionId);
+        // Transfer resumable state onto this (live) session. The paused
+        // session shell is discarded after the transfer.
+        for (const [connectionId, connection] of paused._connections) {
+            connection.session = this;
+            this._connections.set(connectionId, connection);
+        }
+        for (const [subId, entry] of paused._channelSubscriptions) {
+            entry.subscription.session = this;
+            this._channelSubscriptions.set(subId, entry);
+        }
+        this._metadata = { ...paused._metadata };
+        this.data = paused.data;
+        this.sessionId = resumeSessionId;
+        // Transfer any frames queued while the paused session had no
+        // socket. They flush AFTER session-resumed so the client knows
+        // which session they belong to.
+        const queued = paused._outboundQueue || [];
+        paused._outboundQueue = [];
+        paused._connections.clear();
+        paused._channelSubscriptions.clear();
+        paused._paused = false;
+        paused.destroy();
+        this.sendJson({ type: "session-resumed", sessionId: resumeSessionId });
+        for (const body of queued)
+            this.sendJson(body);
+        await this._fireOnResume();
     }
-
-    if (typeof channelType !== "string" || !channelType) {
-      this.sendJson({type: "channel-error", subscriptionId, message: "channelType is required"})
-      return
+    /**
+     * Fires `onClose(reason)` on every live app-defined connection, then
+     * drops them from the registry. No network frame is sent — the
+     * socket is already going away.
+     * @param {"session_destroyed" | "grace_expired" | "error"} reason
+     * @returns {Promise<void>}
+     */
+    async _teardownConnections(reason) {
+        const connections = [...this._connections.values()];
+        this._connections.clear();
+        for (const connection of connections) {
+            connection._closed = true;
+            try {
+                await this._withConnections(async () => {
+                    await connection.onClose(reason);
+                });
+            }
+            catch (error) {
+                this.logger.error(() => [`Failed to tear down connection ${connection.connectionId}`, error]);
+            }
+        }
     }
-
-    if (this._channelSubscriptions.has(subscriptionId)) {
-      this.sendJson({type: "channel-error", subscriptionId, message: "Subscription id already in use"})
-      return
+    /**
+     * Handles a `{type: "connection-open"}` message — instantiates the
+     * registered connection class, stores it on `_connections`, and
+     * fires `onConnect()`. Sends `connection-opened` on success or
+     * `connection-error` on failure.
+     * @param {Record<string, ?>} message
+     * @returns {Promise<void>}
+     */
+    async _handleConnectionOpen(message) {
+        const connectionId = message.connectionId;
+        const connectionType = message.connectionType;
+        const params = message.params || {};
+        if (typeof connectionId !== "string" || !connectionId) {
+            this.sendJson({ type: "error", error: "connection-open requires connectionId" });
+            return;
+        }
+        if (typeof connectionType !== "string" || !connectionType) {
+            this.sendJson({ type: "connection-error", connectionId, message: "connectionType is required" });
+            return;
+        }
+        if (this._connections.has(connectionId)) {
+            this.sendJson({ type: "connection-error", connectionId, message: "Connection id already in use" });
+            return;
+        }
+        const ConnectionClass = this.configuration.getWebsocketConnectionClass?.(connectionType);
+        if (!ConnectionClass) {
+            this.sendJson({ type: "connection-error", connectionId, message: `Unknown connection type: ${connectionType}` });
+            return;
+        }
+        const connection = new ConnectionClass({ connectionId, params, session: this });
+        try {
+            await this._withConnections(async () => {
+                await connection.onConnect();
+            });
+            // Register only after onConnect resolves so a connection-message
+            // can never be routed to a partially initialized connection.
+            this._connections.set(connectionId, connection);
+            this.sendJson({ type: "connection-opened", connectionId });
+        }
+        catch (error) {
+            this.logger.error(() => [`Failed to open connection ${connectionType}:${connectionId}`, error]);
+            this.sendJson({ type: "connection-error", connectionId, message: /**
+                                                                                 * Narrows the runtime value to the documented type.
+                                                                                  @type {Error} */ (error).message || "Failed to open connection" });
+        }
     }
-
-    const ChannelClass = this.configuration.getWebsocketChannelClass?.(channelType)
-
-    if (!ChannelClass) {
-      this.sendJson({type: "channel-error", subscriptionId, message: `Unknown channel type: ${channelType}`})
-      return
+    /**
+     * Handles a `{type: "connection-message"}` from the client.
+     * @param {Record<string, ?>} message
+     * @returns {Promise<void>}
+     */
+    async _handleConnectionMessage(message) {
+        const connectionId = message.connectionId;
+        const connection = typeof connectionId === "string" ? this._connections.get(connectionId) : null;
+        if (!connection) {
+            this.sendJson({ type: "connection-error", connectionId, message: "Unknown connection id" });
+            return;
+        }
+        try {
+            await this._withConnections(async () => {
+                await connection.onMessage(message.body);
+            });
+        }
+        catch (error) {
+            this.logger.error(() => [`Failed to handle connection-message for ${connectionId}`, error]);
+            this.sendJson({ type: "connection-error", connectionId, message: /**
+                                                                                 * Narrows the runtime value to the documented type.
+                                                                                  @type {Error} */ (error).message || "Failed to handle message" });
+        }
     }
-
-    const subscription = new ChannelClass({subscriptionId, params, session: this})
-
-    try {
-      // Resolving the tenant can run database queries (e.g. looking up the
-      // record's project and the caller's access), so it must happen inside a
-      // connection scope. Without this the resolver borrows a connection that
-      // is checked back in before/while it queries, intermittently surfacing as
-      // "Connection … doesn't exist any more" or a falsely unauthorized
-      // subscription.
-      let tenant
-      await this._withConnections(async () => {
-        tenant = await this._resolveTenant({channel: channelType, params})
-      })
-
-      await this.configuration.runWithTenant(tenant, async () => {
-        let allowed = false
-
-        await this._withConnections(async () => {
-          allowed = Boolean(await subscription.canSubscribe())
-        })
-
-        if (!allowed) {
-          this.sendJson({type: "channel-error", subscriptionId, message: "Subscription not authorized"})
-          return
-        }
-
-        this._channelSubscriptions.set(subscriptionId, {channelType, subscription})
-        this.configuration._registerWebsocketChannelSubscription(channelType, subscription)
-
-        await this._withConnections(async () => await subscription.subscribed())
-
-        // Replay missed events BEFORE sending channel-subscribed so
-        // the client knows: everything before the confirmation is
-        // replayed, everything after is live.
-        if (typeof lastEventId === "string" && lastEventId.length > 0) {
-          await this._replayChannelEventsForSubscription({channelType, lastEventId, subscription})
-        }
-
-        this.sendJson({type: "channel-subscribed", subscriptionId})
-      })
-    } catch (error) {
-      this._channelSubscriptions.delete(subscriptionId)
-      this.configuration._unregisterWebsocketChannelSubscription(channelType, subscription)
-      this.logger.error(() => [`Failed to subscribe channel ${channelType}:${subscriptionId}`, error])
-      this.sendJson({type: "channel-error", subscriptionId, message: /**
-                                                                      * Narrows the runtime value to the documented type.
-                                                                       @type {Error} */ (error).message || "Failed to subscribe"})
+    /**
+     * Handles a `{type: "connection-close"}` from the client — fires
+     * `onClose("client_close")` and confirms with `connection-closed`.
+     * @param {Record<string, ?>} message
+     * @returns {Promise<void>}
+     */
+    async _handleConnectionClose(message) {
+        const connectionId = message.connectionId;
+        const connection = typeof connectionId === "string" ? this._connections.get(connectionId) : null;
+        if (!connection)
+            return;
+        this._connections.delete(connectionId);
+        // Mark closed before firing onClose so app code holding the
+        // handle sees `isClosed() === true` and can't re-enter sendMessage.
+        connection._closed = true;
+        try {
+            await this._withConnections(async () => {
+                await connection.onClose("client_close");
+            });
+        }
+        catch (error) {
+            this.logger.error(() => [`Failed to tear down connection ${connectionId}`, error]);
+        }
+        this.sendJson({ type: "connection-closed", connectionId, reason: "client_close" });
     }
-  }
-
-  /**
-   * Replays missed events from the persistent event-log store for a
-   * channel subscription that provided `lastEventId`. Sends each
-   * missed event as a `channel-message` with `replayed: true`.
-   * @param {object} args - Options.
-   * @param {string} args.channelType - Channel type name (event-log key).
-   * @param {string} args.lastEventId - Client's last-seen event id.
-   * @param {import("../websocket-channel.js").default} args.subscription - Live subscription.
-   * @returns {Promise<void>}
-   */
-  async _replayChannelEventsForSubscription({channelType, lastEventId, subscription}) {
-    const store = websocketEventLogStoreForConfiguration(this.configuration)
-
-    await this.configuration.awaitPendingBroadcasts()
-
-    const checkpoint = await store.getEventById({channel: channelType, id: lastEventId})
-
-    if (!checkpoint) {
-      this.sendJson({
-        type: "channel-replay-gap",
-        subscriptionId: subscription.subscriptionId,
-        lastEventId
-      })
-      return
+    /**
+     * Handles `{type: "channel-subscribe"}` — runs `canSubscribe()`,
+     * registers with the Configuration's global routing registry on
+     * success, and sends `channel-subscribed` or `channel-error`.
+     * @param {Record<string, ?>} message
+     * @returns {Promise<void>}
+     */
+    async _handleChannelSubscribe(message) {
+        const subscriptionId = message.subscriptionId;
+        const channelType = message.channelType;
+        const params = message.params || {};
+        const lastEventId = message.lastEventId;
+        if (typeof subscriptionId !== "string" || !subscriptionId) {
+            this.sendJson({ type: "error", error: "channel-subscribe requires subscriptionId" });
+            return;
+        }
+        if (typeof channelType !== "string" || !channelType) {
+            this.sendJson({ type: "channel-error", subscriptionId, message: "channelType is required" });
+            return;
+        }
+        if (this._channelSubscriptions.has(subscriptionId)) {
+            this.sendJson({ type: "channel-error", subscriptionId, message: "Subscription id already in use" });
+            return;
+        }
+        const ChannelClass = this.configuration.getWebsocketChannelClass?.(channelType);
+        if (!ChannelClass) {
+            this.sendJson({ type: "channel-error", subscriptionId, message: `Unknown channel type: ${channelType}` });
+            return;
+        }
+        const subscription = new ChannelClass({ subscriptionId, params, session: this });
+        try {
+            // Resolving the tenant can run database queries (e.g. looking up the
+            // record's project and the caller's access), so it must happen inside a
+            // connection scope. Without this the resolver borrows a connection that
+            // is checked back in before/while it queries, intermittently surfacing as
+            // "Connection … doesn't exist any more" or a falsely unauthorized
+            // subscription.
+            let tenant;
+            await this._withConnections(async () => {
+                tenant = await this._resolveTenant({ channel: channelType, params });
+            });
+            await this.configuration.runWithTenant(tenant, async () => {
+                let allowed = false;
+                await this._withConnections(async () => {
+                    allowed = Boolean(await subscription.canSubscribe());
+                });
+                if (!allowed) {
+                    this.sendJson({ type: "channel-error", subscriptionId, message: "Subscription not authorized" });
+                    return;
+                }
+                this._channelSubscriptions.set(subscriptionId, { channelType, subscription });
+                this.configuration._registerWebsocketChannelSubscription(channelType, subscription);
+                await this._withConnections(async () => await subscription.subscribed());
+                // Replay missed events BEFORE sending channel-subscribed so
+                // the client knows: everything before the confirmation is
+                // replayed, everything after is live.
+                if (typeof lastEventId === "string" && lastEventId.length > 0) {
+                    await this._replayChannelEventsForSubscription({ channelType, lastEventId, subscription });
+                }
+                this.sendJson({ type: "channel-subscribed", subscriptionId });
+            });
+        }
+        catch (error) {
+            this._channelSubscriptions.delete(subscriptionId);
+            this.configuration._unregisterWebsocketChannelSubscription(channelType, subscription);
+            this.logger.error(() => [`Failed to subscribe channel ${channelType}:${subscriptionId}`, error]);
+            this.sendJson({ type: "channel-error", subscriptionId, message: /**
+                                                                                * Narrows the runtime value to the documented type.
+                                                                                 @type {Error} */ (error).message || "Failed to subscribe" });
+        }
     }
-
-    const ceiling = await store.latestSequence(channelType)
-
-    if (!ceiling || ceiling <= checkpoint.sequence) return
-
-    const events = await store.getEventsAfter({
-      channel: channelType,
-      sequence: checkpoint.sequence,
-      upToSequence: ceiling
-    })
-
-    for (const event of events) {
-      if (subscription.isClosed()) break
-
-      subscription.sendMessage(/**
-                                * Narrows the runtime value to the documented type.
-                                 @type {import("../websocket-channel.js").WebsocketJsonValue} */ (event.payload))
+    /**
+     * Replays missed events from the persistent event-log store for a
+     * channel subscription that provided `lastEventId`. Sends each
+     * missed event as a `channel-message` with `replayed: true`.
+     * @param {object} args - Options.
+     * @param {string} args.channelType - Channel type name (event-log key).
+     * @param {string} args.lastEventId - Client's last-seen event id.
+     * @param {import("../websocket-channel.js").default} args.subscription - Live subscription.
+     * @returns {Promise<void>}
+     */
+    async _replayChannelEventsForSubscription({ channelType, lastEventId, subscription }) {
+        const store = websocketEventLogStoreForConfiguration(this.configuration);
+        await this.configuration.awaitPendingBroadcasts();
+        const checkpoint = await store.getEventById({ channel: channelType, id: lastEventId });
+        if (!checkpoint) {
+            this.sendJson({
+                type: "channel-replay-gap",
+                subscriptionId: subscription.subscriptionId,
+                lastEventId
+            });
+            return;
+        }
+        const ceiling = await store.latestSequence(channelType);
+        if (!ceiling || ceiling <= checkpoint.sequence)
+            return;
+        const events = await store.getEventsAfter({
+            channel: channelType,
+            sequence: checkpoint.sequence,
+            upToSequence: ceiling
+        });
+        for (const event of events) {
+            if (subscription.isClosed())
+                break;
+            subscription.sendMessage(/**
+                                      * Narrows the runtime value to the documented type.
+                                       @type {import("../websocket-channel.js").WebsocketJsonValue} */ (event.payload));
+        }
     }
-  }
-
-  /**
-   * Handles `{type: "channel-unsubscribe"}` from the client — calls
-   * `unsubscribed()` and sends `channel-unsubscribed`.
-   * @param {Record<string, ?>} message
-   * @returns {Promise<void>}
-   */
-  async _handleChannelUnsubscribe(message) {
-    const subscriptionId = message.subscriptionId
-
-    if (typeof subscriptionId !== "string") return
-
-    const entry = this._channelSubscriptions.get(subscriptionId)
-
-    if (!entry) return
-
-    this._channelSubscriptions.delete(subscriptionId)
-    this.configuration._unregisterWebsocketChannelSubscription(entry.channelType, entry.subscription)
-    entry.subscription._closed = true
-
-    try {
-      await this._withConnections(async () => await entry.subscription.unsubscribed())
-    } catch (error) {
-      this.logger.error(() => [`Failed to unsubscribe channel ${entry.channelType}:${subscriptionId}`, error])
+    /**
+     * Handles `{type: "channel-unsubscribe"}` from the client — calls
+     * `unsubscribed()` and sends `channel-unsubscribed`.
+     * @param {Record<string, ?>} message
+     * @returns {Promise<void>}
+     */
+    async _handleChannelUnsubscribe(message) {
+        const subscriptionId = message.subscriptionId;
+        if (typeof subscriptionId !== "string")
+            return;
+        const entry = this._channelSubscriptions.get(subscriptionId);
+        if (!entry)
+            return;
+        this._channelSubscriptions.delete(subscriptionId);
+        this.configuration._unregisterWebsocketChannelSubscription(entry.channelType, entry.subscription);
+        entry.subscription._closed = true;
+        try {
+            await this._withConnections(async () => await entry.subscription.unsubscribed());
+        }
+        catch (error) {
+            this.logger.error(() => [`Failed to unsubscribe channel ${entry.channelType}:${subscriptionId}`, error]);
+        }
+        this.sendJson({ type: "channel-unsubscribed", subscriptionId });
     }
-
-    this.sendJson({type: "channel-unsubscribed", subscriptionId})
-  }
-
-  /**
-   * Fires `unsubscribed()` on every live channel-v2 subscription,
-   * removes them from the Configuration's global registry, and
-   * drops the session's own map. No network frames — the socket
-   * is already going away.
-   * @returns {Promise<void>}
-   */
-  async _teardownChannelSubscriptions() {
-    const entries = [...this._channelSubscriptions.values()]
-
-    this._channelSubscriptions.clear()
-
-    for (const {channelType, subscription} of entries) {
-      this.configuration._unregisterWebsocketChannelSubscription(channelType, subscription)
-      subscription._closed = true
-
-      try {
-        await this._withConnections(async () => await subscription.unsubscribed())
-      } catch (error) {
-        this.logger.error(() => [`Failed to tear down channel-v2 ${channelType}:${subscription.subscriptionId}`, error])
-      }
+    /**
+     * Fires `unsubscribed()` on every live channel-v2 subscription,
+     * removes them from the Configuration's global registry, and
+     * drops the session's own map. No network frames — the socket
+     * is already going away.
+     * @returns {Promise<void>}
+     */
+    async _teardownChannelSubscriptions() {
+        const entries = [...this._channelSubscriptions.values()];
+        this._channelSubscriptions.clear();
+        for (const { channelType, subscription } of entries) {
+            this.configuration._unregisterWebsocketChannelSubscription(channelType, subscription);
+            subscription._closed = true;
+            try {
+                await this._withConnections(async () => await subscription.unsubscribed());
+            }
+            catch (error) {
+                this.logger.error(() => [`Failed to tear down channel-v2 ${channelType}:${subscription.subscriptionId}`, error]);
+            }
+        }
     }
-  }
-
-  async _teardownChannel() {
-    for (const channel of this.channels) {
-      await this._teardownSingleChannel(channel)
+    async _teardownChannel() {
+        for (const channel of this.channels) {
+            await this._teardownSingleChannel(channel);
+        }
+        this.channels.clear();
+        this.channelReplayStates.clear();
     }
-    this.channels.clear()
-    this.channelReplayStates.clear()
-  }
-
-  /**
-   * Runs teardown single channel.
-   * @param {WebsocketChannel} channel - Channel instance.
-   * @returns {Promise<void>} - Resolves when complete.
-   */
-  async _teardownSingleChannel(channel) {
-    try {
-      const tenant = this.channelTenants.get(channel)
-
-      await this.configuration.runWithTenant(tenant, async () => {
-        await this._withConnections(async () => {
-          await channel?.unsubscribed?.()
-        })
-      })
-    } catch (error) {
-      this.logger.error(() => ["Failed to teardown websocket channel", error])
+    /**
+     * Runs teardown single channel.
+     * @param {WebsocketChannel} channel - Channel instance.
+     * @returns {Promise<void>} - Resolves when complete.
+     */
+    async _teardownSingleChannel(channel) {
+        try {
+            const tenant = this.channelTenants.get(channel);
+            await this.configuration.runWithTenant(tenant, async () => {
+                await this._withConnections(async () => {
+                    await channel?.unsubscribed?.();
+                });
+            });
+        }
+        catch (error) {
+            this.logger.error(() => ["Failed to teardown websocket channel", error]);
+        }
+        const subscriptions = this.handlerSubscriptions.get(channel);
+        if (subscriptions) {
+            for (const subscriptionChannel of subscriptions) {
+                this.subscriptionHandlers.get(subscriptionChannel)?.delete(channel);
+                if (this.subscriptionHandlers.get(subscriptionChannel)?.size === 0) {
+                    this.subscriptionHandlers.delete(subscriptionChannel);
+                }
+            }
+            this.handlerSubscriptions.delete(channel);
+        }
+        this.channelTenants.delete(channel);
     }
-
-    const subscriptions = this.handlerSubscriptions.get(channel)
-
-    if (subscriptions) {
-      for (const subscriptionChannel of subscriptions) {
-        this.subscriptionHandlers.get(subscriptionChannel)?.delete(channel)
-
-        if (this.subscriptionHandlers.get(subscriptionChannel)?.size === 0) {
-          this.subscriptionHandlers.delete(subscriptionChannel)
-        }
-      }
-
-      this.handlerSubscriptions.delete(channel)
+    /**
+     * Runs register channel.
+     * @param {WebsocketChannel | undefined} channel - Channel instance.
+     * @param {string | null | undefined} tenant - Tenant key.
+     * @returns {Promise<void>} - Resolves when complete.
+     */
+    async _registerChannel(channel, tenant) {
+        if (!channel)
+            return;
+        this.channels.add(channel);
+        this.channelTenants.set(channel, tenant);
+        await this.configuration.runWithTenant(tenant, async () => {
+            await this._withConnections(async () => {
+                await channel?.subscribed?.();
+            });
+        });
     }
-
-    this.channelTenants.delete(channel)
-  }
-
-  /**
-   * Runs register channel.
-   * @param {WebsocketChannel | undefined} channel - Channel instance.
-   * @param {string | null | undefined} tenant - Tenant key.
-   * @returns {Promise<void>} - Resolves when complete.
-   */
-  async _registerChannel(channel, tenant) {
-    if (!channel) return
-
-    this.channels.add(channel)
-    this.channelTenants.set(channel, tenant)
-    await this.configuration.runWithTenant(tenant, async () => {
-      await this._withConnections(async () => {
-        await channel?.subscribed?.()
-      })
-    })
-  }
-
-  /**
-   * Runs with connections.
-   * @param {() => Promise<void>} callback - Callback.
-   * @returns {Promise<void>} - Resolves when complete.
-   */
-  async _withConnections(callback) {
-    await this.configuration.ensureConnections({name: "Websocket session"}, async () => {
-      await callback()
-    })
-  }
-
-  /**
-   * Runs handle channel subscription.
-   * @param {{channel: string, lastEventId?: string, params?: Record<string, ?>}} args - Subscription args.
-   * @returns {Promise<void>} - Resolves when complete.
-   */
-  async _handleChannelSubscription({channel, lastEventId, params}) {
-    const resolver = this.configuration.getWebsocketChannelResolver?.()
-
-    if (!resolver) return
-
-    try {
-      // Tenant resolution can run database queries, so it must happen inside a
-      // connection scope (see _handleChannelSubscribe).
-      let tenant
-      await this._withConnections(async () => {
-        tenant = await this._resolveTenant({channel, params})
-      })
-      const resolved = await this.configuration.runWithTenant(tenant, async () => {
-        return await resolver({
-          client: this.client,
-          configuration: this.configuration,
-          request: this.upgradeRequest,
-          subscription: {channel, params},
-          websocketSession: this
-        })
-      })
-
-      if (!resolved) {
-        this.sendJson({channel, error: "Subscription rejected", type: "error"})
-        return
-      }
-
-      const channelInstance = typeof resolved === "function"
-        ? new resolved({
-          client: this.client,
-          configuration: this.configuration,
-          lastEventId,
-          request: this.upgradeRequest,
-          subscriptionChannel: channel,
-          subscriptionParams: params,
-          websocketSession: this
-        })
-        : resolved
-
-      if (channelInstance && !(channelInstance instanceof WebsocketChannel)) {
-        throw new Error("Resolved websocket channel must extend WebsocketChannel")
-      }
-
-      await this._registerChannel(channelInstance, tenant)
-    } catch (error) {
-      this.logger.warn(() => ["Websocket channel subscription failed", error])
-      this.sendJson({channel, error: "Subscription rejected", type: "error"})
+    /**
+     * Runs with connections.
+     * @param {() => Promise<void>} callback - Callback.
+     * @returns {Promise<void>} - Resolves when complete.
+     */
+    async _withConnections(callback) {
+        await this.configuration.ensureConnections({ name: "Websocket session" }, async () => {
+            await callback();
+        });
     }
-  }
-
-  /**
-   * Runs prepare replay state.
-   * @param {object} args - Options.
-   * @param {string} args.channel - Internal channel name.
-   * @param {string | undefined} args.lastEventId - Last received event id.
-   * @param {string} args.subscriptionChannel - Client-facing channel name.
-   * @param {Record<string, ?> | undefined} args.subscriptionParams - Client-facing params.
-   * @returns {Promise<false | {buffered: boolean, ceilingSequence: number, checkpointSequence: number, replaying: boolean} | null>} - Replay state.
-   */
-  async _prepareReplayState({channel, lastEventId, subscriptionChannel, subscriptionParams}) {
-    if (!lastEventId) return null
-
-    const store = websocketEventLogStoreForConfiguration(this.configuration)
-    const checkpoint = await store.getEventById({channel, id: lastEventId})
-
-    if (!checkpoint) {
-      this.sendJson({channel: subscriptionChannel, lastEventId, params: subscriptionParams, type: "replay-gap"})
-      return false
+    /**
+     * Runs handle channel subscription.
+     * @param {{channel: string, lastEventId?: string, params?: Record<string, ?>}} args - Subscription args.
+     * @returns {Promise<void>} - Resolves when complete.
+     */
+    async _handleChannelSubscription({ channel, lastEventId, params }) {
+        const resolver = this.configuration.getWebsocketChannelResolver?.();
+        if (!resolver)
+            return;
+        try {
+            // Tenant resolution can run database queries, so it must happen inside a
+            // connection scope (see _handleChannelSubscribe).
+            let tenant;
+            await this._withConnections(async () => {
+                tenant = await this._resolveTenant({ channel, params });
+            });
+            const resolved = await this.configuration.runWithTenant(tenant, async () => {
+                return await resolver({
+                    client: this.client,
+                    configuration: this.configuration,
+                    request: this.upgradeRequest,
+                    subscription: { channel, params },
+                    websocketSession: this
+                });
+            });
+            if (!resolved) {
+                this.sendJson({ channel, error: "Subscription rejected", type: "error" });
+                return;
+            }
+            const channelInstance = typeof resolved === "function"
+                ? new resolved({
+                    client: this.client,
+                    configuration: this.configuration,
+                    lastEventId,
+                    request: this.upgradeRequest,
+                    subscriptionChannel: channel,
+                    subscriptionParams: params,
+                    websocketSession: this
+                })
+                : resolved;
+            if (channelInstance && !(channelInstance instanceof WebsocketChannel)) {
+                throw new Error("Resolved websocket channel must extend WebsocketChannel");
+            }
+            await this._registerChannel(channelInstance, tenant);
+        }
+        catch (error) {
+            this.logger.warn(() => ["Websocket channel subscription failed", error]);
+            this.sendJson({ channel, error: "Subscription rejected", type: "error" });
+        }
     }
-
-    return {
-      buffered: false,
-      ceilingSequence: (await store.latestSequence(channel)) || checkpoint.sequence,
-      checkpointSequence: checkpoint.sequence,
-      replaying: true
+    /**
+     * Runs prepare replay state.
+     * @param {object} args - Options.
+     * @param {string} args.channel - Internal channel name.
+     * @param {string | undefined} args.lastEventId - Last received event id.
+     * @param {string} args.subscriptionChannel - Client-facing channel name.
+     * @param {Record<string, ?> | undefined} args.subscriptionParams - Client-facing params.
+     * @returns {Promise<false | {buffered: boolean, ceilingSequence: number, checkpointSequence: number, replaying: boolean} | null>} - Replay state.
+     */
+    async _prepareReplayState({ channel, lastEventId, subscriptionChannel, subscriptionParams }) {
+        if (!lastEventId)
+            return null;
+        const store = websocketEventLogStoreForConfiguration(this.configuration);
+        const checkpoint = await store.getEventById({ channel, id: lastEventId });
+        if (!checkpoint) {
+            this.sendJson({ channel: subscriptionChannel, lastEventId, params: subscriptionParams, type: "replay-gap" });
+            return false;
+        }
+        return {
+            buffered: false,
+            ceilingSequence: (await store.latestSequence(channel)) || checkpoint.sequence,
+            checkpointSequence: checkpoint.sequence,
+            replaying: true
+        };
     }
-  }
-
-  /**
-   * Runs replay channel events.
-   * @param {object} args - Options.
-   * @param {string} args.channel - Channel name.
-   * @param {{buffered: boolean, ceilingSequence: number, checkpointSequence: number, replaying: boolean}} args.replayState - Replay state.
-   * @returns {Promise<void>} - Resolves when replay completes.
-   */
-  async _replayChannelEvents({channel, replayState}) {
-    const store = websocketEventLogStoreForConfiguration(this.configuration)
-    const events = await store.getEventsAfter({
-      channel,
-      sequence: replayState.checkpointSequence,
-      upToSequence: replayState.ceilingSequence
-    })
-
-    for (const event of events) {
-      await this.sendEvent(channel, event.payload, {
-        createdAt: event.createdAt,
-        eventId: event.id,
-        replayed: true,
-        sequence: event.sequence
-      })
+    /**
+     * Runs replay channel events.
+     * @param {object} args - Options.
+     * @param {string} args.channel - Channel name.
+     * @param {{buffered: boolean, ceilingSequence: number, checkpointSequence: number, replaying: boolean}} args.replayState - Replay state.
+     * @returns {Promise<void>} - Resolves when replay completes.
+     */
+    async _replayChannelEvents({ channel, replayState }) {
+        const store = websocketEventLogStoreForConfiguration(this.configuration);
+        const events = await store.getEventsAfter({
+            channel,
+            sequence: replayState.checkpointSequence,
+            upToSequence: replayState.ceilingSequence
+        });
+        for (const event of events) {
+            await this.sendEvent(channel, event.payload, {
+                createdAt: event.createdAt,
+                eventId: event.id,
+                replayed: true,
+                sequence: event.sequence
+            });
+        }
     }
-  }
-
-  /**
-   * Runs finish replay state.
-   * @param {string} channel - Channel name.
-   * @param {{buffered: boolean, ceilingSequence: number, checkpointSequence: number, replaying: boolean}} replayState - Replay state.
-   * @returns {Promise<void>} - Resolves when buffered events are flushed.
-   */
-  async _finishReplayState(channel, replayState) {
-    const store = websocketEventLogStoreForConfiguration(this.configuration)
-
-    replayState.replaying = false
-    this.channelReplayStates.delete(channel)
-
-    if (!replayState.buffered) return
-
-    const liveEvents = await store.getEventsAfter({
-      channel,
-      sequence: replayState.ceilingSequence
-    })
-
-    for (const event of liveEvents) {
-      await this.sendEvent(channel, event.payload, {
-        createdAt: event.createdAt,
-        eventId: event.id,
-        sequence: event.sequence
-      })
+    /**
+     * Runs finish replay state.
+     * @param {string} channel - Channel name.
+     * @param {{buffered: boolean, ceilingSequence: number, checkpointSequence: number, replaying: boolean}} replayState - Replay state.
+     * @returns {Promise<void>} - Resolves when buffered events are flushed.
+     */
+    async _finishReplayState(channel, replayState) {
+        const store = websocketEventLogStoreForConfiguration(this.configuration);
+        replayState.replaying = false;
+        this.channelReplayStates.delete(channel);
+        if (!replayState.buffered)
+            return;
+        const liveEvents = await store.getEventsAfter({
+            channel,
+            sequence: replayState.ceilingSequence
+        });
+        for (const event of liveEvents) {
+            await this.sendEvent(channel, event.payload, {
+                createdAt: event.createdAt,
+                eventId: event.id,
+                sequence: event.sequence
+            });
+        }
     }
-  }
-
-  /**
-   * Runs resolve tenant.
-   * @param {{channel?: string, params?: Record<string, ?>}} args - Tenant resolution args.
-   * @returns {Promise<string | null | undefined>} - Resolved tenant.
-   */
-  async _resolveTenant({channel, params}) {
-    const requestParams = this.upgradeRequest?.params?.()
-    const mergedParams = {
-      ...(requestParams && typeof requestParams === "object" ? requestParams : {}),
-      ...(params && typeof params === "object" ? params : {})
+    /**
+     * Runs resolve tenant.
+     * @param {{channel?: string, params?: Record<string, ?>}} args - Tenant resolution args.
+     * @returns {Promise<string | null | undefined>} - Resolved tenant.
+     */
+    async _resolveTenant({ channel, params }) {
+        const requestParams = this.upgradeRequest?.params?.();
+        const mergedParams = {
+            ...(requestParams && typeof requestParams === "object" ? requestParams : {}),
+            ...(params && typeof params === "object" ? params : {})
+        };
+        return /** Narrows the runtime value to the documented type. @type {Promise<string | null | undefined>} */ (this.configuration.resolveTenant({
+            params: mergedParams,
+            request: this.upgradeRequest,
+            response: undefined,
+            subscription: channel ? { channel, params } : undefined
+        }));
     }
-
-    return /** Narrows the runtime value to the documented type. @type {Promise<string | null | undefined>} */ (this.configuration.resolveTenant({
-      params: mergedParams,
-      request: this.upgradeRequest,
-      response: undefined,
-      subscription: channel ? {channel, params} : undefined
-    }))
-  }
-
-  /**
-   * Runs unmask payload.
-   * @param {Buffer} payload - Payload data.
-   * @param {Buffer} mask - Mask.
-   * @returns {Buffer} - The unmask payload.
-   */
-  _unmaskPayload(payload, mask) {
     /**
-     * Result.
-      @type {Buffer} */
-    const result = Buffer.alloc(payload.length)
-
-    for (let i = 0; i < payload.length; i++) {
-      result[i] = payload[i] ^ mask[i % 4]
+     * Runs unmask payload.
+     * @param {Buffer} payload - Payload data.
+     * @param {Buffer} mask - Mask.
+     * @returns {Buffer} - The unmask payload.
+     */
+    _unmaskPayload(payload, mask) {
+        /**
+         * Result.
+          @type {Buffer} */
+        const result = Buffer.alloc(payload.length);
+        for (let i = 0; i < payload.length; i++) {
+            result[i] = payload[i] ^ mask[i % 4];
+        }
+        return result;
+    }
+    async _runMessageHandlerOpen() {
+        try {
+            const handler = this.messageHandler;
+            const onOpen = handler ? handler.onOpen : null;
+            if (onOpen) {
+                await onOpen({ session: this });
+            }
+        }
+        catch (error) {
+            this.logger.error(() => ["Websocket open handler failed", error]);
+        }
     }
-
-    return result
-  }
-
-  async _runMessageHandlerOpen() {
-    try {
-      const handler = this.messageHandler
-      const onOpen = handler ? handler.onOpen : null
-
-      if (onOpen) {
-        await onOpen({session: this})
-      }
-    } catch (error) {
-      this.logger.error(() => ["Websocket open handler failed", error])
+    /**
+     * Runs run message handler message.
+     * @param {WebsocketSessionMessage} message - Incoming websocket message.
+     * @returns {Promise<void>} - Resolves when complete.
+     */
+    async _runMessageHandlerMessage(message) {
+        try {
+            const handler = this.messageHandler;
+            const onMessage = handler ? handler.onMessage : null;
+            if (onMessage) {
+                await onMessage({ message, session: this });
+            }
+        }
+        catch (error) {
+            this.logger.error(() => ["Websocket message handler failed", error]);
+            const handler = this.messageHandler;
+            const onError = handler ? handler.onError : null;
+            if (onError) {
+                await onError({ error: error instanceof Error ? error : new Error(String(error)), session: this });
+            }
+        }
     }
-  }
-
-  /**
-   * Runs run message handler message.
-   * @param {WebsocketSessionMessage} message - Incoming websocket message.
-   * @returns {Promise<void>} - Resolves when complete.
-   */
-  async _runMessageHandlerMessage(message) {
-    try {
-      const handler = this.messageHandler
-      const onMessage = handler ? handler.onMessage : null
-
-      if (onMessage) {
-        await onMessage({message, session: this})
-      }
-    } catch (error) {
-      this.logger.error(() => ["Websocket message handler failed", error])
-      const handler = this.messageHandler
-      const onError = handler ? handler.onError : null
-
-      if (onError) {
-        await onError({error: error instanceof Error ? error : new Error(String(error)), session: this})
-      }
+    async _runMessageHandlerClose() {
+        try {
+            const handler = this.messageHandler;
+            const onClose = handler ? handler.onClose : null;
+            if (onClose) {
+                await onClose({ session: this });
+            }
+        }
+        catch (error) {
+            this.logger.error(() => ["Websocket close handler failed", error]);
+        }
     }
-  }
-
-  async _runMessageHandlerClose() {
-    try {
-      const handler = this.messageHandler
-      const onClose = handler ? handler.onClose : null
-
-      if (onClose) {
-        await onClose({session: this})
-      }
-    } catch (error) {
-      this.logger.error(() => ["Websocket close handler failed", error])
+    /**
+     * Runs remote address.
+     * @returns {string | undefined} - Remote address resolved from the websocket upgrade request.
+     */
+    remoteAddress() {
+        return this.upgradeRequest?.remoteAddress() || this.client.remoteAddress;
     }
-  }
-
-  /**
-   * Runs remote address.
-   * @returns {string | undefined} - Remote address resolved from the websocket upgrade request.
-   */
-  remoteAddress() {
-    return this.upgradeRequest?.remoteAddress() || this.client.remoteAddress
-  }
-
-  /**
-   * Runs set message handler.
-   * @param {import("../../configuration-types.js").WebsocketMessageHandler} handler - Handler instance.
-   * @returns {void}
-   */
-  setMessageHandler(handler) {
-    this.messageHandler = handler
-    void this._runMessageHandlerOpen()
-  }
-
-  async _resolveMessageHandlerPromise() {
-    if (!this.messageHandlerPromise) return
-
-    try {
-      const handler = await this.messageHandlerPromise
-
-      if (handler) {
-        this.pendingMessageHandler = false
-        this.messageHandlerPromise = undefined
-        // Install handler and drain onOpen before replaying queued
-        // messages. setMessageHandler() fires onOpen as fire-and-forget;
-        // awaiting _runMessageHandlerOpen() directly here closes the
-        // race where queued subscribe/connection-* frames would
-        // dispatch while an async onOpen is still setting up session
-        // state.
-        this.messageHandler = handler
-        await this._runMessageHandlerOpen()
-        await this._flushQueuedMessages({useHandler: typeof handler.onMessage === "function"})
-        return
-      }
-    } catch (error) {
-      this.logger.error(() => ["Websocket message handler resolver failed", error])
+    /**
+     * Runs set message handler.
+     * @param {import("../../configuration-types.js").WebsocketMessageHandler} handler - Handler instance.
+     * @returns {void}
+     */
+    setMessageHandler(handler) {
+        this.messageHandler = handler;
+        void this._runMessageHandlerOpen();
+    }
+    async _resolveMessageHandlerPromise() {
+        if (!this.messageHandlerPromise)
+            return;
+        try {
+            const handler = await this.messageHandlerPromise;
+            if (handler) {
+                this.pendingMessageHandler = false;
+                this.messageHandlerPromise = undefined;
+                // Install handler and drain onOpen before replaying queued
+                // messages. setMessageHandler() fires onOpen as fire-and-forget;
+                // awaiting _runMessageHandlerOpen() directly here closes the
+                // race where queued subscribe/connection-* frames would
+                // dispatch while an async onOpen is still setting up session
+                // state.
+                this.messageHandler = handler;
+                await this._runMessageHandlerOpen();
+                await this._flushQueuedMessages({ useHandler: typeof handler.onMessage === "function" });
+                return;
+            }
+        }
+        catch (error) {
+            this.logger.error(() => ["Websocket message handler resolver failed", error]);
+        }
+        this.pendingMessageHandler = false;
+        this.messageHandlerPromise = undefined;
+        await this._flushQueuedMessages({ useHandler: false });
     }
-
-    this.pendingMessageHandler = false
-    this.messageHandlerPromise = undefined
-    await this._flushQueuedMessages({useHandler: false})
-  }
-
-  /**
-   * Runs flush queued messages.
-   * @param {{useHandler: boolean}} args - Args.
-   * @returns {Promise<void>} - Resolves when complete.
-   */
-  async _flushQueuedMessages({useHandler}) {
-    if (this.messageQueue.length === 0) return
-
-    const queued = this.messageQueue.slice()
-    this.messageQueue = []
-
-    for (const message of queued) {
-      if (useHandler && this.messageHandler) {
-        await this._runMessageHandlerMessage(message)
-      } else {
-        await this._handleMessage(message)
-      }
+    /**
+     * Runs flush queued messages.
+     * @param {{useHandler: boolean}} args - Args.
+     * @returns {Promise<void>} - Resolves when complete.
+     */
+    async _flushQueuedMessages({ useHandler }) {
+        if (this.messageQueue.length === 0)
+            return;
+        const queued = this.messageQueue.slice();
+        this.messageQueue = [];
+        for (const message of queued) {
+            if (useHandler && this.messageHandler) {
+                await this._runMessageHandlerMessage(message);
+            }
+            else {
+                await this._handleMessage(message);
+            }
+        }
     }
-  }
 }
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"websocket-session.js","sourceRoot":"","sources":["../../../../src/http-server/client/websocket-session.js"],"names":[],"mappings":"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","sourcesContent":["// @ts-check\n\nimport {randomUUID} from \"node:crypto\"\n\nimport EventEmitter from \"../../utils/event-emitter.js\"\nimport Logger from \"../../logger.js\"\nimport RequestRunner from \"./request-runner.js\"\nimport WebsocketRequest from \"./websocket-request.js\"\nimport WebsocketChannel from \"../websocket-channel.js\"\nimport {websocketEventLogStoreForConfiguration} from \"../websocket-event-log-store.js\"\n\nconst WEBSOCKET_FINAL_FRAME = 0x80\nconst WEBSOCKET_OPCODE_CONTINUATION = 0x0\nconst WEBSOCKET_OPCODE_TEXT = 0x1\nconst WEBSOCKET_OPCODE_BINARY = 0x2\nconst WEBSOCKET_OPCODE_CLOSE = 0x8\nconst WEBSOCKET_OPCODE_PING = 0x9\nconst WEBSOCKET_OPCODE_PONG = 0xA\n\n/** Cap on the paused outbound queue; oldest frames drop on overflow. */\nconst WEBSOCKET_PAUSED_QUEUE_CAP = 1000\n\n/** Cap on total bytes buffered for a single fragmented message. */\nconst WEBSOCKET_MAX_FRAGMENTED_MESSAGE_BYTES = 16 * 1024 * 1024\n\n/** Cap on fragment count for a single fragmented message. */\nconst WEBSOCKET_MAX_FRAGMENTED_MESSAGE_FRAGMENTS = 1024\n\n/**\n * Defines this typedef.\n * @typedef {{type: \"subscribe\", channel: string, lastEventId?: string, params?: Record<string, ?>} | {type: \"metadata\", data?: Record<string, ?>} | {type?: \"request\", body?: ?, headers?: Record<string, ?>, id?: string | number | null, method: string, path: string} | Record<string, ?>} WebsocketSessionMessage\n */\n\n/**\n * Runs subscribe message.\n * @param {WebsocketSessionMessage} message - Raw websocket message.\n * @returns {{type: \"subscribe\", channel: string, lastEventId?: string, params?: Record<string, ?>} | null} - Subscribe message when matched.\n */\nfunction subscribeMessage(message) {\n  return message.type === \"subscribe\"\n    ? /**\n       * Narrows the runtime value to the documented type.\n        @type {{type: \"subscribe\", channel: string, lastEventId?: string, params?: Record<string, ?>}} */ (message)\n    : null\n}\n\n/**\n * Runs request message.\n * @param {WebsocketSessionMessage} message - Raw websocket message.\n * @returns {{type?: \"request\", body?: ?, headers?: Record<string, ?>, id?: string | number | null, method: string, path: string} | null} - Request message when matched.\n */\nfunction requestMessage(message) {\n  if (message.type && message.type !== \"request\") return null\n\n  return /** Narrows the runtime value to the documented type. @type {{type?: \"request\", body?: ?, headers?: Record<string, ?>, id?: string | number | null, method: string, path: string}} */ (message)\n}\n\n/**\n * Compares two identity values from `getWebsocketSessionIdentityResolver`.\n * Nullish values compare equal to each other but not to a real identity.\n * Plain objects are compared via JSON round-trip so apps can return a\n * `{userId, tenantId}`-style object without building their own equality.\n * @param {?} a - Paused-time identity.\n * @param {?} b - Resume-time identity.\n * @returns {boolean} - True when the two identities are considered the same caller.\n */\nfunction identitiesMatch(a, b) {\n  if (a === b) return true\n  if (a == null || b == null) return false\n  if (typeof a !== \"object\" || typeof b !== \"object\") return false\n\n  try {\n    return JSON.stringify(a) === JSON.stringify(b)\n  } catch {\n    return false\n  }\n}\n\nexport default class VelociousHttpServerClientWebsocketSession {\n  events = new EventEmitter()\n  subscriptions = new Set()\n  channels = new Set()\n  subscriptionHandlers = new Map()\n  handlerSubscriptions = new Map()\n  channelTenants = new Map()\n  channelReplayStates = new Map()\n  /**\n   * Message queue.\n    @type {WebsocketSessionMessage[]} */\n  messageQueue = []\n\n  /**\n   * Runs constructor.\n   * @param {object} args - Options object.\n   * @param {import(\"../../configuration.js\").default} args.configuration - Configuration instance.\n   * @param {import(\"./index.js\").default} args.client - Client instance.\n   * @param {import(\"./request.js\").default | import(\"./websocket-request.js\").default} [args.upgradeRequest] - Initial websocket upgrade request.\n   * @param {import(\"../../configuration-types.js\").WebsocketMessageHandler} [args.messageHandler] - Optional raw message handler.\n   * @param {Promise<import(\"../../configuration-types.js\").WebsocketMessageHandler | void>} [args.messageHandlerPromise] - Optional raw message handler promise.\n   */\n  constructor({client, configuration, upgradeRequest, messageHandler, messageHandlerPromise}) {\n    this.buffer = Buffer.alloc(0)\n    this.client = client\n    this.configuration = configuration\n    this.upgradeRequest = upgradeRequest\n    this.messageHandler = messageHandler\n    this.messageHandlerPromise = messageHandlerPromise\n    this.pendingMessageHandler = Boolean(messageHandlerPromise)\n    this.logger = new Logger(this)\n\n    /**\n     * Narrows the runtime value to the documented type.\n      @type {Record<string, ?>} */\n    this._metadata = {}\n\n    /**\n     * Long-lived per-session state bag. Stable across reconnects once\n     * grace-period resumption lands in Phase 2; today it just lives\n     * for the duration of the underlying socket.\n     * @type {Record<string, ?>}\n     */\n    this.data = {}\n\n    /**\n     * Narrows the runtime value to the documented type.\n      @type {Map<string, import(\"../websocket-connection.js\").default>} */\n    this._connections = new Map()\n\n    /**\n     * Narrows the runtime value to the documented type.\n      @type {Map<string, {channelType: string, subscription: import(\"../websocket-channel.js\").default}>} */\n    this._channelSubscriptions = new Map()\n\n    /**\n     * Unique id assigned to this session on first connect. Sent to the\n     * client via `session-established`; the client echoes it back via\n     * `session-resume` after a WS drop to reattach to this session\n     * within the grace period.\n     * @type {string}\n     */\n    this.sessionId = randomUUID()\n\n    /**\n     * Narrows the runtime value to the documented type.\n     * @type {boolean} - true after `_handleClose` pauses instead of tearing down.\n     */\n    this._paused = false\n\n    /**\n     * Narrows the runtime value to the documented type.\n     * @type {Array<?>} - frames produced while paused; flushed on resume.\n     */\n    this._outboundQueue = []\n\n    /**\n     * Narrows the runtime value to the documented type.\n      @type {import(\"./index.js\").default | null} */\n    this.socket = null\n\n    /**\n     * Tail of a per-session promise chain that serializes message\n     * handling. Prevents races where message B reads `session.data`\n     * before message A's handler finishes writing it (e.g. a\n     * connection-message setting the locale vs. a subsequent request\n     * whose aroundRequest wrapper reads it).\n     * @type {Promise<void>}\n     */\n    this._messageChain = Promise.resolve()\n\n    /**\n     * Promise that resolves to the auth identity captured at pause\n     * time by `getWebsocketSessionIdentityResolver`. Awaited at resume\n     * time to compare against the fresh caller's identity. Undefined\n     * on a live (non-paused) session.\n     * @type {Promise<?> | undefined}\n     */\n    this._resumeIdentityPromise = undefined\n\n    /**\n     * Accumulates payloads for a fragmented websocket message per\n     * RFC 6455. Non-null while mid-fragment; cleared when the frame\n     * with FIN=1 completes and the message is dispatched.\n     * @type {Buffer[] | null}\n     */\n    this._fragmentedPayloads = null\n\n    /**\n     * Opcode (TEXT/BINARY) captured from the first frame of a\n     * fragmented message. Continuation frames (opcode 0) inherit it\n     * at reassembly time.\n     * @type {number | null}\n     */\n    this._fragmentedOpcode = null\n\n    /**\n     * Running byte total for `_fragmentedPayloads`. Used to enforce\n     * `WEBSOCKET_MAX_FRAGMENTED_MESSAGE_BYTES` so a peer cannot\n     * exhaust memory by streaming non-final fragments indefinitely.\n     * @type {number}\n     */\n    this._fragmentedBytes = 0\n\n    this.configuration._websocketSessions.add(this)\n  }\n\n  /**\n   * Sends the client its sessionId + grace window. Called by\n   * `VelociousHttpServerClient` after the WS upgrade completes.\n   * @returns {void}\n   */\n  sendSessionEstablished() {\n    this.sendJson({\n      type: \"session-established\",\n      sessionId: this.sessionId,\n      graceSeconds: this.configuration.getWebsocketSessionGraceSeconds?.() || 300\n    })\n  }\n\n  /**\n   * Removes a closed connection from the session registry. Called by\n   * `VelociousWebsocketConnection.close()` after it sends the final\n   * `connection-closed` frame.\n   * @param {string} connectionId\n   * @returns {void}\n   */\n  _removeConnection(connectionId) {\n    this._connections.delete(connectionId)\n  }\n\n  /**\n   * Runs get metadata.\n   * @returns {Record<string, ?>} - Client-provided metadata (defensive copy).\n   */\n  getMetadata() {\n    return {...this._metadata}\n  }\n\n  /**\n   * Runs is paused.\n   * @returns {boolean} - true while the session is in the paused/grace registry.\n   */\n  isPaused() {\n    return this._paused\n  }\n\n  /**\n   * Runs add subscription.\n   * @param {string} channel - Channel name.\n   * @returns {void} - No return value.\n   */\n  addSubscription(channel) {\n    this.subscriptions.add(channel)\n  }\n\n  destroy() {\n    this.configuration._websocketSessions.delete(this)\n    this._paused = false\n    void this._teardownChannel()\n    void this._teardownConnections(\"session_destroyed\")\n    void this._teardownChannelSubscriptions()\n    this.events.removeAllListeners()\n  }\n\n  /**\n   * Runs has subscription.\n   * @param {string} channel - Channel name.\n   * @returns {boolean} - Whether it has subscription.\n   */\n  hasSubscription(channel) {\n    return this.subscriptions.has(channel)\n  }\n\n  /**\n   * Runs on data.\n   * @param {Buffer} data - Data payload.\n   * @returns {void} - No return value.\n   */\n  onData(data) {\n    this.buffer = Buffer.concat([this.buffer, data])\n    this._processBuffer()\n  }\n\n  /**\n   * Runs send event.\n   * @param {string} channel - Channel name.\n   * @param {?} payload - Payload data.\n   * @param {{createdAt?: string, eventId?: string, replayed?: boolean, sequence?: number}} [options] - Event metadata.\n   * @returns {Promise<void>} - Resolves when complete.\n   */\n  async sendEvent(channel, payload, options = {}) {\n    const channelHandlers = this.subscriptionHandlers.get(channel)\n    const hasChannelHandlers = Boolean(channelHandlers && channelHandlers.size > 0)\n    const replayState = this.channelReplayStates.get(channel)\n\n    if (replayState?.replaying && !options.replayed) {\n      replayState.buffered = true\n      return\n    }\n\n    if (!this.hasSubscription(channel) && !hasChannelHandlers) return\n\n    if (hasChannelHandlers) {\n      await Promise.all(Array.from(channelHandlers).map(async (handler) => {\n        const tenant = this.channelTenants.get(handler)\n\n        await this.configuration.runWithTenant(tenant, async () => {\n          await this._withConnections(async () => {\n            await handler.receivedBroadcast({\n              channel,\n              createdAt: options.createdAt,\n              eventId: options.eventId,\n              payload,\n              replayed: options.replayed,\n              sequence: options.sequence\n            })\n          })\n        })\n      }))\n      return\n    }\n\n    this.sendJson({\n      channel,\n      createdAt: options.createdAt,\n      eventId: options.eventId,\n      payload,\n      replayed: options.replayed,\n      sequence: options.sequence,\n      type: \"event\"\n    })\n  }\n\n  /**\n   * Runs initialize channel.\n   * @returns {Promise<void>} - Resolves when complete.\n   */\n  async initializeChannel() {\n    if (this.messageHandlerPromise) {\n      await this._resolveMessageHandlerPromise()\n\n      if (this.messageHandler) return\n    }\n\n    if (this.messageHandler) {\n      await this._runMessageHandlerOpen()\n      return\n    }\n\n    const resolver = this.configuration.getWebsocketChannelResolver?.()\n\n    if (!resolver) return\n\n    try {\n      const tenant = await this._resolveTenant({})\n      const resolved = await this.configuration.runWithTenant(tenant, async () => {\n        return await resolver({\n          client: this.client,\n          configuration: this.configuration,\n          request: this.upgradeRequest,\n          websocketSession: this\n        })\n      })\n\n      if (!resolved) return\n\n      const channel = typeof resolved === \"function\"\n        ? new resolved({client: this.client, configuration: this.configuration, request: this.upgradeRequest, websocketSession: this})\n        : resolved\n\n      if (channel && !(channel instanceof WebsocketChannel)) {\n        throw new Error(\"Resolved websocket channel must extend WebsocketChannel\")\n      }\n\n      await this._registerChannel(channel, tenant)\n    } catch (error) {\n      this.logger.error(() => [\"Failed to initialize websocket channel\", error])\n    }\n  }\n\n  /**\n   * Runs send goodbye.\n   * @param {import(\"./index.js\").default} client - Client instance.\n   * @returns {void} - No return value.\n   */\n  sendGoodbye(client) {\n    const frame = Buffer.from([WEBSOCKET_FINAL_FRAME | WEBSOCKET_OPCODE_CLOSE, 0x00])\n\n    client.events.emit(\"output\", frame)\n  }\n\n  /**\n   * Runs handle message.\n   * @param {WebsocketSessionMessage} message - Message text.\n   * @returns {Promise<void>} - Resolves when complete.\n   */\n  async _handleMessage(message) {\n    // Serialize per-session: chain onto `_messageChain` so messages\n    // are processed one at a time. Without this, fire-and-forget\n    // dispatch from `_processBuffer` lets message B read\n    // `session.data` before A has finished writing it.\n    const previous = this._messageChain\n    const next = previous.then(() => this._dispatchMessage(message))\n\n    this._messageChain = next.catch(() => {})\n    await next\n  }\n\n  /**\n   * Runs dispatch message.\n   * @param {WebsocketSessionMessage} message - Message text.\n   * @returns {Promise<void>} - Resolves when complete.\n   */\n  async _dispatchMessage(message) {\n    const wrapper = this.configuration.getWebsocketAroundRequest?.()\n\n    if (wrapper) {\n      await wrapper(this, () => this._handleMessageInner(message))\n      return\n    }\n\n    await this._handleMessageInner(message)\n  }\n\n  /**\n   * The actual message dispatch, extracted so\n   * `configuration.getWebsocketAroundRequest()` can wrap it in any\n   * per-request context (AsyncLocalStorage, tracing, etc.).\n   * @param {WebsocketSessionMessage} message\n   * @returns {Promise<void>}\n   */\n  async _handleMessageInner(message) {\n    if (this.pendingMessageHandler) {\n      this.messageQueue.push(message)\n      return\n    }\n\n    // The messageHandler short-circuits default routing only when the\n    // app actually declared an `onMessage` hook. Apps that only want\n    // session-lifecycle tracking (`onOpen`/`onClose`) still need the\n    // built-in subscribe/connection/channel-subscribe routing below,\n    // otherwise every incoming message is silently dropped.\n    if (this.messageHandler && typeof this.messageHandler.onMessage === \"function\") {\n      await this._runMessageHandlerMessage(message)\n      return\n    }\n\n    const subscribePayload = subscribeMessage(message)\n\n    if (subscribePayload) {\n      const {channel, lastEventId, params} = subscribePayload\n\n      if (!channel) throw new Error(\"channel is required for subscribe\")\n      const resolver = this.configuration.getWebsocketChannelResolver?.()\n\n      if (resolver) {\n        await this._handleChannelSubscription({channel, lastEventId, params})\n      } else {\n        await this.subscribeToChannel(channel, {acknowledge: true, lastEventId, params})\n      }\n\n      return\n    }\n\n    if (message.type === \"metadata\") {\n      const metadataPayload = /**\n                               * Narrows the runtime value to the documented type.\n                                @type {{data?: Record<string, ?>}} */ (message)\n\n      this._metadata = metadataPayload.data && typeof metadataPayload.data === \"object\" ? {...metadataPayload.data} : {}\n\n      for (const {subscription} of this._channelSubscriptions.values()) {\n        if (typeof subscription.onMetadataChanged === \"function\") {\n          await this._withConnections(async () => {\n            await subscription.onMetadataChanged(this._metadata)\n          })\n        }\n      }\n\n      return\n    }\n\n    if (message.type === \"session-resume\") {\n      await this._handleSessionResume(message)\n      return\n    }\n\n    if (message.type === \"connection-open\") {\n      await this._handleConnectionOpen(message)\n      return\n    }\n\n    if (message.type === \"connection-message\") {\n      await this._handleConnectionMessage(message)\n      return\n    }\n\n    if (message.type === \"connection-close\") {\n      await this._handleConnectionClose(message)\n      return\n    }\n\n    if (message.type === \"channel-subscribe\") {\n      await this._handleChannelSubscribe(message)\n      return\n    }\n\n    if (message.type === \"channel-unsubscribe\") {\n      await this._handleChannelUnsubscribe(message)\n      return\n    }\n\n    if (message.type && message.type !== \"request\") {\n      this.sendJson({error: `Unknown message type: ${message.type}`, type: \"error\"})\n      return\n    }\n\n    const requestPayload = requestMessage(message)\n\n    if (!requestPayload) {\n      this.sendJson({error: `Unknown message type: ${message.type}`, type: \"error\"})\n      return\n    }\n\n    const {body, headers, id, method, path} = requestPayload\n\n    if (!method) throw new Error(\"method is required\")\n    if (!path) throw new Error(\"path is required\")\n\n    const request = new WebsocketRequest({\n      body,\n      headers,\n      metadata: this.getMetadata(),\n      method,\n      path,\n      remoteAddress: this.remoteAddress()\n    })\n    const requestRunner = new RequestRunner({\n      configuration: this.configuration,\n      request\n    })\n\n    requestRunner.events.on(\"done\", () => {\n      const response = requestRunner.response\n      const body = response.getBody()\n      const headers = response.headers\n\n      this.sendJson({\n        body,\n        headers,\n        id,\n        statusCode: response.getStatusCode(),\n        statusMessage: response.getStatusMessage(),\n        type: \"response\"\n      })\n      void requestRunner.logCompletedRequest().catch((error) => {\n        this.logger.warn(\"Failed to log completed request\", error)\n      })\n    })\n\n    await requestRunner.run()\n  }\n\n  /**\n   * Runs process buffer.\n   * @returns {void} - No return value.\n   */\n  _processBuffer() {\n    while (this.buffer.length >= 2) {\n      const firstByte = this.buffer[0]\n      const secondByte = this.buffer[1]\n      const isFinal = (firstByte & WEBSOCKET_FINAL_FRAME) === WEBSOCKET_FINAL_FRAME\n      const opcode = firstByte & 0x0F\n      const isMasked = (secondByte & 0x80) === 0x80\n      let payloadLength = secondByte & 0x7F\n      let offset = 2\n\n      if (payloadLength === 126) {\n        if (this.buffer.length < offset + 2) return\n        payloadLength = this.buffer.readUInt16BE(offset)\n        offset += 2\n      } else if (payloadLength === 127) {\n        if (this.buffer.length < offset + 8) return\n        const bigLength = this.buffer.readBigUInt64BE(offset)\n\n        payloadLength = Number(bigLength)\n        offset += 8\n      }\n\n      const maskLength = isMasked ? 4 : 0\n\n      if (this.buffer.length < offset + maskLength + payloadLength) return\n\n      /** Payload. @type {Buffer} */\n      let payload = this.buffer.slice(offset + maskLength, offset + maskLength + payloadLength)\n\n      if (isMasked) {\n        const mask = this.buffer.slice(offset, offset + maskLength)\n        payload = this._unmaskPayload(payload, mask)\n      }\n\n      this.buffer = this.buffer.slice(offset + maskLength + payloadLength)\n\n      // Control frames (opcode >= 0x8) must not be fragmented per\n      // RFC 6455 and can arrive interleaved with a fragmented data\n      // message. Handle them first without touching the fragment\n      // accumulator.\n      if (opcode === WEBSOCKET_OPCODE_PING) {\n        this._sendControlFrame(WEBSOCKET_OPCODE_PONG, payload)\n        continue\n      }\n\n      if (opcode === WEBSOCKET_OPCODE_CLOSE) {\n        this.sendGoodbye(this.client)\n        this._handleClose()\n        continue\n      }\n\n      if (opcode >= 0x8) {\n        this.logger.warn(`Unsupported websocket control opcode: ${opcode}`)\n        continue\n      }\n\n      // Data frame (TEXT/BINARY/CONTINUATION). Reassemble fragments\n      // before dispatching. Browsers (Chrome) legitimately fragment\n      // longer client→server text frames; a prior version dropped\n      // every fragmented message silently, so any payload large\n      // enough to hit the browser's fragmentation threshold\n      // (e.g. a channel-subscribe with an auth token) never reached\n      // the handler.\n      if (opcode === WEBSOCKET_OPCODE_CONTINUATION) {\n        if (this._fragmentedPayloads === null) {\n          this.logger.warn(\"Received continuation frame with no fragmented message in progress\")\n          continue\n        }\n\n        if (!this._appendFragment(payload)) return\n\n        if (!isFinal) continue\n      } else if (opcode === WEBSOCKET_OPCODE_TEXT || opcode === WEBSOCKET_OPCODE_BINARY) {\n        if (this._fragmentedPayloads !== null) {\n          this.logger.warn(\"Received new data frame while a fragmented message was in progress; discarding prior fragments\")\n          this._resetFragmentBuffer()\n        }\n\n        if (!isFinal) {\n          this._fragmentedPayloads = [payload]\n          this._fragmentedOpcode = opcode\n          this._fragmentedBytes = payload.length\n\n          if (!this._enforceFragmentLimits()) return\n\n          continue\n        }\n      } else {\n        this.logger.warn(`Unsupported websocket data opcode: ${opcode}`)\n        continue\n      }\n\n      /**\n       * Defines finalPayload.\n        @type {Buffer} */\n      let finalPayload\n      /**\n       * Defines finalOpcode.\n        @type {number} */\n      let finalOpcode\n\n      if (this._fragmentedPayloads !== null) {\n        if (opcode === WEBSOCKET_OPCODE_CONTINUATION) {\n          finalPayload = Buffer.concat(this._fragmentedPayloads)\n          finalOpcode = this._fragmentedOpcode ?? WEBSOCKET_OPCODE_TEXT\n        } else {\n          finalPayload = payload\n          finalOpcode = opcode\n        }\n        this._resetFragmentBuffer()\n      } else {\n        finalPayload = payload\n        finalOpcode = opcode\n      }\n\n      if (finalOpcode !== WEBSOCKET_OPCODE_TEXT) {\n        this.logger.warn(`Unsupported websocket data opcode after reassembly: ${finalOpcode}`)\n        continue\n      }\n\n      try {\n        const message = JSON.parse(finalPayload.toString(\"utf-8\"))\n\n        this._handleMessage(message).catch((error) => {\n          this.logger.error(() => [\"Websocket message handler failed\", error])\n          this.sendJson({error: error.message, type: \"error\"})\n        })\n      } catch (error) {\n        this.logger.error(() => [\"Failed to parse websocket message\", error])\n        this.sendJson({error: \"Invalid websocket message\", type: \"error\"})\n      }\n    }\n  }\n\n  /**\n   * Appends a continuation-frame payload to the in-progress\n   * fragmented message. Returns true when the fragment was accepted\n   * and false when the per-message cap was hit and the socket has\n   * been closed.\n   * @param {Buffer} payload\n   * @returns {boolean}\n   */\n  _appendFragment(payload) {\n    // Guard pushing first so `_enforceFragmentLimits` sees the final\n    // state; on overflow the reset inside the enforcer drops the\n    // buffered fragments.\n    this._fragmentedPayloads?.push(payload)\n    this._fragmentedBytes += payload.length\n\n    return this._enforceFragmentLimits()\n  }\n\n  /**\n   * Verifies the fragmented message has not exceeded the byte or\n   * fragment-count caps. On overflow, clears the buffer, sends a\n   * close frame, and tears the session down. Returns true when the\n   * caller can continue processing, false when the session is being\n   * closed.\n   * @returns {boolean}\n   */\n  _enforceFragmentLimits() {\n    if (this._fragmentedPayloads === null) return true\n\n    const fragmentCount = this._fragmentedPayloads.length\n    const overBytes = this._fragmentedBytes > WEBSOCKET_MAX_FRAGMENTED_MESSAGE_BYTES\n    const overFragments = fragmentCount > WEBSOCKET_MAX_FRAGMENTED_MESSAGE_FRAGMENTS\n\n    if (!overBytes && !overFragments) return true\n\n    this.logger.warn(() => [\n      \"Fragmented websocket message exceeded caps; closing connection\",\n      {\n        fragmentBytes: this._fragmentedBytes,\n        fragmentCount,\n        maxBytes: WEBSOCKET_MAX_FRAGMENTED_MESSAGE_BYTES,\n        maxFragments: WEBSOCKET_MAX_FRAGMENTED_MESSAGE_FRAGMENTS\n      }\n    ])\n\n    this._resetFragmentBuffer()\n    this.buffer = Buffer.alloc(0)\n    this.sendGoodbye(this.client)\n    this._handleClose()\n\n    return false\n  }\n\n  /**\n   * Runs reset fragment buffer.\n    @returns {void} */\n  _resetFragmentBuffer() {\n    this._fragmentedPayloads = null\n    this._fragmentedOpcode = null\n    this._fragmentedBytes = 0\n  }\n\n  /**\n   * Runs send control frame.\n   * @param {number} opcode - Opcode.\n   * @param {Buffer} payload - Payload data.\n   * @returns {void} - No return value.\n   */\n  _sendControlFrame(opcode, payload) {\n    const header = Buffer.alloc(2)\n\n    header[0] = WEBSOCKET_FINAL_FRAME | opcode\n    header[1] = payload.length\n\n    this.client.events.emit(\"output\", Buffer.concat([header, payload]))\n  }\n\n  /**\n   * Runs send json.\n   * @param {object} body - Request body.\n   * @returns {void} - No return value.\n   */\n  sendJson(body) {\n    // While paused (waiting for a resume), stash frames in an\n    // outbound queue and flush them in order on resume. Capped to\n    // prevent runaway memory use while the client is offline.\n    if (this._paused) {\n      this._outboundQueue ||= []\n\n      if (this._outboundQueue.length >= WEBSOCKET_PAUSED_QUEUE_CAP) {\n        // Drop oldest so the most recent activity wins on resume.\n        this._outboundQueue.shift()\n      }\n\n      this._outboundQueue.push(body)\n      return\n    }\n\n    if (!this.client?.events) return\n\n    const json = JSON.stringify(body)\n    const payload = Buffer.from(json, \"utf-8\")\n    let header\n\n    if (payload.length < 126) {\n      header = Buffer.alloc(2)\n      header[1] = payload.length\n    } else if (payload.length < 65536) {\n      header = Buffer.alloc(4)\n      header[1] = 126\n      header.writeUInt16BE(payload.length, 2)\n    } else {\n      header = Buffer.alloc(10)\n      header[1] = 127\n      header.writeBigUInt64BE(BigInt(payload.length), 2)\n    }\n\n    header[0] = WEBSOCKET_FINAL_FRAME | WEBSOCKET_OPCODE_TEXT\n\n    this.client.events.emit(\"output\", Buffer.concat([header, payload]))\n  }\n\n  /**\n   * Flushes the paused outbound queue over the current socket.\n   * Called during resume after `session-resumed` has been sent on\n   * the NEW session's socket (not this session's).\n   * @returns {void}\n   */\n  _flushOutboundQueue() {\n    const queue = this._outboundQueue || []\n\n    this._outboundQueue = []\n\n    for (const body of queue) {\n      this.sendJson(body)\n    }\n  }\n\n  /**\n   * Runs subscribe to channel.\n   * @param {string} channel - Channel name.\n   * @param {{acknowledge?: boolean, channelHandler?: import(\"../websocket-channel.js\").default, lastEventId?: string, params?: Record<string, ?>, subscriptionChannel?: string}} [options] - Subscribe options.\n   * @returns {Promise<boolean>} - Whether the subscription was added.\n   */\n  async subscribeToChannel(channel, {acknowledge = true, channelHandler, lastEventId, params, subscriptionChannel} = {}) {\n    await websocketEventLogStoreForConfiguration(this.configuration).markChannelInterested(channel)\n\n    const replayState = await this._prepareReplayState({\n      channel,\n      lastEventId,\n      subscriptionChannel: subscriptionChannel || channel,\n      subscriptionParams: params\n    })\n\n    if (replayState === false) return false\n    if (replayState) {\n      this.channelReplayStates.set(channel, replayState)\n    }\n\n    this.addSubscription(channel)\n\n    if (channelHandler) {\n      if (!this.subscriptionHandlers.has(channel)) {\n        this.subscriptionHandlers.set(channel, new Set())\n      }\n\n      this.subscriptionHandlers.get(channel)?.add(channelHandler)\n\n      if (!this.handlerSubscriptions.has(channelHandler)) {\n        this.handlerSubscriptions.set(channelHandler, new Set())\n      }\n\n      this.handlerSubscriptions.get(channelHandler)?.add(channel)\n    }\n\n    if (replayState) {\n      try {\n        await this._replayChannelEvents({channel, replayState})\n      } finally {\n        await this._finishReplayState(channel, replayState)\n      }\n    }\n\n    if (acknowledge) {\n      this.sendJson({channel, type: \"subscribed\"})\n    }\n    return true\n  }\n\n  _handleClose() {\n    // If the session has resumable state (live Connection or\n    // ChannelV2 subscription), move it into the paused registry\n    // instead of tearing down; a new socket presenting the sessionId\n    // via `session-resume` within the grace window will reattach.\n    const hasResumableState = this._connections.size > 0 || this._channelSubscriptions.size > 0\n\n    if (hasResumableState && !this._paused) {\n      this._paused = true\n      this.socket = null\n      // Kick off auth-identity capture for resume verification. Runs\n      // in the background — `_handleSessionResume` awaits\n      // `_resumeIdentityPromise` before comparing. Pause registration\n      // is synchronous so a resume arriving immediately still finds\n      // the session.\n      this._resumeIdentityPromise = this._captureResumeIdentity()\n      void this._fireOnDisconnect()\n      this.configuration._pauseWebsocketSession(this)\n      this.events.emit(\"close\")\n      return\n    }\n\n    void this._runMessageHandlerClose()\n    void this._teardownChannel()\n    void this._teardownConnections(\"session_destroyed\")\n    void this._teardownChannelSubscriptions()\n    this.events.emit(\"close\")\n  }\n\n  /**\n   * Called by the grace timer when the paused period expires without\n   * a resume. Tears down all live Connections + Channel subs and\n   * drops the session.\n   * @returns {void}\n   */\n  _finalizeGraceExpiry() {\n    void this._runMessageHandlerClose()\n    void this._teardownChannel()\n    void this._teardownConnections(\"grace_expired\")\n    void this._teardownChannelSubscriptions()\n    this.events.emit(\"close\")\n  }\n\n  /**\n   * Runs the configured identity resolver against this session.\n   * The returned promise is stored at pause time and awaited at\n   * resume time so we can reject resume attempts from a different\n   * authenticated caller (signed out, swapped user, expired cookie).\n   * @returns {Promise<?>}\n   */\n  async _captureResumeIdentity() {\n    const resolver = this.configuration.getWebsocketSessionIdentityResolver?.()\n\n    if (typeof resolver !== \"function\") return undefined\n\n    try {\n      return await resolver(this)\n    } catch (error) {\n      this.logger.error(() => [\"Websocket session identity resolver failed at pause\", error])\n      return undefined\n    }\n  }\n\n  /**\n   * Fires `onDisconnect` on every live Connection and Channel sub so\n   * apps can pause per-instance work while the session is paused.\n   * Errors are logged, not rethrown — one broken handler must not\n   * block the rest.\n   * @returns {Promise<void>}\n   */\n  async _fireOnDisconnect() {\n    await this._fireLifecycleCallback(\"onDisconnect\")\n  }\n\n  /**\n   * Fires `onResume` on every live Connection and Channel sub after\n   * a successful `session-resume` handoff.\n   * @returns {Promise<void>}\n   */\n  async _fireOnResume() {\n    await this._fireLifecycleCallback(\"onResume\")\n  }\n\n  /**\n   * Runs fire lifecycle callback.\n   * @param {\"onDisconnect\" | \"onResume\"} callbackName Lifecycle callback to fire.\n   * @returns {Promise<void>} Resolves when every live handler has been attempted.\n   */\n  async _fireLifecycleCallback(callbackName) {\n    for (const connection of this._connections.values()) {\n      try {\n        await connection[callbackName]?.()\n      } catch (error) {\n        this.logger.error(() => [`${callbackName} failed for ${connection.connectionId}`, error])\n      }\n    }\n\n    for (const {subscription} of this._channelSubscriptions.values()) {\n      try {\n        await subscription[callbackName]?.()\n      } catch (error) {\n        this.logger.error(() => [`${callbackName} failed for channel sub ${subscription.subscriptionId}`, error])\n      }\n    }\n  }\n\n  /**\n   * Handles `{type: \"session-resume\"}`. This session (the newly-\n   * created one whose socket just connected) transfers state from\n   * the paused session and instructs the client via\n   * `session-resumed` or `session-gone`.\n   * @param {Record<string, ?>} message\n   * @returns {Promise<void>}\n   */\n  async _handleSessionResume(message) {\n    const resumeSessionId = message.sessionId\n\n    if (typeof resumeSessionId !== \"string\" || !resumeSessionId) {\n      this.sendJson({type: \"session-gone\"})\n      return\n    }\n\n    const paused = this.configuration._findPausedWebsocketSession(resumeSessionId)\n\n    if (!paused) {\n      this.sendJson({type: \"session-gone\"})\n      return\n    }\n\n    // Auth re-verify: compare the fresh caller's identity against the\n    // one captured at pause. Mismatch means a different user (or a\n    // signed-out session) is trying to reclaim state that isn't\n    // theirs — destroy the paused session outright.\n    const resolver = this.configuration.getWebsocketSessionIdentityResolver?.()\n\n    if (typeof resolver === \"function\") {\n      const pausedIdentity = await paused._resumeIdentityPromise\n      let freshIdentity\n\n      try {\n        freshIdentity = await resolver(this)\n      } catch (error) {\n        this.logger.error(() => [\"Websocket session identity resolver failed at resume\", error])\n        freshIdentity = undefined\n      }\n\n      if (!identitiesMatch(pausedIdentity, freshIdentity)) {\n        this.configuration._clearPausedWebsocketSession(resumeSessionId)\n        paused._finalizeGraceExpiry()\n        this.sendJson({type: \"session-gone\"})\n        return\n      }\n    }\n\n    this.configuration._clearPausedWebsocketSession(resumeSessionId)\n\n    // Transfer resumable state onto this (live) session. The paused\n    // session shell is discarded after the transfer.\n    for (const [connectionId, connection] of paused._connections) {\n      connection.session = this\n      this._connections.set(connectionId, connection)\n    }\n\n    for (const [subId, entry] of paused._channelSubscriptions) {\n      entry.subscription.session = this\n      this._channelSubscriptions.set(subId, entry)\n    }\n\n    this._metadata = {...paused._metadata}\n    this.data = paused.data\n    this.sessionId = resumeSessionId\n\n    // Transfer any frames queued while the paused session had no\n    // socket. They flush AFTER session-resumed so the client knows\n    // which session they belong to.\n    const queued = paused._outboundQueue || []\n\n    paused._outboundQueue = []\n    paused._connections.clear()\n    paused._channelSubscriptions.clear()\n    paused._paused = false\n    paused.destroy()\n\n    this.sendJson({type: \"session-resumed\", sessionId: resumeSessionId})\n    for (const body of queued) this.sendJson(body)\n    await this._fireOnResume()\n  }\n\n  /**\n   * Fires `onClose(reason)` on every live app-defined connection, then\n   * drops them from the registry. No network frame is sent — the\n   * socket is already going away.\n   * @param {\"session_destroyed\" | \"grace_expired\" | \"error\"} reason\n   * @returns {Promise<void>}\n   */\n  async _teardownConnections(reason) {\n    const connections = [...this._connections.values()]\n\n    this._connections.clear()\n\n    for (const connection of connections) {\n      connection._closed = true\n\n      try {\n        await this._withConnections(async () => {\n          await connection.onClose(reason)\n        })\n      } catch (error) {\n        this.logger.error(() => [`Failed to tear down connection ${connection.connectionId}`, error])\n      }\n    }\n  }\n\n  /**\n   * Handles a `{type: \"connection-open\"}` message — instantiates the\n   * registered connection class, stores it on `_connections`, and\n   * fires `onConnect()`. Sends `connection-opened` on success or\n   * `connection-error` on failure.\n   * @param {Record<string, ?>} message\n   * @returns {Promise<void>}\n   */\n  async _handleConnectionOpen(message) {\n    const connectionId = message.connectionId\n    const connectionType = message.connectionType\n    const params = message.params || {}\n\n    if (typeof connectionId !== \"string\" || !connectionId) {\n      this.sendJson({type: \"error\", error: \"connection-open requires connectionId\"})\n      return\n    }\n\n    if (typeof connectionType !== \"string\" || !connectionType) {\n      this.sendJson({type: \"connection-error\", connectionId, message: \"connectionType is required\"})\n      return\n    }\n\n    if (this._connections.has(connectionId)) {\n      this.sendJson({type: \"connection-error\", connectionId, message: \"Connection id already in use\"})\n      return\n    }\n\n    const ConnectionClass = this.configuration.getWebsocketConnectionClass?.(connectionType)\n\n    if (!ConnectionClass) {\n      this.sendJson({type: \"connection-error\", connectionId, message: `Unknown connection type: ${connectionType}`})\n      return\n    }\n\n    const connection = new ConnectionClass({connectionId, params, session: this})\n\n    try {\n      await this._withConnections(async () => {\n        await connection.onConnect()\n      })\n      // Register only after onConnect resolves so a connection-message\n      // can never be routed to a partially initialized connection.\n      this._connections.set(connectionId, connection)\n      this.sendJson({type: \"connection-opened\", connectionId})\n    } catch (error) {\n      this.logger.error(() => [`Failed to open connection ${connectionType}:${connectionId}`, error])\n      this.sendJson({type: \"connection-error\", connectionId, message: /**\n                                                                       * Narrows the runtime value to the documented type.\n                                                                        @type {Error} */ (error).message || \"Failed to open connection\"})\n    }\n  }\n\n  /**\n   * Handles a `{type: \"connection-message\"}` from the client.\n   * @param {Record<string, ?>} message\n   * @returns {Promise<void>}\n   */\n  async _handleConnectionMessage(message) {\n    const connectionId = message.connectionId\n    const connection = typeof connectionId === \"string\" ? this._connections.get(connectionId) : null\n\n    if (!connection) {\n      this.sendJson({type: \"connection-error\", connectionId, message: \"Unknown connection id\"})\n      return\n    }\n\n    try {\n      await this._withConnections(async () => {\n        await connection.onMessage(message.body)\n      })\n    } catch (error) {\n      this.logger.error(() => [`Failed to handle connection-message for ${connectionId}`, error])\n      this.sendJson({type: \"connection-error\", connectionId, message: /**\n                                                                       * Narrows the runtime value to the documented type.\n                                                                        @type {Error} */ (error).message || \"Failed to handle message\"})\n    }\n  }\n\n  /**\n   * Handles a `{type: \"connection-close\"}` from the client — fires\n   * `onClose(\"client_close\")` and confirms with `connection-closed`.\n   * @param {Record<string, ?>} message\n   * @returns {Promise<void>}\n   */\n  async _handleConnectionClose(message) {\n    const connectionId = message.connectionId\n    const connection = typeof connectionId === \"string\" ? this._connections.get(connectionId) : null\n\n    if (!connection) return\n\n    this._connections.delete(connectionId)\n    // Mark closed before firing onClose so app code holding the\n    // handle sees `isClosed() === true` and can't re-enter sendMessage.\n    connection._closed = true\n\n    try {\n      await this._withConnections(async () => {\n        await connection.onClose(\"client_close\")\n      })\n    } catch (error) {\n      this.logger.error(() => [`Failed to tear down connection ${connectionId}`, error])\n    }\n\n    this.sendJson({type: \"connection-closed\", connectionId, reason: \"client_close\"})\n  }\n\n  /**\n   * Handles `{type: \"channel-subscribe\"}` — runs `canSubscribe()`,\n   * registers with the Configuration's global routing registry on\n   * success, and sends `channel-subscribed` or `channel-error`.\n   * @param {Record<string, ?>} message\n   * @returns {Promise<void>}\n   */\n  async _handleChannelSubscribe(message) {\n    const subscriptionId = message.subscriptionId\n    const channelType = message.channelType\n    const params = message.params || {}\n    const lastEventId = message.lastEventId\n\n    if (typeof subscriptionId !== \"string\" || !subscriptionId) {\n      this.sendJson({type: \"error\", error: \"channel-subscribe requires subscriptionId\"})\n      return\n    }\n\n    if (typeof channelType !== \"string\" || !channelType) {\n      this.sendJson({type: \"channel-error\", subscriptionId, message: \"channelType is required\"})\n      return\n    }\n\n    if (this._channelSubscriptions.has(subscriptionId)) {\n      this.sendJson({type: \"channel-error\", subscriptionId, message: \"Subscription id already in use\"})\n      return\n    }\n\n    const ChannelClass = this.configuration.getWebsocketChannelClass?.(channelType)\n\n    if (!ChannelClass) {\n      this.sendJson({type: \"channel-error\", subscriptionId, message: `Unknown channel type: ${channelType}`})\n      return\n    }\n\n    const subscription = new ChannelClass({subscriptionId, params, session: this})\n\n    try {\n      // Resolving the tenant can run database queries (e.g. looking up the\n      // record's project and the caller's access), so it must happen inside a\n      // connection scope. Without this the resolver borrows a connection that\n      // is checked back in before/while it queries, intermittently surfacing as\n      // \"Connection … doesn't exist any more\" or a falsely unauthorized\n      // subscription.\n      let tenant\n      await this._withConnections(async () => {\n        tenant = await this._resolveTenant({channel: channelType, params})\n      })\n\n      await this.configuration.runWithTenant(tenant, async () => {\n        let allowed = false\n\n        await this._withConnections(async () => {\n          allowed = Boolean(await subscription.canSubscribe())\n        })\n\n        if (!allowed) {\n          this.sendJson({type: \"channel-error\", subscriptionId, message: \"Subscription not authorized\"})\n          return\n        }\n\n        this._channelSubscriptions.set(subscriptionId, {channelType, subscription})\n        this.configuration._registerWebsocketChannelSubscription(channelType, subscription)\n\n        await this._withConnections(async () => await subscription.subscribed())\n\n        // Replay missed events BEFORE sending channel-subscribed so\n        // the client knows: everything before the confirmation is\n        // replayed, everything after is live.\n        if (typeof lastEventId === \"string\" && lastEventId.length > 0) {\n          await this._replayChannelEventsForSubscription({channelType, lastEventId, subscription})\n        }\n\n        this.sendJson({type: \"channel-subscribed\", subscriptionId})\n      })\n    } catch (error) {\n      this._channelSubscriptions.delete(subscriptionId)\n      this.configuration._unregisterWebsocketChannelSubscription(channelType, subscription)\n      this.logger.error(() => [`Failed to subscribe channel ${channelType}:${subscriptionId}`, error])\n      this.sendJson({type: \"channel-error\", subscriptionId, message: /**\n                                                                      * Narrows the runtime value to the documented type.\n                                                                       @type {Error} */ (error).message || \"Failed to subscribe\"})\n    }\n  }\n\n  /**\n   * Replays missed events from the persistent event-log store for a\n   * channel subscription that provided `lastEventId`. Sends each\n   * missed event as a `channel-message` with `replayed: true`.\n   * @param {object} args - Options.\n   * @param {string} args.channelType - Channel type name (event-log key).\n   * @param {string} args.lastEventId - Client's last-seen event id.\n   * @param {import(\"../websocket-channel.js\").default} args.subscription - Live subscription.\n   * @returns {Promise<void>}\n   */\n  async _replayChannelEventsForSubscription({channelType, lastEventId, subscription}) {\n    const store = websocketEventLogStoreForConfiguration(this.configuration)\n\n    await this.configuration.awaitPendingBroadcasts()\n\n    const checkpoint = await store.getEventById({channel: channelType, id: lastEventId})\n\n    if (!checkpoint) {\n      this.sendJson({\n        type: \"channel-replay-gap\",\n        subscriptionId: subscription.subscriptionId,\n        lastEventId\n      })\n      return\n    }\n\n    const ceiling = await store.latestSequence(channelType)\n\n    if (!ceiling || ceiling <= checkpoint.sequence) return\n\n    const events = await store.getEventsAfter({\n      channel: channelType,\n      sequence: checkpoint.sequence,\n      upToSequence: ceiling\n    })\n\n    for (const event of events) {\n      if (subscription.isClosed()) break\n\n      subscription.sendMessage(/**\n                                * Narrows the runtime value to the documented type.\n                                 @type {import(\"../websocket-channel.js\").WebsocketJsonValue} */ (event.payload))\n    }\n  }\n\n  /**\n   * Handles `{type: \"channel-unsubscribe\"}` from the client — calls\n   * `unsubscribed()` and sends `channel-unsubscribed`.\n   * @param {Record<string, ?>} message\n   * @returns {Promise<void>}\n   */\n  async _handleChannelUnsubscribe(message) {\n    const subscriptionId = message.subscriptionId\n\n    if (typeof subscriptionId !== \"string\") return\n\n    const entry = this._channelSubscriptions.get(subscriptionId)\n\n    if (!entry) return\n\n    this._channelSubscriptions.delete(subscriptionId)\n    this.configuration._unregisterWebsocketChannelSubscription(entry.channelType, entry.subscription)\n    entry.subscription._closed = true\n\n    try {\n      await this._withConnections(async () => await entry.subscription.unsubscribed())\n    } catch (error) {\n      this.logger.error(() => [`Failed to unsubscribe channel ${entry.channelType}:${subscriptionId}`, error])\n    }\n\n    this.sendJson({type: \"channel-unsubscribed\", subscriptionId})\n  }\n\n  /**\n   * Fires `unsubscribed()` on every live channel-v2 subscription,\n   * removes them from the Configuration's global registry, and\n   * drops the session's own map. No network frames — the socket\n   * is already going away.\n   * @returns {Promise<void>}\n   */\n  async _teardownChannelSubscriptions() {\n    const entries = [...this._channelSubscriptions.values()]\n\n    this._channelSubscriptions.clear()\n\n    for (const {channelType, subscription} of entries) {\n      this.configuration._unregisterWebsocketChannelSubscription(channelType, subscription)\n      subscription._closed = true\n\n      try {\n        await this._withConnections(async () => await subscription.unsubscribed())\n      } catch (error) {\n        this.logger.error(() => [`Failed to tear down channel-v2 ${channelType}:${subscription.subscriptionId}`, error])\n      }\n    }\n  }\n\n  async _teardownChannel() {\n    for (const channel of this.channels) {\n      await this._teardownSingleChannel(channel)\n    }\n    this.channels.clear()\n    this.channelReplayStates.clear()\n  }\n\n  /**\n   * Runs teardown single channel.\n   * @param {WebsocketChannel} channel - Channel instance.\n   * @returns {Promise<void>} - Resolves when complete.\n   */\n  async _teardownSingleChannel(channel) {\n    try {\n      const tenant = this.channelTenants.get(channel)\n\n      await this.configuration.runWithTenant(tenant, async () => {\n        await this._withConnections(async () => {\n          await channel?.unsubscribed?.()\n        })\n      })\n    } catch (error) {\n      this.logger.error(() => [\"Failed to teardown websocket channel\", error])\n    }\n\n    const subscriptions = this.handlerSubscriptions.get(channel)\n\n    if (subscriptions) {\n      for (const subscriptionChannel of subscriptions) {\n        this.subscriptionHandlers.get(subscriptionChannel)?.delete(channel)\n\n        if (this.subscriptionHandlers.get(subscriptionChannel)?.size === 0) {\n          this.subscriptionHandlers.delete(subscriptionChannel)\n        }\n      }\n\n      this.handlerSubscriptions.delete(channel)\n    }\n\n    this.channelTenants.delete(channel)\n  }\n\n  /**\n   * Runs register channel.\n   * @param {WebsocketChannel | undefined} channel - Channel instance.\n   * @param {string | null | undefined} tenant - Tenant key.\n   * @returns {Promise<void>} - Resolves when complete.\n   */\n  async _registerChannel(channel, tenant) {\n    if (!channel) return\n\n    this.channels.add(channel)\n    this.channelTenants.set(channel, tenant)\n    await this.configuration.runWithTenant(tenant, async () => {\n      await this._withConnections(async () => {\n        await channel?.subscribed?.()\n      })\n    })\n  }\n\n  /**\n   * Runs with connections.\n   * @param {() => Promise<void>} callback - Callback.\n   * @returns {Promise<void>} - Resolves when complete.\n   */\n  async _withConnections(callback) {\n    await this.configuration.ensureConnections({name: \"Websocket session\"}, async () => {\n      await callback()\n    })\n  }\n\n  /**\n   * Runs handle channel subscription.\n   * @param {{channel: string, lastEventId?: string, params?: Record<string, ?>}} args - Subscription args.\n   * @returns {Promise<void>} - Resolves when complete.\n   */\n  async _handleChannelSubscription({channel, lastEventId, params}) {\n    const resolver = this.configuration.getWebsocketChannelResolver?.()\n\n    if (!resolver) return\n\n    try {\n      // Tenant resolution can run database queries, so it must happen inside a\n      // connection scope (see _handleChannelSubscribe).\n      let tenant\n      await this._withConnections(async () => {\n        tenant = await this._resolveTenant({channel, params})\n      })\n      const resolved = await this.configuration.runWithTenant(tenant, async () => {\n        return await resolver({\n          client: this.client,\n          configuration: this.configuration,\n          request: this.upgradeRequest,\n          subscription: {channel, params},\n          websocketSession: this\n        })\n      })\n\n      if (!resolved) {\n        this.sendJson({channel, error: \"Subscription rejected\", type: \"error\"})\n        return\n      }\n\n      const channelInstance = typeof resolved === \"function\"\n        ? new resolved({\n          client: this.client,\n          configuration: this.configuration,\n          lastEventId,\n          request: this.upgradeRequest,\n          subscriptionChannel: channel,\n          subscriptionParams: params,\n          websocketSession: this\n        })\n        : resolved\n\n      if (channelInstance && !(channelInstance instanceof WebsocketChannel)) {\n        throw new Error(\"Resolved websocket channel must extend WebsocketChannel\")\n      }\n\n      await this._registerChannel(channelInstance, tenant)\n    } catch (error) {\n      this.logger.warn(() => [\"Websocket channel subscription failed\", error])\n      this.sendJson({channel, error: \"Subscription rejected\", type: \"error\"})\n    }\n  }\n\n  /**\n   * Runs prepare replay state.\n   * @param {object} args - Options.\n   * @param {string} args.channel - Internal channel name.\n   * @param {string | undefined} args.lastEventId - Last received event id.\n   * @param {string} args.subscriptionChannel - Client-facing channel name.\n   * @param {Record<string, ?> | undefined} args.subscriptionParams - Client-facing params.\n   * @returns {Promise<false | {buffered: boolean, ceilingSequence: number, checkpointSequence: number, replaying: boolean} | null>} - Replay state.\n   */\n  async _prepareReplayState({channel, lastEventId, subscriptionChannel, subscriptionParams}) {\n    if (!lastEventId) return null\n\n    const store = websocketEventLogStoreForConfiguration(this.configuration)\n    const checkpoint = await store.getEventById({channel, id: lastEventId})\n\n    if (!checkpoint) {\n      this.sendJson({channel: subscriptionChannel, lastEventId, params: subscriptionParams, type: \"replay-gap\"})\n      return false\n    }\n\n    return {\n      buffered: false,\n      ceilingSequence: (await store.latestSequence(channel)) || checkpoint.sequence,\n      checkpointSequence: checkpoint.sequence,\n      replaying: true\n    }\n  }\n\n  /**\n   * Runs replay channel events.\n   * @param {object} args - Options.\n   * @param {string} args.channel - Channel name.\n   * @param {{buffered: boolean, ceilingSequence: number, checkpointSequence: number, replaying: boolean}} args.replayState - Replay state.\n   * @returns {Promise<void>} - Resolves when replay completes.\n   */\n  async _replayChannelEvents({channel, replayState}) {\n    const store = websocketEventLogStoreForConfiguration(this.configuration)\n    const events = await store.getEventsAfter({\n      channel,\n      sequence: replayState.checkpointSequence,\n      upToSequence: replayState.ceilingSequence\n    })\n\n    for (const event of events) {\n      await this.sendEvent(channel, event.payload, {\n        createdAt: event.createdAt,\n        eventId: event.id,\n        replayed: true,\n        sequence: event.sequence\n      })\n    }\n  }\n\n  /**\n   * Runs finish replay state.\n   * @param {string} channel - Channel name.\n   * @param {{buffered: boolean, ceilingSequence: number, checkpointSequence: number, replaying: boolean}} replayState - Replay state.\n   * @returns {Promise<void>} - Resolves when buffered events are flushed.\n   */\n  async _finishReplayState(channel, replayState) {\n    const store = websocketEventLogStoreForConfiguration(this.configuration)\n\n    replayState.replaying = false\n    this.channelReplayStates.delete(channel)\n\n    if (!replayState.buffered) return\n\n    const liveEvents = await store.getEventsAfter({\n      channel,\n      sequence: replayState.ceilingSequence\n    })\n\n    for (const event of liveEvents) {\n      await this.sendEvent(channel, event.payload, {\n        createdAt: event.createdAt,\n        eventId: event.id,\n        sequence: event.sequence\n      })\n    }\n  }\n\n  /**\n   * Runs resolve tenant.\n   * @param {{channel?: string, params?: Record<string, ?>}} args - Tenant resolution args.\n   * @returns {Promise<string | null | undefined>} - Resolved tenant.\n   */\n  async _resolveTenant({channel, params}) {\n    const requestParams = this.upgradeRequest?.params?.()\n    const mergedParams = {\n      ...(requestParams && typeof requestParams === \"object\" ? requestParams : {}),\n      ...(params && typeof params === \"object\" ? params : {})\n    }\n\n    return /** Narrows the runtime value to the documented type. @type {Promise<string | null | undefined>} */ (this.configuration.resolveTenant({\n      params: mergedParams,\n      request: this.upgradeRequest,\n      response: undefined,\n      subscription: channel ? {channel, params} : undefined\n    }))\n  }\n\n  /**\n   * Runs unmask payload.\n   * @param {Buffer} payload - Payload data.\n   * @param {Buffer} mask - Mask.\n   * @returns {Buffer} - The unmask payload.\n   */\n  _unmaskPayload(payload, mask) {\n    /**\n     * Result.\n      @type {Buffer} */\n    const result = Buffer.alloc(payload.length)\n\n    for (let i = 0; i < payload.length; i++) {\n      result[i] = payload[i] ^ mask[i % 4]\n    }\n\n    return result\n  }\n\n  async _runMessageHandlerOpen() {\n    try {\n      const handler = this.messageHandler\n      const onOpen = handler ? handler.onOpen : null\n\n      if (onOpen) {\n        await onOpen({session: this})\n      }\n    } catch (error) {\n      this.logger.error(() => [\"Websocket open handler failed\", error])\n    }\n  }\n\n  /**\n   * Runs run message handler message.\n   * @param {WebsocketSessionMessage} message - Incoming websocket message.\n   * @returns {Promise<void>} - Resolves when complete.\n   */\n  async _runMessageHandlerMessage(message) {\n    try {\n      const handler = this.messageHandler\n      const onMessage = handler ? handler.onMessage : null\n\n      if (onMessage) {\n        await onMessage({message, session: this})\n      }\n    } catch (error) {\n      this.logger.error(() => [\"Websocket message handler failed\", error])\n      const handler = this.messageHandler\n      const onError = handler ? handler.onError : null\n\n      if (onError) {\n        await onError({error: error instanceof Error ? error : new Error(String(error)), session: this})\n      }\n    }\n  }\n\n  async _runMessageHandlerClose() {\n    try {\n      const handler = this.messageHandler\n      const onClose = handler ? handler.onClose : null\n\n      if (onClose) {\n        await onClose({session: this})\n      }\n    } catch (error) {\n      this.logger.error(() => [\"Websocket close handler failed\", error])\n    }\n  }\n\n  /**\n   * Runs remote address.\n   * @returns {string | undefined} - Remote address resolved from the websocket upgrade request.\n   */\n  remoteAddress() {\n    return this.upgradeRequest?.remoteAddress() || this.client.remoteAddress\n  }\n\n  /**\n   * Runs set message handler.\n   * @param {import(\"../../configuration-types.js\").WebsocketMessageHandler} handler - Handler instance.\n   * @returns {void}\n   */\n  setMessageHandler(handler) {\n    this.messageHandler = handler\n    void this._runMessageHandlerOpen()\n  }\n\n  async _resolveMessageHandlerPromise() {\n    if (!this.messageHandlerPromise) return\n\n    try {\n      const handler = await this.messageHandlerPromise\n\n      if (handler) {\n        this.pendingMessageHandler = false\n        this.messageHandlerPromise = undefined\n        // Install handler and drain onOpen before replaying queued\n        // messages. setMessageHandler() fires onOpen as fire-and-forget;\n        // awaiting _runMessageHandlerOpen() directly here closes the\n        // race where queued subscribe/connection-* frames would\n        // dispatch while an async onOpen is still setting up session\n        // state.\n        this.messageHandler = handler\n        await this._runMessageHandlerOpen()\n        await this._flushQueuedMessages({useHandler: typeof handler.onMessage === \"function\"})\n        return\n      }\n    } catch (error) {\n      this.logger.error(() => [\"Websocket message handler resolver failed\", error])\n    }\n\n    this.pendingMessageHandler = false\n    this.messageHandlerPromise = undefined\n    await this._flushQueuedMessages({useHandler: false})\n  }\n\n  /**\n   * Runs flush queued messages.\n   * @param {{useHandler: boolean}} args - Args.\n   * @returns {Promise<void>} - Resolves when complete.\n   */\n  async _flushQueuedMessages({useHandler}) {\n    if (this.messageQueue.length === 0) return\n\n    const queued = this.messageQueue.slice()\n    this.messageQueue = []\n\n    for (const message of queued) {\n      if (useHandler && this.messageHandler) {\n        await this._runMessageHandlerMessage(message)\n      } else {\n        await this._handleMessage(message)\n      }\n    }\n  }\n}\n"]}