@rlanz/socket 0.0.1-4 → 0.0.1-6

package/build/providers/socket_provider.js

@@ -1,16 +1,1737 @@
 import {
+  BaseChannel,
   ChannelRouter,
+  PRESENCE_DATA_KEY,
   PresenceManager,
-  SocketService
-} from "../chunk-ILDK672E.js";
-import "../chunk-XUDFDJME.js";
-import "../chunk-GKAD2UOA.js";
+  SocketResponseError
+} from "../chunk-YAX5EHHB.js";
+import "../chunk-SHH6U4CI.js";
+import {
+  broadcastChannel,
+  channelMessageChannel,
+  connectChannel,
+  disconnectChannel,
+  subscribeChannel,
+  unsubscribeChannel
+} from "../chunk-D3HUBCBW.js";
+import {
+  SocketFake
+} from "../chunk-B4Y3TNDI.js";
 
 // providers/socket_provider.ts
 import { ServerResponse } from "http";
-function isMiddlewareClass(middleware) {
-  return typeof middleware === "function" && middleware.prototype !== void 0 && "handle" in middleware.prototype;
+
+// 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(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 wasPresent = (await this.presenceManager.snapshot(channelName)).users.some(
+          (user) => user.id === presenceInfo.id
+        );
+        const { joinedAt: _joinedAt, ...member } = this.presenceManager.join(
+          channelName,
+          socket.raw,
+          presenceInfo
+        );
+        presenceJoined = true;
+        presenceSnapshot = await this.presenceManager.snapshot(channelName);
+        presenceData = presenceSnapshot;
+        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(
+        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(channelName, operation) {
+    const previous = this.#channelOperations.get(channelName) ?? Promise.resolve();
+    const release = Promise.withResolvers();
+    const queued = previous.then(() => release.promise);
+    this.#channelOperations.set(channelName, queued);
+    await previous;
+    try {
+      return await operation();
+    } finally {
+      release.resolve();
+      if (this.#channelOperations.get(channelName) === queued) {
+        this.#channelOperations.delete(channelName);
+      }
+    }
+  }
+  #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/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;
+function parsePresenceSocket(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    return null;
+  }
+  const socket = value;
+  if (typeof socket.id !== "string" || !socket.data || typeof socket.data !== "object" || Array.isArray(socket.data)) {
+    return null;
+  }
+  const presence = socket.data[PRESENCE_DATA_KEY];
+  if (presence === void 0) {
+    return socket;
+  }
+  if (!presence || typeof presence !== "object" || Array.isArray(presence)) {
+    return null;
+  }
+  for (const user of Object.values(presence)) {
+    if (!user || typeof user !== "object" || typeof user.id !== "string" || typeof user.name !== "string" || typeof user.joinedAt !== "string" || Number.isNaN(Date.parse(user.joinedAt))) {
+      return null;
+    }
+  }
+  return socket;
+}
+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 "user:event":
+      return typeof message.room === "string" && typeof message.event === "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, parsePresenceSocket);
+      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: { enabled: true } });
+  }
+  #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 "user:event":
+            this.handlers.user(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);
+  }
+  publishUser(room, event, data) {
+    const message = {
+      type: "user:event",
+      origin: this.#origin,
+      room,
+      event,
+      data
+    };
+    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) => this.#deserializePresenceSocket(socket)));
+      }, 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) => this.#deserializePresenceSocket(socket)));
+      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);
+  }
+  #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, runWithHttpContext, reportError = () => {
+  }) {
+    this.server = server;
+    this.config = config;
+    this.runWithHttpContext = runWithHttpContext;
+    this.reportError = reportError;
+    this.#path = config?.path ?? DEFAULT_WEBSOCKET_PATH;
+    this.#allowedOrigins = new Set((config?.allowedOrigins ?? []).map(_SocketUpgrader.#parseOrigin));
+  }
+  #path;
+  #allowedOrigins;
+  async handle(request, socket, head, accept) {
+    if (!this.#matchesPath(request)) {
+      return false;
+    }
+    if (!this.#isOriginAllowed(request)) {
+      _SocketUpgrader.reject(socket, 403, "Forbidden");
+      return true;
+    }
+    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();
+  }
+  static #parseOrigin(value) {
+    let url;
+    try {
+      url = new URL(value);
+    } catch {
+      throw new Error(`websocket.allowedOrigins contains an invalid origin: ${value}`);
+    }
+    if (!["http:", "https:"].includes(url.protocol) || url.username || url.password || url.pathname !== "/" || url.search || url.hash) {
+      throw new Error(`websocket.allowedOrigins contains an invalid origin: ${value}`);
+    }
+    return url.origin;
+  }
+  #matchesPath(request) {
+    const url = new URL(request.url ?? "/", "ws://localhost");
+    return url.pathname === this.#path;
+  }
+  #isOriginAllowed(request) {
+    const origin = request.headers.origin;
+    if (!origin) {
+      return true;
+    }
+    let parsedOrigin;
+    try {
+      parsedOrigin = _SocketUpgrader.#parseOrigin(origin);
+    } catch {
+      return false;
+    }
+    if (this.#allowedOrigins.has(parsedOrigin)) {
+      return true;
+    }
+    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 parsedOrigin === new URL(`${protocol}://${host}`).origin;
+    } catch {
+      return false;
+    }
+  }
+  async #authenticate(request) {
+    const config = this.config;
+    return this.runWithHttpContext(request, async (httpContext) => {
+      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 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";
+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();
+  #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();
+  #socketFinalizations = /* @__PURE__ */ new Map();
+  #closePromise = null;
+  #outboundMessageConfig = resolveOutboundMessageConfig(void 0);
+  #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();
+  }
+  async boot(httpServer, config, channelRouter, logger, runWithHttpContext) {
+    this.#closePromise = null;
+    this.#status = "starting";
+    this.#lastError = null;
+    this.#logger = logger;
+    const websocketConfig = config.websocket;
+    const heartbeatConfig = resolveHeartbeatConfig(websocketConfig);
+    const inboundMessageConfig = resolveInboundMessageConfig(websocketConfig);
+    this.#outboundMessageConfig = resolveOutboundMessageConfig(websocketConfig);
+    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
+              )
+            );
+          },
+          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,
+        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) {
+      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 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 this.#channelSubscriptions?.leaveAll(socket);
+        this.#channelSubscriptions?.deleteSocket(socket.id);
+        this.#sockets.delete(socket.id);
+        this.#leaveUserRoom(socket.id);
+        this.#emitLifecycleEvent("disconnect", { socket, reason: "close" });
+      },
+      {
+        socketId: socket.id,
+        reason: "close",
+        subscriptions: this.#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 }));
+      },
+      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;
+        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 "user": {
+        const room = emission.room;
+        const serializedFrame = serializeFrame({
+          type: "event",
+          event: emission.event,
+          data: emission.data
+        });
+        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, 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;
+  }
+  #emitToUserRoomLocally(room, event, data, serializedFrame = serializeFrame({ type: "event", event, data })) {
+    let delivered = 0;
+    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, 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 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";
+  }
+  #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.#userRooms.clear();
+    this.#socketUserRoom.clear();
+    this.#messageQueue.clear();
+    this.#messageRates.clear();
+    this.#socketFinalizations.clear();
+    this.#channelSubscriptions?.clear();
+  }
+  close() {
+    if (!this.#closePromise) {
+      this.#closePromise = this.#close();
+    }
+    return this.#closePromise;
+  }
+  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.#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) {
+      socket.raw.connection.terminate();
+    }
+    const errors = [];
+    const finalizations = sockets.map((socket) => {
+      return Promise.resolve().then(() => this.#finalizeSocket(socket));
+    });
+    const results = await Promise.allSettled(finalizations);
+    for (const result of results) {
+      if (result.status === "rejected") {
+        errors.push(result.reason);
+      }
+    }
+    this.#cleanup();
+    this.#presenceManager?.setSocketFetcher(null);
+    this.#bus = null;
+    try {
+      await bus?.close();
+    } catch (error) {
+      errors.push(error);
+    }
+    const serverCloseError = await serverClose;
+    if (serverCloseError) {
+      errors.push(serverCloseError);
+    }
+    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";
+    }
+  }
+};
+
+// providers/socket_provider.ts
 var SocketProvider = class {
   constructor(app) {
     this.app = app;
@@ -56,7 +1777,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);
@@ -80,83 +1807,79 @@ var SocketProvider = class {
   /**
    * Creates an AdonisJS HTTP context for WebSocket upgrade requests.
    */
-  #withHttpContextFactory(config, server) {
+  #createUpgradeContextRunner(config, server) {
     const middleware = config.websocket?.middleware ?? [];
-    if (!config.websocket?.authenticate && middleware.length === 0) {
-      return config;
-    }
-    const createContext = config.websocket?.createContext;
-    return {
-      ...config,
-      websocket: {
-        ...config.websocket,
-        createContextOnUpgrade: middleware.length > 0,
-        createContext: async (request) => {
-          if (createContext) {
-            const httpContext2 = await createContext(request);
-            await this.#runUpgradeMiddleware(server, middleware, httpContext2);
-            return httpContext2;
-          }
-          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()
-          );
-          await this.#runUpgradeMiddleware(server, middleware, httpContext);
-          return httpContext;
-        }
-      }
+    return async (request, handler) => {
+      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()
+      );
+      return this.#runUpgradeMiddleware(server, middleware, httpContext, handler);
     };
   }
   /**
    * Runs middleware attached to WebSocket upgrade requests.
    */
-  async #runUpgradeMiddleware(server, middleware, httpContext) {
+  async #runUpgradeMiddleware(server, middleware, httpContext, handler) {
     if (middleware.length === 0) {
-      return;
+      return handler(httpContext);
     }
-    const ctx = httpContext;
     const middlewareClasses = await Promise.all(
       middleware.map(async (one) => {
-        if (isMiddlewareClass(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 () => {
-    }).run(ctx);
+      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);
-        }
+    const legacyChannels = config.channels;
+    if (legacyChannels?.patterns) {
+      throw new Error(
+        "Socket channel patterns are managed by the Assembler hook and cannot be configured at runtime"
+      );
+    }
+    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);
   }