@rlanz/socket 0.0.1-4 → 0.0.1-5

package/build/chunk-ILDK672E.js

@@ -1,1921 +0,0 @@
-import {
-  getDecoratedChannelHandlers
-} from "./chunk-XUDFDJME.js";
-import {
-  broadcastChannel,
-  channelMessageChannel,
-  connectChannel,
-  disconnectChannel,
-  subscribeChannel,
-  unsubscribeChannel
-} from "./chunk-GKAD2UOA.js";
-
-// 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) {
-    if (!this.#presence.has(channel)) {
-      this.#presence.set(channel, /* @__PURE__ */ new Map());
-    }
-    const presenceUser = typeof member === "string" ? { id: socket.id, name: member } : {
-      ...member,
-      id: member.id || socket.id
-    };
-    const user = {
-      ...presenceUser,
-      joinedAt: /* @__PURE__ */ new Date()
-    };
-    this.#presence.get(channel).set(socket.id, user);
-    this.#setSocketPresence(socket, channel, 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;
-  }
-  /**
-   * 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) {
-    const users = this.#presence.get(channel);
-    return {
-      channel,
-      users: users ? Array.from(users.values()) : [],
-      count: users?.size || 0
-    };
-  }
-  async #getFromSockets(channel) {
-    const sockets = await this.#fetchSockets(channel);
-    const users = sockets.map((socket) => socket.data?.[PRESENCE_DATA_KEY]?.[channel]).filter((user) => Boolean(user));
-    return {
-      channel,
-      users,
-      count: users.length
-    };
-  }
-  #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/base_channel.ts
-var MissingPresenceInfoError = class extends Error {
-  constructor() {
-    super("Presence channels must implement getPresenceInfo(socket)");
-  }
-};
-var BaseChannel = class {
-  /**
-   * URL-like channel pattern, for example: 'chat/:roomId'.
-   */
-  static pattern;
-  /**
-   * Channel options.
-   */
-  static options;
-  /**
-   * Middlewares to run before subscription.
-   */
-  static middlewares;
-  /**
-   * Event handler map.
-   * Ex: { 'chat:send': 'handleSend' }
-   */
-  handlers = {};
-  /**
-   * Injected socket service.
-   */
-  socket;
-  /**
-   * Full channel name, for example: 'chat/general'.
-   */
-  channelName;
-  /**
-   * Parameters extracted from the pattern, for example: { roomId: 'general' }.
-   */
-  params;
-  /**
-   * Injected presence manager when presence is enabled.
-   */
-  presence;
-  /**
-   * Injects dependencies.
-   */
-  $setContext(socket, channelName, params, presence) {
-    this.socket = socket;
-    this.channelName = channelName;
-    this.params = params;
-    if (presence) {
-      this.presence = presence;
-    }
-  }
-  /**
-   * Emits to every channel member.
-   */
-  broadcast(event, data) {
-    this.socket.to(this.channelName).emit(event, data);
-  }
-  /**
-   * Emits to every channel member except one socket.
-   */
-  broadcastExcept(socketId, event, data) {
-    this.socket.to(this.channelName).except(socketId).emit(event, data);
-  }
-  /**
-   * Runs the middleware chain.
-   *
-   * middleware[0] -> middleware[1] -> ... -> subscribe
-   */
-  async $runMiddlewares(ctx) {
-    const middlewares = this.constructor.middlewares || [];
-    let index = 0;
-    const next = async () => {
-      if (index >= middlewares.length) return;
-      const middleware = middlewares[index++];
-      if (typeof middleware === "function") {
-        await middleware(ctx, next);
-      } else {
-        await middleware.handle(ctx, next);
-      }
-    };
-    await next();
-  }
-  /**
-   * Dispatches a message to the matching handler.
-   * Called by SocketService. Do not override.
-   */
-  async $handleMessage(socket, event, data) {
-    const handlers = {
-      ...this.handlers,
-      ...getDecoratedChannelHandlers(this)
-    };
-    const handler = handlers[event];
-    if (typeof handler === "function") {
-      return handler.call(this, socket, data);
-    }
-    return this.onMessage?.(socket, event, data);
-  }
-  /**
-   * Runs the generic join hook. ChannelSubscriptions owns subscription lifecycle.
-   */
-  async $handleJoin(socket, ...params) {
-    await this.onJoin?.(socket, ...params);
-  }
-  /**
-   * Runs the generic leave hook. ChannelSubscriptions owns subscription lifecycle.
-   */
-  async $handleLeave(socket, ...params) {
-    await this.onLeave?.(socket, ...params);
-  }
-  $getPresenceInfo(socket) {
-    if (!this.getPresenceInfo) {
-      throw new MissingPresenceInfoError();
-    }
-    return this.getPresenceInfo(socket);
-  }
-};
-
-// src/fake_socket.ts
-import { AssertionError } from "assert";
-import { isDeepStrictEqual } from "util";
-var SocketFake = class {
-  #emissions = [];
-  #restore;
-  constructor(restore) {
-    this.#restore = restore;
-  }
-  get emissions() {
-    return [...this.#emissions];
-  }
-  record(emission) {
-    this.#emissions.push({
-      ...emission,
-      ..."except" in emission && emission.except ? { except: [...emission.except] } : {}
-    });
-  }
-  dispatch(emission) {
-    this.record(emission);
-  }
-  clear() {
-    this.#emissions = [];
-  }
-  restore() {
-    this.#restore();
-  }
-  [Symbol.dispose]() {
-    this.restore();
-  }
-  assertBroadcasted(event, query) {
-    this.#assertEmitted(
-      (emission) => emission.target === "global" && emission.event === event,
-      query,
-      `Expected socket event "${event}" to have been broadcasted`
-    );
-  }
-  assertNotBroadcasted(event, query) {
-    this.#assertNotEmitted(
-      (emission) => emission.target === "global" && emission.event === event,
-      query,
-      `Expected socket event "${event}" not to have been broadcasted`
-    );
-  }
-  assertEmittedTo(channel, event, query) {
-    this.#assertEmitted(
-      (emission) => emission.target === "channel" && emission.channel === channel && emission.event === event,
-      query,
-      `Expected socket event "${event}" to have been emitted to channel "${channel}"`
-    );
-  }
-  assertNotEmittedTo(channel, event, query) {
-    this.#assertNotEmitted(
-      (emission) => emission.target === "channel" && emission.channel === channel && emission.event === event,
-      query,
-      `Expected socket event "${event}" not to have been emitted to channel "${channel}"`
-    );
-  }
-  assertEmittedToUser(userId, event, query) {
-    this.#assertEmitted(
-      (emission) => emission.target === "user" && emission.userId === userId && emission.event === event,
-      query,
-      `Expected socket event "${event}" to have been emitted to user "${String(userId)}"`
-    );
-  }
-  assertNotEmittedToUser(userId, event, query) {
-    this.#assertNotEmitted(
-      (emission) => emission.target === "user" && emission.userId === userId && emission.event === event,
-      query,
-      `Expected socket event "${event}" not to have been emitted to user "${String(userId)}"`
-    );
-  }
-  assertEmittedCount(count, query) {
-    const actual = this.#matching(query).length;
-    if (actual !== count) {
-      throw new AssertionError({
-        message: `Expected ${count} socket event(s) to have been emitted, but found ${actual}`,
-        actual,
-        expected: count,
-        operator: "strictEqual"
-      });
-    }
-  }
-  assertNothingEmitted() {
-    this.assertEmittedCount(0);
-  }
-  #assertEmitted(predicate, query, message) {
-    const matching = this.#emissions.filter((emission) => {
-      return predicate(emission) && this.#matchesQuery(emission, query);
-    });
-    if (matching.length === 0) {
-      throw new AssertionError({
-        message,
-        actual: this.#emissions,
-        expected: query,
-        operator: "includes"
-      });
-    }
-  }
-  #assertNotEmitted(predicate, query, message) {
-    const matching = this.#emissions.filter((emission) => {
-      return predicate(emission) && this.#matchesQuery(emission, query);
-    });
-    if (matching.length > 0) {
-      throw new AssertionError({
-        message,
-        actual: matching,
-        expected: [],
-        operator: "doesNotInclude"
-      });
-    }
-  }
-  #matching(query) {
-    return this.#emissions.filter((emission) => {
-      if (query?.target && emission.target !== query.target) {
-        return false;
-      }
-      if (query?.event && emission.event !== query.event) {
-        return false;
-      }
-      if (query?.channel && (!("channel" in emission) || emission.channel !== query.channel)) {
-        return false;
-      }
-      if (query?.userId !== void 0 && (!("userId" in emission) || emission.userId !== query.userId)) {
-        return false;
-      }
-      return this.#matchesQuery(emission, query);
-    });
-  }
-  #matchesQuery(emission, query) {
-    if (!query) {
-      return true;
-    }
-    if ("data" in query) {
-      if (typeof query.data === "function") {
-        if (!query.data(emission.data)) {
-          return false;
-        }
-      } else if (!isDeepStrictEqual(emission.data, query.data)) {
-        return false;
-      }
-    }
-    if ("except" in query) {
-      if (typeof query.except === "function") {
-        if (!query.except("except" in emission ? emission.except : void 0)) {
-          return false;
-        }
-      } else if (!isDeepStrictEqual(("except" in emission ? emission.except : void 0) ?? [], query.except)) {
-        return false;
-      }
-    }
-    return true;
-  }
-};
-
-// 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() ?? []];
-  }
-  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 {
-  constructor(socketService, channelRouter, logger, presenceManager) {
-    this.socketService = socketService;
-    this.channelRouter = channelRouter;
-    this.logger = logger;
-    this.presenceManager = presenceManager;
-  }
-  #storage = new ChannelSubscriptionStorage();
-  setPresenceManager(presenceManager) {
-    this.presenceManager = presenceManager;
-  }
-  async subscribe(socket, channelName) {
-    if (this.#storage.has(socket.id, channelName)) {
-      return {
-        ack: {
-          ok: true,
-          presenceData: await this.#getPresenceData(socket, channelName)
-        },
-        created: false
-      };
-    }
-    const result = await this.channelRouter.authorize(socket, channelName);
-    if (!result.success) {
-      return {
-        ack: { ok: false, error: result.error },
-        created: false
-      };
-    }
-    result.instance.$setContext(
-      this.socketService,
-      channelName,
-      result.params,
-      this.presenceManager
-    );
-    let presenceData = result.presenceData;
-    let presenceJoined = false;
-    try {
-      if (this.#usesPresence(result.instance)) {
-        const member = this.#getPresenceMember(result.instance, socket);
-        this.presenceManager.join(channelName, socket.raw, member);
-        presenceJoined = true;
-        await result.instance.onMemberJoin?.(socket, member, ...result.paramValues);
-        await result.instance.onJoin?.(socket, ...result.paramValues);
-        presenceData = await this.presenceManager.snapshot(channelName);
-      } else {
-        await result.instance.onJoin?.(socket, ...result.paramValues);
-      }
-      this.#storage.set(socket.id, channelName, {
-        channelName,
-        instance: result.instance,
-        paramValues: result.paramValues
-      });
-      socket.channels.add(channelName);
-      if (this.#usesPresence(result.instance) && presenceData) {
-        this.socketService.to(channelName).except(socket.id).emit("presence:update", presenceData);
-      }
-    } 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", rollbackData);
-        }
-      }
-      this.#storage.delete(socket.id, channelName);
-      socket.channels.delete(channelName);
-      return {
-        ack: {
-          ok: false,
-          error: error instanceof MissingPresenceInfoError ? 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) {
-      this.#storage.delete(socket.id, channelName);
-      socket.channels.delete(channelName);
-      try {
-        if (this.#usesPresence(subscription.instance)) {
-          const member = this.#getPresenceMember(subscription.instance, socket);
-          this.presenceManager.leave(channelName, socket.raw);
-          const presenceData = await this.presenceManager.snapshot(channelName);
-          this.socketService.to(channelName).emit("presence:update", presenceData);
-          await subscription.instance.onMemberLeave?.(socket, member, ...subscription.paramValues);
-          await subscription.instance.onLeave?.(socket, ...subscription.paramValues);
-        } else {
-          await subscription.instance.onLeave?.(socket, ...subscription.paramValues);
-        }
-      } catch (error) {
-        this.logger.warn(`failed to leave channel "${channelName}": %s`, error);
-      }
-    } else {
-      socket.channels.delete(channelName);
-    }
-  }
-  async leaveAll(socket) {
-    for (const channelName of this.getChannelNames(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);
-      return { ok: true, data: result };
-    } catch (error) {
-      return {
-        ok: false,
-        error: error instanceof Error ? 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();
-  }
-  getSocketIds(channelName) {
-    return this.#storage.socketIdsFor(channelName);
-  }
-  getChannelNames(socketId) {
-    return this.#storage.channelNamesFor(socketId);
-  }
-  get channelsCount() {
-    return this.#storage.channelsCount;
-  }
-  #usesPresence(instance) {
-    return Boolean(
-      instance.constructor.options?.presence && this.presenceManager
-    );
-  }
-  #getPresenceMember(instance, socket) {
-    return instance.$getPresenceInfo(socket);
-  }
-  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;
-  }
-  delete(key) {
-    this.#queues.delete(key);
-    this.#depths.delete(key);
-  }
-  clear() {
-    this.#queues.clear();
-    this.#depths.clear();
-  }
-};
-
-// src/broadcasting.ts
-function userRoom(userId) {
-  return `socket:user:${String(userId)}`;
-}
-
-// src/socket_bus.ts
-import { randomUUID } from "crypto";
-import { Bus } from "@boringnode/bus";
-
-// 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 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: { enabled: true } });
-  }
-  #origin = randomUUID();
-  #channel;
-  #bus;
-  #presenceTimeout;
-  #pendingPresenceRequests = /* @__PURE__ */ new Map();
-  async start() {
-    await this.#bus.subscribe(this.#channel, async (payload) => {
-      const message = payload;
-      if (message.origin === this.#origin) {
-        return;
-      }
-      switch (message.type) {
-        case "channel:event":
-          this.handlers.channel(message);
-          return;
-        case "user:event":
-          this.handlers.user(message);
-          return;
-        case "broadcast:event":
-          this.handlers.broadcast(message);
-          return;
-        case "presence:sockets:request":
-          await this.#respondToPresenceRequest(message);
-          return;
-        case "presence:sockets:response":
-          this.#handlePresenceResponse(message);
-          return;
-      }
-    });
-  }
-  publishChannel(channel, event, data, except) {
-    const message = {
-      type: "channel:event",
-      origin: this.#origin,
-      channel,
-      event,
-      data
-    };
-    if (except) {
-      message.except = except;
-    }
-    void this.#bus.publish(this.#channel, message);
-  }
-  publishUser(room, event, data) {
-    void this.#bus.publish(this.#channel, {
-      type: "user:event",
-      origin: this.#origin,
-      room,
-      event,
-      data
-    });
-  }
-  publishBroadcast(event, data) {
-    void this.#bus.publish(this.#channel, {
-      type: "broadcast:event",
-      origin: this.#origin,
-      event,
-      data
-    });
-  }
-  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) => this.#deserializePresenceSocket(socket)));
-      }, this.#presenceTimeout);
-      this.#pendingPresenceRequests.set(requestId, {
-        sockets: [],
-        resolve,
-        timeout
-      });
-      void this.#bus.publish(this.#channel, {
-        type: "presence:sockets:request",
-        origin: this.#origin,
-        requestId,
-        channel
-      });
-    });
-  }
-  async close() {
-    for (const [requestId, request] of this.#pendingPresenceRequests) {
-      clearTimeout(request.timeout);
-      request.resolve(request.sockets.map((socket) => this.#deserializePresenceSocket(socket)));
-      this.#pendingPresenceRequests.delete(requestId);
-    }
-    await this.#bus.disconnect();
-  }
-  async #respondToPresenceRequest(message) {
-    await this.#bus.publish(this.#channel, {
-      type: "presence:sockets:response",
-      origin: this.#origin,
-      target: message.origin,
-      requestId: message.requestId,
-      sockets: this.handlers.presenceSockets(message.channel)
-    });
-  }
-  #handlePresenceResponse(message) {
-    if (message.target !== this.#origin) {
-      return;
-    }
-    const request = this.#pendingPresenceRequests.get(message.requestId);
-    if (!request) {
-      return;
-    }
-    request.sockets.push(...message.sockets);
-  }
-  #deserializePresenceSocket(socket) {
-    const presence = socket.data[PRESENCE_DATA_KEY];
-    return {
-      id: socket.id,
-      data: {
-        [PRESENCE_DATA_KEY]: presence ? Object.fromEntries(
-          Object.entries(presence).map(([channel, user]) => [
-            channel,
-            {
-              ...user,
-              joinedAt: new Date(user.joinedAt)
-            }
-          ])
-        ) : void 0
-      }
-    };
-  }
-};
-
-// src/socket_upgrader.ts
-var DEFAULT_WEBSOCKET_PATH = "/socket";
-var SocketUpgrader = class _SocketUpgrader {
-  constructor(server, config) {
-    this.server = server;
-    this.config = config;
-    this.#path = config?.path ?? DEFAULT_WEBSOCKET_PATH;
-  }
-  #path;
-  async handle(request, socket, head, accept) {
-    if (!this.#matchesPath(request)) {
-      return false;
-    }
-    const accepted = await this.#authenticate(request);
-    if (!accepted) {
-      _SocketUpgrader.reject(socket, 401, "Unauthorized");
-      return true;
-    }
-    this.server.handleUpgrade(request, socket, head, (connection) => {
-      accept(connection, request, 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;
-  }
-  async #authenticate(request) {
-    const config = this.config;
-    if (!config) {
-      return {};
-    }
-    if (!config.authenticate && !config.createContextOnUpgrade) {
-      return {};
-    }
-    let httpContext;
-    try {
-      httpContext = await config.createContext?.(request);
-      if (!config.authenticate) {
-        return { httpContext };
-      }
-      const ctx = {
-        httpContext
-      };
-      const result = await config.authenticate(ctx);
-      if (result === false || result === null) {
-        return null;
-      }
-      return {
-        httpContext,
-        user: result
-      };
-    } 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 CLOSE_POLICY_VIOLATION = 1008;
-var CLOSE_MESSAGE_TOO_BIG = 1009;
-var CLOSE_OUTBOUND_BUFFER_LIMIT = "Socket outbound buffer limit exceeded";
-function serializeFrame(frame) {
-  return JSON.stringify(frame);
-}
-function sendSerializedFrame(connection, serializedFrame) {
-  if (connection.readyState !== WebSocket.OPEN) {
-    return false;
-  }
-  connection.send(serializedFrame);
-  return true;
-}
-function sendFrame(connection, frame) {
-  return sendSerializedFrame(connection, serializeFrame(frame));
-}
-function sendSerializedFrameWithBackpressure(connection, serializedFrame, config) {
-  if (connection.readyState !== WebSocket.OPEN) {
-    return false;
-  }
-  if (connection.bufferedAmount > 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
-  };
-}
-function resolveOutboundMessageConfig(config) {
-  return {
-    maxBufferedAmount: parsePositiveInteger(
-      "websocket.maxBufferedAmount",
-      config?.maxBufferedAmount,
-      DEFAULT_MAX_BUFFERED_AMOUNT
-    )
-  };
-}
-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();
-  #userRooms = /* @__PURE__ */ new Map();
-  #socketUserRoom = /* @__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();
-  #outboundMessageConfig = resolveOutboundMessageConfig(void 0);
-  /**
-   * 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();
-  }
-  async boot(httpServer, config, channelRouter, logger) {
-    this.#status = "starting";
-    this.#lastError = null;
-    this.#channelSubscriptions = new ChannelSubscriptions(
-      this,
-      channelRouter,
-      logger,
-      this.#presenceManager ?? void 0
-    );
-    const websocketConfig = config.websocket;
-    const heartbeatConfig = resolveHeartbeatConfig(websocketConfig);
-    const inboundMessageConfig = resolveInboundMessageConfig(websocketConfig);
-    this.#outboundMessageConfig = resolveOutboundMessageConfig(websocketConfig);
-    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
-              )
-            );
-          },
-          user: (message) => {
-            this.#traceBroadcast(
-              { target: "user", room: message.room, event: message.event, via: "bus" },
-              () => this.#emitToUserRoomLocally(message.room, message.event, message.data)
-            );
-          },
-          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();
-        this.#configurePresenceFetcher();
-      }
-      const websocketServer = new WebSocketServer({
-        noServer: true,
-        maxPayload: inboundMessageConfig.maxPayload
-      });
-      this.#server = websocketServer;
-      this.#httpServer = httpServer;
-      const upgrader = new SocketUpgrader(websocketServer, websocketConfig);
-      this.#upgradeHandler = (request, socket, head) => {
-        upgrader.handle(request, socket, head, (connection, upgradeRequest, accepted) => {
-          this.#handleConnection(connection, upgradeRequest, accepted, inboundMessageConfig);
-        }).catch((error) => {
-          logger.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) {
-      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) {
-    const socket = this.#wrapSocket(connection, request, upgrade);
-    connectChannel.traceSync(
-      () => {
-        this.#sockets.set(socket.id, socket);
-        this.emit("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" });
-        return;
-      }
-      const enqueued = this.#messageQueue.enqueue(
-        socket.id,
-        async () => {
-          await this.#handleMessage(socket, message).catch((error) => {
-            sendFrame(connection, {
-              type: "error",
-              error: error instanceof Error ? error.message : "Unexpected socket error"
-            });
-          });
-        },
-        { 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", async () => {
-      const traceMessage = {
-        socketId: socket.id,
-        reason: "close",
-        subscriptions: socket.channels.size
-      };
-      await disconnectChannel.tracePromise(async () => {
-        this.#clearHeartbeatTimeout(socket.id);
-        this.#messageQueue.delete(socket.id);
-        this.#messageRates.delete(socket.id);
-        await this.#channelSubscriptions?.leaveAll(socket);
-        this.#channelSubscriptions?.deleteSocket(socket.id);
-        this.#sockets.delete(socket.id);
-        this.#leaveUserRoom(socket.id);
-        this.emit("disconnect", { socket, reason: "close" });
-      }, traceMessage);
-    });
-  }
-  async #handleMessage(socket, message) {
-    if (!message.valid) {
-      sendFrame(socket.raw.connection, message.toRejectionFrame());
-      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.emit("subscribe", { socket, channel: message.channel });
-          }
-          sendFrame(socket.raw.connection, Reply.fromSubscribeResult(message.id, result).toFrame());
-        }, traceMessage);
-        return;
-      }
-      case "unsubscribe": {
-        const traceMessage = {
-          socketId: socket.id,
-          channel: message.channel
-        };
-        await unsubscribeChannel.tracePromise(async () => {
-          traceMessage.removed = socket.channels.has(message.channel);
-          await this.#channelSubscriptions?.leave(socket, message.channel);
-          traceMessage.ok = true;
-          this.emit("unsubscribe", { socket, channel: message.channel });
-          sendFrame(socket.raw.connection, Reply.ok(message.id).toFrame());
-        }, 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());
-    }, 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,
-      channels: /* @__PURE__ */ new Set(),
-      emit: (event, data) => {
-        this.#sendEventFrame(connection, { type: "event", event, data });
-      },
-      joinUserRoom: (userId) => {
-        this.#joinUserRoom(raw.id, userRoom(userId));
-        return Promise.resolve();
-      },
-      leaveUserRoom: () => {
-        this.#leaveUserRoom(raw.id);
-        return Promise.resolve();
-      },
-      disconnect() {
-        connection.close();
-      },
-      raw
-    };
-  }
-  #joinUserRoom(socketId, room) {
-    this.#leaveUserRoom(socketId);
-    if (!this.#userRooms.has(room)) {
-      this.#userRooms.set(room, /* @__PURE__ */ new Set());
-    }
-    this.#userRooms.get(room).add(socketId);
-    this.#socketUserRoom.set(socketId, room);
-  }
-  #leaveUserRoom(socketId) {
-    const room = this.#socketUserRoom.get(socketId);
-    if (!room) {
-      return;
-    }
-    const sockets = this.#userRooms.get(room);
-    sockets?.delete(socketId);
-    if (sockets?.size === 0) {
-      this.#userRooms.delete(room);
-    }
-    this.#socketUserRoom.delete(socketId);
-  }
-  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]
-          });
-        }
-      })
-    };
-  }
-  toUser(userId) {
-    const room = userRoom(userId);
-    return {
-      emit: (event, data) => {
-        this.#broadcastSink.dispatch({ target: "user", userId, room, event, data });
-      }
-    };
-  }
-  broadcast(event, data) {
-    this.#broadcastSink.dispatch({ target: "global", event, data });
-  }
-  #deliverBroadcast(emission) {
-    switch (emission.target) {
-      case "channel": {
-        const channel = emission.channel;
-        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)
-        );
-        return;
-      }
-      case "user": {
-        const room = emission.room;
-        this.#bus?.publishUser(room, emission.event, emission.data);
-        this.#traceBroadcast(
-          { target: "user", room, event: emission.event, via: "local" },
-          () => this.#emitToUserRoomLocally(room, emission.event, emission.data)
-        );
-        return;
-      }
-      case "global":
-        this.#bus?.publishBroadcast(emission.event, emission.data);
-        this.#traceBroadcast(
-          { target: "global", event: emission.event, via: "local" },
-          () => this.#broadcastLocally(emission.event, emission.data)
-        );
-    }
-  }
-  #traceBroadcast(message, deliver) {
-    broadcastChannel.traceSync(() => {
-      message.delivered = deliver();
-    }, message);
-  }
-  #sendEventFrame(connection, frame) {
-    return this.#sendSerializedEventFrame(connection, serializeFrame(frame));
-  }
-  #sendSerializedEventFrame(connection, serializedFrame) {
-    return sendSerializedFrameWithBackpressure(
-      connection,
-      serializedFrame,
-      this.#outboundMessageConfig
-    );
-  }
-  #emitToChannelLocally(channel, event, data, except = []) {
-    let delivered = 0;
-    const serializedFrame = serializeFrame({ type: "event", channel, event, data });
-    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;
-  }
-  #emitToUserRoomLocally(room, event, data) {
-    let delivered = 0;
-    const serializedFrame = serializeFrame({ type: "event", event, data });
-    for (const socketId of this.#userRooms.get(room) ?? []) {
-      const socket = this.#sockets.get(socketId);
-      if (socket && this.#sendSerializedEventFrame(socket.raw.connection, serializedFrame)) {
-        delivered += 1;
-      }
-    }
-    return delivered;
-  }
-  #broadcastLocally(event, data) {
-    let delivered = 0;
-    const serializedFrame = serializeFrame({ type: "event", event, data });
-    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 this.#serializePresenceSocket(channel, socket);
-    });
-  }
-  #serializePresenceSocket(channel, socket) {
-    const user = socket.data[PRESENCE_DATA_KEY][channel];
-    return {
-      id: socket.id,
-      data: {
-        [PRESENCE_DATA_KEY]: {
-          [channel]: {
-            ...user,
-            joinedAt: user.joinedAt.toISOString()
-          }
-        }
-      }
-    };
-  }
-  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";
-  }
-  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();
-    for (const socket of this.#sockets.values()) {
-      socket.raw.connection.terminate();
-    }
-    this.#sockets.clear();
-    this.#userRooms.clear();
-    this.#socketUserRoom.clear();
-    this.#messageQueue.clear();
-    this.#messageRates.clear();
-    this.#channelSubscriptions?.clear();
-  }
-  async close() {
-    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.#bus = null;
-    this.#httpServer = null;
-    this.#upgradeHandler = null;
-    if (httpServer && upgradeHandler) {
-      httpServer.off("upgrade", upgradeHandler);
-    }
-    this.#cleanup();
-    try {
-      await bus?.close();
-      if (!server) {
-        if (this.#status !== "failed") {
-          this.#status = "stopped";
-        }
-        return;
-      }
-      await new Promise((resolve) => {
-        server.close(() => {
-          resolve();
-        });
-      });
-      if (this.#status !== "failed") {
-        this.#status = "stopped";
-      }
-    } catch (error) {
-      this.markFailed(error);
-      throw error;
-    }
-  }
-};
-
-// src/channel_pattern.ts
-import { exec, match, parse } from "@poppinss/matchit";
-var ChannelPattern = class _ChannelPattern {
-  constructor(value) {
-    this.value = value;
-    this.route = parse(value);
-    this.score = this.route.map((segment) => {
-      switch (segment.type) {
-        case 0:
-          return 40;
-        case 1:
-          return 30;
-        case 3:
-          return 20;
-        case 2:
-          return 0;
-      }
-    });
-  }
-  route;
-  score;
-  static from(value) {
-    return new _ChannelPattern(value);
-  }
-  match(channelName) {
-    const matched = match(channelName, [this.route]);
-    if (matched.length === 0) {
-      return null;
-    }
-    return exec(channelName, matched, true);
-  }
-  /**
-   * Returns the most specific matching candidate. Static segments outrank params,
-   * params outrank optional params, and optional params outrank wildcards.
-   * Insertion order is preserved for ties.
-   */
-  static firstMatch(channelName, candidates) {
-    const sorted = [...candidates].sort((left, right) => {
-      return _ChannelPattern.#compareSpecificity(left.pattern, right.pattern);
-    });
-    const routes = sorted.map((candidate) => candidate.pattern.route);
-    const matched = match(channelName, routes);
-    if (matched.length === 0) {
-      return null;
-    }
-    for (const { pattern, channel } of sorted) {
-      if (pattern.route !== matched) {
-        continue;
-      }
-      const params = pattern.match(channelName);
-      if (params) {
-        return { pattern, channel, params };
-      }
-    }
-    return null;
-  }
-  static #compareSpecificity(left, right) {
-    const length = Math.max(left.score.length, right.score.length);
-    for (let index = 0; index < length; index++) {
-      const scoreDifference = (right.score[index] ?? -1) - (left.score[index] ?? -1);
-      if (scoreDifference !== 0) {
-        return scoreDifference;
-      }
-    }
-    return right.score.length - left.score.length;
-  }
-};
-
-// src/channel_router.ts
-var ChannelRouter = class {
-  /**
-   * 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 = new 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);
-    } catch (error) {
-      return {
-        success: false,
-        error: error instanceof Error ? error.message : "Middleware rejected"
-      };
-    }
-    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;
-  }
-};
-
-export {
-  PresenceManager,
-  BaseChannel,
-  SocketFake,
-  SocketService,
-  ChannelRouter
-};
-//# sourceMappingURL=chunk-ILDK672E.js.map