@rlanz/socket 0.0.1-1 → 0.0.1-10

package/build/providers/socket_provider.js

@@ -1,13 +1,2084 @@
 import {
-  ChannelRouter,
-  PresenceManager,
-  SocketService
-} from "../chunk-5X4SKZQS.js";
-import "../chunk-XUDFDJME.js";
-import "../chunk-GKAD2UOA.js";
+  SERVER_DISCONNECT_CODE
+} from "../chunk-BLRAKPXW.js";
+import {
+  BaseChannel,
+  SocketResponseError
+} from "../chunk-K243S3QP.js";
+import {
+  ChannelPatternSyntax
+} from "../chunk-E6ILCRL3.js";
+import "../chunk-G75J233Z.js";
+import {
+  broadcastChannel,
+  channelMessageChannel,
+  connectChannel,
+  disconnectChannel,
+  subscribeChannel,
+  unsubscribeChannel
+} from "../chunk-NUPBNOP3.js";
+import {
+  SocketFake
+} from "../chunk-IUQ3GYZZ.js";
+
+// providers/socket_provider.ts
+import { ServerResponse } from "http";
+
+// src/socket_service.ts
+import { randomUUID as randomUUID2 } from "crypto";
+import Emittery from "emittery";
+import { WebSocket, WebSocketServer } from "ws";
+
+// src/channel_subscription_storage.ts
+var ChannelSubscriptionStorage = class {
+  #subscriptions = /* @__PURE__ */ new Map();
+  #subscribers = /* @__PURE__ */ new Map();
+  has(socketId, channelName) {
+    return this.#subscriptions.get(socketId)?.has(channelName) ?? false;
+  }
+  get(socketId, channelName) {
+    return this.#subscriptions.get(socketId)?.get(channelName);
+  }
+  set(socketId, channelName, subscription) {
+    if (!this.#subscriptions.has(socketId)) {
+      this.#subscriptions.set(socketId, /* @__PURE__ */ new Map());
+    }
+    this.#subscriptions.get(socketId).set(channelName, subscription);
+    if (!this.#subscribers.has(channelName)) {
+      this.#subscribers.set(channelName, /* @__PURE__ */ new Set());
+    }
+    this.#subscribers.get(channelName).add(socketId);
+  }
+  delete(socketId, channelName) {
+    const subscriptions = this.#subscriptions.get(socketId);
+    if (!subscriptions) {
+      return;
+    }
+    subscriptions.delete(channelName);
+    if (subscriptions.size === 0) {
+      this.#subscriptions.delete(socketId);
+    }
+    const subscribers = this.#subscribers.get(channelName);
+    subscribers?.delete(socketId);
+    if (subscribers?.size === 0) {
+      this.#subscribers.delete(channelName);
+    }
+  }
+  deleteSocket(socketId) {
+    for (const channelName of this.channelNamesFor(socketId)) {
+      this.delete(socketId, channelName);
+    }
+  }
+  channelNamesFor(socketId) {
+    return [...this.#subscriptions.get(socketId)?.keys() ?? []];
+  }
+  countForSocket(socketId) {
+    return this.#subscriptions.get(socketId)?.size ?? 0;
+  }
+  socketIdsFor(channelName) {
+    return [...this.#subscribers.get(channelName) ?? []];
+  }
+  get channelsCount() {
+    return this.#subscribers.size;
+  }
+  clear() {
+    this.#subscriptions.clear();
+    this.#subscribers.clear();
+  }
+};
+
+// src/channel_subscriptions.ts
+var ChannelSubscriptions = class _ChannelSubscriptions {
+  constructor(socketService, channelRouter, logger, presenceManager, limits) {
+    this.socketService = socketService;
+    this.channelRouter = channelRouter;
+    this.logger = logger;
+    this.presenceManager = presenceManager;
+    this.limits = limits;
+  }
+  #storage = new ChannelSubscriptionStorage();
+  #channelOperations = /* @__PURE__ */ new Map();
+  static #serializePresenceData(presenceData) {
+    return {
+      ...presenceData,
+      users: presenceData.users.map((user) => ({
+        ...user,
+        joinedAt: user.joinedAt.toISOString()
+      }))
+    };
+  }
+  setPresenceManager(presenceManager) {
+    this.presenceManager = presenceManager;
+  }
+  async subscribe(socket, channelName) {
+    return this.#subscribe(socket, channelName);
+  }
+  async #subscribe(socket, channelName) {
+    const existing = await this.#refreshExistingSubscription(socket, channelName);
+    if (existing) {
+      return existing;
+    }
+    if (this.limits && channelName.length > this.limits.maxChannelNameLength) {
+      return {
+        ack: { ok: false, error: "Channel name is too long" },
+        created: false
+      };
+    }
+    if (this.limits && this.#storage.channelNamesFor(socket.id).length >= this.limits.maxSubscriptionsPerSocket) {
+      return {
+        ack: { ok: false, error: "Socket subscription limit exceeded" },
+        created: false
+      };
+    }
+    const result = await this.channelRouter.authorize(socket, channelName);
+    if (!result.success) {
+      if ("cause" in result && !(result.cause instanceof SocketResponseError)) {
+        this.#warn(`failed to authorize channel "${channelName}": %s`, result.cause);
+      }
+      return {
+        ack: { ok: false, error: result.error },
+        created: false
+      };
+    }
+    if (this.#usesPresence(result.instance)) {
+      return this.#withChannelOperation(`${socket.id}\0${channelName}`, async () => {
+        const concurrentSubscription = await this.#refreshExistingSubscription(socket, channelName);
+        if (concurrentSubscription) {
+          return concurrentSubscription;
+        }
+        return this.#completeSubscription(socket, channelName, result);
+      });
+    }
+    return this.#completeSubscription(socket, channelName, result);
+  }
+  async #completeSubscription(socket, channelName, result) {
+    result.instance.$setContext(
+      this.socketService,
+      channelName,
+      result.params,
+      this.presenceManager
+    );
+    let presenceData = result.presenceData;
+    let presenceSnapshot = null;
+    let presenceJoined = false;
+    let serializationError;
+    try {
+      if (this.#usesPresence(result.instance)) {
+        const presenceInfo = result.instance.$getPresenceInfo(socket);
+        const joinedUser = this.presenceManager.join(channelName, socket.raw, presenceInfo);
+        const { joinedAt: _joinedAt, ...member } = joinedUser;
+        presenceJoined = true;
+        presenceSnapshot = await this.presenceManager.snapshot(channelName);
+        presenceData = presenceSnapshot;
+        const visibleUser = presenceSnapshot.users.find((user) => user.id === presenceInfo.id);
+        const wasPresent = Boolean(visibleUser && visibleUser !== joinedUser);
+        try {
+          JSON.stringify(presenceData);
+        } catch (error) {
+          serializationError = error;
+          throw error;
+        }
+        if (!wasPresent) {
+          await result.instance.onMemberJoin?.(socket, member, ...result.paramValues);
+        }
+        await result.instance.onJoin?.(socket, ...result.paramValues);
+      } else {
+        try {
+          JSON.stringify(presenceData);
+        } catch (error) {
+          serializationError = error;
+          throw error;
+        }
+        await result.instance.onJoin?.(socket, ...result.paramValues);
+      }
+      this.#storage.set(socket.id, channelName, {
+        channelName,
+        instance: result.instance,
+        paramValues: result.paramValues
+      });
+      if (presenceSnapshot) {
+        this.socketService.to(channelName).except(socket.id).emit("presence:update", _ChannelSubscriptions.#serializePresenceData(presenceSnapshot));
+      }
+    } catch (error) {
+      if (presenceJoined) {
+        this.presenceManager.leave(channelName, socket.raw);
+        const rollbackData = await this.presenceManager.snapshot(channelName).catch(() => null);
+        if (rollbackData) {
+          this.socketService.to(channelName).emit("presence:update", _ChannelSubscriptions.#serializePresenceData(rollbackData));
+        }
+      }
+      this.#storage.delete(socket.id, channelName);
+      if (serializationError) {
+        this.#warn(
+          `failed to serialize subscription response for channel "${channelName}": %s`,
+          serializationError
+        );
+      } else if (!(error instanceof SocketResponseError)) {
+        this.#warn(`failed to join channel "${channelName}": %s`, error);
+      }
+      return {
+        ack: {
+          ok: false,
+          error: serializationError ? "Subscription response is not serializable" : error instanceof SocketResponseError ? error.message : "Join failed"
+        },
+        created: false
+      };
+    }
+    return {
+      ack: { ok: true, presenceData },
+      created: true
+    };
+  }
+  async leave(socket, channelName) {
+    const subscription = this.#storage.get(socket.id, channelName);
+    if (!subscription) {
+      return false;
+    }
+    this.#storage.delete(socket.id, channelName);
+    if (this.#usesPresence(subscription.instance)) {
+      await this.#withChannelOperation(
+        `${socket.id}\0${channelName}`,
+        () => this.#cleanupAfterLeave(socket, channelName, subscription)
+      );
+    } else {
+      await this.#cleanupAfterLeave(socket, channelName, subscription);
+    }
+    return true;
+  }
+  async #cleanupAfterLeave(socket, channelName, subscription) {
+    if (this.#usesPresence(subscription.instance)) {
+      const presenceUser = this.presenceManager.getLocalUser(channelName, socket.id);
+      this.presenceManager.leave(channelName, socket.raw);
+      try {
+        const presenceData = await this.presenceManager.snapshot(channelName);
+        this.socketService.to(channelName).emit("presence:update", _ChannelSubscriptions.#serializePresenceData(presenceData));
+        if (presenceUser && !presenceData.users.some((user) => user.id === presenceUser.id)) {
+          const { joinedAt: _joinedAt, ...member } = presenceUser;
+          await subscription.instance.onMemberLeave?.(socket, member, ...subscription.paramValues);
+        }
+      } catch (error) {
+        this.#warn(`failed to update presence while leaving channel "${channelName}": %s`, error);
+      }
+    }
+    try {
+      await subscription.instance.onLeave?.(socket, ...subscription.paramValues);
+    } catch (error) {
+      this.#warn(`failed to leave channel "${channelName}": %s`, error);
+    }
+  }
+  async leaveAll(socket) {
+    for (const channelName of this.#storage.channelNamesFor(socket.id)) {
+      await this.leave(socket, channelName);
+    }
+  }
+  async handleMessage(socket, payload) {
+    const subscription = this.#storage.get(socket.id, payload.channel);
+    if (!subscription) {
+      return { ok: false, error: "Not subscribed" };
+    }
+    try {
+      const result = await subscription.instance.$handleMessage(socket, payload.event, payload.data);
+      try {
+        JSON.stringify(result);
+      } catch (error) {
+        this.#warn(
+          `failed to serialize handler response for channel "${payload.channel}": %s`,
+          error
+        );
+        return { ok: false, error: "Handler response is not serializable" };
+      }
+      return { ok: true, data: result };
+    } catch (error) {
+      if (!(error instanceof SocketResponseError)) {
+        this.#warn(`channel handler failed for "${payload.channel}": %s`, error);
+      }
+      return {
+        ok: false,
+        error: error instanceof SocketResponseError ? error.message : "Handler error"
+      };
+    }
+  }
+  relayWhisper(socket, payload) {
+    if (!this.#storage.has(socket.id, payload.channel)) {
+      return { ok: false, error: "Not subscribed" };
+    }
+    this.socketService.to(payload.channel).except(socket.id).emit(`client:${payload.event}`, payload.data);
+    return { ok: true };
+  }
+  deleteSocket(socketId) {
+    this.#storage.deleteSocket(socketId);
+  }
+  clear() {
+    this.#storage.clear();
+    this.#channelOperations.clear();
+  }
+  getSocketIds(channelName) {
+    return this.#storage.socketIdsFor(channelName);
+  }
+  subscriptionCountFor(socketId) {
+    return this.#storage.countForSocket(socketId);
+  }
+  get channelsCount() {
+    return this.#storage.channelsCount;
+  }
+  #warn(message, error) {
+    try {
+      this.logger.warn(message, error);
+    } catch {
+    }
+  }
+  async #withChannelOperation(operationKey, operation) {
+    const previous = this.#channelOperations.get(operationKey) ?? Promise.resolve();
+    const release = Promise.withResolvers();
+    const queued = previous.then(() => release.promise);
+    this.#channelOperations.set(operationKey, queued);
+    await previous;
+    try {
+      return await operation();
+    } finally {
+      release.resolve();
+      if (this.#channelOperations.get(operationKey) === queued) {
+        this.#channelOperations.delete(operationKey);
+      }
+    }
+  }
+  #usesPresence(instance) {
+    return Boolean(
+      instance.constructor.options?.presence && this.presenceManager
+    );
+  }
+  async #refreshExistingSubscription(socket, channelName) {
+    if (!this.#storage.has(socket.id, channelName)) {
+      return null;
+    }
+    let presenceData;
+    try {
+      presenceData = await this.#getPresenceData(socket, channelName);
+    } catch (error) {
+      this.#warn(`failed to refresh subscription for channel "${channelName}": %s`, error);
+      return {
+        ack: { ok: false, error: "Subscribe failed" },
+        created: false
+      };
+    }
+    try {
+      JSON.stringify(presenceData);
+    } catch (error) {
+      this.#warn(
+        `failed to serialize subscription response for channel "${channelName}": %s`,
+        error
+      );
+      return {
+        ack: { ok: false, error: "Subscription response is not serializable" },
+        created: false
+      };
+    }
+    return {
+      ack: {
+        ok: true,
+        presenceData
+      },
+      created: false
+    };
+  }
+  async #getPresenceData(socket, channelName) {
+    if (!this.presenceManager?.hasLocal(channelName, socket.id)) {
+      return void 0;
+    }
+    return this.presenceManager.snapshot(channelName);
+  }
+};
+
+// src/protocol/reply.ts
+var INVALID_SOCKET_MESSAGE = "Invalid socket message";
+var Reply = class _Reply {
+  constructor(id, ok, data, error) {
+    this.id = id;
+    this.ok = ok;
+    this.data = data;
+    this.error = error;
+  }
+  static ok(id, data) {
+    return new _Reply(id, true, data, void 0);
+  }
+  static error(id, error) {
+    return new _Reply(id, false, void 0, error);
+  }
+  static invalidMessage(id) {
+    if (id === void 0) {
+      return { type: "error", error: INVALID_SOCKET_MESSAGE };
+    }
+    return _Reply.error(id, INVALID_SOCKET_MESSAGE).toFrame();
+  }
+  static fromSubscribeResult(id, result) {
+    if (!result) {
+      return _Reply.error(id, "Socket service is not initialized");
+    }
+    if (!result.ack.ok) {
+      return _Reply.error(id, result.ack.error ?? "Subscribe failed");
+    }
+    const data = result.ack.presenceData ? {
+      presenceData: result.ack.presenceData
+    } : void 0;
+    return _Reply.ok(id, data);
+  }
+  static fromChannelAck(id, ack) {
+    return ack.ok ? _Reply.ok(id, ack.data) : _Reply.error(id, ack.error ?? "Handler error");
+  }
+  toFrame() {
+    const frame = {
+      id: this.id,
+      type: "ack",
+      ok: this.ok
+    };
+    if (this.data !== void 0) {
+      frame.data = this.data;
+    }
+    if (this.error !== void 0) {
+      frame.error = this.error;
+    }
+    return frame;
+  }
+};
+
+// src/protocol/message.ts
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+var Message = class _Message {
+  static fromTransport(raw) {
+    try {
+      return _Message.fromParsedTransport(JSON.parse(raw));
+    } catch {
+      return new InvalidMessage(void 0);
+    }
+  }
+  static fromParsedTransport(value) {
+    if (!isRecord(value)) {
+      return new InvalidMessage(void 0);
+    }
+    const id = typeof value.id === "string" ? value.id : void 0;
+    if ("id" in value && typeof value.id !== "string") {
+      return new InvalidMessage(void 0);
+    }
+    if (!isClientMessageType(value.type)) {
+      return new InvalidMessage(id);
+    }
+    if (value.type === "ping") {
+      return new PingMessage(id);
+    }
+    if (value.type === "subscribe" && typeof value.channel === "string") {
+      return new SubscribeMessage(id, value.channel);
+    }
+    if (value.type === "unsubscribe" && typeof value.channel === "string") {
+      return new UnsubscribeMessage(id, value.channel);
+    }
+    if ((value.type === "message" || value.type === "whisper") && typeof value.channel === "string" && typeof value.event === "string") {
+      return new ChannelProtocolMessage(id, value.type, value.channel, value.event, value.data);
+    }
+    return new InvalidMessage(id);
+  }
+};
+var InvalidMessage = class extends Message {
+  constructor(id) {
+    super();
+    this.id = id;
+  }
+  valid = false;
+  type = "invalid";
+  toRejectionFrame() {
+    return Reply.invalidMessage(this.id);
+  }
+};
+var PingMessage = class extends Message {
+  constructor(id) {
+    super();
+    this.id = id;
+  }
+  valid = true;
+  type = "ping";
+};
+var SubscribeMessage = class extends Message {
+  constructor(id, channel) {
+    super();
+    this.id = id;
+    this.channel = channel;
+  }
+  valid = true;
+  type = "subscribe";
+};
+var UnsubscribeMessage = class extends Message {
+  constructor(id, channel) {
+    super();
+    this.id = id;
+    this.channel = channel;
+  }
+  valid = true;
+  type = "unsubscribe";
+};
+var ChannelProtocolMessage = class extends Message {
+  constructor(id, type, channel, event, data) {
+    super();
+    this.id = id;
+    this.type = type;
+    this.channel = channel;
+    this.event = event;
+    this.data = data;
+  }
+  valid = true;
+  toChannelMessage() {
+    return {
+      channel: this.channel,
+      event: this.event,
+      data: this.data
+    };
+  }
+};
+function isClientMessageType(value) {
+  return value === "ping" || value === "subscribe" || value === "unsubscribe" || value === "message" || value === "whisper";
+}
+
+// src/message_queue.ts
+var MessageQueue = class {
+  #queues = /* @__PURE__ */ new Map();
+  #depths = /* @__PURE__ */ new Map();
+  enqueue(key, task, options = {}) {
+    const depth = this.#depths.get(key) ?? 0;
+    if (options.maxDepth !== void 0 && depth >= options.maxDepth) {
+      return false;
+    }
+    this.#depths.set(key, depth + 1);
+    const previous = this.#queues.get(key) ?? Promise.resolve();
+    const next = previous.catch(() => {
+    }).then(task).catch(() => {
+    }).finally(() => {
+      const nextDepth = (this.#depths.get(key) ?? 1) - 1;
+      if (nextDepth <= 0) {
+        this.#depths.delete(key);
+      } else {
+        this.#depths.set(key, nextDepth);
+      }
+      if (this.#queues.get(key) === next) {
+        this.#queues.delete(key);
+      }
+    });
+    this.#queues.set(key, next);
+    return true;
+  }
+  drain(key) {
+    return this.#queues.get(key) ?? Promise.resolve();
+  }
+  delete(key) {
+    this.#queues.delete(key);
+    this.#depths.delete(key);
+  }
+  clear() {
+    this.#queues.clear();
+    this.#depths.clear();
+  }
+};
+
+// src/socket_bus.ts
+import { randomUUID } from "crypto";
+import { Bus } from "@boringnode/bus";
+
+// src/presence_manager.ts
+var PRESENCE_DATA_KEY = "__rlanzSocketPresence";
+var PresenceManager = class {
+  #presence = /* @__PURE__ */ new Map();
+  #fetchSockets = null;
+  /**
+   * Sets the socket fetcher used to build distributed snapshots.
+   */
+  setSocketFetcher(fetchSockets) {
+    this.#fetchSockets = fetchSockets;
+  }
+  /**
+   * Adds a user to a channel.
+   */
+  join(channel, socket, member) {
+    const user = {
+      ...member.data,
+      id: member.id,
+      joinedAt: /* @__PURE__ */ new Date()
+    };
+    const users = this.#presence.get(channel) ?? /* @__PURE__ */ new Map();
+    users.set(socket.id, user);
+    this.#presence.set(channel, users);
+    this.#setSocketPresence(socket, channel, user);
+    return user;
+  }
+  /**
+   * Removes a user from a channel.
+   */
+  leave(channel, socket) {
+    const channelPresence = this.#presence.get(channel);
+    if (channelPresence) {
+      channelPresence.delete(socket.id);
+      if (channelPresence.size === 0) {
+        this.#presence.delete(channel);
+      }
+    }
+    this.#deleteSocketPresence(socket, channel);
+  }
+  /**
+   * Removes a user from every channel.
+   * Returns the list of channels the user left.
+   */
+  leaveAll(socket) {
+    const leftChannels = [];
+    for (const [channel, users] of this.#presence) {
+      if (users.has(socket.id)) {
+        users.delete(socket.id);
+        leftChannels.push(channel);
+        if (users.size === 0) {
+          this.#presence.delete(channel);
+        }
+        this.#deleteSocketPresence(socket, channel);
+      }
+    }
+    return leftChannels;
+  }
+  /**
+   * Gets presence data for a channel.
+   */
+  async snapshot(channel) {
+    if (this.#fetchSockets) {
+      return this.#getFromSockets(channel);
+    }
+    return this.#localSnapshot(channel);
+  }
+  /**
+   * Gets the number of users in a channel.
+   */
+  async count(channel) {
+    return (await this.snapshot(channel)).count;
+  }
+  /**
+   * Checks whether a socket is locally present in a channel.
+   */
+  hasLocal(channel, socketId) {
+    return this.#presence.get(channel)?.has(socketId) || false;
+  }
+  /**
+   * Gets the presence user retained for one local socket.
+   */
+  getLocalUser(channel, socketId) {
+    return this.#presence.get(channel)?.get(socketId);
+  }
+  /**
+   * Lists every local channel where a socket is present.
+   */
+  getLocalChannelsForSocket(socketId) {
+    const channels = [];
+    for (const [channel, users] of this.#presence) {
+      if (users.has(socketId)) {
+        channels.push(channel);
+      }
+    }
+    return channels;
+  }
+  /**
+   * Lists sockets that are locally present in a channel.
+   */
+  getLocalSockets(channel) {
+    const users = this.#presence.get(channel);
+    if (!users) {
+      return [];
+    }
+    return Array.from(users.entries()).map(([socketId, user]) => ({
+      id: socketId,
+      data: {
+        [PRESENCE_DATA_KEY]: {
+          [channel]: user
+        }
+      }
+    }));
+  }
+  #localSnapshot(channel) {
+    return this.#createSnapshot(channel, Array.from(this.#presence.get(channel)?.entries() ?? []));
+  }
+  async #getFromSockets(channel) {
+    const sockets = await this.#fetchSockets(channel);
+    const users = sockets.flatMap((socket) => {
+      const user = socket.data?.[PRESENCE_DATA_KEY]?.[channel];
+      return user ? [[socket.id, user]] : [];
+    });
+    return this.#createSnapshot(channel, users);
+  }
+  #createSnapshot(channel, connections) {
+    const usersById = /* @__PURE__ */ new Map();
+    for (const connection of connections) {
+      const current = usersById.get(connection[1].id);
+      if (!current || this.#compareConnections(connection, current) < 0) {
+        usersById.set(connection[1].id, connection);
+      }
+    }
+    const users = [...usersById.values()].sort((left, right) => this.#compareConnections(left, right)).map(([, user]) => user);
+    return {
+      channel,
+      users,
+      count: users.length
+    };
+  }
+  #compareConnections([leftSocketId, leftUser], [rightSocketId, rightUser]) {
+    const joinedAtDifference = leftUser.joinedAt.getTime() - rightUser.joinedAt.getTime();
+    return joinedAtDifference || leftSocketId.localeCompare(rightSocketId);
+  }
+  #setSocketPresence(socket, channel, user) {
+    socket.data[PRESENCE_DATA_KEY] ??= {};
+    socket.data[PRESENCE_DATA_KEY][channel] = user;
+  }
+  #deleteSocketPresence(socket, channel) {
+    if (!socket.data[PRESENCE_DATA_KEY]) {
+      return;
+    }
+    delete socket.data[PRESENCE_DATA_KEY][channel];
+    if (Object.keys(socket.data[PRESENCE_DATA_KEY]).length === 0) {
+      delete socket.data[PRESENCE_DATA_KEY];
+    }
+  }
+};
+
+// src/presence_socket_frame.ts
+var PresenceSocketFrame = class _PresenceSocketFrame {
+  constructor(transportValue, socketValue) {
+    this.transportValue = transportValue;
+    this.socketValue = socketValue;
+  }
+  /**
+   * Create one transport frame from a local socket presence entry.
+   */
+  static fromSocket(channel, socket) {
+    const user = socket.data[PRESENCE_DATA_KEY]?.[channel];
+    if (!user || Number.isNaN(user.joinedAt.getTime())) {
+      throw new Error(`Socket "${socket.id}" has no valid presence for channel "${channel}"`);
+    }
+    const transport = {
+      id: socket.id,
+      data: {
+        [PRESENCE_DATA_KEY]: {
+          [channel]: {
+            // Keep custom fields. Convert only the presence timestamp.
+            ...user,
+            joinedAt: user.joinedAt.toISOString()
+          }
+        }
+      }
+    };
+    return new _PresenceSocketFrame(transport, socket);
+  }
+  /**
+   * Validate one transport value and restore its presence timestamps.
+   */
+  static fromTransport(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value)) {
+      return null;
+    }
+    const transport = value;
+    if (typeof transport.id !== "string" || !transport.data || typeof transport.data !== "object" || Array.isArray(transport.data)) {
+      return null;
+    }
+    const data = transport.data;
+    const presence = data[PRESENCE_DATA_KEY];
+    if (presence === void 0) {
+      return new _PresenceSocketFrame(transport, {
+        id: transport.id,
+        data: { ...data }
+      });
+    }
+    if (!presence || typeof presence !== "object" || Array.isArray(presence)) {
+      return null;
+    }
+    const restoredPresence = {};
+    for (const [channel, candidate] of Object.entries(presence)) {
+      if (!candidate || typeof candidate !== "object" || Array.isArray(candidate)) {
+        return null;
+      }
+      const user = candidate;
+      if (typeof user.id !== "string" || typeof user.joinedAt !== "string" || Number.isNaN(Date.parse(user.joinedAt))) {
+        return null;
+      }
+      restoredPresence[channel] = {
+        ...user,
+        id: user.id,
+        joinedAt: new Date(user.joinedAt)
+      };
+    }
+    return new _PresenceSocketFrame(transport, {
+      id: transport.id,
+      data: {
+        ...data,
+        [PRESENCE_DATA_KEY]: restoredPresence
+      }
+    });
+  }
+  /**
+   * Return the validated transport value.
+   */
+  toTransport() {
+    return this.transportValue;
+  }
+  /**
+   * Return the socket value with restored presence timestamps.
+   */
+  toSocket() {
+    return this.socketValue;
+  }
+};
+
+// src/duration.ts
+import { parse as parseDurationExpression } from "@lukeed/ms";
+function parseDuration(name, duration) {
+  if (duration === void 0) {
+    return void 0;
+  }
+  const milliseconds = typeof duration === "number" ? duration : parseDurationExpression(duration);
+  if (typeof milliseconds === "undefined" || !Number.isFinite(milliseconds) || milliseconds <= 0) {
+    throw new Error(`${name} must be a positive duration`);
+  }
+  return milliseconds;
+}
+
+// src/socket_bus.ts
+var DEFAULT_CHANNEL = "socket::broadcast";
+var DEFAULT_PRESENCE_TIMEOUT = 100;
+var DEFAULT_RETRY_QUEUE_MAX_SIZE = 1e3;
+function resolveRetryQueueConfig(config) {
+  const maxSize = config?.maxSize === void 0 ? DEFAULT_RETRY_QUEUE_MAX_SIZE : config.maxSize;
+  if (maxSize !== null && (!Number.isSafeInteger(maxSize) || maxSize <= 0)) {
+    throw new Error("transport.retryQueue.maxSize must be a positive integer or null");
+  }
+  return {
+    enabled: true,
+    maxSize,
+    ...config
+  };
+}
+function parseBusMessage(payload) {
+  if (!payload || typeof payload !== "object" || Array.isArray(payload)) {
+    return null;
+  }
+  const message = payload;
+  if (typeof message.origin !== "string") {
+    return null;
+  }
+  switch (message.type) {
+    case "channel:event":
+      return typeof message.channel === "string" && typeof message.event === "string" && Array.isArray(message.except) && message.except.every((socketId) => typeof socketId === "string") ? message : null;
+    case "broadcast:event":
+      return typeof message.event === "string" ? message : null;
+    case "presence:sockets:request":
+      return typeof message.requestId === "string" && typeof message.channel === "string" ? message : null;
+    case "presence:sockets:response":
+      if (typeof message.target !== "string" || typeof message.requestId !== "string" || !Array.isArray(message.sockets)) {
+        return null;
+      }
+      const sockets = Array.from(message.sockets, PresenceSocketFrame.fromTransport);
+      return sockets.every((socket) => socket !== null) ? { ...message, sockets } : null;
+    default:
+      return null;
+  }
+}
+var SocketBus = class {
+  constructor(transport, handlers) {
+    this.handlers = handlers;
+    this.#channel = transport.channel ?? DEFAULT_CHANNEL;
+    this.#presenceTimeout = parseDuration("transport.presenceTimeout", transport.presenceTimeout) ?? DEFAULT_PRESENCE_TIMEOUT;
+    this.#bus = new Bus(transport.driver(), {
+      retryQueue: resolveRetryQueueConfig(transport.retryQueue)
+    });
+  }
+  #origin = randomUUID();
+  #channel;
+  #bus;
+  #presenceTimeout;
+  #pendingPresenceRequests = /* @__PURE__ */ new Map();
+  async start() {
+    await this.#bus.subscribe(this.#channel, (payload) => {
+      try {
+        const message = parseBusMessage(payload);
+        if (!message || message.origin === this.#origin) {
+          return;
+        }
+        switch (message.type) {
+          case "channel:event":
+            this.handlers.channel(message);
+            return;
+          case "broadcast:event":
+            this.handlers.broadcast(message);
+            return;
+          case "presence:sockets:request":
+            void this.#respondToPresenceRequest(message).catch(() => {
+            });
+            return;
+          case "presence:sockets:response":
+            this.#handlePresenceResponse(message);
+            return;
+        }
+      } catch {
+        return;
+      }
+    });
+  }
+  publishChannel(channel, event, data, except) {
+    const message = {
+      type: "channel:event",
+      origin: this.#origin,
+      channel,
+      event,
+      data,
+      except: except ?? []
+    };
+    void this.#bus.publish(this.#channel, message);
+  }
+  publishBroadcast(event, data) {
+    const message = {
+      type: "broadcast:event",
+      origin: this.#origin,
+      event,
+      data
+    };
+    void this.#bus.publish(this.#channel, message);
+  }
+  fetchPresenceSockets(channel) {
+    const requestId = randomUUID();
+    return new Promise((resolve) => {
+      const timeout = setTimeout(() => {
+        const request = this.#pendingPresenceRequests.get(requestId);
+        if (!request) {
+          return;
+        }
+        this.#pendingPresenceRequests.delete(requestId);
+        resolve(request.sockets.map((socket) => socket.toSocket()));
+      }, this.#presenceTimeout);
+      this.#pendingPresenceRequests.set(requestId, {
+        sockets: [],
+        resolve,
+        timeout
+      });
+      const message = {
+        type: "presence:sockets:request",
+        origin: this.#origin,
+        requestId,
+        channel
+      };
+      void this.#bus.publish(this.#channel, message);
+    });
+  }
+  async close() {
+    for (const [requestId, request] of this.#pendingPresenceRequests) {
+      clearTimeout(request.timeout);
+      request.resolve(request.sockets.map((socket) => socket.toSocket()));
+      this.#pendingPresenceRequests.delete(requestId);
+    }
+    await this.#bus.disconnect();
+  }
+  async #respondToPresenceRequest(message) {
+    const response = {
+      type: "presence:sockets:response",
+      origin: this.#origin,
+      target: message.origin,
+      requestId: message.requestId,
+      sockets: this.handlers.presenceSockets(message.channel)
+    };
+    await this.#bus.publish(this.#channel, response);
+  }
+  #handlePresenceResponse(message) {
+    if (message.target !== this.#origin) {
+      return;
+    }
+    const request = this.#pendingPresenceRequests.get(message.requestId);
+    if (!request) {
+      return;
+    }
+    request.sockets.push(...message.sockets);
+  }
+};
+
+// src/socket_upgrader.ts
+var DEFAULT_WEBSOCKET_PATH = "/socket";
+var SocketUpgrader = class _SocketUpgrader {
+  constructor(server, config, runWithHttpContext, reportError = () => {
+  }) {
+    this.server = server;
+    this.config = config;
+    this.runWithHttpContext = runWithHttpContext;
+    this.reportError = reportError;
+    this.#path = config?.path ?? DEFAULT_WEBSOCKET_PATH;
+  }
+  #path;
+  async handle(request, socket, head, accept) {
+    if (!this.#matchesPath(request)) {
+      return false;
+    }
+    const result = await this.#prepareUpgrade(request);
+    if ("rejected" in result) {
+      if (result.rejected === "origin") {
+        _SocketUpgrader.reject(socket, 403, "Forbidden");
+        return true;
+      }
+      _SocketUpgrader.reject(socket, 401, "Unauthorized");
+      return true;
+    }
+    this.server.handleUpgrade(request, socket, head, (connection) => {
+      accept(connection, request, result.accepted);
+    });
+    return true;
+  }
+  static reject(socket, statusCode, reason) {
+    if (!socket.writableEnded) {
+      socket.write(`HTTP/1.1 ${statusCode} ${reason}\r
+\r
+`);
+    }
+    socket.destroy();
+  }
+  #matchesPath(request) {
+    const url = new URL(request.url ?? "/", "ws://localhost");
+    return url.pathname === this.#path;
+  }
+  #isOriginAllowed(request, httpContext) {
+    const origin = request.headers.origin;
+    if (!origin) {
+      return true;
+    }
+    if (this.config?.origin !== void 0) {
+      return this.#matchesOriginPolicy(origin, httpContext);
+    }
+    const host = request.headers.host;
+    if (!host) {
+      return false;
+    }
+    const forwardedHeader = request.headers["x-forwarded-proto"];
+    const forwardedProtocol = (Array.isArray(forwardedHeader) ? forwardedHeader[0] : forwardedHeader)?.split(",")[0]?.trim();
+    const protocol = forwardedProtocol === "http" || forwardedProtocol === "https" ? forwardedProtocol : request.socket.encrypted ? "https" : "http";
+    try {
+      return origin === new URL(`${protocol}://${host}`).origin;
+    } catch {
+      return false;
+    }
+  }
+  #matchesOriginPolicy(origin, httpContext) {
+    let originPolicy = this.config?.origin ?? false;
+    if (typeof originPolicy === "function") {
+      originPolicy = originPolicy(origin, httpContext);
+    }
+    if (originPolicy === true || originPolicy === "*") {
+      return true;
+    }
+    if (originPolicy === false) {
+      return false;
+    }
+    if (Array.isArray(originPolicy)) {
+      return originPolicy.includes(origin);
+    }
+    return originPolicy.split(",").includes(origin);
+  }
+  async #prepareUpgrade(request) {
+    return this.runWithHttpContext(
+      request,
+      async (httpContext) => {
+        const accepted = await this.#authenticate(httpContext);
+        return accepted ? { accepted } : { rejected: "authentication" };
+      },
+      (httpContext) => {
+        return this.#isOriginAllowed(request, httpContext) ? void 0 : { rejected: "origin" };
+      }
+    );
+  }
+  async #authenticate(httpContext) {
+    const config = this.config;
+    if (!config?.authenticate) {
+      return { httpContext };
+    }
+    try {
+      const ctx = {
+        httpContext
+      };
+      const result = await config.authenticate(ctx);
+      if (result === false || result === null || result === void 0) {
+        return null;
+      }
+      return {
+        httpContext,
+        user: result
+      };
+    } catch (error) {
+      try {
+        this.reportError("socket authentication failed: %s", error);
+      } catch {
+      }
+      return null;
+    }
+  }
+};
+
+// src/socket_service.ts
+var DEFAULT_PING_INTERVAL = 25e3;
+var DEFAULT_PING_TIMEOUT = 5e3;
+var DEFAULT_MAX_PAYLOAD = 1024 * 1024;
+var DEFAULT_MAX_QUEUED_MESSAGES = 100;
+var DEFAULT_MAX_MESSAGES_PER_INTERVAL = 1e3;
+var DEFAULT_MESSAGE_RATE_INTERVAL = 1e3;
+var DEFAULT_MAX_BUFFERED_AMOUNT = 16 * 1024 * 1024;
+var DEFAULT_MAX_OUTBOUND_PAYLOAD = 1024 * 1024;
+var DEFAULT_MAX_SUBSCRIPTIONS_PER_SOCKET = 100;
+var DEFAULT_MAX_CHANNEL_NAME_LENGTH = 255;
+var DEFAULT_SHUTDOWN_TIMEOUT = 5e3;
+var CLOSE_POLICY_VIOLATION = 1008;
+var CLOSE_MESSAGE_TOO_BIG = 1009;
+var CLOSE_OUTBOUND_BUFFER_LIMIT = "Socket outbound buffer limit exceeded";
+var CLOSE_OUTBOUND_MESSAGE_TOO_BIG = "Socket outbound message too big";
+var SERVER_DISCONNECT_REASON = "Socket server disconnected";
+async function settleBeforeDeadline(promise, deadline) {
+  const remaining = deadline - Date.now();
+  if (remaining <= 0) {
+    void promise.catch(() => {
+    });
+    return null;
+  }
+  let timer;
+  try {
+    return await Promise.race([
+      promise.then(
+        (value) => ({ status: "fulfilled", value }),
+        (reason) => ({ status: "rejected", reason })
+      ),
+      new Promise((resolve) => {
+        timer = setTimeout(() => resolve(null), remaining);
+      })
+    ]);
+  } finally {
+    if (timer) clearTimeout(timer);
+  }
+}
+function serializeFrame(frame) {
+  return JSON.stringify(frame);
+}
+function sendFrame(connection, frame, config) {
+  const serializedFrame = serializeFrame(frame);
+  return sendSerializedFrameWithBackpressure(connection, serializedFrame, config);
+}
+function sendSerializedFrameWithBackpressure(connection, serializedFrame, config) {
+  if (connection.readyState !== WebSocket.OPEN) {
+    return false;
+  }
+  const payloadSize = Buffer.byteLength(serializedFrame);
+  if (payloadSize > config.maxOutboundPayload) {
+    closeConnection(connection, CLOSE_MESSAGE_TOO_BIG, CLOSE_OUTBOUND_MESSAGE_TOO_BIG);
+    return false;
+  }
+  if (connection.bufferedAmount + payloadSize > config.maxBufferedAmount) {
+    closeConnection(connection, CLOSE_POLICY_VIOLATION, CLOSE_OUTBOUND_BUFFER_LIMIT);
+    return false;
+  }
+  connection.send(serializedFrame);
+  return true;
+}
+function parsePositiveInteger(name, value, fallback) {
+  if (value === void 0) {
+    return fallback;
+  }
+  if (!Number.isSafeInteger(value) || value <= 0) {
+    throw new Error(`${name} must be a positive integer`);
+  }
+  return value;
+}
+function resolveHeartbeatConfig(config) {
+  const pingInterval = parseDuration("websocket.pingInterval", config?.pingInterval);
+  const pingTimeout = parseDuration("websocket.pingTimeout", config?.pingTimeout);
+  if (pingInterval === void 0 && pingTimeout === void 0) {
+    return null;
+  }
+  return {
+    interval: pingInterval ?? DEFAULT_PING_INTERVAL,
+    timeout: pingTimeout ?? DEFAULT_PING_TIMEOUT
+  };
+}
+function resolveInboundMessageConfig(config) {
+  const messageRateInterval = parseDuration("websocket.messageRateInterval", config?.messageRateInterval) ?? DEFAULT_MESSAGE_RATE_INTERVAL;
+  return {
+    maxPayload: parsePositiveInteger(
+      "websocket.maxPayload",
+      config?.maxPayload,
+      DEFAULT_MAX_PAYLOAD
+    ),
+    maxQueuedMessages: parsePositiveInteger(
+      "websocket.maxQueuedMessages",
+      config?.maxQueuedMessages,
+      DEFAULT_MAX_QUEUED_MESSAGES
+    ),
+    maxMessagesPerInterval: parsePositiveInteger(
+      "websocket.maxMessagesPerInterval",
+      config?.maxMessagesPerInterval,
+      DEFAULT_MAX_MESSAGES_PER_INTERVAL
+    ),
+    messageRateInterval,
+    subscriptionLimits: {
+      maxSubscriptionsPerSocket: parsePositiveInteger(
+        "websocket.maxSubscriptionsPerSocket",
+        config?.maxSubscriptionsPerSocket,
+        DEFAULT_MAX_SUBSCRIPTIONS_PER_SOCKET
+      ),
+      maxChannelNameLength: parsePositiveInteger(
+        "websocket.maxChannelNameLength",
+        config?.maxChannelNameLength,
+        DEFAULT_MAX_CHANNEL_NAME_LENGTH
+      )
+    }
+  };
+}
+function resolveOutboundMessageConfig(config) {
+  return {
+    maxBufferedAmount: parsePositiveInteger(
+      "websocket.maxBufferedAmount",
+      config?.maxBufferedAmount,
+      DEFAULT_MAX_BUFFERED_AMOUNT
+    ),
+    maxOutboundPayload: parsePositiveInteger(
+      "websocket.maxOutboundPayload",
+      config?.maxOutboundPayload,
+      DEFAULT_MAX_OUTBOUND_PAYLOAD
+    )
+  };
+}
+function getRawDataByteLength(data) {
+  if (Array.isArray(data)) {
+    return data.reduce((total, chunk) => total + chunk.byteLength, 0);
+  }
+  return data.byteLength;
+}
+function closeConnection(connection, code, reason) {
+  if (connection.readyState === WebSocket.OPEN) {
+    connection.close(code, reason);
+  }
+}
+var SocketService = class extends Emittery {
+  #server = null;
+  #httpServer = null;
+  #upgradeHandler = null;
+  #sockets = /* @__PURE__ */ new Map();
+  #channelSubscriptions = null;
+  #presenceManager = null;
+  #bus = null;
+  #fake = null;
+  #deliverySink = {
+    dispatch: (emission) => {
+      this.#deliverBroadcast(emission);
+    }
+  };
+  #broadcastSink = this.#deliverySink;
+  #status = "stopped";
+  #lastError = null;
+  #heartbeatInterval = null;
+  #heartbeatTimeouts = /* @__PURE__ */ new Map();
+  #messageQueue = new MessageQueue();
+  #messageRates = /* @__PURE__ */ new Map();
+  #socketFinalizations = /* @__PURE__ */ new Map();
+  #bootGeneration = 0;
+  #bootPromise = null;
+  #closePromise = null;
+  #outboundMessageConfig = resolveOutboundMessageConfig(void 0);
+  #shutdownTimeout = DEFAULT_SHUTDOWN_TIMEOUT;
+  #logger = null;
+  /**
+   * Accesses the underlying ws server.
+   */
+  get server() {
+    if (!this.#server) {
+      throw new Error("WebSocket server is not initialized. Call boot() first.");
+    }
+    return this.#server;
+  }
+  setPresenceManager(presenceManager) {
+    this.#presenceManager = presenceManager;
+    this.#channelSubscriptions?.setPresenceManager(presenceManager);
+    this.#configurePresenceFetcher();
+  }
+  boot(httpServer, config, channelRouter, logger, runWithHttpContext) {
+    if (this.#status === "ready") return Promise.resolve();
+    if (this.#bootPromise) return this.#bootPromise;
+    if (this.#status === "stopping") {
+      return Promise.reject(new Error("Socket service is stopping"));
+    }
+    this.#closePromise = null;
+    this.#status = "starting";
+    this.#lastError = null;
+    this.#logger = logger;
+    const generation = ++this.#bootGeneration;
+    const bootPromise = this.#boot(
+      httpServer,
+      config,
+      channelRouter,
+      logger,
+      runWithHttpContext,
+      generation
+    ).finally(() => {
+      if (this.#bootPromise === bootPromise) this.#bootPromise = null;
+    });
+    this.#bootPromise = bootPromise;
+    return bootPromise;
+  }
+  async #boot(httpServer, config, channelRouter, logger, runWithHttpContext, generation) {
+    const websocketConfig = config.websocket;
+    const heartbeatConfig = resolveHeartbeatConfig(websocketConfig);
+    const inboundMessageConfig = resolveInboundMessageConfig(websocketConfig);
+    this.#outboundMessageConfig = resolveOutboundMessageConfig(websocketConfig);
+    this.#shutdownTimeout = parseDuration("websocket.shutdownTimeout", websocketConfig?.shutdownTimeout) ?? DEFAULT_SHUTDOWN_TIMEOUT;
+    this.#channelSubscriptions = new ChannelSubscriptions(
+      this,
+      channelRouter,
+      logger,
+      this.#presenceManager ?? void 0,
+      inboundMessageConfig.subscriptionLimits
+    );
+    try {
+      if (config.transport) {
+        this.#bus = new SocketBus(config.transport, {
+          channel: (message) => {
+            this.#traceBroadcast(
+              {
+                target: "channel",
+                channel: message.channel,
+                event: message.event,
+                via: "bus",
+                except: message.except
+              },
+              () => this.#emitToChannelLocally(
+                message.channel,
+                message.event,
+                message.data,
+                message.except
+              )
+            );
+          },
+          broadcast: (message) => {
+            this.#traceBroadcast(
+              { target: "global", event: message.event, via: "bus" },
+              () => this.#broadcastLocally(message.event, message.data)
+            );
+          },
+          presenceSockets: (channel) => {
+            return this.#getLocalPresenceSockets(channel);
+          }
+        });
+        await this.#bus.start();
+        if (generation !== this.#bootGeneration || this.#status !== "starting") {
+          throw new Error("Socket service boot interrupted by shutdown");
+        }
+        this.#configurePresenceFetcher();
+      }
+      const websocketServer = new WebSocketServer({
+        noServer: true,
+        maxPayload: inboundMessageConfig.maxPayload
+      });
+      this.#server = websocketServer;
+      this.#httpServer = httpServer;
+      const upgrader = new SocketUpgrader(
+        websocketServer,
+        websocketConfig,
+        runWithHttpContext,
+        (message, error) => this.#warn(message, error)
+      );
+      this.#upgradeHandler = (request, socket, head) => {
+        upgrader.handle(request, socket, head, (connection, upgradeRequest, accepted) => {
+          this.#handleConnection(connection, upgradeRequest, accepted, inboundMessageConfig);
+        }).catch((error) => {
+          this.#warn("failed to upgrade socket connection: %s", error);
+          SocketUpgrader.reject(socket, 500, "Internal Server Error");
+        });
+      };
+      httpServer.on("upgrade", this.#upgradeHandler);
+      this.#startHeartbeat(heartbeatConfig);
+      this.#status = "ready";
+    } catch (error) {
+      if (generation !== this.#bootGeneration || this.#status === "stopping") throw error;
+      this.#lastError = error instanceof Error ? error : new Error("Socket service boot failed");
+      this.#status = "failed";
+      await this.close();
+      throw error;
+    }
+  }
+  #handleConnection(connection, request, upgrade, inboundMessageConfig) {
+    if (this.#status !== "ready") {
+      connection.terminate();
+      return;
+    }
+    const socket = this.#wrapSocket(connection, request, upgrade);
+    connectChannel.traceSync(
+      () => {
+        this.#sockets.set(socket.id, socket);
+        this.#emitLifecycleEvent("connect", { socket });
+      },
+      { socketId: socket.id }
+    );
+    connection.on("error", () => {
+    });
+    connection.on("message", (data) => {
+      if (getRawDataByteLength(data) > inboundMessageConfig.maxPayload) {
+        closeConnection(connection, CLOSE_MESSAGE_TOO_BIG, "Message too big");
+        return;
+      }
+      if (!this.#acceptMessageRate(socket.id, inboundMessageConfig)) {
+        closeConnection(connection, CLOSE_POLICY_VIOLATION, "Socket message rate limit exceeded");
+        return;
+      }
+      const message = Message.fromTransport(data.toString());
+      if (message.type === "ping") {
+        sendFrame(
+          socket.raw.connection,
+          { id: message.id, type: "pong" },
+          this.#outboundMessageConfig
+        );
+        return;
+      }
+      const enqueued = this.#messageQueue.enqueue(
+        socket.id,
+        async () => {
+          await this.#handleMessage(socket, message).catch((error) => {
+            try {
+              this.#logger?.warn("unexpected socket message failure: %s", error);
+            } catch {
+            }
+            sendFrame(
+              connection,
+              message.id === void 0 ? { type: "error", error: "Unexpected socket error" } : Reply.error(message.id, "Unexpected socket error").toFrame(),
+              this.#outboundMessageConfig
+            );
+          });
+        },
+        { maxDepth: inboundMessageConfig.maxQueuedMessages }
+      );
+      if (!enqueued) {
+        closeConnection(connection, CLOSE_POLICY_VIOLATION, "Socket message queue limit exceeded");
+      }
+    });
+    connection.on("pong", () => {
+      this.#clearHeartbeatTimeout(socket.id);
+    });
+    connection.on("close", () => {
+      void Promise.resolve().then(() => this.#finalizeSocket(socket)).catch((error) => this.markFailed(error));
+    });
+  }
+  #finalizeSocket(socket) {
+    const pending = this.#socketFinalizations.get(socket.id);
+    if (pending) {
+      return pending;
+    }
+    if (!this.#sockets.has(socket.id)) {
+      return Promise.resolve();
+    }
+    const channelSubscriptions = this.#channelSubscriptions;
+    const finalization = disconnectChannel.tracePromise(
+      async () => {
+        this.#clearHeartbeatTimeout(socket.id);
+        this.#messageRates.delete(socket.id);
+        await this.#messageQueue.drain(socket.id);
+        this.#messageQueue.delete(socket.id);
+        await channelSubscriptions?.leaveAll(socket);
+        channelSubscriptions?.deleteSocket(socket.id);
+        this.#sockets.delete(socket.id);
+        this.#emitLifecycleEvent("disconnect", { socket, reason: "close" });
+      },
+      {
+        socketId: socket.id,
+        reason: "close",
+        subscriptions: channelSubscriptions?.subscriptionCountFor(socket.id) ?? 0
+      }
+    ).finally(() => {
+      this.#socketFinalizations.delete(socket.id);
+    });
+    this.#socketFinalizations.set(socket.id, finalization);
+    return finalization;
+  }
+  async #handleMessage(socket, message) {
+    if (!message.valid) {
+      sendFrame(socket.raw.connection, message.toRejectionFrame(), this.#outboundMessageConfig);
+      return;
+    }
+    switch (message.type) {
+      case "ping":
+        return;
+      case "subscribe": {
+        const traceMessage = {
+          socketId: socket.id,
+          channel: message.channel
+        };
+        await subscribeChannel.tracePromise(async () => {
+          const result = await this.#channelSubscriptions?.subscribe(socket, message.channel);
+          traceMessage.created = result?.created ?? false;
+          traceMessage.ok = result?.ack.ok ?? false;
+          if (!result?.ack.ok) {
+            traceMessage.error = result?.ack.error ?? "Socket service is not initialized";
+          }
+          if (result?.created) {
+            this.#emitLifecycleEvent("subscribe", { socket, channel: message.channel });
+          }
+          sendFrame(
+            socket.raw.connection,
+            Reply.fromSubscribeResult(message.id, result).toFrame(),
+            this.#outboundMessageConfig
+          );
+        }, traceMessage);
+        return;
+      }
+      case "unsubscribe": {
+        const traceMessage = {
+          socketId: socket.id,
+          channel: message.channel
+        };
+        await unsubscribeChannel.tracePromise(async () => {
+          traceMessage.removed = await this.#channelSubscriptions?.leave(socket, message.channel) ?? false;
+          traceMessage.ok = true;
+          this.#emitLifecycleEvent("unsubscribe", { socket, channel: message.channel });
+          sendFrame(
+            socket.raw.connection,
+            Reply.ok(message.id).toFrame(),
+            this.#outboundMessageConfig
+          );
+        }, traceMessage);
+        return;
+      }
+      case "message":
+      case "whisper": {
+        await this.#handleChannelFrame(socket, message);
+        return;
+      }
+    }
+  }
+  async #handleChannelFrame(socket, message) {
+    const payload = message.toChannelMessage();
+    const traceMessage = {
+      socketId: socket.id,
+      channel: payload.channel,
+      event: payload.event
+    };
+    await channelMessageChannel.tracePromise(async () => {
+      const ack = await this.#handleChannelPayload(socket, message.type, payload);
+      traceMessage.ok = ack.ok;
+      if (!ack.ok) {
+        traceMessage.error = ack.error ?? "Handler error";
+      }
+      sendFrame(
+        socket.raw.connection,
+        Reply.fromChannelAck(message.id, ack).toFrame(),
+        this.#outboundMessageConfig
+      );
+    }, traceMessage);
+  }
+  async #handleChannelPayload(socket, type, payload) {
+    if (typeof payload.channel !== "string" || typeof payload.event !== "string") {
+      return { ok: false, error: `Invalid channel ${type}` };
+    }
+    if (type === "message") {
+      return this.#channelSubscriptions.handleMessage(socket, payload);
+    }
+    return this.#channelSubscriptions.relayWhisper(socket, payload);
+  }
+  #wrapSocket(connection, request, upgrade) {
+    const raw = {
+      id: randomUUID2(),
+      data: {},
+      connection,
+      request,
+      httpContext: upgrade.httpContext
+    };
+    return {
+      id: raw.id,
+      user: upgrade.user,
+      getUserOrFail() {
+        if (this.user === void 0) {
+          throw new SocketResponseError("Unauthorized");
+        }
+        return this.user;
+      },
+      emit: (event, data) => {
+        this.#sendSerializedEventFrame(connection, serializeFrame({ type: "event", event, data }));
+      },
+      disconnect() {
+        connection.close(SERVER_DISCONNECT_CODE, SERVER_DISCONNECT_REASON);
+      },
+      raw
+    };
+  }
+  to(channel) {
+    return {
+      emit: (event, data) => {
+        this.#broadcastSink.dispatch({ target: "channel", channel, event, data });
+      },
+      except: (socketId) => ({
+        emit: (event, data) => {
+          this.#broadcastSink.dispatch({
+            target: "channel",
+            channel,
+            event,
+            data,
+            except: [socketId]
+          });
+        }
+      })
+    };
+  }
+  broadcast(event, data) {
+    this.#broadcastSink.dispatch({ target: "global", event, data });
+  }
+  #deliverBroadcast(emission) {
+    switch (emission.target) {
+      case "channel": {
+        const channel = emission.channel;
+        const serializedFrame = serializeFrame({
+          type: "event",
+          channel,
+          event: emission.event,
+          data: emission.data
+        });
+        this.#bus?.publishChannel(channel, emission.event, emission.data, emission.except);
+        const traceMessage = {
+          target: "channel",
+          channel,
+          event: emission.event,
+          via: "local"
+        };
+        if (emission.except) {
+          traceMessage.except = emission.except;
+        }
+        this.#traceBroadcast(
+          traceMessage,
+          () => this.#emitToChannelLocally(
+            channel,
+            emission.event,
+            emission.data,
+            emission.except,
+            serializedFrame
+          )
+        );
+        return;
+      }
+      case "global": {
+        const serializedFrame = serializeFrame({
+          type: "event",
+          event: emission.event,
+          data: emission.data
+        });
+        this.#bus?.publishBroadcast(emission.event, emission.data);
+        this.#traceBroadcast(
+          { target: "global", event: emission.event, via: "local" },
+          () => this.#broadcastLocally(emission.event, emission.data, serializedFrame)
+        );
+      }
+    }
+  }
+  #traceBroadcast(message, deliver) {
+    broadcastChannel.traceSync(() => {
+      message.delivered = deliver();
+    }, message);
+  }
+  #sendSerializedEventFrame(connection, serializedFrame) {
+    return sendSerializedFrameWithBackpressure(
+      connection,
+      serializedFrame,
+      this.#outboundMessageConfig
+    );
+  }
+  #emitToChannelLocally(channel, event, data, except = [], serializedFrame = serializeFrame({ type: "event", channel, event, data })) {
+    let delivered = 0;
+    for (const socketId of this.#channelSubscriptions?.getSocketIds(channel) ?? []) {
+      if (except.includes(socketId)) {
+        continue;
+      }
+      const socket = this.#sockets.get(socketId);
+      if (socket && this.#sendSerializedEventFrame(socket.raw.connection, serializedFrame)) {
+        delivered += 1;
+      }
+    }
+    return delivered;
+  }
+  #broadcastLocally(event, data, serializedFrame = serializeFrame({ type: "event", event, data })) {
+    let delivered = 0;
+    for (const socket of this.#sockets.values()) {
+      if (this.#sendSerializedEventFrame(socket.raw.connection, serializedFrame)) {
+        delivered += 1;
+      }
+    }
+    return delivered;
+  }
+  #configurePresenceFetcher() {
+    if (!this.#presenceManager || !this.#bus) {
+      return;
+    }
+    this.#presenceManager.setSocketFetcher(async (channel) => {
+      return [
+        ...this.#presenceManager.getLocalSockets(channel),
+        ...await this.#bus.fetchPresenceSockets(channel)
+      ];
+    });
+  }
+  #getLocalPresenceSockets(channel) {
+    return (this.#presenceManager?.getLocalSockets(channel) ?? []).map((socket) => {
+      return PresenceSocketFrame.fromSocket(channel, socket).toTransport();
+    });
+  }
+  getSocket(socketId) {
+    return this.#sockets.get(socketId);
+  }
+  get connectionsCount() {
+    return this.#sockets.size;
+  }
+  get status() {
+    return this.#status;
+  }
+  get ready() {
+    return this.#status === "ready" && Boolean(this.#server);
+  }
+  fake() {
+    const fake = new SocketFake(() => {
+      if (this.#fake === fake) {
+        this.restore();
+      }
+    });
+    this.#fake = fake;
+    this.#broadcastSink = fake;
+    return fake;
+  }
+  restore() {
+    this.#fake = null;
+    this.#broadcastSink = this.#deliverySink;
+  }
+  markFailed(error) {
+    this.#lastError = error instanceof Error ? error : new Error("Socket service failed");
+    this.#status = "failed";
+  }
+  #warn(message, error) {
+    try {
+      this.#logger?.warn(message, error);
+    } catch {
+    }
+  }
+  #emitLifecycleEvent(eventName, event) {
+    void this.emit(eventName, event).catch((error) => {
+      try {
+        this.#logger?.warn("socket %s listener failed: %s", eventName, error);
+      } catch {
+      }
+    });
+  }
+  health() {
+    return {
+      status: this.#status,
+      ready: this.ready,
+      connections: this.#sockets.size,
+      channels: this.#channelSubscriptions?.channelsCount ?? 0,
+      ...this.#lastError ? { lastError: this.#lastError.message } : {}
+    };
+  }
+  #startHeartbeat(config) {
+    this.#stopHeartbeat();
+    if (!config) {
+      return;
+    }
+    this.#heartbeatInterval = setInterval(() => {
+      this.#pingSockets(config.timeout);
+    }, config.interval);
+  }
+  #pingSockets(timeout) {
+    for (const socket of this.#sockets.values()) {
+      const { connection } = socket.raw;
+      if (connection.readyState !== WebSocket.OPEN) {
+        this.#clearHeartbeatTimeout(socket.id);
+        continue;
+      }
+      if (this.#heartbeatTimeouts.has(socket.id)) {
+        continue;
+      }
+      const timeoutId = setTimeout(() => {
+        this.#heartbeatTimeouts.delete(socket.id);
+        connection.terminate();
+      }, timeout);
+      this.#heartbeatTimeouts.set(socket.id, timeoutId);
+      try {
+        connection.ping();
+      } catch {
+        this.#clearHeartbeatTimeout(socket.id);
+        connection.terminate();
+      }
+    }
+  }
+  #clearHeartbeatTimeout(socketId) {
+    const timeout = this.#heartbeatTimeouts.get(socketId);
+    if (!timeout) {
+      return;
+    }
+    clearTimeout(timeout);
+    this.#heartbeatTimeouts.delete(socketId);
+  }
+  #stopHeartbeat() {
+    if (this.#heartbeatInterval) {
+      clearInterval(this.#heartbeatInterval);
+      this.#heartbeatInterval = null;
+    }
+    for (const timeout of this.#heartbeatTimeouts.values()) {
+      clearTimeout(timeout);
+    }
+    this.#heartbeatTimeouts.clear();
+  }
+  #acceptMessageRate(socketId, config) {
+    const now = Date.now();
+    const rate = this.#messageRates.get(socketId);
+    if (!rate || now - rate.intervalStartedAt >= config.messageRateInterval) {
+      this.#messageRates.set(socketId, { count: 1, intervalStartedAt: now });
+      return true;
+    }
+    if (rate.count >= config.maxMessagesPerInterval) {
+      return false;
+    }
+    rate.count += 1;
+    return true;
+  }
+  #cleanup() {
+    this.#stopHeartbeat();
+    this.#sockets.clear();
+    this.#messageQueue.clear();
+    this.#messageRates.clear();
+    this.#socketFinalizations.clear();
+    this.#channelSubscriptions?.clear();
+  }
+  close() {
+    if (!this.#closePromise) {
+      if (this.#status === "starting" && this.#bootPromise) {
+        this.#status = "stopping";
+        this.#bootGeneration++;
+        this.#closePromise = this.#close(this.#bootPromise);
+      } else {
+        this.#closePromise = this.#close();
+      }
+    }
+    return this.#closePromise;
+  }
+  async #close(pendingBoot) {
+    const deadline = Date.now() + this.#shutdownTimeout;
+    if (pendingBoot) {
+      const bootResult = await settleBeforeDeadline(pendingBoot, deadline);
+      if (bootResult === null) {
+        if (this.#bootPromise === pendingBoot) this.#bootPromise = null;
+        this.#warn(
+          "socket boot exceeded the %dms shutdown timeout; forcing cleanup",
+          this.#shutdownTimeout
+        );
+      }
+    }
+    const server = this.#server;
+    const bus = this.#bus;
+    const httpServer = this.#httpServer;
+    const upgradeHandler = this.#upgradeHandler;
+    if (this.#status !== "failed") {
+      this.#status = "stopping";
+    }
+    this.#server = null;
+    this.#httpServer = null;
+    this.#upgradeHandler = null;
+    if (httpServer && upgradeHandler) {
+      httpServer.off("upgrade", upgradeHandler);
+    }
+    const serverClose = server ? new Promise((resolve) => {
+      server.close((error) => resolve(error ?? null));
+    }) : Promise.resolve(null);
+    this.#stopHeartbeat();
+    const sockets = [...this.#sockets.values()];
+    for (const socket of sockets) {
+      const { connection } = socket.raw;
+      connection.close(SERVER_DISCONNECT_CODE, SERVER_DISCONNECT_REASON);
+      const terminateTimer = setTimeout(() => connection.terminate(), 50);
+      connection.once("close", () => clearTimeout(terminateTimer));
+    }
+    const errors = [];
+    const finalizations = sockets.map((socket) => {
+      return Promise.resolve().then(() => this.#finalizeSocket(socket));
+    });
+    const results = await settleBeforeDeadline(Promise.allSettled(finalizations), deadline);
+    if (results === null) {
+      this.#warn(
+        "socket finalization exceeded the %dms shutdown timeout; forcing cleanup",
+        this.#shutdownTimeout
+      );
+    } else if (results.status === "fulfilled") {
+      for (const result of results.value) {
+        if (result.status === "rejected") {
+          errors.push(result.reason);
+        }
+      }
+    }
+    this.#cleanup();
+    this.#presenceManager?.setSocketFetcher(null);
+    this.#bus = null;
+    if (bus) {
+      const busCloseResult = await settleBeforeDeadline(bus.close(), deadline);
+      if (busCloseResult === null) {
+        this.#warn(
+          "socket transport exceeded the %dms shutdown timeout; forcing cleanup",
+          this.#shutdownTimeout
+        );
+      } else if (busCloseResult.status === "rejected") {
+        errors.push(busCloseResult.reason);
+      }
+    }
+    const serverCloseResult = await settleBeforeDeadline(serverClose, deadline);
+    if (serverCloseResult === null) {
+      this.#warn(
+        "socket server exceeded the %dms shutdown timeout; forcing cleanup",
+        this.#shutdownTimeout
+      );
+    } else if (serverCloseResult.status === "fulfilled" && serverCloseResult.value) {
+      errors.push(serverCloseResult.value);
+    }
+    if (errors.length > 0) {
+      const error = errors.length === 1 && errors[0] instanceof Error ? errors[0] : new AggregateError(errors, "Socket service shutdown failed");
+      this.markFailed(error);
+      throw error;
+    }
+    if (this.#status !== "failed") {
+      this.#status = "stopped";
+    }
+  }
+};
+
+// src/channel_pattern.ts
+var ChannelPattern = class _ChannelPattern {
+  constructor(value) {
+    this.value = value;
+    this.syntax = ChannelPatternSyntax.from(value);
+  }
+  syntax;
+  /**
+   * Parse one runtime channel pattern.
+   */
+  static from(value) {
+    return new _ChannelPattern(value);
+  }
+  /**
+   * Match one concrete channel name.
+   */
+  match(channelName) {
+    return this.syntax.match(channelName);
+  }
+  /**
+   * Return the most specific matching candidate. Static segments have the highest score.
+   * Parameters score above optional parameters. Wildcards have the lowest score.
+   * Insertion order is preserved for ties.
+   */
+  static firstMatch(channelName, candidates) {
+    const sorted = [...candidates].sort((left, right) => {
+      return _ChannelPattern.#compareSpecificity(left.pattern, right.pattern);
+    });
+    const matched = ChannelPatternSyntax.firstMatch(
+      sorted.map(({ pattern: pattern2 }) => pattern2.syntax),
+      channelName
+    );
+    if (!matched) return null;
+    const { pattern, channel } = sorted[matched.index];
+    return { pattern, channel, params: matched.params };
+  }
+  static #compareSpecificity(left, right) {
+    return left.syntax.compareSpecificity(right.syntax);
+  }
+};
+
+// src/channel_router.ts
+var ChannelRouter = class {
+  constructor(makeChannel = (channel) => new channel(), createMiddlewareRunner) {
+    this.makeChannel = makeChannel;
+    this.createMiddlewareRunner = createMiddlewareRunner;
+  }
+  /**
+   * Registered channels keyed by their pattern.
+   */
+  #channels = /* @__PURE__ */ new Map();
+  /**
+   * Registers a channel.
+   */
+  register(channel) {
+    const patternValue = channel.pattern;
+    if (!patternValue) {
+      throw new Error(`Channel ${channel.name} must define a static pattern`);
+    }
+    if (this.#channels.has(patternValue)) {
+      throw new Error(`Channel pattern "${patternValue}" is already registered`);
+    }
+    const pattern = ChannelPattern.from(patternValue);
+    this.#channels.set(pattern.value, { pattern, channel });
+  }
+  /**
+   * Matches a channel name against registered patterns.
+   */
+  match(channelName) {
+    const matched = ChannelPattern.firstMatch(channelName, this.#channels.values());
+    if (!matched) {
+      return null;
+    }
+    return {
+      channel: matched.channel,
+      pattern: matched.pattern.value,
+      params: matched.params
+    };
+  }
+  /**
+   * Authorizes a socket before it joins a channel.
+   */
+  async authorize(socket, channelName) {
+    const matched = this.match(channelName);
+    if (!matched) {
+      return {
+        success: false,
+        error: "Channel not found"
+      };
+    }
+    const instance = await this.makeChannel(matched.channel);
+    const paramValues = Object.values(matched.params);
+    const ctx = {
+      socket,
+      channel: channelName,
+      params: matched.params,
+      presenceData: void 0,
+      setPresenceData(data) {
+        ctx.presenceData = data;
+      }
+    };
+    try {
+      await instance.$runMiddlewares(ctx, this.createMiddlewareRunner?.());
+    } catch (error) {
+      return {
+        success: false,
+        error: error instanceof SocketResponseError ? error.message : "Authorization failed",
+        cause: error
+      };
+    }
+    return {
+      success: true,
+      instance,
+      params: matched.params,
+      paramValues,
+      presenceData: ctx.presenceData ?? null
+    };
+  }
+  /**
+   * Lists all registered channels.
+   */
+  list() {
+    return [...this.#channels.values()].map(({ pattern, channel }) => ({
+      pattern: pattern.value,
+      name: channel.name,
+      options: channel.options
+    }));
+  }
+  /**
+   * Number of registered channels.
+   */
+  get size() {
+    return this.#channels.size;
+  }
+};
 
 // providers/socket_provider.ts
-import { ServerResponse } from "http";
 var SocketProvider = class {
   constructor(app) {
     this.app = app;
@@ -17,7 +2088,16 @@ var SocketProvider = class {
    */
   register() {
     this.app.container.singleton("socket.router", () => {
-      return new ChannelRouter();
+      return new ChannelRouter(
+        (channel) => this.app.container.make(channel),
+        () => {
+          const resolver = this.app.container.createResolver();
+          return async (Middleware, ctx, next) => {
+            const instance = await resolver.make(Middleware);
+            await resolver.call(instance, "handle", [ctx, next]);
+          };
+        }
+      );
     });
     this.app.container.singleton("socket.presence", () => {
       return new PresenceManager();
@@ -53,7 +2133,13 @@ var SocketProvider = class {
       return;
     }
     try {
-      await socket.boot(httpServer, this.#withHttpContextFactory(config, server), router, logger);
+      await socket.boot(
+        httpServer,
+        config,
+        router,
+        logger,
+        this.#createUpgradeContextRunner(config, server)
+      );
       logger.info("server started");
     } catch (error) {
       socket.markFailed(error);
@@ -77,51 +2163,76 @@ var SocketProvider = class {
   /**
    * Creates an AdonisJS HTTP context for WebSocket upgrade requests.
    */
-  #withHttpContextFactory(config, server) {
-    if (!config.websocket?.authenticate || config.websocket.createContext) {
-      return config;
-    }
-    return {
-      ...config,
-      websocket: {
-        ...config.websocket,
-        createContext: (request) => {
-          const response = new ServerResponse(request);
-          const adonisRequest = server.createRequest(request, response);
-          const adonisResponse = server.createResponse(request, response);
-          return server.createHttpContext(
-            adonisRequest,
-            adonisResponse,
-            this.app.container.createResolver()
-          );
-        }
+  #createUpgradeContextRunner(config, server) {
+    const middleware = config.websocket?.middleware ?? [];
+    return async (request, handler, shortCircuitBeforeMiddleware) => {
+      const response = new ServerResponse(request);
+      const adonisRequest = server.createRequest(request, response);
+      const adonisResponse = server.createResponse(request, response);
+      const httpContext = server.createHttpContext(
+        adonisRequest,
+        adonisResponse,
+        this.app.container.createResolver()
+      );
+      const earlyResult = await shortCircuitBeforeMiddleware?.(httpContext);
+      if (earlyResult !== void 0) {
+        return earlyResult;
       }
+      return this.#runUpgradeMiddleware(server, middleware, httpContext, handler);
     };
   }
+  /**
+   * Runs middleware attached to WebSocket upgrade requests.
+   */
+  async #runUpgradeMiddleware(server, middleware, httpContext, handler) {
+    if (middleware.length === 0) {
+      return handler(httpContext);
+    }
+    const middlewareClasses = await Promise.all(
+      middleware.map(async (one) => {
+        if (one.prototype?.handle) {
+          return one;
+        }
+        const moduleExports = await one();
+        return moduleExports.default;
+      })
+    );
+    let outcome;
+    await server.pipeline(middlewareClasses).errorHandler((error) => {
+      throw error;
+    }).finalHandler(async () => {
+      outcome = { value: await handler(httpContext) };
+    }).run(httpContext);
+    if (!outcome) {
+      throw new Error("WebSocket upgrade middleware must call next()");
+    }
+    return outcome.value;
+  }
   /**
    * Scans and registers channel classes.
    */
   async #registerChannels(router) {
     const logger = await this.#resolveLogger();
-    const { glob } = await import("fs/promises");
-    const { resolve } = await import("path");
-    const config = this.app.config.get("socket", {});
-    const patterns = config.channels?.patterns ?? ["app/channels/**/*_channel.{ts,js}"];
-    for (const channelPattern of patterns) {
-      const pattern = this.app.makePath(channelPattern);
-      for await (const file of glob(pattern)) {
-        try {
-          const absolutePath = resolve(file);
-          const module = await import(`file://${absolutePath}`);
-          const channelClass = module.default;
-          if (channelClass?.pattern) {
-            router.register(channelClass);
-            logger.info("registered channel: %s", channelClass.pattern);
-          }
-        } catch (error) {
-          logger.warn("failed to load channel from %s: %s", file, error);
-        }
+    let generated;
+    try {
+      generated = await this.app.import("#generated/socket_channels");
+    } catch (error) {
+      throw new Error("Failed to load generated socket channels", { cause: error });
+    }
+    if (!Array.isArray(generated.socketChannels)) {
+      throw new Error("Generated socket channel manifest must export a socketChannels array");
+    }
+    for (const [index, channelClass] of generated.socketChannels.entries()) {
+      const source = `generated channel at index ${index}`;
+      if (typeof channelClass !== "function" || !(channelClass.prototype instanceof BaseChannel) || !channelClass.pattern) {
+        throw new Error(`Socket channel ${source} must default export a BaseChannel with a pattern`);
+      }
+      try {
+        router.register(channelClass);
+      } catch (error) {
+        throw new Error(`Failed to register socket channel from ${source}`, { cause: error });
       }
+      logger.info("registered channel: %s", channelClass.pattern);
     }
     logger.info("total channels registered: %d", router.size);
   }