@rlanz/socket 0.0.1-6 → 0.0.1-8

package/build/providers/socket_provider.js

@@ -1,11 +1,11 @@
 import {
   BaseChannel,
-  ChannelRouter,
-  PRESENCE_DATA_KEY,
-  PresenceManager,
   SocketResponseError
-} from "../chunk-YAX5EHHB.js";
-import "../chunk-SHH6U4CI.js";
+} from "../chunk-K243S3QP.js";
+import {
+  ChannelPatternSyntax
+} from "../chunk-E6ILCRL3.js";
+import "../chunk-G75J233Z.js";
 import {
   broadcastChannel,
   channelMessageChannel,
@@ -16,7 +16,7 @@ import {
 } from "../chunk-D3HUBCBW.js";
 import {
   SocketFake
-} from "../chunk-B4Y3TNDI.js";
+} from "../chunk-IUQ3GYZZ.js";
 
 // providers/socket_provider.ts
 import { ServerResponse } from "http";
@@ -579,15 +579,255 @@ var MessageQueue = class {
   }
 };
 
-// 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/presence_manager.ts
+var PRESENCE_DATA_KEY = "__rlanzSocketPresence";
+var PresenceManager = class {
+  #presence = /* @__PURE__ */ new Map();
+  #fetchSockets = null;
+  /**
+   * Sets the socket fetcher used to build distributed snapshots.
+   */
+  setSocketFetcher(fetchSockets) {
+    this.#fetchSockets = fetchSockets;
+  }
+  /**
+   * Adds a user to a channel.
+   */
+  join(channel, socket, member) {
+    const user = {
+      ...member.data,
+      id: member.id,
+      joinedAt: /* @__PURE__ */ new Date()
+    };
+    const users = this.#presence.get(channel) ?? /* @__PURE__ */ new Map();
+    users.set(socket.id, user);
+    this.#presence.set(channel, users);
+    this.#setSocketPresence(socket, channel, user);
+    return user;
+  }
+  /**
+   * Removes a user from a channel.
+   */
+  leave(channel, socket) {
+    const channelPresence = this.#presence.get(channel);
+    if (channelPresence) {
+      channelPresence.delete(socket.id);
+      if (channelPresence.size === 0) {
+        this.#presence.delete(channel);
+      }
+    }
+    this.#deleteSocketPresence(socket, channel);
+  }
+  /**
+   * Removes a user from every channel.
+   * Returns the list of channels the user left.
+   */
+  leaveAll(socket) {
+    const leftChannels = [];
+    for (const [channel, users] of this.#presence) {
+      if (users.has(socket.id)) {
+        users.delete(socket.id);
+        leftChannels.push(channel);
+        if (users.size === 0) {
+          this.#presence.delete(channel);
+        }
+        this.#deleteSocketPresence(socket, channel);
+      }
+    }
+    return leftChannels;
+  }
+  /**
+   * Gets presence data for a channel.
+   */
+  async snapshot(channel) {
+    if (this.#fetchSockets) {
+      return this.#getFromSockets(channel);
+    }
+    return this.#localSnapshot(channel);
+  }
+  /**
+   * Gets the number of users in a channel.
+   */
+  async count(channel) {
+    return (await this.snapshot(channel)).count;
+  }
+  /**
+   * Checks whether a socket is locally present in a channel.
+   */
+  hasLocal(channel, socketId) {
+    return this.#presence.get(channel)?.has(socketId) || false;
+  }
+  /**
+   * Gets the presence user retained for one local socket.
+   */
+  getLocalUser(channel, socketId) {
+    return this.#presence.get(channel)?.get(socketId);
+  }
+  /**
+   * Lists every local channel where a socket is present.
+   */
+  getLocalChannelsForSocket(socketId) {
+    const channels = [];
+    for (const [channel, users] of this.#presence) {
+      if (users.has(socketId)) {
+        channels.push(channel);
+      }
+    }
+    return channels;
+  }
+  /**
+   * Lists sockets that are locally present in a channel.
+   */
+  getLocalSockets(channel) {
+    const users = this.#presence.get(channel);
+    if (!users) {
+      return [];
+    }
+    return Array.from(users.entries()).map(([socketId, user]) => ({
+      id: socketId,
+      data: {
+        [PRESENCE_DATA_KEY]: {
+          [channel]: user
+        }
+      }
+    }));
+  }
+  #localSnapshot(channel) {
+    return this.#createSnapshot(channel, Array.from(this.#presence.get(channel)?.entries() ?? []));
+  }
+  async #getFromSockets(channel) {
+    const sockets = await this.#fetchSockets(channel);
+    const users = sockets.flatMap((socket) => {
+      const user = socket.data?.[PRESENCE_DATA_KEY]?.[channel];
+      return user ? [[socket.id, user]] : [];
+    });
+    return this.#createSnapshot(channel, users);
+  }
+  #createSnapshot(channel, connections) {
+    const usersById = /* @__PURE__ */ new Map();
+    for (const connection of connections) {
+      const current = usersById.get(connection[1].id);
+      if (!current || this.#compareConnections(connection, current) < 0) {
+        usersById.set(connection[1].id, connection);
+      }
+    }
+    const users = [...usersById.values()].sort((left, right) => this.#compareConnections(left, right)).map(([, user]) => user);
+    return {
+      channel,
+      users,
+      count: users.length
+    };
+  }
+  #compareConnections([leftSocketId, leftUser], [rightSocketId, rightUser]) {
+    const joinedAtDifference = leftUser.joinedAt.getTime() - rightUser.joinedAt.getTime();
+    return joinedAtDifference || leftSocketId.localeCompare(rightSocketId);
+  }
+  #setSocketPresence(socket, channel, user) {
+    socket.data[PRESENCE_DATA_KEY] ??= {};
+    socket.data[PRESENCE_DATA_KEY][channel] = user;
+  }
+  #deleteSocketPresence(socket, channel) {
+    if (!socket.data[PRESENCE_DATA_KEY]) {
+      return;
+    }
+    delete socket.data[PRESENCE_DATA_KEY][channel];
+    if (Object.keys(socket.data[PRESENCE_DATA_KEY]).length === 0) {
+      delete socket.data[PRESENCE_DATA_KEY];
+    }
+  }
+};
+
+// src/presence_socket_frame.ts
+var PresenceSocketFrame = class _PresenceSocketFrame {
+  constructor(transportValue, socketValue) {
+    this.transportValue = transportValue;
+    this.socketValue = socketValue;
+  }
+  /**
+   * Create one transport frame from a local socket presence entry.
+   */
+  static fromSocket(channel, socket) {
+    const user = socket.data[PRESENCE_DATA_KEY]?.[channel];
+    if (!user || Number.isNaN(user.joinedAt.getTime())) {
+      throw new Error(`Socket "${socket.id}" has no valid presence for channel "${channel}"`);
+    }
+    const transport = {
+      id: socket.id,
+      data: {
+        [PRESENCE_DATA_KEY]: {
+          [channel]: {
+            // Keep custom fields. Convert only the presence timestamp.
+            ...user,
+            joinedAt: user.joinedAt.toISOString()
+          }
+        }
+      }
+    };
+    return new _PresenceSocketFrame(transport, socket);
+  }
+  /**
+   * Validate one transport value and restore its presence timestamps.
+   */
+  static fromTransport(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value)) {
+      return null;
+    }
+    const transport = value;
+    if (typeof transport.id !== "string" || !transport.data || typeof transport.data !== "object" || Array.isArray(transport.data)) {
+      return null;
+    }
+    const data = transport.data;
+    const presence = data[PRESENCE_DATA_KEY];
+    if (presence === void 0) {
+      return new _PresenceSocketFrame(transport, {
+        id: transport.id,
+        data: { ...data }
+      });
+    }
+    if (!presence || typeof presence !== "object" || Array.isArray(presence)) {
+      return null;
+    }
+    const restoredPresence = {};
+    for (const [channel, candidate] of Object.entries(presence)) {
+      if (!candidate || typeof candidate !== "object" || Array.isArray(candidate)) {
+        return null;
+      }
+      const user = candidate;
+      if (typeof user.id !== "string" || typeof user.joinedAt !== "string" || Number.isNaN(Date.parse(user.joinedAt))) {
+        return null;
+      }
+      restoredPresence[channel] = {
+        ...user,
+        id: user.id,
+        joinedAt: new Date(user.joinedAt)
+      };
+    }
+    return new _PresenceSocketFrame(transport, {
+      id: transport.id,
+      data: {
+        ...data,
+        [PRESENCE_DATA_KEY]: restoredPresence
+      }
+    });
+  }
+  /**
+   * Return the validated transport value.
+   */
+  toTransport() {
+    return this.transportValue;
+  }
+  /**
+   * Return the socket value with restored presence timestamps.
+   */
+  toSocket() {
+    return this.socketValue;
+  }
+};
+
 // src/duration.ts
 import { parse as parseDurationExpression } from "@lukeed/ms";
 function parseDuration(name, duration) {
@@ -604,27 +844,17 @@ function parseDuration(name, duration) {
 // 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;
-    }
+var DEFAULT_RETRY_QUEUE_MAX_SIZE = 1e3;
+function resolveRetryQueueConfig(config) {
+  const maxSize = config?.maxSize === void 0 ? DEFAULT_RETRY_QUEUE_MAX_SIZE : config.maxSize;
+  if (maxSize !== null && (!Number.isSafeInteger(maxSize) || maxSize <= 0)) {
+    throw new Error("transport.retryQueue.maxSize must be a positive integer or null");
   }
-  return socket;
+  return {
+    enabled: true,
+    maxSize,
+    ...config
+  };
 }
 function parseBusMessage(payload) {
   if (!payload || typeof payload !== "object" || Array.isArray(payload)) {
@@ -637,8 +867,6 @@ function parseBusMessage(payload) {
   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":
@@ -647,7 +875,7 @@ function parseBusMessage(payload) {
       if (typeof message.target !== "string" || typeof message.requestId !== "string" || !Array.isArray(message.sockets)) {
         return null;
       }
-      const sockets = Array.from(message.sockets, parsePresenceSocket);
+      const sockets = Array.from(message.sockets, PresenceSocketFrame.fromTransport);
       return sockets.every((socket) => socket !== null) ? { ...message, sockets } : null;
     default:
       return null;
@@ -658,7 +886,9 @@ var SocketBus = class {
     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 } });
+    this.#bus = new Bus(transport.driver(), {
+      retryQueue: resolveRetryQueueConfig(transport.retryQueue)
+    });
   }
   #origin = randomUUID();
   #channel;
@@ -676,9 +906,6 @@ var SocketBus = class {
           case "channel:event":
             this.handlers.channel(message);
             return;
-          case "user:event":
-            this.handlers.user(message);
-            return;
           case "broadcast:event":
             this.handlers.broadcast(message);
             return;
@@ -706,16 +933,6 @@ var SocketBus = class {
     };
     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",
@@ -734,7 +951,7 @@ var SocketBus = class {
           return;
         }
         this.#pendingPresenceRequests.delete(requestId);
-        resolve(request.sockets.map((socket) => this.#deserializePresenceSocket(socket)));
+        resolve(request.sockets.map((socket) => socket.toSocket()));
       }, this.#presenceTimeout);
       this.#pendingPresenceRequests.set(requestId, {
         sockets: [],
@@ -753,7 +970,7 @@ var SocketBus = class {
   async close() {
     for (const [requestId, request] of this.#pendingPresenceRequests) {
       clearTimeout(request.timeout);
-      request.resolve(request.sockets.map((socket) => this.#deserializePresenceSocket(socket)));
+      request.resolve(request.sockets.map((socket) => socket.toSocket()));
       this.#pendingPresenceRequests.delete(requestId);
     }
     await this.#bus.disconnect();
@@ -778,23 +995,6 @@ var SocketBus = class {
     }
     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
@@ -807,25 +1007,23 @@ var SocketUpgrader = class _SocketUpgrader {
     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) {
+    const result = await this.#prepareUpgrade(request);
+    if ("rejected" in result) {
+      if (result.rejected === "origin") {
+        _SocketUpgrader.reject(socket, 403, "Forbidden");
+        return true;
+      }
       _SocketUpgrader.reject(socket, 401, "Unauthorized");
       return true;
     }
     this.server.handleUpgrade(request, socket, head, (connection) => {
-      accept(connection, request, accepted);
+      accept(connection, request, result.accepted);
     });
     return true;
   }
@@ -837,35 +1035,17 @@ var SocketUpgrader = class _SocketUpgrader {
     }
     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) {
+  #isOriginAllowed(request, httpContext) {
     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;
+    if (this.config?.origin !== void 0) {
+      return this.#matchesOriginPolicy(origin, httpContext);
     }
     const host = request.headers.host;
     if (!host) {
@@ -875,37 +1055,63 @@ var SocketUpgrader = class _SocketUpgrader {
     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;
+      return origin === new URL(`${protocol}://${host}`).origin;
     } catch {
       return false;
     }
   }
-  async #authenticate(request) {
+  #matchesOriginPolicy(origin, httpContext) {
+    let originPolicy = this.config?.origin ?? false;
+    if (typeof originPolicy === "function") {
+      originPolicy = originPolicy(origin, httpContext);
+    }
+    if (originPolicy === true || originPolicy === "*") {
+      return true;
+    }
+    if (originPolicy === false) {
+      return false;
+    }
+    if (Array.isArray(originPolicy)) {
+      return originPolicy.includes(origin);
+    }
+    return originPolicy.split(",").includes(origin);
+  }
+  async #prepareUpgrade(request) {
+    return this.runWithHttpContext(
+      request,
+      async (httpContext) => {
+        const accepted = await this.#authenticate(httpContext);
+        return accepted ? { accepted } : { rejected: "authentication" };
+      },
+      (httpContext) => {
+        return this.#isOriginAllowed(request, httpContext) ? void 0 : { rejected: "origin" };
+      }
+    );
+  }
+  async #authenticate(httpContext) {
     const config = this.config;
-    return this.runWithHttpContext(request, async (httpContext) => {
-      if (!config?.authenticate) {
-        return { 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 {
-        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;
+        this.reportError("socket authentication failed: %s", error);
+      } catch {
       }
-    });
+      return null;
+    }
   }
 };
 
@@ -1030,8 +1236,6 @@ var SocketService = class extends Emittery {
   #httpServer = null;
   #upgradeHandler = null;
   #sockets = /* @__PURE__ */ new Map();
-  #userRooms = /* @__PURE__ */ new Map();
-  #socketUserRoom = /* @__PURE__ */ new Map();
   #channelSubscriptions = null;
   #presenceManager = null;
   #bus = null;
@@ -1102,12 +1306,6 @@ var SocketService = class extends Emittery {
               )
             );
           },
-          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" },
@@ -1229,7 +1427,6 @@ var SocketService = class extends Emittery {
         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" });
       },
       {
@@ -1347,40 +1544,12 @@ var SocketService = class extends Emittery {
       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) => {
@@ -1399,14 +1568,6 @@ var SocketService = class extends Emittery {
       })
     };
   }
-  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 });
   }
@@ -1442,20 +1603,6 @@ var SocketService = class extends Emittery {
         );
         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",
@@ -1495,16 +1642,6 @@ var SocketService = class extends Emittery {
     }
     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()) {
@@ -1527,23 +1664,9 @@ var SocketService = class extends Emittery {
   }
   #getLocalPresenceSockets(channel) {
     return (this.#presenceManager?.getLocalSockets(channel) ?? []).map((socket) => {
-      return this.#serializePresenceSocket(channel, socket);
+      return PresenceSocketFrame.fromSocket(channel, socket).toTransport();
     });
   }
-  #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);
   }
@@ -1663,8 +1786,6 @@ var SocketService = class extends Emittery {
   #cleanup() {
     this.#stopHeartbeat();
     this.#sockets.clear();
-    this.#userRooms.clear();
-    this.#socketUserRoom.clear();
     this.#messageQueue.clear();
     this.#messageRates.clear();
     this.#socketFinalizations.clear();
@@ -1731,6 +1852,142 @@ var SocketService = class extends Emittery {
   }
 };
 
+// src/channel_pattern.ts
+var ChannelPattern = class _ChannelPattern {
+  constructor(value) {
+    this.value = value;
+    this.syntax = ChannelPatternSyntax.from(value);
+  }
+  syntax;
+  /**
+   * Parse one runtime channel pattern.
+   */
+  static from(value) {
+    return new _ChannelPattern(value);
+  }
+  /**
+   * Match one concrete channel name.
+   */
+  match(channelName) {
+    return this.syntax.match(channelName);
+  }
+  /**
+   * Return the most specific matching candidate. Static segments have the highest score.
+   * Parameters score above optional parameters. Wildcards have the lowest score.
+   * Insertion order is preserved for ties.
+   */
+  static firstMatch(channelName, candidates) {
+    const sorted = [...candidates].sort((left, right) => {
+      return _ChannelPattern.#compareSpecificity(left.pattern, right.pattern);
+    });
+    const matched = ChannelPatternSyntax.firstMatch(
+      sorted.map(({ pattern: pattern2 }) => pattern2.syntax),
+      channelName
+    );
+    if (!matched) return null;
+    const { pattern, channel } = sorted[matched.index];
+    return { pattern, channel, params: matched.params };
+  }
+  static #compareSpecificity(left, right) {
+    return left.syntax.compareSpecificity(right.syntax);
+  }
+};
+
+// src/channel_router.ts
+var ChannelRouter = class {
+  constructor(makeChannel = (channel) => new channel(), createMiddlewareRunner) {
+    this.makeChannel = makeChannel;
+    this.createMiddlewareRunner = createMiddlewareRunner;
+  }
+  /**
+   * Registered channels keyed by their pattern.
+   */
+  #channels = /* @__PURE__ */ new Map();
+  /**
+   * Registers a channel.
+   */
+  register(channel) {
+    const patternValue = channel.pattern;
+    if (!patternValue) {
+      throw new Error(`Channel ${channel.name} must define a static pattern`);
+    }
+    if (this.#channels.has(patternValue)) {
+      throw new Error(`Channel pattern "${patternValue}" is already registered`);
+    }
+    const pattern = ChannelPattern.from(patternValue);
+    this.#channels.set(pattern.value, { pattern, channel });
+  }
+  /**
+   * Matches a channel name against registered patterns.
+   */
+  match(channelName) {
+    const matched = ChannelPattern.firstMatch(channelName, this.#channels.values());
+    if (!matched) {
+      return null;
+    }
+    return {
+      channel: matched.channel,
+      pattern: matched.pattern.value,
+      params: matched.params
+    };
+  }
+  /**
+   * Authorizes a socket before it joins a channel.
+   */
+  async authorize(socket, channelName) {
+    const matched = this.match(channelName);
+    if (!matched) {
+      return {
+        success: false,
+        error: "Channel not found"
+      };
+    }
+    const instance = await this.makeChannel(matched.channel);
+    const paramValues = Object.values(matched.params);
+    const ctx = {
+      socket,
+      channel: channelName,
+      params: matched.params,
+      presenceData: void 0,
+      setPresenceData(data) {
+        ctx.presenceData = data;
+      }
+    };
+    try {
+      await instance.$runMiddlewares(ctx, this.createMiddlewareRunner?.());
+    } catch (error) {
+      return {
+        success: false,
+        error: error instanceof SocketResponseError ? error.message : "Authorization failed",
+        cause: error
+      };
+    }
+    return {
+      success: true,
+      instance,
+      params: matched.params,
+      paramValues,
+      presenceData: ctx.presenceData ?? null
+    };
+  }
+  /**
+   * Lists all registered channels.
+   */
+  list() {
+    return [...this.#channels.values()].map(({ pattern, channel }) => ({
+      pattern: pattern.value,
+      name: channel.name,
+      options: channel.options
+    }));
+  }
+  /**
+   * Number of registered channels.
+   */
+  get size() {
+    return this.#channels.size;
+  }
+};
+
 // providers/socket_provider.ts
 var SocketProvider = class {
   constructor(app) {
@@ -1741,7 +1998,16 @@ var SocketProvider = class {
    */
   register() {
     this.app.container.singleton("socket.router", () => {
-      return new ChannelRouter();
+      return new ChannelRouter(
+        (channel) => this.app.container.make(channel),
+        () => {
+          const resolver = this.app.container.createResolver();
+          return async (Middleware, ctx, next) => {
+            const instance = await resolver.make(Middleware);
+            await resolver.call(instance, "handle", [ctx, next]);
+          };
+        }
+      );
     });
     this.app.container.singleton("socket.presence", () => {
       return new PresenceManager();
@@ -1809,7 +2075,7 @@ var SocketProvider = class {
    */
   #createUpgradeContextRunner(config, server) {
     const middleware = config.websocket?.middleware ?? [];
-    return async (request, handler) => {
+    return async (request, handler, shortCircuitBeforeMiddleware) => {
       const response = new ServerResponse(request);
       const adonisRequest = server.createRequest(request, response);
       const adonisResponse = server.createResponse(request, response);
@@ -1818,6 +2084,10 @@ var SocketProvider = class {
         adonisResponse,
         this.app.container.createResolver()
       );
+      const earlyResult = await shortCircuitBeforeMiddleware?.(httpContext);
+      if (earlyResult !== void 0) {
+        return earlyResult;
+      }
       return this.#runUpgradeMiddleware(server, middleware, httpContext, handler);
     };
   }
@@ -1853,13 +2123,6 @@ var SocketProvider = class {
    */
   async #registerChannels(router) {
     const logger = await this.#resolveLogger();
-    const config = this.app.config.get("socket", {});
-    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");