@velajs/vela 1.18.0 → 1.19.1

package/dist/websocket-DXmB-MWJ.js

@@ -0,0 +1,697 @@
+import { C as InjectionToken, a as Injectable, i as Inject, k as MetadataRegistry, m as Scope, n as __decorateParam, o as Optional, r as __decorateMetadata, t as __decorate } from "./decorate-GcSMAbKn.js";
+import { F as shouldFilterCatch, I as ComponentManager, L as PipelineRunner, V as instantiateMany, t as RouteManager } from "./route.manager-DRAZ5X04.js";
+import { n as resolveErrorReporter, t as DiscoveryService } from "./discovery.service-BYm95SSD.js";
+import { t as Container } from "./container-BqUHID4l.js";
+import { n as defineModule } from "./define-module-NOyOZNXD.js";
+import { toErrorBody } from "@velajs/errors";
+//#region src/discovery/discoverable.decorator.ts
+/**
+* Mint a discoverable decorator for a module's extension surface:
+*
+* ```ts
+* export interface QueueConsumerMeta { queue: string }
+* export const QueueConsumer = createDiscoverableDecorator<QueueConsumerMeta>('vela:queue:consumer');
+*
+* @QueueConsumer({ queue: 'emails' })
+* @Injectable()
+* class EmailConsumer { ... }
+*
+* // At bootstrap, anywhere:
+* discovery.providersWithMeta(QueueConsumer)  // typed { meta: QueueConsumerMeta }
+* ```
+*
+* Unlike `Reflector.createDecorator`, the key is required and caller-chosen:
+* a random key would mint a fresh identity on every HMR re-eval and orphan
+* previously-decorated classes. Namespace it (`'<pkg>:<area>:<thing>'`).
+*/
+function createDiscoverableDecorator(key, options = {}) {
+	const decorator = (value) => {
+		return (target, propertyKey) => {
+			const ctor = propertyKey !== void 0 ? target.constructor : target;
+			if (options.append) if (propertyKey !== void 0) MetadataRegistry.appendCustomClassMeta(ctor, key, {
+				methodName: propertyKey,
+				...value
+			});
+			else MetadataRegistry.appendCustomClassMeta(ctor, key, value);
+			else if (propertyKey !== void 0) MetadataRegistry.setCustomHandlerMeta(ctor, propertyKey, key, value);
+			else MetadataRegistry.setCustomClassMeta(ctor, key, value);
+		};
+	};
+	decorator.KEY = key;
+	return decorator;
+}
+//#endregion
+//#region src/websocket/websocket.tokens.ts
+const WS_GATEWAY_METADATA = "vela:ws-gateway";
+const WS_SUBSCRIBE_METADATA = "vela:ws-subscribe";
+const WS_RESERVED_METADATA = "vela:ws-reserved";
+/**
+* Event names starting with this prefix are RESERVED for framework modules
+* (`$live`, …): app gateways may not subscribe to them, and inbound frames
+* carrying them route to `@ReservedWsEvent` handlers instead of gateways.
+*/
+const RESERVED_WS_EVENT_PREFIX = "$";
+const WsParamType = {
+	SOCKET: "ws_socket",
+	BODY: "ws_body",
+	SERVER: "ws_server"
+};
+/**
+* The connected gateway server handle. Injected into gateways/controllers via
+* `@WebSocketServer()` (constructor injection only — the container has no
+* property-injection pass) or `@Inject(WS_SERVER)`.
+*/
+const WS_SERVER = new InjectionToken("WS_SERVER");
+/** The active cross-instance sync driver (`local()` by default). */
+const WS_SYNC_DRIVER = new InjectionToken("WS_SYNC_DRIVER");
+/** The local room-membership registry a transport reads/writes. */
+const WS_ROOM_REGISTRY = new InjectionToken("WS_ROOM_REGISTRY");
+const WS_MODULE_OPTIONS = new InjectionToken("WS_MODULE_OPTIONS");
+//#endregion
+//#region src/websocket/websocket.decorators.ts
+/**
+* Marks a class as a WebSocket gateway. Mirrors `@Controller` for the socket
+* transport: registers the class as an injectable singleton and stores its
+* routing options (`path`, Cloudflare `binding`).
+*
+* @example
+* ```ts
+* @WebSocketGateway({ path: '/rooms/:id/ws', binding: 'CHAT_ROOM' })
+* class ChatGateway {}
+* ```
+*/
+function WebSocketGateway(options = {}) {
+	return (target) => {
+		const ctor = target;
+		MetadataRegistry.setCustomClassMeta(ctor, WS_GATEWAY_METADATA, options);
+		MetadataRegistry.markInjectable(ctor);
+		MetadataRegistry.setScope(ctor, Scope.SINGLETON);
+	};
+}
+/**
+* Binds a gateway method to an inbound event. Stackable — one class-level list,
+* exactly like `@OnEvent` (`event-emitter.decorators.ts`).
+*/
+function SubscribeMessage(event) {
+	return (target, propertyKey) => {
+		MetadataRegistry.appendCustomClassMeta(target.constructor, WS_SUBSCRIBE_METADATA, {
+			event,
+			methodName: String(propertyKey)
+		});
+	};
+}
+const ReservedWsEventMeta = createDiscoverableDecorator(WS_RESERVED_METADATA);
+/**
+* Claims a reserved (`$`-prefixed) envelope event for a framework-module
+* provider (see `ReservedWsEventHandler`). Reserved frames route to the
+* decorated provider across every gateway path — gateways themselves may not
+* subscribe to `$…` events. Stack with `@Injectable()` like `@Processor`.
+*
+* @example
+* ```ts
+* @ReservedWsEvent('$live')
+* @Injectable()
+* class LiveEngine implements ReservedWsEventHandler { … }
+* ```
+*/
+function ReservedWsEvent(event) {
+	if (!event.startsWith("$")) throw new Error(`@ReservedWsEvent('${event}') must claim a '\$'-prefixed event — unprefixed events belong to app gateways (@SubscribeMessage).`);
+	return ReservedWsEventMeta({ event });
+}
+function wsParamDecorator(type) {
+	return () => (target, propertyKey, parameterIndex) => {
+		if (propertyKey === void 0) throw new Error("WebSocket parameter decorators can only be used on method parameters");
+		MetadataRegistry.addParameter(target.constructor, propertyKey, {
+			index: parameterIndex,
+			type
+		});
+	};
+}
+/** Injects the inbound message payload (the envelope's `data`) into a handler parameter. */
+const MessageBody = wsParamDecorator(WsParamType.BODY);
+/** Injects the connected socket (`WsClient`) into a handler parameter. */
+const ConnectedSocket = wsParamDecorator(WsParamType.SOCKET);
+/**
+* Injects the gateway server handle (`WsServer`). Constructor injection only —
+* the container has no property-injection pass, so this is sugar for
+* `@Inject(WS_SERVER)` on a constructor parameter.
+*
+* @example
+* ```ts
+* constructor(@WebSocketServer() private server: WsServer) {}
+* ```
+*/
+function WebSocketServer() {
+	return Inject(WS_SERVER);
+}
+//#endregion
+//#region src/websocket/ws-argument-resolver.ts
+/**
+* Builds handler arguments for a gateway message. WS sibling of the HTTP
+* `ArgumentResolver`, but sourced from the envelope (`data`) and the socket
+* (`client`) instead of the Hono `Context`.
+*
+* With no parameter decorators the handler receives `(client, data)` — the
+* NestJS gateway convention. Pipes run only over `@MessageBody()` values, where
+* validation/transformation is meaningful.
+*/
+async function resolveWsArgs(paramMeta, client, data, pipes, paramTypes) {
+	if (paramMeta.length === 0) return [client, data];
+	const maxIndex = paramMeta[paramMeta.length - 1].index;
+	const args = new Array(maxIndex + 1).fill(void 0);
+	for (const param of paramMeta) {
+		if (param.type === WsParamType.SOCKET) {
+			args[param.index] = client;
+			continue;
+		}
+		if (param.type === WsParamType.BODY) {
+			let value = data;
+			const metadata = {
+				type: param.type,
+				data: param.name,
+				metatype: paramTypes?.[param.index]
+			};
+			for (const pipe of pipes) value = await pipe.transform(value, metadata);
+			args[param.index] = value;
+			continue;
+		}
+		args[param.index] = void 0;
+	}
+	return args;
+}
+//#endregion
+//#region src/websocket/ws-execution-context.ts
+const HTTP_ON_WS = (accessor) => () => {
+	throw new Error(`${accessor} called on a WebSocket ExecutionContext. This handler runs over a gateway message, not HTTP — use switchToWs().`);
+};
+/**
+* WebSocket sibling of `buildExecutionContext` (`http/execution-context.ts`).
+* Guards/pipes/interceptors/filters that read `getClass()`/`getHandler()` or
+* call `switchToWs()` reuse unchanged; the HTTP-only accessors throw rather
+* than fabricate a fake `Request`.
+*/
+function buildWsExecutionContext(client, data, controller, handlerName, pattern) {
+	const host = {
+		getClient: () => client,
+		getData: () => data,
+		getPattern: () => pattern
+	};
+	return {
+		getType: () => "ws",
+		getClass: () => controller,
+		getHandler: () => handlerName,
+		getContext: HTTP_ON_WS("getContext()"),
+		getRequest: HTTP_ON_WS("getRequest()"),
+		switchToHttp: HTTP_ON_WS("switchToHttp()"),
+		switchToWs: () => host
+	};
+}
+//#endregion
+//#region src/websocket/ws-exception.ts
+/**
+* WebSocket analogue of `HttpException`. Thrown from guards/pipes/handlers to
+* signal a client-facing error; the dispatcher serializes it to an
+* `{ event: 'exception', data }` frame unless a matching exception filter
+* handles it first.
+*/
+var WsException = class extends Error {
+	err;
+	constructor(err) {
+		super(typeof err === "string" ? err : String(err.message ?? "WsException"));
+		this.err = err;
+		this.name = "WsException";
+	}
+	getError() {
+		return this.err;
+	}
+};
+/**
+* Default serialization of an uncaught error into the outbound exception frame.
+*
+* A `WsException` ships its own payload verbatim (string → `{ message }`,
+* object → as-is). Every other error routes through `toErrorBody` — the single
+* wire-redaction seam shared with the HTTP edge — so unbranded/internal errors
+* are redacted to their catalog title and only branded `VelaError`s echo a
+* client-safe `{ code, message, ... }`.
+*/
+function toErrorFrame(error, catalog) {
+	if (error instanceof WsException) {
+		const e = error.getError();
+		return {
+			event: "exception",
+			data: typeof e === "string" ? { message: e } : e
+		};
+	}
+	const { body } = toErrorBody(error, { catalog });
+	return {
+		event: "exception",
+		data: body.error
+	};
+}
+//#endregion
+//#region src/websocket/ws-dispatcher.ts
+function hasAfterInit(x) {
+	return typeof x?.afterInit === "function";
+}
+function hasHandleConnection(x) {
+	return typeof x?.handleConnection === "function";
+}
+function hasHandleDisconnect(x) {
+	return typeof x?.handleDisconnect === "function";
+}
+function isWsResponse(x) {
+	return typeof x === "object" && x !== null && typeof x.event === "string";
+}
+let WsDispatcher = class WsDispatcher {
+	container;
+	discovery;
+	server;
+	routeManager;
+	gateways = /* @__PURE__ */ new Map();
+	reserved = /* @__PURE__ */ new Map();
+	constructor(container, discovery, server, routeManager) {
+		this.container = container;
+		this.discovery = discovery;
+		this.server = server;
+		this.routeManager = routeManager;
+	}
+	/** Paths of every discovered `@WebSocketGateway` — used by transports to register routes. */
+	get gatewayPaths() {
+		return [...this.gateways.keys()];
+	}
+	async onApplicationBootstrap() {
+		for (const found of this.discovery.providersWithMeta(WS_RESERVED_METADATA)) {
+			if (!found.instance) continue;
+			const event = found.meta.event;
+			if (this.reserved.has(event)) {
+				const msg = `[vela] duplicate @ReservedWsEvent('${event}') (${found.metatype.name}); keeping the first.`;
+				if (this.container.getDiagnostics() === "throw") throw new Error(msg);
+				console.warn(msg);
+				continue;
+			}
+			this.reserved.set(event, found.instance);
+		}
+		for (const found of this.discovery.providersWithMeta(WS_GATEWAY_METADATA)) {
+			if (!found.instance) continue;
+			const gatewayClass = found.metatype;
+			const instance = found.instance;
+			const entry = this.buildGatewayEntry(gatewayClass, found.meta, instance);
+			if (this.gateways.has(entry.path)) {
+				const msg = `[vela] duplicate @WebSocketGateway path '${entry.path}' (${gatewayClass.name}); keeping the first. Give each gateway a distinct path.`;
+				if (this.container.getDiagnostics() === "throw") throw new Error(msg);
+				console.warn(msg);
+				continue;
+			}
+			this.gateways.set(entry.path, entry);
+			if (this.server && hasAfterInit(instance)) try {
+				await instance.afterInit(this.server);
+			} catch (err) {
+				this.reportBootstrapError(gatewayClass.name, err);
+			}
+		}
+	}
+	/** One `'websocket'` entrypoint per discovered gateway (authoritative). */
+	collectEntrypoints() {
+		return [...this.gateways.values()].map((entry) => ({
+			kind: "websocket",
+			token: entry.gatewayClass,
+			instance: entry.instance,
+			meta: {
+				path: entry.path,
+				dispatcher: this
+			}
+		}));
+	}
+	async handleOpen(path, client) {
+		const entry = this.gateways.get(path);
+		if (entry && hasHandleConnection(entry.instance)) await entry.instance.handleConnection(client);
+	}
+	async handleClose(path, client, _code, _reason) {
+		for (const handler of this.reserved.values()) try {
+			await handler.handleSocketClose?.(path, client);
+		} catch (err) {
+			await this.handleError(path, client, err);
+		}
+		const entry = this.gateways.get(path);
+		if (entry && hasHandleDisconnect(entry.instance)) await entry.instance.handleDisconnect(client);
+	}
+	async handleError(path, _client, err) {
+		resolveErrorReporter(this.container).report(err, {
+			edge: "ws",
+			source: path ? `reserved-frame ${path}` : "reserved-frame"
+		});
+	}
+	async dispatchMessage(path, client, raw) {
+		const entry = this.gateways.get(path);
+		if (!entry) return;
+		let message;
+		try {
+			message = this.parse(raw);
+		} catch {
+			this.trySend(client, "exception", { message: "Invalid message" });
+			return;
+		}
+		if (message.event.startsWith("$")) {
+			await this.dispatchReserved(path, client, message);
+			return;
+		}
+		const handler = entry.handlers.get(message.event);
+		if (!handler) return;
+		const ctx = buildWsExecutionContext(client, message.data, entry.gatewayClass, handler.methodName, message.event);
+		const globals = this.routeManager?.getGlobalComponents();
+		const guards = [...instantiateMany(globals?.guards ?? [], this.container), ...instantiateMany(handler.guards, this.container)];
+		const pipes = [...instantiateMany(globals?.pipes ?? [], this.container), ...instantiateMany(handler.pipes, this.container)];
+		const interceptors = [...instantiateMany(globals?.interceptors ?? [], this.container), ...instantiateMany(handler.interceptors, this.container)];
+		const filters = [...instantiateMany(handler.filters, this.container), ...instantiateMany(globals?.filters ?? [], this.container)];
+		try {
+			const method = entry.instance[handler.methodName];
+			const result = await PipelineRunner.run({
+				context: ctx,
+				guards,
+				interceptors,
+				resolveArgs: () => resolveWsArgs(handler.paramMeta, client, message.data, pipes, handler.paramTypes),
+				invoke: async (args) => method.apply(entry.instance, args),
+				onGuardReject: () => new WsException("Forbidden")
+			});
+			this.reply(client, message, result);
+		} catch (error) {
+			const reporter = resolveErrorReporter(this.container);
+			const source = `${entry.gatewayClass.name}.${handler.methodName}`;
+			reporter.report(error, {
+				edge: "ws",
+				source
+			});
+			await this.runFilters(client, message, error, filters, ctx, reporter, source);
+		}
+	}
+	/**
+	* Route a reserved (`$…`) frame to its claiming handler. App-wide (`APP_*` /
+	* `useGlobalGuards`) guards protect reserved frames exactly like gateway
+	* messages — guards-first, WS convention; handler/class-tier components are
+	* the claiming module's own concern (e.g. live resolvers run their scoped
+	* guards at subscribe).
+	*/
+	async dispatchReserved(path, client, message) {
+		const handler = this.reserved.get(message.event);
+		if (!handler) return;
+		const ctx = buildWsExecutionContext(client, message.data, handler.constructor, "handleReservedEvent", message.event);
+		const globals = this.routeManager?.getGlobalComponents();
+		const guards = instantiateMany(globals?.guards ?? [], this.container);
+		try {
+			for (const guard of guards) if (!await guard.canActivate(ctx)) {
+				const frame = toErrorFrame(new WsException("Forbidden"), resolveErrorReporter(this.container).catalog);
+				this.trySend(client, frame.event, frame.data, message.id);
+				return;
+			}
+			await handler.handleReservedEvent(path, client, message);
+		} catch (err) {
+			await this.handleError(path, client, err);
+		}
+	}
+	reply(client, message, result) {
+		if (result === void 0 || result === null) return;
+		if (isWsResponse(result)) this.trySend(client, result.event, result.data, message.id);
+		else this.trySend(client, message.event, result, message.id);
+	}
+	async runFilters(client, message, error, filters, ctx, reporter, source) {
+		for (const filter of filters) if (shouldFilterCatch(filter, error)) {
+			try {
+				const handled = await filter.catch(error, ctx);
+				if (isWsResponse(handled)) this.trySend(client, handled.event, handled.data, message.id);
+			} catch (filterError) {
+				reporter.report(filterError, {
+					edge: "ws",
+					source,
+					note: "exception filter threw"
+				});
+				const frame = toErrorFrame(error, reporter.catalog);
+				this.trySend(client, frame.event, frame.data, message.id);
+			}
+			return;
+		}
+		const errorFrame = toErrorFrame(error, reporter.catalog);
+		this.trySend(client, errorFrame.event, errorFrame.data, message.id);
+	}
+	trySend(client, event, data, id) {
+		try {
+			client.send(event, data, id);
+		} catch {}
+	}
+	reportBootstrapError(name, err) {
+		const mode = this.container.getDiagnostics();
+		if (mode === "throw") throw err;
+		if (mode === "log") console.warn(`[vela] websocket gateway ${name} afterInit failed:`, err);
+	}
+	parse(raw) {
+		const text = typeof raw === "string" ? raw : new TextDecoder().decode(raw);
+		const parsed = JSON.parse(text);
+		if (!parsed || typeof parsed !== "object" || typeof parsed.event !== "string") throw new Error("Invalid WebSocket message envelope");
+		return parsed;
+	}
+	buildGatewayEntry(gatewayClass, options, instance) {
+		const ctor = gatewayClass;
+		const subs = MetadataRegistry.getCustomClassMeta(ctor, "vela:ws-subscribe") ?? [];
+		const allParams = MetadataRegistry.getParameters(ctor);
+		const handlers = /* @__PURE__ */ new Map();
+		for (const { event, methodName } of subs) {
+			if (event.startsWith("$")) {
+				const msg = `[vela] @SubscribeMessage('${event}') on ${gatewayClass.name}: the '\$' event prefix is reserved for framework modules — skipped.`;
+				if (this.container.getDiagnostics() === "throw") throw new Error(msg);
+				console.warn(msg);
+				continue;
+			}
+			const paramMeta = [...allParams.get(methodName) ?? []].sort((a, b) => a.index - b.index);
+			const paramTypes = Reflect.getMetadata("design:paramtypes", gatewayClass.prototype, methodName);
+			handlers.set(event, {
+				methodName,
+				paramMeta,
+				paramTypes,
+				guards: ComponentManager.getScopedComponents("guard", ctor, methodName),
+				pipes: ComponentManager.getScopedComponents("pipe", ctor, methodName),
+				interceptors: ComponentManager.getScopedComponents("interceptor", ctor, methodName),
+				filters: [...ComponentManager.getScopedComponents("filter", ctor, methodName)].reverse()
+			});
+		}
+		return {
+			path: options.path ?? "",
+			instance,
+			gatewayClass,
+			handlers
+		};
+	}
+};
+WsDispatcher = __decorate([
+	Injectable(),
+	__decorateParam(0, Inject(Container)),
+	__decorateParam(1, Inject(DiscoveryService)),
+	__decorateParam(2, Optional()),
+	__decorateParam(2, Inject(WS_SERVER)),
+	__decorateParam(3, Optional()),
+	__decorateParam(3, Inject(RouteManager)),
+	__decorateMetadata("design:paramtypes", [
+		typeof Container === "undefined" ? Object : Container,
+		typeof DiscoveryService === "undefined" ? Object : DiscoveryService,
+		Object,
+		typeof RouteManager === "undefined" ? Object : RouteManager
+	])
+], WsDispatcher);
+//#endregion
+//#region src/websocket/ws-server.ts
+/**
+* Accumulates `{ rooms, exceptRooms, exceptIds }` across a fluent chain and, on
+* `.emit()`, produces a serializable `BroadcastCommand` handed to the active
+* `SyncDriver`. The driver decides local-vs-remote delivery.
+*/
+var BroadcastOperatorImpl = class {
+	driver;
+	rooms;
+	exceptRooms;
+	exceptIds;
+	constructor(driver, rooms = /* @__PURE__ */ new Set(), exceptRooms = /* @__PURE__ */ new Set(), exceptIds = /* @__PURE__ */ new Set()) {
+		this.driver = driver;
+		this.rooms = rooms;
+		this.exceptRooms = exceptRooms;
+		this.exceptIds = exceptIds;
+	}
+	to(room) {
+		this.rooms.add(room);
+		return this;
+	}
+	in(room) {
+		return this.to(room);
+	}
+	except(room) {
+		this.exceptRooms.add(room);
+		return this;
+	}
+	emit(event, data) {
+		const cmd = {
+			rooms: [...this.rooms],
+			exceptRooms: this.exceptRooms.size ? [...this.exceptRooms] : void 0,
+			exceptIds: this.exceptIds.size ? [...this.exceptIds] : void 0,
+			frame: JSON.stringify({
+				event,
+				data
+			})
+		};
+		return this.driver.dispatch(cmd);
+	}
+};
+/**
+* The `@WebSocketServer()`-injected handle. Server-origin broadcasts never
+* pre-exclude anyone (a client-origin `client.to()` seeds `exceptIds` with the
+* sender — that lives in the transport's client, not here).
+*/
+var WsServerImpl = class {
+	driver;
+	constructor(driver) {
+		this.driver = driver;
+	}
+	emit(event, data) {
+		return this.driver.dispatch({
+			rooms: [],
+			frame: JSON.stringify({
+				event,
+				data
+			})
+		});
+	}
+	to(room) {
+		return new BroadcastOperatorImpl(this.driver).to(room);
+	}
+	in(room) {
+		return this.to(room);
+	}
+	except(room) {
+		return new BroadcastOperatorImpl(this.driver).except(room);
+	}
+};
+//#endregion
+//#region src/websocket/ws-sync.ts
+/** Single-instance default: deliver straight to the local registry, no cross-node hop. */
+function local() {
+	let registry;
+	return {
+		kind: "local",
+		bind(r) {
+			registry = r;
+		},
+		dispatch(cmd) {
+			return registry?.deliverLocal(cmd);
+		}
+	};
+}
+/** In-memory `RoomRegistry` for node/bun/deno and tests. Edge-safe (plain Maps). */
+var InMemoryRoomRegistry = class {
+	rooms = /* @__PURE__ */ new Map();
+	clientRooms = /* @__PURE__ */ new Map();
+	clients = /* @__PURE__ */ new Map();
+	register(client) {
+		this.clients.set(client.id, client);
+	}
+	join(client, room) {
+		this.register(client);
+		let members = this.rooms.get(room);
+		if (!members) {
+			members = /* @__PURE__ */ new Set();
+			this.rooms.set(room, members);
+		}
+		members.add(client);
+		let joined = this.clientRooms.get(client.id);
+		if (!joined) {
+			joined = /* @__PURE__ */ new Set();
+			this.clientRooms.set(client.id, joined);
+		}
+		joined.add(room);
+	}
+	leave(client, room) {
+		const members = this.rooms.get(room);
+		members?.delete(client);
+		if (members && members.size === 0) this.rooms.delete(room);
+		this.clientRooms.get(client.id)?.delete(room);
+	}
+	leaveAll(client) {
+		for (const room of this.clientRooms.get(client.id) ?? []) {
+			const members = this.rooms.get(room);
+			members?.delete(client);
+			if (members && members.size === 0) this.rooms.delete(room);
+		}
+		this.clientRooms.delete(client.id);
+		this.clients.delete(client.id);
+	}
+	localIdsInRoom(room) {
+		return [...this.rooms.get(room) ?? []].map((c) => c.id);
+	}
+	deliverLocal(cmd) {
+		const excludeIds = new Set(cmd.exceptIds ?? []);
+		const excludeRooms = cmd.exceptRooms ?? [];
+		const candidates = cmd.rooms.length === 0 ? new Set(this.clients.values()) : (() => {
+			const set = /* @__PURE__ */ new Set();
+			for (const room of cmd.rooms) for (const client of this.rooms.get(room) ?? []) set.add(client);
+			return set;
+		})();
+		for (const client of candidates) {
+			if (excludeIds.has(client.id)) continue;
+			const joined = this.clientRooms.get(client.id);
+			if (excludeRooms.some((room) => joined?.has(room))) continue;
+			client.sendRaw(cmd.frame);
+		}
+	}
+};
+//#endregion
+//#region src/websocket/websocket.module.ts
+/**
+* Registers the WebSocket gateway machinery: the message dispatcher (discovers
+* `@WebSocketGateway` classes via DiscoveryService at bootstrap), the room
+* registry, the sync driver, and the `@WebSocketServer()`-injected server
+* handle.
+*
+* Construction lives in chained provider factories — registry → driver
+* (bound to THAT registry) → server — so the single shared registry instance
+* is preserved and everything materializes at bootstrap's eager
+* instantiation, before any lifecycle hook or message dispatch.
+*
+* The instance key derives from the sync driver kind: two `forRoot()` calls
+* with the same driver kind dedup (HMR-idempotent); pass an explicit `key`
+* to run multiple same-kind instances side by side.
+*/
+const { ConfigurableModuleClass } = defineModule({
+	name: "WebSocket",
+	optionsToken: WS_MODULE_OPTIONS,
+	key: (options) => `ws#${options.sync?.kind ?? "local"}`,
+	setup: ({ OPTIONS }) => ({
+		providers: [
+			{
+				provide: WS_ROOM_REGISTRY,
+				useFactory: (o) => o.registry ?? new InMemoryRoomRegistry(),
+				inject: [OPTIONS]
+			},
+			{
+				provide: WS_SYNC_DRIVER,
+				useFactory: (o, registry) => {
+					const driver = o.sync ?? local();
+					driver.bind(registry);
+					return driver;
+				},
+				inject: [OPTIONS, WS_ROOM_REGISTRY]
+			},
+			{
+				provide: WS_SERVER,
+				useFactory: (driver) => new WsServerImpl(driver),
+				inject: [WS_SYNC_DRIVER]
+			},
+			WsDispatcher
+		],
+		exports: [
+			WS_SERVER,
+			WS_SYNC_DRIVER,
+			WS_ROOM_REGISTRY,
+			WsDispatcher
+		]
+	})
+});
+var WebSocketModule = class extends ConfigurableModuleClass {};
+//#endregion
+export { WS_SUBSCRIBE_METADATA as C, createDiscoverableDecorator as E, WS_SERVER as S, WsParamType as T, RESERVED_WS_EVENT_PREFIX as _, WsServerImpl as a, WS_RESERVED_METADATA as b, toErrorFrame as c, ConnectedSocket as d, MessageBody as f, WebSocketServer as g, WebSocketGateway as h, BroadcastOperatorImpl as i, buildWsExecutionContext as l, SubscribeMessage as m, InMemoryRoomRegistry as n, WsDispatcher as o, ReservedWsEvent as p, local as r, WsException as s, WebSocketModule as t, resolveWsArgs as u, WS_GATEWAY_METADATA as v, WS_SYNC_DRIVER as w, WS_ROOM_REGISTRY as x, WS_MODULE_OPTIONS as y };
+
+//# sourceMappingURL=websocket-DXmB-MWJ.js.map