@fluojs/websockets 1.0.0-beta.1

package/dist/cloudflare-workers/cloudflare-workers-module.js

@@ -0,0 +1,27 @@
+import { defineModule } from '@fluojs/runtime';
+import { WEBSOCKET_OPTIONS_INTERNAL } from '../options-token.internal.js';
+import { CloudflareWorkersWebSocketGatewayLifecycleService } from './cloudflare-workers-service.js';
+function createCloudflareWorkersWebSocketProviders(options = {}) {
+  return [{
+    provide: WEBSOCKET_OPTIONS_INTERNAL,
+    useValue: options
+  }, CloudflareWorkersWebSocketGatewayLifecycleService];
+}
+
+/**
+ * Explicit Cloudflare Workers websocket module entrypoint.
+ */
+export class CloudflareWorkersWebSocketModule {
+  /**
+   * Registers the Cloudflare Workers websocket lifecycle service for request-upgrade gateway hosting.
+   *
+   * @param options Websocket gateway runtime options for guards, limits, heartbeat, and shutdown behavior.
+   * @returns A runtime module definition scoped to the Cloudflare Workers websocket adapter.
+   */
+  static forRoot(options = {}) {
+    class CloudflareWorkersWebSocketRuntimeModule extends CloudflareWorkersWebSocketModule {}
+    return defineModule(CloudflareWorkersWebSocketRuntimeModule, {
+      providers: createCloudflareWorkersWebSocketProviders(options)
+    });
+  }
+}

package/dist/cloudflare-workers/cloudflare-workers-service.d.ts

@@ -0,0 +1,61 @@
+import type { Container } from '@fluojs/di';
+import type { ApplicationLogger, CompiledModule, OnApplicationBootstrap, OnApplicationShutdown, OnModuleDestroy } from '@fluojs/runtime';
+import type { HttpApplicationAdapter } from '@fluojs/http';
+import type { WebSocketRoomService } from '../types.js';
+import type { WebSocketModuleOptions } from './cloudflare-workers-types.js';
+/**
+ * Boots Cloudflare Workers websocket gateways and manages their room lifecycle state.
+ */
+export declare class CloudflareWorkersWebSocketGatewayLifecycleService implements OnApplicationBootstrap, OnApplicationShutdown, OnModuleDestroy, WebSocketRoomService {
+    private readonly runtimeContainer;
+    private readonly compiledModules;
+    private readonly logger;
+    private readonly adapter;
+    private readonly moduleOptions;
+    private pendingUpgradeReservations;
+    private readonly roomSockets;
+    private shutdownPromise;
+    private readonly socketRegistry;
+    private readonly socketRooms;
+    constructor(runtimeContainer: Container, compiledModules: readonly CompiledModule[], logger: ApplicationLogger, adapter: HttpApplicationAdapter, moduleOptions: WebSocketModuleOptions);
+    onApplicationBootstrap(): Promise<void>;
+    private assertNoServerBackedGatewayOptIn;
+    onApplicationShutdown(): Promise<void>;
+    onModuleDestroy(): Promise<void>;
+    private createBinding;
+    private groupDescriptorsByPath;
+    private bindConnectionHandlers;
+    private createConnectionHandlerState;
+    private attachConnectionListeners;
+    private getBufferedMessageCount;
+    private getQueuedMessageCount;
+    private maybeCompactBufferedMessages;
+    private clearBufferedMessages;
+    private maybeCompactQueuedMessages;
+    private clearQueuedMessages;
+    private bufferIncomingMessage;
+    private enqueueMessageDispatch;
+    private drainMessageQueue;
+    private normalizeMessage;
+    private enqueueDisconnectDispatch;
+    private resolveConnectionGateways;
+    private runConnectHandlers;
+    private finalizeConnectionBinding;
+    private replayBufferedConnectionEvents;
+    private findSocketId;
+    private resolveUpgradeRejection;
+    private closeOversizedPayload;
+    private resolveMaxConnectionCount;
+    private resolveReservedConnectionCount;
+    private tryReserveUpgradeSlot;
+    private releaseUpgradeReservation;
+    private resolveMaxPayloadBytes;
+    private shutdown;
+    private runShutdownLifecycle;
+    joinRoom(socketId: string, room: string): void;
+    leaveRoom(socketId: string, room: string): void;
+    broadcastToRoom(room: string, event: string, data: unknown): void;
+    getRooms(socketId: string): ReadonlySet<string>;
+    private unregisterSocket;
+}
+//# sourceMappingURL=cloudflare-workers-service.d.ts.map

package/dist/cloudflare-workers/cloudflare-workers-service.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cloudflare-workers-service.d.ts","sourceRoot":"","sources":["../../src/cloudflare-workers/cloudflare-workers-service.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,YAAY,CAAC;AAC5C,OAAO,KAAK,EAAE,iBAAiB,EAAE,cAAc,EAAE,sBAAsB,EAAE,qBAAqB,EAAE,eAAe,EAAE,MAAM,iBAAiB,CAAC;AAEzI,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,cAAc,CAAC;AAa3D,OAAO,KAAK,EAA8B,oBAAoB,EAA6B,MAAM,aAAa,CAAC;AAC/G,OAAO,KAAK,EAKV,sBAAsB,EACvB,MAAM,+BAA+B,CAAC;AA0GvC;;GAEG;AACH,qBACa,iDACX,YAAW,sBAAsB,EAAE,qBAAqB,EAAE,eAAe,EAAE,oBAAoB;IAS7F,OAAO,CAAC,QAAQ,CAAC,gBAAgB;IACjC,OAAO,CAAC,QAAQ,CAAC,eAAe;IAChC,OAAO,CAAC,QAAQ,CAAC,MAAM;IACvB,OAAO,CAAC,QAAQ,CAAC,OAAO;IACxB,OAAO,CAAC,QAAQ,CAAC,aAAa;IAXhC,OAAO,CAAC,0BAA0B,CAAK;IACvC,OAAO,CAAC,QAAQ,CAAC,WAAW,CAAkC;IAC9D,OAAO,CAAC,eAAe,CAA4B;IACnD,OAAO,CAAC,QAAQ,CAAC,cAAc,CAAgD;IAC/E,OAAO,CAAC,QAAQ,CAAC,WAAW,CAAkC;gBAG3C,gBAAgB,EAAE,SAAS,EAC3B,eAAe,EAAE,SAAS,cAAc,EAAE,EAC1C,MAAM,EAAE,iBAAiB,EACzB,OAAO,EAAE,sBAAsB,EAC/B,aAAa,EAAE,sBAAsB;IAGlD,sBAAsB,IAAI,OAAO,CAAC,IAAI,CAAC;IAoB7C,OAAO,CAAC,gCAAgC;IAclC,qBAAqB,IAAI,OAAO,CAAC,IAAI,CAAC;IAItC,eAAe,IAAI,OAAO,CAAC,IAAI,CAAC;IAItC,OAAO,CAAC,aAAa;IAqDrB,OAAO,CAAC,sBAAsB;YAmBhB,sBAAsB;IAgBpC,OAAO,CAAC,4BAA4B;IAqBpC,OAAO,CAAC,yBAAyB;IAyCjC,OAAO,CAAC,uBAAuB;IAI/B,OAAO,CAAC,qBAAqB;IAI7B,OAAO,CAAC,4BAA4B;IASpC,OAAO,CAAC,qBAAqB;IAK7B,OAAO,CAAC,0BAA0B;IASlC,OAAO,CAAC,mBAAmB;IAM3B,OAAO,CAAC,qBAAqB;IA0C7B,OAAO,CAAC,sBAAsB;YAyDhB,iBAAiB;YAqBjB,gBAAgB;IAU9B,OAAO,CAAC,yBAAyB;YAsBnB,yBAAyB;YAczB,kBAAkB;YAgBlB,yBAAyB;YAUzB,8BAA8B;IAqB5C,OAAO,CAAC,YAAY;YAUN,uBAAuB;IAmDrC,OAAO,CAAC,qBAAqB;IAmB7B,OAAO,CAAC,yBAAyB;IAUjC,OAAO,CAAC,8BAA8B;IAItC,OAAO,CAAC,qBAAqB;IAS7B,OAAO,CAAC,yBAAyB;IAMjC,OAAO,CAAC,sBAAsB;YAUhB,QAAQ;YAUR,oBAAoB;IAWlC,QAAQ,CAAC,QAAQ,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,IAAI;IAmB9C,SAAS,CAAC,QAAQ,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,IAAI;IAc/C,eAAe,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,IAAI,EAAE,OAAO,GAAG,IAAI;IA4BjE,QAAQ,CAAC,QAAQ,EAAE,MAAM,GAAG,WAAW,CAAC,MAAM,CAAC;IAU/C,OAAO,CAAC,gBAAgB;CAoBzB"}

package/dist/cloudflare-workers/cloudflare-workers-service.js

@@ -0,0 +1,538 @@
+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 hasCloudflareWorkerWebSocketBindingHost(adapter) {
+  return 'configureWebSocketBinding' in adapter && typeof adapter.configureWebSocketBinding === 'function';
+}
+function resolveSupportedFetchStyleRealtimeCapability(adapter) {
+  if (typeof adapter.getRealtimeCapability !== 'function') {
+    throw new Error('Cloudflare Workers WebSocket gateway bootstrap requires an HTTP adapter with getRealtimeCapability(). Use @fluojs/platform-cloudflare-workers together with @fluojs/websockets/cloudflare-workers.');
+  }
+  const capability = adapter.getRealtimeCapability();
+  if (capability.kind !== 'fetch-style' || capability.contract !== 'raw-websocket-expansion') {
+    throw new Error('Cloudflare Workers WebSocket gateway bootstrap requires a fetch-style raw-websocket-expansion realtime capability from the selected HTTP adapter.');
+  }
+  if (capability.support !== 'supported') {
+    throw new Error(`Cloudflare Workers 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);
+  }
+  if (message instanceof Blob) {
+    return message.size;
+  }
+  return message.byteLength;
+}
+
+/**
+ * Boots Cloudflare Workers websocket gateways and manages their room lifecycle state.
+ */
+let _CloudflareWorkersWeb;
+class CloudflareWorkersWebSocketGatewayLifecycleService {
+  static {
+    [_CloudflareWorkersWeb, _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 (!hasCloudflareWorkerWebSocketBindingHost(this.adapter)) {
+      throw new Error('Cloudflare Workers WebSocket gateway bootstrap requires the selected adapter to expose Cloudflare websocket binding configuration. Use @fluojs/platform-cloudflare-workers with @fluojs/websockets/cloudflare-workers.');
+    }
+    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/cloudflare-workers. 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 matchedDescriptors = descriptorsByPath.get(targetPath);
+        if (!matchedDescriptors) {
+          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 serverSocket;
+        try {
+          ({
+            response,
+            serverSocket
+          } = host.upgrade(request));
+        } catch (error) {
+          this.releaseUpgradeReservation();
+          throw error;
+        }
+        serverSocket.accept();
+        void this.bindConnectionHandlers(serverSocket, request, matchedDescriptors).catch(error => {
+          this.unregisterSocket(this.findSocketId(serverSocket));
+          this.logger.error('WebSocket gateway open lifecycle failed.', error, LIFECYCLE_LOG_CONTEXT);
+          serverSocket.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 closeEvent = event;
+      const disconnectEvent = {
+        code: closeEvent.code,
+        reason: closeEvent.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 (message instanceof Blob) {
+      return await message.arrayBuffer();
+    }
+    return message;
+  }
+  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 (hasCloudflareWorkerWebSocketBindingHost(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 { _CloudflareWorkersWeb as CloudflareWorkersWebSocketGatewayLifecycleService };

package/dist/cloudflare-workers/cloudflare-workers-types.d.ts

@@ -0,0 +1,30 @@
+import type { WebSocketModuleOptions as SharedWebSocketModuleOptions } from '../types.js';
+export type CloudflareWorkerWebSocketMessage = ArrayBuffer | ArrayBufferView | Blob | string;
+export interface CloudflareWorkerWebSocket extends Pick<WebSocket, 'addEventListener' | 'close' | 'removeEventListener' | 'send'> {
+    readonly readyState: number;
+    accept(): void;
+}
+export interface CloudflareWorkerWebSocketPair {
+    0: CloudflareWorkerWebSocket;
+    1: CloudflareWorkerWebSocket;
+}
+export interface CloudflareWorkerWebSocketUpgradeResult {
+    response: Response;
+    serverSocket: CloudflareWorkerWebSocket;
+}
+export interface CloudflareWorkerWebSocketUpgradeHost {
+    upgrade(request: Request): CloudflareWorkerWebSocketUpgradeResult;
+}
+export interface CloudflareWorkerWebSocketBinding {
+    fetch(request: Request, host: CloudflareWorkerWebSocketUpgradeHost): Response | Promise<Response>;
+}
+export interface CloudflareWorkerWebSocketBindingHost {
+    configureWebSocketBinding(binding: CloudflareWorkerWebSocketBinding | undefined): void;
+}
+export type TypedOnMessageHandler<TEvents extends Record<string, unknown>, K extends keyof TEvents> = (payload: TEvents[K], socket: CloudflareWorkerWebSocket, request: Request) => void | Promise<void>;
+export interface WebSocketGatewayContext {
+    request: Request;
+    socket: CloudflareWorkerWebSocket;
+}
+export type WebSocketModuleOptions = SharedWebSocketModuleOptions;
+//# sourceMappingURL=cloudflare-workers-types.d.ts.map

package/dist/cloudflare-workers/cloudflare-workers-types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cloudflare-workers-types.d.ts","sourceRoot":"","sources":["../../src/cloudflare-workers/cloudflare-workers-types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,sBAAsB,IAAI,4BAA4B,EAAE,MAAM,aAAa,CAAC;AAE1F,MAAM,MAAM,gCAAgC,GAAG,WAAW,GAAG,eAAe,GAAG,IAAI,GAAG,MAAM,CAAC;AAE7F,MAAM,WAAW,yBACf,SAAQ,IAAI,CAAC,SAAS,EAAE,kBAAkB,GAAG,OAAO,GAAG,qBAAqB,GAAG,MAAM,CAAC;IACtF,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,MAAM,IAAI,IAAI,CAAC;CAChB;AAED,MAAM,WAAW,6BAA6B;IAC5C,CAAC,EAAE,yBAAyB,CAAC;IAC7B,CAAC,EAAE,yBAAyB,CAAC;CAC9B;AAED,MAAM,WAAW,sCAAsC;IACrD,QAAQ,EAAE,QAAQ,CAAC;IACnB,YAAY,EAAE,yBAAyB,CAAC;CACzC;AAED,MAAM,WAAW,oCAAoC;IACnD,OAAO,CAAC,OAAO,EAAE,OAAO,GAAG,sCAAsC,CAAC;CACnE;AAED,MAAM,WAAW,gCAAgC;IAC/C,KAAK,CAAC,OAAO,EAAE,OAAO,EAAE,IAAI,EAAE,oCAAoC,GAAG,QAAQ,GAAG,OAAO,CAAC,QAAQ,CAAC,CAAC;CACnG;AAED,MAAM,WAAW,oCAAoC;IACnD,yBAAyB,CAAC,OAAO,EAAE,gCAAgC,GAAG,SAAS,GAAG,IAAI,CAAC;CACxF;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,yBAAyB,EACjC,OAAO,EAAE,OAAO,KACb,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;AAE1B,MAAM,WAAW,uBAAuB;IACtC,OAAO,EAAE,OAAO,CAAC;IACjB,MAAM,EAAE,yBAAyB,CAAC;CACnC;AAED,MAAM,MAAM,sBAAsB,GAAG,4BAA4B,CAAC"}

package/dist/cloudflare-workers/cloudflare-workers-types.js

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

package/dist/cloudflare-workers/cloudflare-workers.d.ts

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