@fluojs/websockets 1.0.0-beta.1

package/dist/deno/deno-service.js

@@ -0,0 +1,533 @@
+let _initClass;
+function _applyDecs(e, t, n, r, o, i) { var a, c, u, s, f, l, p, d = Symbol.metadata || Symbol.for("Symbol.metadata"), m = Object.defineProperty, h = Object.create, y = [h(null), h(null)], v = t.length; function g(t, n, r) { return function (o, i) { n && (i = o, o = e); for (var a = 0; a < t.length; a++) i = t[a].apply(o, r ? [i] : []); return r ? i : o; }; } function b(e, t, n, r) { if ("function" != typeof e && (r || void 0 !== e)) throw new TypeError(t + " must " + (n || "be") + " a function" + (r ? "" : " or undefined")); return e; } function applyDec(e, t, n, r, o, i, u, s, f, l, p) { function d(e) { if (!p(e)) throw new TypeError("Attempted to access private element on non-instance"); } var h = [].concat(t[0]), v = t[3], w = !u, D = 1 === o, S = 3 === o, j = 4 === o, E = 2 === o; function I(t, n, r) { return function (o, i) { return n && (i = o, o = e), r && r(o), P[t].call(o, i); }; } if (!w) { var P = {}, k = [], F = S ? "get" : j || D ? "set" : "value"; if (f ? (l || D ? P = { get: _setFunctionName(function () { return v(this); }, r, "get"), set: function (e) { t[4](this, e); } } : P[F] = v, l || _setFunctionName(P[F], r, E ? "" : F)) : l || (P = Object.getOwnPropertyDescriptor(e, r)), !l && !f) { if ((c = y[+s][r]) && 7 !== (c ^ o)) throw Error("Decorating two elements with the same name (" + P[F].name + ") is not supported yet"); y[+s][r] = o < 3 ? 1 : o; } } for (var N = e, O = h.length - 1; O >= 0; O -= n ? 2 : 1) { var T = b(h[O], "A decorator", "be", !0), z = n ? h[O - 1] : void 0, A = {}, H = { kind: ["field", "accessor", "method", "getter", "setter", "class"][o], name: r, metadata: a, addInitializer: function (e, t) { if (e.v) throw new TypeError("attempted to call addInitializer after decoration was finished"); b(t, "An initializer", "be", !0), i.push(t); }.bind(null, A) }; if (w) c = T.call(z, N, H), A.v = 1, b(c, "class decorators", "return") && (N = c);else if (H.static = s, H.private = f, c = H.access = { has: f ? p.bind() : function (e) { return r in e; } }, j || (c.get = f ? E ? function (e) { return d(e), P.value; } : I("get", 0, d) : function (e) { return e[r]; }), E || S || (c.set = f ? I("set", 0, d) : function (e, t) { e[r] = t; }), N = T.call(z, D ? { get: P.get, set: P.set } : P[F], H), A.v = 1, D) { if ("object" == typeof N && N) (c = b(N.get, "accessor.get")) && (P.get = c), (c = b(N.set, "accessor.set")) && (P.set = c), (c = b(N.init, "accessor.init")) && k.unshift(c);else if (void 0 !== N) throw new TypeError("accessor decorators must return an object with get, set, or init properties or undefined"); } else b(N, (l ? "field" : "method") + " decorators", "return") && (l ? k.unshift(N) : P[F] = N); } return o < 2 && u.push(g(k, s, 1), g(i, s, 0)), l || w || (f ? D ? u.splice(-1, 0, I("get", s), I("set", s)) : u.push(E ? P[F] : b.call.bind(P[F])) : m(e, r, P)), N; } function w(e) { return m(e, d, { configurable: !0, enumerable: !0, value: a }); } return void 0 !== i && (a = i[d]), a = h(null == a ? null : a), f = [], l = function (e) { e && f.push(g(e)); }, p = function (t, r) { for (var i = 0; i < n.length; i++) { var a = n[i], c = a[1], l = 7 & c; if ((8 & c) == t && !l == r) { var p = a[2], d = !!a[3], m = 16 & c; applyDec(t ? e : e.prototype, a, m, d ? "#" + p : _toPropertyKey(p), l, l < 2 ? [] : t ? s = s || [] : u = u || [], f, !!t, d, r, t && d ? function (t) { return _checkInRHS(t) === e; } : o); } } }, p(8, 0), p(0, 0), p(8, 1), p(0, 1), l(u), l(s), c = f, v || w(e), { e: c, get c() { var n = []; return v && [w(e = applyDec(e, [t], r, e.name, 5, n)), g(n, 1)]; } }; }
+function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == typeof i ? i : i + ""; }
+function _toPrimitive(t, r) { if ("object" != typeof t || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != typeof i) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
+function _setFunctionName(e, t, n) { "symbol" == typeof t && (t = (t = t.description) ? "[" + t + "]" : ""); try { Object.defineProperty(e, "name", { configurable: !0, value: n ? n + " " + t : t }); } catch (e) {} return e; }
+function _checkInRHS(e) { if (Object(e) !== e) throw TypeError("right-hand side of 'in' should be an object, got " + (null !== e ? typeof e : "null")); return e; }
+import { Inject } from '@fluojs/core';
+import { APPLICATION_LOGGER, COMPILED_MODULES, HTTP_APPLICATION_ADAPTER, RUNTIME_CONTAINER } from '@fluojs/runtime/internal';
+import { dispatchGatewayDisconnect, dispatchGatewayMessage, discoverGatewayDescriptors, isFinitePositiveInteger, normalizeGatewayPath, resolveGatewayInstance, runGatewayHandlers } from '../internal/shared.js';
+import { WEBSOCKET_OPTIONS_INTERNAL } from '../options-token.internal.js';
+const DEFAULT_MAX_PENDING_MESSAGES_PER_SOCKET = 256;
+const DEFAULT_MAX_WEBSOCKET_CONNECTIONS = 1_000;
+const DEFAULT_MAX_WEBSOCKET_PAYLOAD_BYTES = 1_048_576;
+const LIFECYCLE_LOG_CONTEXT = 'WebSocketGatewayLifecycleService';
+const WEBSOCKET_OPEN_READY_STATE = 1;
+function hasDenoWebSocketBindingHost(adapter) {
+  return 'configureWebSocketBinding' in adapter && typeof adapter.configureWebSocketBinding === 'function';
+}
+function resolveSupportedFetchStyleRealtimeCapability(adapter) {
+  if (typeof adapter.getRealtimeCapability !== 'function') {
+    throw new Error('Deno WebSocket gateway bootstrap requires an HTTP adapter with getRealtimeCapability(). Use @fluojs/platform-deno together with @fluojs/websockets/deno.');
+  }
+  const capability = adapter.getRealtimeCapability();
+  if (capability.kind !== 'fetch-style' || capability.contract !== 'raw-websocket-expansion') {
+    throw new Error('Deno WebSocket gateway bootstrap requires a fetch-style raw-websocket-expansion realtime capability from the selected HTTP adapter.');
+  }
+  if (capability.support !== 'supported') {
+    throw new Error(`Deno WebSocket gateway bootstrap requires supported fetch-style websocket hosting. ${capability.reason}`);
+  }
+  return capability;
+}
+function isWebSocketUpgradeRequest(request) {
+  return request.headers.get('upgrade')?.toLowerCase() === 'websocket';
+}
+function isHttpExceptionLike(error) {
+  return typeof error === 'object' && error !== null && 'message' in error && 'status' in error;
+}
+function resolveMessageByteLength(message) {
+  if (typeof message === 'string') {
+    return Buffer.byteLength(message);
+  }
+  return message.size;
+}
+
+/**
+ * Boots Deno-backed websocket gateways and manages their room lifecycle state.
+ */
+let _DenoWebSocketGateway;
+class DenoWebSocketGatewayLifecycleService {
+  static {
+    [_DenoWebSocketGateway, _initClass] = _applyDecs(this, [Inject(RUNTIME_CONTAINER, COMPILED_MODULES, APPLICATION_LOGGER, HTTP_APPLICATION_ADAPTER, WEBSOCKET_OPTIONS_INTERNAL)], []).c;
+  }
+  pendingUpgradeReservations = 0;
+  roomSockets = new Map();
+  shutdownPromise;
+  socketRegistry = new Map();
+  socketRooms = new Map();
+  constructor(runtimeContainer, compiledModules, logger, adapter, moduleOptions) {
+    this.runtimeContainer = runtimeContainer;
+    this.compiledModules = compiledModules;
+    this.logger = logger;
+    this.adapter = adapter;
+    this.moduleOptions = moduleOptions;
+  }
+  async onApplicationBootstrap() {
+    const descriptors = discoverGatewayDescriptors(this.compiledModules, this.logger, LIFECYCLE_LOG_CONTEXT);
+    if (descriptors.length === 0) {
+      return;
+    }
+    this.assertNoServerBackedGatewayOptIn(descriptors);
+    resolveSupportedFetchStyleRealtimeCapability(this.adapter);
+    if (!hasDenoWebSocketBindingHost(this.adapter)) {
+      throw new Error('Deno WebSocket gateway bootstrap requires the selected adapter to expose Deno websocket binding configuration. Use @fluojs/platform-deno with @fluojs/websockets/deno.');
+    }
+    this.adapter.configureWebSocketBinding(this.createBinding(descriptors));
+  }
+  assertNoServerBackedGatewayOptIn(descriptors) {
+    const descriptor = descriptors.find(entry => entry.serverBacked !== undefined);
+    if (!descriptor) {
+      return;
+    }
+    throw new Error(`@WebSocketGateway({ serverBacked }) is not supported on @fluojs/websockets/deno. Gateway path ${descriptor.path} must use the default fetch-style request-upgrade host instead.`);
+  }
+  async onApplicationShutdown() {
+    await this.shutdown();
+  }
+  async onModuleDestroy() {
+    await this.shutdown();
+  }
+  createBinding(descriptors) {
+    const descriptorsByPath = this.groupDescriptorsByPath(descriptors);
+    return {
+      fetch: async (request, host) => {
+        if (!isWebSocketUpgradeRequest(request)) {
+          return new Response(null, {
+            status: 426
+          });
+        }
+        let targetPath;
+        try {
+          targetPath = normalizeGatewayPath(new URL(request.url).pathname);
+        } catch {
+          return new Response(null, {
+            status: 400
+          });
+        }
+        const descriptors = descriptorsByPath.get(targetPath);
+        if (!descriptors) {
+          return new Response(null, {
+            status: 404
+          });
+        }
+        const rejection = await this.resolveUpgradeRejection(request, targetPath);
+        if (rejection) {
+          return new Response(rejection.body ?? null, {
+            headers: rejection.headers,
+            status: rejection.status
+          });
+        }
+        let response;
+        let socket;
+        try {
+          ({
+            response,
+            socket
+          } = host.upgrade(request));
+        } catch (error) {
+          this.releaseUpgradeReservation();
+          throw error;
+        }
+        void this.bindConnectionHandlers(socket, request, descriptors).catch(error => {
+          this.unregisterSocket(this.findSocketId(socket));
+          this.logger.error('WebSocket gateway open lifecycle failed.', error, LIFECYCLE_LOG_CONTEXT);
+          socket.close(1011, 'Internal server error');
+        });
+        return response;
+      }
+    };
+  }
+  groupDescriptorsByPath(descriptors) {
+    const descriptorsByPath = new Map();
+    for (const descriptor of descriptors) {
+      const current = descriptorsByPath.get(descriptor.path);
+      if (current) {
+        current.push(descriptor);
+        continue;
+      }
+      descriptorsByPath.set(descriptor.path, [descriptor]);
+    }
+    return descriptorsByPath;
+  }
+  async bindConnectionHandlers(socket, request, descriptors) {
+    const state = this.createConnectionHandlerState(request, descriptors);
+    this.releaseUpgradeReservation();
+    this.socketRegistry.set(state.socketId, socket);
+    this.attachConnectionListeners(state, socket, request);
+    await this.resolveConnectionGateways(state);
+    await this.runConnectHandlers(state, socket);
+    await this.finalizeConnectionBinding(state, socket, request);
+  }
+  createConnectionHandlerState(request, descriptors) {
+    return {
+      bufferedDisconnect: undefined,
+      bufferedMessages: [],
+      bufferedMessagesStartIndex: 0,
+      descriptors,
+      enqueuedMessageCount: 0,
+      handlerQueue: Promise.resolve(),
+      handlersReady: false,
+      processingMessageQueue: false,
+      queuedMessages: [],
+      queuedMessagesStartIndex: 0,
+      request,
+      resolved: [],
+      socketId: crypto.randomUUID()
+    };
+  }
+  attachConnectionListeners(state, socket, request) {
+    socket.addEventListener('message', event => {
+      if (this.closeOversizedPayload(state.socketId, socket, event.data)) {
+        return;
+      }
+      if (!state.handlersReady) {
+        this.bufferIncomingMessage(state, socket, event.data);
+        return;
+      }
+      this.enqueueMessageDispatch(state, socket, request, event.data);
+    });
+    socket.addEventListener('error', event => {
+      this.unregisterSocket(state.socketId);
+      this.logger.error('WebSocket gateway socket emitted an error.', event, LIFECYCLE_LOG_CONTEXT);
+    });
+    socket.addEventListener('close', event => {
+      this.unregisterSocket(state.socketId);
+      const disconnectEvent = {
+        code: event.code,
+        reason: event.reason
+      };
+      if (!state.handlersReady) {
+        state.bufferedDisconnect = disconnectEvent;
+        return;
+      }
+      this.enqueueDisconnectDispatch(state, socket, disconnectEvent);
+    });
+  }
+  getBufferedMessageCount(state) {
+    return state.bufferedMessages.length - state.bufferedMessagesStartIndex;
+  }
+  getQueuedMessageCount(state) {
+    return state.queuedMessages.length - state.queuedMessagesStartIndex;
+  }
+  maybeCompactBufferedMessages(state) {
+    if (state.bufferedMessagesStartIndex === 0 || state.bufferedMessagesStartIndex < state.bufferedMessages.length / 2) {
+      return;
+    }
+    state.bufferedMessages = state.bufferedMessages.slice(state.bufferedMessagesStartIndex);
+    state.bufferedMessagesStartIndex = 0;
+  }
+  clearBufferedMessages(state) {
+    state.bufferedMessages = [];
+    state.bufferedMessagesStartIndex = 0;
+  }
+  maybeCompactQueuedMessages(state) {
+    if (state.queuedMessagesStartIndex === 0 || state.queuedMessagesStartIndex < state.queuedMessages.length / 2) {
+      return;
+    }
+    state.queuedMessages = state.queuedMessages.slice(state.queuedMessagesStartIndex);
+    state.queuedMessagesStartIndex = 0;
+  }
+  clearQueuedMessages(state) {
+    state.queuedMessages = [];
+    state.queuedMessagesStartIndex = 0;
+    state.enqueuedMessageCount = 0;
+  }
+  bufferIncomingMessage(state, socket, message) {
+    const limit = isFinitePositiveInteger(this.moduleOptions.buffer?.maxPendingMessagesPerSocket) ? this.moduleOptions.buffer.maxPendingMessagesPerSocket : DEFAULT_MAX_PENDING_MESSAGES_PER_SOCKET;
+    const policy = this.moduleOptions.buffer?.overflowPolicy ?? 'drop-oldest';
+    if (this.getBufferedMessageCount(state) < limit) {
+      state.bufferedMessages.push(message);
+      return;
+    }
+    if (policy === 'close') {
+      socket.close(1013, 'Pending message buffer limit exceeded');
+      this.clearBufferedMessages(state);
+      this.logger.warn(`WebSocket connection ${state.socketId} exceeded pending message buffer limit (${String(limit)}). Connection closed.`, LIFECYCLE_LOG_CONTEXT);
+      return;
+    }
+    if (policy === 'drop-newest') {
+      this.logger.warn(`WebSocket connection ${state.socketId} dropped an incoming message due to pending buffer limit (${String(limit)}).`, LIFECYCLE_LOG_CONTEXT);
+      return;
+    }
+    state.bufferedMessagesStartIndex += 1;
+    this.maybeCompactBufferedMessages(state);
+    state.bufferedMessages.push(message);
+    this.logger.warn(`WebSocket connection ${state.socketId} dropped the oldest pending message due to buffer limit (${String(limit)}).`, LIFECYCLE_LOG_CONTEXT);
+  }
+  enqueueMessageDispatch(state, socket, request, message) {
+    const limit = isFinitePositiveInteger(this.moduleOptions.buffer?.maxPendingMessagesPerSocket) ? this.moduleOptions.buffer.maxPendingMessagesPerSocket : DEFAULT_MAX_PENDING_MESSAGES_PER_SOCKET;
+    const policy = this.moduleOptions.buffer?.overflowPolicy ?? 'drop-oldest';
+    if (this.getQueuedMessageCount(state) >= limit) {
+      if (policy === 'close') {
+        socket.close(1013, 'Ready-state message queue limit exceeded');
+        this.clearQueuedMessages(state);
+        this.unregisterSocket(state.socketId);
+        this.logger.warn(`WebSocket connection ${state.socketId} exceeded ready-state message queue limit (${String(limit)}). Connection closed.`, LIFECYCLE_LOG_CONTEXT);
+        return;
+      }
+      if (policy === 'drop-oldest') {
+        state.queuedMessagesStartIndex += 1;
+        this.maybeCompactQueuedMessages(state);
+        this.logger.warn(`WebSocket connection ${state.socketId} dropped the oldest ready-state message because queue limit (${String(limit)}) was reached.`, LIFECYCLE_LOG_CONTEXT);
+      } else {
+        this.logger.warn(`WebSocket connection ${state.socketId} dropped a ready-state message because queue limit (${String(limit)}) was reached.`, LIFECYCLE_LOG_CONTEXT);
+        return;
+      }
+    }
+    state.queuedMessages.push(message);
+    state.enqueuedMessageCount = this.getQueuedMessageCount(state);
+    if (state.processingMessageQueue) {
+      return;
+    }
+    state.processingMessageQueue = true;
+    state.handlerQueue = this.drainMessageQueue(state, socket, request).finally(() => {
+      state.processingMessageQueue = false;
+      state.enqueuedMessageCount = this.getQueuedMessageCount(state);
+    }).catch(error => {
+      this.logger.error('WebSocket gateway message dispatch failed.', error, LIFECYCLE_LOG_CONTEXT);
+    });
+  }
+  async drainMessageQueue(state, socket, request) {
+    while (state.queuedMessagesStartIndex < state.queuedMessages.length) {
+      const nextMessage = state.queuedMessages[state.queuedMessagesStartIndex];
+      state.queuedMessagesStartIndex += 1;
+      state.enqueuedMessageCount = this.getQueuedMessageCount(state);
+      if (nextMessage === undefined) {
+        continue;
+      }
+      const normalizedMessage = await this.normalizeMessage(nextMessage);
+      await dispatchGatewayMessage(state.resolved, socket, request, normalizedMessage, this.logger, LIFECYCLE_LOG_CONTEXT);
+    }
+    this.clearQueuedMessages(state);
+  }
+  async normalizeMessage(message) {
+    if (typeof message === 'string') {
+      return message;
+    }
+    return await message.arrayBuffer();
+  }
+  enqueueDisconnectDispatch(state, socket, disconnectEvent) {
+    state.handlerQueue = state.handlerQueue.then(async () => {
+      await dispatchGatewayDisconnect(state.resolved, socket, disconnectEvent.code, disconnectEvent.reason, state.socketId, this.logger, LIFECYCLE_LOG_CONTEXT);
+    }).catch(error => {
+      this.logger.error('WebSocket gateway disconnect dispatch failed.', error, LIFECYCLE_LOG_CONTEXT);
+    });
+  }
+  async resolveConnectionGateways(state) {
+    const resolved = [];
+    for (const descriptor of state.descriptors) {
+      const instance = await resolveGatewayInstance(this.runtimeContainer, descriptor, this.logger, LIFECYCLE_LOG_CONTEXT);
+      if (instance !== undefined) {
+        resolved.push({
+          descriptor,
+          instance
+        });
+      }
+    }
+    state.resolved = resolved;
+  }
+  async runConnectHandlers(state, socket) {
+    for (const {
+      descriptor,
+      instance
+    } of state.resolved) {
+      await runGatewayHandlers(instance, descriptor, 'connect', [socket, state.request, state.socketId], this.logger, LIFECYCLE_LOG_CONTEXT);
+    }
+  }
+  async finalizeConnectionBinding(state, socket, request) {
+    state.handlersReady = true;
+    await this.replayBufferedConnectionEvents(state, socket, request);
+    await state.handlerQueue;
+  }
+  async replayBufferedConnectionEvents(state, socket, request) {
+    for (let index = state.bufferedMessagesStartIndex; index < state.bufferedMessages.length; index += 1) {
+      const message = state.bufferedMessages[index];
+      if (message !== undefined) {
+        this.enqueueMessageDispatch(state, socket, request, message);
+      }
+    }
+    if (state.bufferedDisconnect) {
+      this.enqueueDisconnectDispatch(state, socket, state.bufferedDisconnect);
+      state.bufferedDisconnect = undefined;
+    }
+    this.clearBufferedMessages(state);
+  }
+  findSocketId(target) {
+    for (const [socketId, socket] of this.socketRegistry) {
+      if (socket === target) {
+        return socketId;
+      }
+    }
+    return '';
+  }
+  async resolveUpgradeRejection(request, path) {
+    if (!this.tryReserveUpgradeSlot()) {
+      return {
+        body: 'WebSocket connection limit exceeded.',
+        status: 429
+      };
+    }
+    const guard = this.moduleOptions.upgrade?.guard;
+    if (!guard) {
+      return undefined;
+    }
+    try {
+      const result = await guard(request, {
+        activeConnectionCount: this.resolveReservedConnectionCount() - 1,
+        path
+      });
+      if (result === false) {
+        this.releaseUpgradeReservation();
+        return {
+          body: 'WebSocket upgrade rejected.',
+          status: 403
+        };
+      }
+      if (typeof result === 'object' && result !== null && 'status' in result) {
+        this.releaseUpgradeReservation();
+        return result;
+      }
+      return undefined;
+    } catch (error) {
+      this.releaseUpgradeReservation();
+      if (isHttpExceptionLike(error)) {
+        return {
+          body: error.message,
+          status: error.status
+        };
+      }
+      throw error;
+    }
+  }
+  closeOversizedPayload(socketId, socket, message) {
+    const maxPayloadBytes = this.resolveMaxPayloadBytes();
+    if (resolveMessageByteLength(message) <= maxPayloadBytes) {
+      return false;
+    }
+    socket.close(1009, 'Payload too large');
+    this.logger.warn(`WebSocket connection ${socketId} exceeded payload limit (${String(maxPayloadBytes)} bytes). Connection closed.`, LIFECYCLE_LOG_CONTEXT);
+    return true;
+  }
+  resolveMaxConnectionCount() {
+    const configured = this.moduleOptions.limits?.maxConnections;
+    if (!isFinitePositiveInteger(configured)) {
+      return DEFAULT_MAX_WEBSOCKET_CONNECTIONS;
+    }
+    return configured;
+  }
+  resolveReservedConnectionCount() {
+    return this.socketRegistry.size + this.pendingUpgradeReservations;
+  }
+  tryReserveUpgradeSlot() {
+    if (this.resolveReservedConnectionCount() >= this.resolveMaxConnectionCount()) {
+      return false;
+    }
+    this.pendingUpgradeReservations += 1;
+    return true;
+  }
+  releaseUpgradeReservation() {
+    if (this.pendingUpgradeReservations > 0) {
+      this.pendingUpgradeReservations -= 1;
+    }
+  }
+  resolveMaxPayloadBytes() {
+    const configured = this.moduleOptions.limits?.maxPayloadBytes;
+    if (!isFinitePositiveInteger(configured)) {
+      return DEFAULT_MAX_WEBSOCKET_PAYLOAD_BYTES;
+    }
+    return configured;
+  }
+  async shutdown() {
+    if (this.shutdownPromise) {
+      await this.shutdownPromise;
+      return;
+    }
+    this.shutdownPromise = this.runShutdownLifecycle();
+    await this.shutdownPromise;
+  }
+  async runShutdownLifecycle() {
+    if (hasDenoWebSocketBindingHost(this.adapter)) {
+      this.adapter.configureWebSocketBinding(undefined);
+    }
+    this.pendingUpgradeReservations = 0;
+    this.socketRegistry.clear();
+    this.socketRooms.clear();
+    this.roomSockets.clear();
+  }
+  joinRoom(socketId, room) {
+    let rooms = this.socketRooms.get(socketId);
+    if (!rooms) {
+      rooms = new Set();
+      this.socketRooms.set(socketId, rooms);
+    }
+    rooms.add(room);
+    let sockets = this.roomSockets.get(room);
+    if (!sockets) {
+      sockets = new Set();
+      this.roomSockets.set(room, sockets);
+    }
+    sockets.add(socketId);
+  }
+  leaveRoom(socketId, room) {
+    const rooms = this.socketRooms.get(socketId);
+    rooms?.delete(room);
+    if (rooms && rooms.size === 0) {
+      this.socketRooms.delete(socketId);
+    }
+    const sockets = this.roomSockets.get(room);
+    sockets?.delete(socketId);
+    if (sockets && sockets.size === 0) {
+      this.roomSockets.delete(room);
+    }
+  }
+  broadcastToRoom(room, event, data) {
+    const socketIds = this.roomSockets.get(room);
+    if (!socketIds) {
+      return;
+    }
+    const message = JSON.stringify({
+      data,
+      event
+    });
+    for (const socketId of socketIds) {
+      const socket = this.socketRegistry.get(socketId);
+      if (!socket || socket.readyState !== WEBSOCKET_OPEN_READY_STATE) {
+        continue;
+      }
+      try {
+        socket.send(message);
+      } catch (error) {
+        this.unregisterSocket(socketId);
+        this.logger.warn(`WebSocket connection ${socketId} failed to send a room broadcast and was removed. ${error instanceof Error ? error.message : 'Unknown error.'}`, LIFECYCLE_LOG_CONTEXT);
+      }
+    }
+  }
+  getRooms(socketId) {
+    const rooms = this.socketRooms.get(socketId);
+    if (!rooms) {
+      return new Set();
+    }
+    return new Set(rooms);
+  }
+  unregisterSocket(socketId) {
+    if (!socketId) {
+      return;
+    }
+    this.socketRegistry.delete(socketId);
+    const rooms = this.socketRooms.get(socketId);
+    if (rooms) {
+      for (const room of rooms) {
+        const sockets = this.roomSockets.get(room);
+        sockets?.delete(socketId);
+        if (sockets && sockets.size === 0) {
+          this.roomSockets.delete(room);
+        }
+      }
+      this.socketRooms.delete(socketId);
+    }
+  }
+  static {
+    _initClass();
+  }
+}
+export { _DenoWebSocketGateway as DenoWebSocketGatewayLifecycleService };

package/dist/deno/deno-types.d.ts

@@ -0,0 +1,25 @@
+import type { WebSocketModuleOptions as SharedWebSocketModuleOptions } from '../types.js';
+export type DenoWebSocketMessage = Blob | string;
+export interface DenoServerWebSocket extends Pick<WebSocket, 'addEventListener' | 'close' | 'removeEventListener' | 'send'> {
+    readonly readyState: number;
+}
+export interface DenoWebSocketUpgradeResult<TSocket extends DenoServerWebSocket = DenoServerWebSocket> {
+    response: Response;
+    socket: TSocket;
+}
+export interface DenoWebSocketUpgradeHost<TSocket extends DenoServerWebSocket = DenoServerWebSocket> {
+    upgrade(request: Request): DenoWebSocketUpgradeResult<TSocket>;
+}
+export interface DenoWebSocketBinding<TSocket extends DenoServerWebSocket = DenoServerWebSocket> {
+    fetch(request: Request, host: DenoWebSocketUpgradeHost<TSocket>): Response | Promise<Response>;
+}
+export interface DenoWebSocketBindingHost<TSocket extends DenoServerWebSocket = DenoServerWebSocket> {
+    configureWebSocketBinding(binding: DenoWebSocketBinding<TSocket> | undefined): void;
+}
+export type TypedOnMessageHandler<TEvents extends Record<string, unknown>, K extends keyof TEvents> = (payload: TEvents[K], socket: DenoServerWebSocket, request: Request) => void | Promise<void>;
+export interface WebSocketGatewayContext {
+    request: Request;
+    socket: DenoServerWebSocket;
+}
+export type WebSocketModuleOptions = SharedWebSocketModuleOptions;
+//# sourceMappingURL=deno-types.d.ts.map

package/dist/deno/deno-types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"deno-types.d.ts","sourceRoot":"","sources":["../../src/deno/deno-types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,sBAAsB,IAAI,4BAA4B,EAAE,MAAM,aAAa,CAAC;AAE1F,MAAM,MAAM,oBAAoB,GAAG,IAAI,GAAG,MAAM,CAAC;AAEjD,MAAM,WAAW,mBAAoB,SAAQ,IAAI,CAAC,SAAS,EAAE,kBAAkB,GAAG,OAAO,GAAG,qBAAqB,GAAG,MAAM,CAAC;IACzH,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;CAC7B;AAED,MAAM,WAAW,0BAA0B,CAAC,OAAO,SAAS,mBAAmB,GAAG,mBAAmB;IACnG,QAAQ,EAAE,QAAQ,CAAC;IACnB,MAAM,EAAE,OAAO,CAAC;CACjB;AAED,MAAM,WAAW,wBAAwB,CAAC,OAAO,SAAS,mBAAmB,GAAG,mBAAmB;IACjG,OAAO,CAAC,OAAO,EAAE,OAAO,GAAG,0BAA0B,CAAC,OAAO,CAAC,CAAC;CAChE;AAED,MAAM,WAAW,oBAAoB,CAAC,OAAO,SAAS,mBAAmB,GAAG,mBAAmB;IAC7F,KAAK,CAAC,OAAO,EAAE,OAAO,EAAE,IAAI,EAAE,wBAAwB,CAAC,OAAO,CAAC,GAAG,QAAQ,GAAG,OAAO,CAAC,QAAQ,CAAC,CAAC;CAChG;AAED,MAAM,WAAW,wBAAwB,CAAC,OAAO,SAAS,mBAAmB,GAAG,mBAAmB;IACjG,yBAAyB,CAAC,OAAO,EAAE,oBAAoB,CAAC,OAAO,CAAC,GAAG,SAAS,GAAG,IAAI,CAAC;CACrF;AAED,MAAM,MAAM,qBAAqB,CAAC,OAAO,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,CAAC,SAAS,MAAM,OAAO,IAAI,CACpG,OAAO,EAAE,OAAO,CAAC,CAAC,CAAC,EACnB,MAAM,EAAE,mBAAmB,EAC3B,OAAO,EAAE,OAAO,KACb,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;AAE1B,MAAM,WAAW,uBAAuB;IACtC,OAAO,EAAE,OAAO,CAAC;IACjB,MAAM,EAAE,mBAAmB,CAAC;CAC7B;AAED,MAAM,MAAM,sBAAsB,GAAG,4BAA4B,CAAC"}

package/dist/deno/deno-types.js

@@ -0,0 +1 @@
+export {};

package/dist/deno/deno.d.ts

@@ -0,0 +1,4 @@
+export * from './deno-module.js';
+export * from './deno-service.js';
+export * from './deno-types.js';
+//# sourceMappingURL=deno.d.ts.map

package/dist/deno/deno.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"deno.d.ts","sourceRoot":"","sources":["../../src/deno/deno.ts"],"names":[],"mappings":"AAAA,cAAc,kBAAkB,CAAC;AACjC,cAAc,mBAAmB,CAAC;AAClC,cAAc,iBAAiB,CAAC"}

package/dist/deno/deno.js

@@ -0,0 +1,3 @@
+export * from './deno-module.js';
+export * from './deno-service.js';
+export * from './deno-types.js';

package/dist/deno.d.ts

@@ -0,0 +1,2 @@
+export * from './deno/deno.js';
+//# sourceMappingURL=deno.d.ts.map

package/dist/deno.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"deno.d.ts","sourceRoot":"","sources":["../src/deno.ts"],"names":[],"mappings":"AAAA,cAAc,gBAAgB,CAAC"}

package/dist/deno.js

@@ -0,0 +1 @@
+export * from './deno/deno.js';

package/dist/index.d.ts

@@ -0,0 +1,6 @@
+export * from './decorators.js';
+export * from './metadata.js';
+export * from './module.js';
+export * from './service.js';
+export * from './types.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,iBAAiB,CAAC;AAChC,cAAc,eAAe,CAAC;AAC9B,cAAc,aAAa,CAAC;AAC5B,cAAc,cAAc,CAAC;AAC7B,cAAc,YAAY,CAAC"}

package/dist/index.js

@@ -0,0 +1,5 @@
+export * from './decorators.js';
+export * from './metadata.js';
+export * from './module.js';
+export * from './service.js';
+export * from './types.js';

package/dist/internal/shared.d.ts

@@ -0,0 +1,28 @@
+import type { Token } from '@fluojs/core';
+import type { Container } from '@fluojs/di';
+import type { ApplicationLogger, CompiledModule } from '@fluojs/runtime';
+import type { WebSocketGatewayDescriptor, WebSocketGatewayHandlerDescriptor } from '../types.js';
+export interface DiscoveryCandidate {
+    moduleName: string;
+    scope: 'request' | 'singleton' | 'transient';
+    targetType: Function;
+    token: Token;
+}
+export interface ResolvedGatewayInstance {
+    descriptor: WebSocketGatewayDescriptor;
+    instance: unknown;
+}
+export type ParsedWebSocketMessage = {
+    event?: string;
+    payload: unknown;
+};
+export type SharedWebSocketIncomingMessage = ArrayBuffer | ArrayBufferView | Uint8Array[] | string;
+export declare function isFinitePositiveInteger(value: unknown): value is number;
+export declare function normalizeGatewayPath(path: string): string;
+export declare function parseIncomingMessage(data: SharedWebSocketIncomingMessage): ParsedWebSocketMessage;
+export declare function discoverGatewayDescriptors(compiledModules: readonly CompiledModule[], logger: ApplicationLogger, loggerContext: string): WebSocketGatewayDescriptor[];
+export declare function resolveGatewayInstance(runtimeContainer: Container, descriptor: WebSocketGatewayDescriptor, logger: ApplicationLogger, loggerContext: string): Promise<unknown | undefined>;
+export declare function dispatchGatewayMessage<TSocket, TRequest>(resolved: readonly ResolvedGatewayInstance[], socket: TSocket, request: TRequest, data: SharedWebSocketIncomingMessage, logger: ApplicationLogger, loggerContext: string): Promise<void>;
+export declare function dispatchGatewayDisconnect<TSocket>(resolved: readonly ResolvedGatewayInstance[], socket: TSocket, code: number, reason: string, socketId: string, logger: ApplicationLogger, loggerContext: string): Promise<void>;
+export declare function runGatewayHandlers(instance: unknown, descriptor: WebSocketGatewayDescriptor, type: WebSocketGatewayHandlerDescriptor['type'], args: unknown[], logger: ApplicationLogger, loggerContext: string): Promise<void>;
+//# sourceMappingURL=shared.d.ts.map

package/dist/internal/shared.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"shared.d.ts","sourceRoot":"","sources":["../../src/internal/shared.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAuB,KAAK,EAAE,MAAM,cAAc,CAAC;AAE/D,OAAO,KAAK,EAAY,SAAS,EAAE,MAAM,YAAY,CAAC;AACtD,OAAO,KAAK,EAAE,iBAAiB,EAAE,cAAc,EAAE,MAAM,iBAAiB,CAAC;AAGzE,OAAO,KAAK,EACV,0BAA0B,EAC1B,iCAAiC,EAClC,MAAM,aAAa,CAAC;AAIrB,MAAM,WAAW,kBAAkB;IACjC,UAAU,EAAE,MAAM,CAAC;IACnB,KAAK,EAAE,SAAS,GAAG,WAAW,GAAG,WAAW,CAAC;IAC7C,UAAU,EAAE,QAAQ,CAAC;IACrB,KAAK,EAAE,KAAK,CAAC;CACd;AAQD,MAAM,WAAW,uBAAuB;IACtC,UAAU,EAAE,0BAA0B,CAAC;IACvC,QAAQ,EAAE,OAAO,CAAC;CACnB;AAED,MAAM,MAAM,sBAAsB,GAAG;IACnC,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,OAAO,EAAE,OAAO,CAAC;CAClB,CAAC;AAEF,MAAM,MAAM,8BAA8B,GACtC,WAAW,GACX,eAAe,GACf,UAAU,EAAE,GACZ,MAAM,CAAC;AAEX,wBAAgB,uBAAuB,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,MAAM,CAEvE;AAED,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAQzD;AAED,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,8BAA8B,GAAG,sBAAsB,CA4CjG;AAED,wBAAgB,0BAA0B,CACxC,eAAe,EAAE,SAAS,cAAc,EAAE,EAC1C,MAAM,EAAE,iBAAiB,EACzB,aAAa,EAAE,MAAM,GACpB,0BAA0B,EAAE,CA4B9B;AAED,wBAAsB,sBAAsB,CAC1C,gBAAgB,EAAE,SAAS,EAC3B,UAAU,EAAE,0BAA0B,EACtC,MAAM,EAAE,iBAAiB,EACzB,aAAa,EAAE,MAAM,GACpB,OAAO,CAAC,OAAO,GAAG,SAAS,CAAC,CAW9B;AAED,wBAAsB,sBAAsB,CAAC,OAAO,EAAE,QAAQ,EAC5D,QAAQ,EAAE,SAAS,uBAAuB,EAAE,EAC5C,MAAM,EAAE,OAAO,EACf,OAAO,EAAE,QAAQ,EACjB,IAAI,EAAE,8BAA8B,EACpC,MAAM,EAAE,iBAAiB,EACzB,aAAa,EAAE,MAAM,GACpB,OAAO,CAAC,IAAI,CAAC,CAcf;AAED,wBAAsB,yBAAyB,CAAC,OAAO,EACrD,QAAQ,EAAE,SAAS,uBAAuB,EAAE,EAC5C,MAAM,EAAE,OAAO,EACf,IAAI,EAAE,MAAM,EACZ,MAAM,EAAE,MAAM,EACd,QAAQ,EAAE,MAAM,EAChB,MAAM,EAAE,iBAAiB,EACzB,aAAa,EAAE,MAAM,GACpB,OAAO,CAAC,IAAI,CAAC,CAIf;AAED,wBAAsB,kBAAkB,CACtC,QAAQ,EAAE,OAAO,EACjB,UAAU,EAAE,0BAA0B,EACtC,IAAI,EAAE,iCAAiC,CAAC,MAAM,CAAC,EAC/C,IAAI,EAAE,OAAO,EAAE,EACf,MAAM,EAAE,iBAAiB,EACzB,aAAa,EAAE,MAAM,GACpB,OAAO,CAAC,IAAI,CAAC,CAMf"}