sonamu 0.11.16 → 0.13.0

package/dist/stream/ws-registry.d.ts

@@ -1,46 +1,74 @@
+import { type z } from "zod";
 import { type WebSocketAudience as WebSocketAudienceSpec } from "./ws-audience";
-import { WebSocketAudienceResolver } from "./ws-audience-resolver";
 import { type WebSocketClusterBus } from "./ws-cluster-bus";
-import { type ManagedWebSocketConnection, type WebSocketRegistryStats, type WebSocketRoomId, type WebSocketUserId } from "./ws-core";
-import { WebSocketDeliveryEngine } from "./ws-delivery";
+import { type ManagedWebSocketConnection, type WebSocketFrameConnection, type WebSocketRegistryStats, type WebSocketRoomId, type WebSocketUserId } from "./ws-core";
+import { type WebSocketRouteDefinition } from "./ws-delivery";
 import { WebSocketLocalConnectionStore } from "./ws-local-connection-store";
 import { type WebSocketPresenceStore, type WebSocketSessionPresence } from "./ws-presence-store";
 import { type WebSocketTelemetryController } from "./ws-telemetry";
 export type { ManagedWebSocketConnection, WebSocketRegistryStats, WebSocketRoomId, WebSocketUserId, };
 export type WebSocketConnectionMeta = WebSocketSessionPresence;
+export type WebSocketRoomMemberCount = {
+    count: number;
+    partial: boolean;
+};
 export type WebSocketRegistryOptions = {
     nodeId: string;
     presenceStore?: WebSocketPresenceStore;
     clusterBus?: WebSocketClusterBus;
     telemetryController?: WebSocketTelemetryController;
+    drainTimeoutMs?: number;
 };
+/**
+ * 노드 로컬 presence를 메모리에 소유하고, 설정된 store에는 세션별 순서대로 replica를 반영한다.
+ * mutation과 publish는 호출 시점에 메모리를 동기로 갱신하고, store 실패는 telemetry로만 기록하며 reject하지 않는다.
+ */
 export declare class WebSocketRegistry {
     readonly nodeId: string;
     readonly localConnections: WebSocketLocalConnectionStore;
     readonly presenceStore: WebSocketPresenceStore;
     readonly clusterBus: WebSocketClusterBus;
-    readonly audienceResolver: WebSocketAudienceResolver;
-    readonly deliveryEngine: WebSocketDeliveryEngine;
     readonly telemetryController: WebSocketTelemetryController;
+    private readonly memory;
+    private readonly deliveryEngine;
+    private readonly drainTimeoutMs;
+    private readonly mutationQueues;
     constructor(options: WebSocketRegistryOptions);
-    register(connection: ManagedWebSocketConnection, active?: boolean): WebSocketConnectionMeta;
-    activate(connectionId: string): void;
-    unregister(connectionId: string): void;
+    registerRoute(routeKey: string, outEvents: z.ZodObject): void;
+    replaceRoutes(routes: WebSocketRouteDefinition[]): void;
+    /**
+     * 연결을 메모리에 즉시 등록하고 store.register가 끝나면 resolve한다.
+     * store가 실패해도 메모리 전용 등록으로 resolve한다.
+     */
+    register(connection: WebSocketFrameConnection, active?: boolean): Promise<WebSocketConnectionMeta>;
+    activate(connectionId: string): Promise<void>;
+    unregister(connectionId: string): Promise<void>;
     touch(connectionId: string): void;
-    setUserId(connectionId: string, userId: WebSocketUserId): void;
-    clearUserId(connectionId: string): void;
-    join(connectionId: string, roomId: WebSocketRoomId): void;
-    leave(connectionId: string, roomId: WebSocketRoomId): void;
-    private emitMutationSkipped;
-    broadcast<Data>(event: string, data: Data, namespace?: string): void;
-    publishToRoom<Data>(roomId: WebSocketRoomId, event: string, data: Data, namespace?: string): void;
-    publishToUser<Data>(userId: WebSocketUserId, event: string, data: Data, namespace?: string): void;
-    publishToAudience<Data>(audience: WebSocketAudienceSpec, event: string, data: Data): void;
+    setUserId(connectionId: string, userId: WebSocketUserId): Promise<void>;
+    clearUserId(connectionId: string): Promise<void>;
+    join(connectionId: string, roomId: WebSocketRoomId): Promise<void>;
+    leave(connectionId: string, roomId: WebSocketRoomId): Promise<void>;
+    broadcast<Data>(event: string, data: Data, namespace?: string): Promise<void>;
+    publishToRoom<Data>(roomId: WebSocketRoomId, event: string, data: Data, namespace?: string): Promise<void>;
+    publishToUser<Data>(userId: WebSocketUserId, event: string, data: Data, namespace?: string): Promise<void>;
+    publishToAudience<Data>(audience: WebSocketAudienceSpec, event: string, data: Data): Promise<void>;
     getConnection(connectionId: string): WebSocketConnectionMeta | undefined;
     getConnectionCount(namespace?: string): number;
     getRoomMembers(roomId: WebSocketRoomId, namespace?: string): WebSocketConnectionMeta[];
     getStats(): WebSocketRegistryStats;
+    /**
+     * 클러스터 전체의 활성 방 인원수. store가 실패하면 노드 로컬 수에 partial: true를 붙여 반환하며 reject하지 않는다.
+     */
+    getRoomMemberCount(roomId: WebSocketRoomId, namespace?: string): Promise<WebSocketRoomMemberCount>;
     closeAll(code?: number, reason?: string): void;
+    /**
+     * 로컬 연결을 닫고, 진행 중인 store mutation과 publish를 drainTimeoutMs까지 기다린 뒤 store와 bus를 종료한다.
+     */
     shutdown(code?: number, reason?: string): Promise<void>;
+    /**
+     * 세션별 큐 뒤에 store 호출을 이어 붙인다. 실패는 telemetry로만 기록하고, 반환한 promise는 reject하지 않는다.
+     */
+    private enqueueStoreMutation;
+    private emitMutationSkipped;
 }
 //# sourceMappingURL=ws-registry.d.ts.map

package/dist/stream/ws-registry.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ws-registry.d.ts","sourceRoot":"","sources":["../../src/stream/ws-registry.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"ws-registry.d.ts","sourceRoot":"","sources":["../../src/stream/ws-registry.ts"],"names":[],"mappings":"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"}

package/dist/stream/ws-registry.js

@@ -1,13 +1,24 @@
 import { __esmMin } from "../_virtual/_rolldown/runtime.js";
 import { init_runtime_value, isFunctionValue } from "../utils/runtime-value.js";
+import { init_runtime_type, runtimeTypeOf } from "../runtime-type.js";
 import { WebSocketAudience, init_ws_audience } from "./ws-audience.js";
 import { WebSocketAudienceResolver, init_ws_audience_resolver } from "./ws-audience-resolver.js";
 import { NoopWebSocketClusterBus, init_ws_cluster_bus } from "./ws-cluster-bus.js";
 import { NoopWebSocketTelemetryController, init_ws_telemetry } from "./ws-telemetry.js";
 import { WebSocketDeliveryEngine, init_ws_delivery } from "./ws-delivery.js";
 import { WebSocketLocalConnectionStore, init_ws_local_connection_store } from "./ws-local-connection-store.js";
+import { WebSocketPresenceIndex, init_ws_presence_index } from "./ws-presence-index.js";
 import { InMemoryWebSocketPresenceStore, init_ws_presence_store } from "./ws-presence-store.js";
-//#region src/stream/ws-registry.ts
+// src/stream/ws-registry.ts
+function callStore(call) {
+	return Promise.resolve().then(call);
+}
+function assertMatchingNodeId(source, sourceNodeId, nodeId) {
+	if (sourceNodeId !== void 0 && sourceNodeId !== nodeId) throw new Error(`WebSocket ${source}.nodeId (${sourceNodeId}) must match the runtime nodeId (${nodeId}).`);
+}
+function describeError(cause) {
+	return cause instanceof Error ? cause.name : runtimeTypeOf(cause);
+}
 function getConnectionTelemetryContext(connection) {
 	if (!connection || !isTelemetryContextProvider(connection)) return {};
 	return connection.getTelemetryContext();
@@ -18,42 +29,50 @@ function formatUserId(userId) {
 function isTelemetryContextProvider(connection) {
 	return "getTelemetryContext" in connection && isFunctionValue(connection.getTelemetryContext);
 }
-var WebSocketRegistry;
+var DEFAULT_DRAIN_TIMEOUT_MS, WebSocketRegistry;
 var init_ws_registry = __esmMin((() => {
+	init_runtime_type();
 	init_runtime_value();
 	init_ws_audience();
 	init_ws_audience_resolver();
 	init_ws_cluster_bus();
 	init_ws_delivery();
 	init_ws_local_connection_store();
+	init_ws_presence_index();
 	init_ws_presence_store();
 	init_ws_telemetry();
+	DEFAULT_DRAIN_TIMEOUT_MS = 5e3;
 	WebSocketRegistry = class {
 		nodeId;
 		localConnections = new WebSocketLocalConnectionStore();
 		presenceStore;
 		clusterBus;
-		audienceResolver;
-		deliveryEngine;
 		telemetryController;
+		memory = new WebSocketPresenceIndex();
+		deliveryEngine;
+		drainTimeoutMs;
+		mutationQueues = /* @__PURE__ */ new Map();
 		constructor(options) {
 			this.nodeId = options.nodeId;
 			this.presenceStore = options.presenceStore ?? new InMemoryWebSocketPresenceStore();
 			this.clusterBus = options.clusterBus ?? new NoopWebSocketClusterBus();
+			this.drainTimeoutMs = options.drainTimeoutMs ?? DEFAULT_DRAIN_TIMEOUT_MS;
+			assertMatchingNodeId("presenceStore", this.presenceStore.nodeId, this.nodeId);
+			assertMatchingNodeId("clusterBus", this.clusterBus.nodeId, this.nodeId);
 			this.telemetryController = options.telemetryController ?? new NoopWebSocketTelemetryController();
-			this.audienceResolver = new WebSocketAudienceResolver({
-				nodeId: this.nodeId,
-				presenceStore: this.presenceStore
-			});
 			this.deliveryEngine = new WebSocketDeliveryEngine({
 				nodeId: this.nodeId,
 				localConnections: this.localConnections,
-				audienceResolver: this.audienceResolver,
+				resolveLocalSessionIds: (audience) => this.memory.queryAudience(audience).map((session) => session.sessionId),
+				audienceResolver: new WebSocketAudienceResolver({
+					nodeId: this.nodeId,
+					presenceStore: this.presenceStore
+				}),
 				clusterBus: this.clusterBus,
 				telemetryController: this.telemetryController
 			});
 			this.telemetryController.registerMetricSource({ collect: (_now) => {
-				const stats = this.presenceStore.getStats();
+				const stats = this.memory.getStats();
 				const localSnapshot = this.localConnections.getTelemetrySnapshot();
 				return {
 					activeConnections: stats.totalConnections,
@@ -65,14 +84,26 @@ var init_ws_registry = __esmMin((() => {
 				};
 			} });
 		}
-		register(connection, active = true) {
-			this.localConnections.register(connection);
-			const meta = this.presenceStore.register({
+		registerRoute(routeKey, outEvents) {
+			this.deliveryEngine.registerRoute(routeKey, outEvents);
+		}
+		replaceRoutes(routes) {
+			this.deliveryEngine.replaceRoutes(routes);
+		}
+		/**
+		* 연결을 메모리에 즉시 등록하고 store.register가 끝나면 resolve한다.
+		* store가 실패해도 메모리 전용 등록으로 resolve한다.
+		*/
+		async register(connection, active = true) {
+			const registration = {
 				sessionId: connection.id,
 				nodeId: this.nodeId,
 				namespace: connection.namespace,
-				active
-			});
+				active,
+				connectedAt: /* @__PURE__ */ new Date()
+			};
+			this.localConnections.register(connection);
+			this.memory.register(registration);
 			this.telemetryController.emit({
 				name: "ws.connection.registered",
 				level: "info",
@@ -92,14 +123,19 @@ var init_ws_registry = __esmMin((() => {
 				},
 				userId: connection.userId
 			});
-			return meta;
+			await this.enqueueStoreMutation(connection.id, "register", () => this.presenceStore.register(registration));
+			return this.memory.getConnection(connection.id) ?? {
+				...registration,
+				rooms: /* @__PURE__ */ new Set(),
+				lastSeenAt: registration.connectedAt
+			};
 		}
 		activate(connectionId) {
-			if (!this.presenceStore.getConnection(connectionId)) {
+			if (!this.memory.has(connectionId)) {
 				this.emitMutationSkipped(connectionId, { operation: "activate" });
-				return;
+				return Promise.resolve();
 			}
-			this.presenceStore.activate(connectionId);
+			this.memory.activate(connectionId);
 			const connection = this.localConnections.getConnection(connectionId);
 			this.telemetryController.emit({
 				name: "ws.connection.activated",
@@ -108,12 +144,13 @@ var init_ws_registry = __esmMin((() => {
 				userId: connection?.userId,
 				...getConnectionTelemetryContext(connection)
 			});
+			return this.enqueueStoreMutation(connectionId, "activate", () => this.presenceStore.activate(connectionId));
 		}
 		unregister(connectionId) {
 			const connection = this.localConnections.getConnection(connectionId);
 			const telemetryContext = getConnectionTelemetryContext(connection);
-			const userId = connection?.userId ?? formatUserId(this.presenceStore.getConnection(connectionId)?.userId);
-			const meta = this.presenceStore.unregister(connectionId);
+			const meta = this.memory.unregister(connectionId);
+			const userId = connection?.userId ?? formatUserId(meta?.userId);
 			this.localConnections.unregister(connectionId);
 			this.telemetryController.emit({
 				name: "ws.connection.unregistered",
@@ -123,7 +160,8 @@ var init_ws_registry = __esmMin((() => {
 				userId,
 				...telemetryContext
 			});
-			if (meta) this.telemetryController.recordMetric({
+			if (!meta) return Promise.resolve();
+			this.telemetryController.recordMetric({
 				name: "sonamu.ws.connections",
 				kind: "counter",
 				value: 1,
@@ -134,38 +172,40 @@ var init_ws_registry = __esmMin((() => {
 				},
 				userId
 			});
+			return this.enqueueStoreMutation(connectionId, "unregister", () => this.presenceStore.unregister(connectionId));
 		}
 		touch(connectionId) {
-			this.presenceStore.touch(connectionId);
+			this.memory.touch(connectionId);
 		}
 		setUserId(connectionId, userId) {
-			if (!this.presenceStore.getConnection(connectionId)) {
+			const meta = this.memory.getConnection(connectionId);
+			if (!meta) {
 				this.emitMutationSkipped(connectionId, {
 					operation: "setUserId",
 					userId
 				});
-				return;
+				return Promise.resolve();
 			}
-			this.presenceStore.setUserId(connectionId, userId);
-			const meta = this.presenceStore.getConnection(connectionId);
+			this.memory.setUserId(connectionId, userId);
 			this.telemetryController.emit({
 				name: "ws.user.bound",
 				level: "debug",
 				connectionId,
-				namespace: meta?.namespace,
+				namespace: meta.namespace,
 				userId: String(userId),
 				detail: { userId },
 				...getConnectionTelemetryContext(this.localConnections.getConnection(connectionId))
 			});
+			return this.enqueueStoreMutation(connectionId, "setUserId", () => this.presenceStore.setUserId(connectionId, userId));
 		}
 		clearUserId(connectionId) {
-			const meta = this.presenceStore.getConnection(connectionId);
+			const meta = this.memory.getConnection(connectionId);
 			if (!meta) {
 				this.emitMutationSkipped(connectionId, { operation: "clearUserId" });
-				return;
+				return Promise.resolve();
 			}
 			const userId = meta.userId;
-			this.presenceStore.clearUserId(connectionId);
+			this.memory.clearUserId(connectionId);
 			this.telemetryController.emit({
 				name: "ws.user.cleared",
 				level: "debug",
@@ -175,38 +215,40 @@ var init_ws_registry = __esmMin((() => {
 				detail: userId !== void 0 ? { userId } : void 0,
 				...getConnectionTelemetryContext(this.localConnections.getConnection(connectionId))
 			});
+			return this.enqueueStoreMutation(connectionId, "clearUserId", () => this.presenceStore.clearUserId(connectionId));
 		}
 		join(connectionId, roomId) {
-			if (!this.presenceStore.getConnection(connectionId)) {
+			const meta = this.memory.getConnection(connectionId);
+			if (!meta) {
 				this.emitMutationSkipped(connectionId, {
 					operation: "join",
 					roomId
 				});
-				return;
+				return Promise.resolve();
 			}
-			this.presenceStore.join(connectionId, roomId);
-			const meta = this.presenceStore.getConnection(connectionId);
+			this.memory.join(connectionId, roomId);
 			const connection = this.localConnections.getConnection(connectionId);
 			this.telemetryController.emit({
 				name: "ws.room.joined",
 				level: "debug",
 				connectionId,
-				namespace: meta?.namespace,
-				userId: connection?.userId ?? formatUserId(meta?.userId),
+				namespace: meta.namespace,
+				userId: connection?.userId ?? formatUserId(meta.userId),
 				detail: { roomId },
 				...getConnectionTelemetryContext(connection)
 			});
+			return this.enqueueStoreMutation(connectionId, "join", () => this.presenceStore.join(connectionId, roomId));
 		}
 		leave(connectionId, roomId) {
-			const meta = this.presenceStore.getConnection(connectionId);
+			const meta = this.memory.getConnection(connectionId);
 			if (!meta) {
 				this.emitMutationSkipped(connectionId, {
 					operation: "leave",
 					roomId
 				});
-				return;
+				return Promise.resolve();
 			}
-			this.presenceStore.leave(connectionId, roomId);
+			this.memory.leave(connectionId, roomId);
 			const connection = this.localConnections.getConnection(connectionId);
 			this.telemetryController.emit({
 				name: "ws.room.left",
@@ -217,53 +259,119 @@ var init_ws_registry = __esmMin((() => {
 				detail: { roomId },
 				...getConnectionTelemetryContext(connection)
 			});
-		}
-		emitMutationSkipped(connectionId, detail) {
-			this.telemetryController.emit({
-				name: "ws.registry.mutation.skipped",
-				level: "debug",
-				connectionId,
-				detail: {
-					...detail,
-					reason: "connectionMissing"
-				}
-			});
+			return this.enqueueStoreMutation(connectionId, "leave", () => this.presenceStore.leave(connectionId, roomId));
 		}
 		broadcast(event, data, namespace) {
-			this.publishToAudience(WebSocketAudience.all(namespace), event, data);
+			return this.publishToAudience(WebSocketAudience.all(namespace), event, data);
 		}
 		publishToRoom(roomId, event, data, namespace) {
-			this.publishToAudience(WebSocketAudience.room(roomId, namespace), event, data);
+			return this.publishToAudience(WebSocketAudience.room(roomId, namespace), event, data);
 		}
 		publishToUser(userId, event, data, namespace) {
-			this.publishToAudience(WebSocketAudience.user(userId, namespace), event, data);
+			return this.publishToAudience(WebSocketAudience.user(userId, namespace), event, data);
 		}
 		publishToAudience(audience, event, data) {
-			this.deliveryEngine.publishToAudience(audience, event, data);
+			return this.deliveryEngine.publishToAudience(audience, event, data);
 		}
 		getConnection(connectionId) {
-			return this.presenceStore.getConnection(connectionId);
+			return this.memory.getConnection(connectionId);
 		}
 		getConnectionCount(namespace) {
-			return this.presenceStore.getConnectionCount(namespace);
+			return this.memory.getConnectionCount(namespace);
 		}
 		getRoomMembers(roomId, namespace) {
-			return this.presenceStore.getRoomMembers(roomId, namespace);
+			return this.memory.getRoomMembers(roomId, namespace);
 		}
 		getStats() {
-			return this.presenceStore.getStats();
+			return this.memory.getStats();
+		}
+		/**
+		* 클러스터 전체의 활성 방 인원수. store가 실패하면 노드 로컬 수에 partial: true를 붙여 반환하며 reject하지 않는다.
+		*/
+		async getRoomMemberCount(roomId, namespace) {
+			try {
+				return {
+					count: await callStore(() => this.presenceStore.getRoomMemberCount(roomId, namespace)),
+					partial: false
+				};
+			} catch (cause) {
+				this.telemetryController.emit({
+					name: "ws.registry.read.failed",
+					level: "warn",
+					detail: {
+						operation: "getRoomMemberCount",
+						roomId,
+						errorType: describeError(cause)
+					}
+				});
+				return {
+					count: this.memory.getRoomMemberCount(roomId, namespace),
+					partial: true
+				};
+			}
 		}
 		closeAll(code, reason) {
 			this.localConnections.closeAll(code, reason);
 		}
+		/**
+		* 로컬 연결을 닫고, 진행 중인 store mutation과 publish를 drainTimeoutMs까지 기다린 뒤 store와 bus를 종료한다.
+		*/
 		async shutdown(code, reason) {
 			this.closeAll(code, reason);
-			await this.deliveryEngine.shutdown();
+			let timer;
+			const deadline = new Promise((resolve) => {
+				timer = setTimeout(resolve, this.drainTimeoutMs);
+			});
+			try {
+				await Promise.race([Promise.all([...this.mutationQueues.values(), this.deliveryEngine.drainPublishes()]), deadline]);
+			} finally {
+				clearTimeout(timer);
+			}
+			try {
+				await callStore(() => this.presenceStore.shutdown?.());
+			} catch (cause) {
+				this.telemetryController.emit({
+					name: "ws.registry.shutdown.failed",
+					level: "error",
+					detail: { errorType: describeError(cause) }
+				});
+			}
+			await this.deliveryEngine.shutdown(Promise.resolve());
+		}
+		/**
+		* 세션별 큐 뒤에 store 호출을 이어 붙인다. 실패는 telemetry로만 기록하고, 반환한 promise는 reject하지 않는다.
+		*/
+		enqueueStoreMutation(sessionId, operation, call) {
+			const next = (this.mutationQueues.get(sessionId) ?? Promise.resolve()).then(call).then(() => void 0, (cause) => {
+				this.telemetryController.emit({
+					name: "ws.registry.mutation.failed",
+					level: "warn",
+					connectionId: sessionId,
+					detail: {
+						operation,
+						errorType: describeError(cause)
+					}
+				});
+			}).then(() => {
+				if (this.mutationQueues.get(sessionId) === next) this.mutationQueues.delete(sessionId);
+			});
+			this.mutationQueues.set(sessionId, next);
+			return next;
+		}
+		emitMutationSkipped(connectionId, detail) {
+			this.telemetryController.emit({
+				name: "ws.registry.mutation.skipped",
+				level: "debug",
+				connectionId,
+				detail: {
+					...detail,
+					reason: "connectionMissing"
+				}
+			});
 		}
 	};
 }));
-//#endregion
 init_ws_registry();
 export { WebSocketRegistry, init_ws_registry };
 
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"ws-registry.js","names":[],"sources":["../../src/stream/ws-registry.ts"],"sourcesContent":["import { isFunctionValue } from \"../utils/runtime-value\";\nimport { WebSocketAudience, type WebSocketAudience as WebSocketAudienceSpec } from \"./ws-audience\";\nimport { WebSocketAudienceResolver } from \"./ws-audience-resolver\";\nimport { NoopWebSocketClusterBus, type WebSocketClusterBus } from \"./ws-cluster-bus\";\nimport {\n  type ManagedWebSocketConnection,\n  type WebSocketRegistryStats,\n  type WebSocketRoomId,\n  type WebSocketUserId,\n} from \"./ws-core\";\nimport { WebSocketDeliveryEngine } from \"./ws-delivery\";\nimport { WebSocketLocalConnectionStore } from \"./ws-local-connection-store\";\nimport {\n  InMemoryWebSocketPresenceStore,\n  type WebSocketPresenceStore,\n  type WebSocketSessionPresence,\n} from \"./ws-presence-store\";\nimport {\n  type TelemetryContextProvider,\n  NoopWebSocketTelemetryController,\n  type WebSocketTelemetryConnectionContext,\n  type WebSocketTelemetryController,\n} from \"./ws-telemetry\";\n\nexport type {\n  ManagedWebSocketConnection,\n  WebSocketRegistryStats,\n  WebSocketRoomId,\n  WebSocketUserId,\n};\nexport type WebSocketConnectionMeta = WebSocketSessionPresence;\n\nexport type WebSocketRegistryOptions = {\n  // 분산 환경에서 노드 간 라우팅 식별자로 쓰이므로 반드시 호출 측(WebSocketRuntime)에서 결정해 넘긴다\n  nodeId: string;\n  presenceStore?: WebSocketPresenceStore;\n  clusterBus?: WebSocketClusterBus;\n  telemetryController?: WebSocketTelemetryController;\n};\n\nexport class WebSocketRegistry {\n  readonly nodeId: string;\n  readonly localConnections = new WebSocketLocalConnectionStore();\n  readonly presenceStore: WebSocketPresenceStore;\n  readonly clusterBus: WebSocketClusterBus;\n  readonly audienceResolver: WebSocketAudienceResolver;\n  readonly deliveryEngine: WebSocketDeliveryEngine;\n  readonly telemetryController: WebSocketTelemetryController;\n\n  constructor(options: WebSocketRegistryOptions) {\n    this.nodeId = options.nodeId;\n    this.presenceStore = options.presenceStore ?? new InMemoryWebSocketPresenceStore();\n    this.clusterBus = options.clusterBus ?? new NoopWebSocketClusterBus();\n    this.telemetryController =\n      options.telemetryController ?? new NoopWebSocketTelemetryController();\n    this.audienceResolver = new WebSocketAudienceResolver({\n      nodeId: this.nodeId,\n      presenceStore: this.presenceStore,\n    });\n    this.deliveryEngine = new WebSocketDeliveryEngine({\n      nodeId: this.nodeId,\n      localConnections: this.localConnections,\n      audienceResolver: this.audienceResolver,\n      clusterBus: this.clusterBus,\n      telemetryController: this.telemetryController,\n    });\n\n    this.telemetryController.registerMetricSource({\n      collect: (_now) => {\n        const stats = this.presenceStore.getStats();\n        const localSnapshot = this.localConnections.getTelemetrySnapshot();\n        return {\n          activeConnections: stats.totalConnections,\n          activeConnectionsByNamespace: stats.byNamespace,\n          roomCount: stats.totalRooms,\n          pendingInboundMessages: localSnapshot.pendingInboundMessages,\n          pendingOutboundMessages: localSnapshot.pendingOutboundMessages,\n          socketBufferedBytes: localSnapshot.socketBufferedBytes,\n        };\n      },\n    });\n  }\n\n  register(\n    connection: ManagedWebSocketConnection,\n    active: boolean = true,\n  ): WebSocketConnectionMeta {\n    this.localConnections.register(connection);\n    const meta = this.presenceStore.register({\n      sessionId: connection.id,\n      nodeId: this.nodeId,\n      namespace: connection.namespace,\n      active,\n    });\n    this.telemetryController.emit({\n      name: \"ws.connection.registered\",\n      level: \"info\",\n      connectionId: connection.id,\n      namespace: connection.namespace,\n      userId: connection.userId,\n      ...getConnectionTelemetryContext(connection),\n    });\n    this.telemetryController.recordMetric({\n      name: \"sonamu.ws.connections\",\n      kind: \"counter\",\n      value: 1,\n      unit: \"1\",\n      tags: { outcome: \"registered\", namespace: connection.namespace },\n      userId: connection.userId,\n    });\n    return meta;\n  }\n\n  activate(connectionId: string): void {\n    if (!this.presenceStore.getConnection(connectionId)) {\n      this.emitMutationSkipped(connectionId, { operation: \"activate\" });\n      return;\n    }\n\n    this.presenceStore.activate(connectionId);\n    const connection = this.localConnections.getConnection(connectionId);\n    this.telemetryController.emit({\n      name: \"ws.connection.activated\",\n      level: \"info\",\n      connectionId,\n      userId: connection?.userId,\n      ...getConnectionTelemetryContext(connection),\n    });\n  }\n\n  unregister(connectionId: string): void {\n    const connection = this.localConnections.getConnection(connectionId);\n    const telemetryContext = getConnectionTelemetryContext(connection);\n    const userId =\n      connection?.userId ?? formatUserId(this.presenceStore.getConnection(connectionId)?.userId);\n    const meta = this.presenceStore.unregister(connectionId);\n    this.localConnections.unregister(connectionId);\n    this.telemetryController.emit({\n      name: \"ws.connection.unregistered\",\n      level: \"debug\",\n      connectionId,\n      namespace: meta?.namespace,\n      userId,\n      ...telemetryContext,\n    });\n    if (meta) {\n      this.telemetryController.recordMetric({\n        name: \"sonamu.ws.connections\",\n        kind: \"counter\",\n        value: 1,\n        unit: \"1\",\n        tags: { outcome: \"unregistered\", namespace: meta.namespace },\n        userId,\n      });\n    }\n  }\n\n  touch(connectionId: string): void {\n    this.presenceStore.touch(connectionId);\n  }\n\n  setUserId(connectionId: string, userId: WebSocketUserId): void {\n    if (!this.presenceStore.getConnection(connectionId)) {\n      this.emitMutationSkipped(connectionId, { operation: \"setUserId\", userId });\n      return;\n    }\n\n    this.presenceStore.setUserId(connectionId, userId);\n    const meta = this.presenceStore.getConnection(connectionId);\n    this.telemetryController.emit({\n      name: \"ws.user.bound\",\n      level: \"debug\",\n      connectionId,\n      namespace: meta?.namespace,\n      userId: String(userId),\n      detail: { userId },\n      ...getConnectionTelemetryContext(this.localConnections.getConnection(connectionId)),\n    });\n  }\n\n  clearUserId(connectionId: string): void {\n    const meta = this.presenceStore.getConnection(connectionId);\n    if (!meta) {\n      this.emitMutationSkipped(connectionId, { operation: \"clearUserId\" });\n      return;\n    }\n\n    const userId = meta.userId;\n    this.presenceStore.clearUserId(connectionId);\n    this.telemetryController.emit({\n      name: \"ws.user.cleared\",\n      level: \"debug\",\n      connectionId,\n      namespace: meta.namespace,\n      userId: formatUserId(userId),\n      detail: userId !== undefined ? { userId } : undefined,\n      ...getConnectionTelemetryContext(this.localConnections.getConnection(connectionId)),\n    });\n  }\n\n  join(connectionId: string, roomId: WebSocketRoomId): void {\n    if (!this.presenceStore.getConnection(connectionId)) {\n      this.emitMutationSkipped(connectionId, { operation: \"join\", roomId });\n      return;\n    }\n\n    this.presenceStore.join(connectionId, roomId);\n    const meta = this.presenceStore.getConnection(connectionId);\n    const connection = this.localConnections.getConnection(connectionId);\n    this.telemetryController.emit({\n      name: \"ws.room.joined\",\n      level: \"debug\",\n      connectionId,\n      namespace: meta?.namespace,\n      userId: connection?.userId ?? formatUserId(meta?.userId),\n      detail: { roomId },\n      ...getConnectionTelemetryContext(connection),\n    });\n  }\n\n  leave(connectionId: string, roomId: WebSocketRoomId): void {\n    const meta = this.presenceStore.getConnection(connectionId);\n    if (!meta) {\n      this.emitMutationSkipped(connectionId, { operation: \"leave\", roomId });\n      return;\n    }\n\n    this.presenceStore.leave(connectionId, roomId);\n    const connection = this.localConnections.getConnection(connectionId);\n    this.telemetryController.emit({\n      name: \"ws.room.left\",\n      level: \"debug\",\n      connectionId,\n      namespace: meta.namespace,\n      userId: connection?.userId ?? formatUserId(meta.userId),\n      detail: { roomId },\n      ...getConnectionTelemetryContext(connection),\n    });\n  }\n\n  private emitMutationSkipped(\n    connectionId: string,\n    detail: {\n      operation: \"activate\" | \"setUserId\" | \"clearUserId\" | \"join\" | \"leave\";\n      roomId?: WebSocketRoomId;\n      userId?: WebSocketUserId;\n    },\n  ): void {\n    this.telemetryController.emit({\n      name: \"ws.registry.mutation.skipped\",\n      level: \"debug\",\n      connectionId,\n      detail: { ...detail, reason: \"connectionMissing\" },\n    });\n  }\n\n  broadcast<Data>(event: string, data: Data, namespace?: string): void {\n    this.publishToAudience(WebSocketAudience.all(namespace), event, data);\n  }\n\n  publishToRoom<Data>(\n    roomId: WebSocketRoomId,\n    event: string,\n    data: Data,\n    namespace?: string,\n  ): void {\n    this.publishToAudience(WebSocketAudience.room(roomId, namespace), event, data);\n  }\n\n  publishToUser<Data>(\n    userId: WebSocketUserId,\n    event: string,\n    data: Data,\n    namespace?: string,\n  ): void {\n    this.publishToAudience(WebSocketAudience.user(userId, namespace), event, data);\n  }\n\n  publishToAudience<Data>(audience: WebSocketAudienceSpec, event: string, data: Data): void {\n    this.deliveryEngine.publishToAudience(audience, event, data);\n  }\n\n  getConnection(connectionId: string): WebSocketConnectionMeta | undefined {\n    return this.presenceStore.getConnection(connectionId);\n  }\n\n  getConnectionCount(namespace?: string): number {\n    return this.presenceStore.getConnectionCount(namespace);\n  }\n\n  getRoomMembers(roomId: WebSocketRoomId, namespace?: string): WebSocketConnectionMeta[] {\n    return this.presenceStore.getRoomMembers(roomId, namespace);\n  }\n\n  getStats(): WebSocketRegistryStats {\n    return this.presenceStore.getStats();\n  }\n\n  closeAll(code?: number, reason?: string): void {\n    this.localConnections.closeAll(code, reason);\n  }\n\n  async shutdown(code?: number, reason?: string): Promise<void> {\n    this.closeAll(code, reason);\n    await this.deliveryEngine.shutdown();\n  }\n}\n\nfunction getConnectionTelemetryContext(\n  connection: ManagedWebSocketConnection | undefined,\n): WebSocketTelemetryConnectionContext {\n  if (!connection || !isTelemetryContextProvider(connection)) {\n    return {};\n  }\n\n  return connection.getTelemetryContext();\n}\n\n// telemetry record의 userId는 string 정규화 — presence store는 number | string 그대로 보관함\nfunction formatUserId(userId: WebSocketUserId | undefined): string | undefined {\n  return userId === undefined ? undefined : String(userId);\n}\n\nfunction isTelemetryContextProvider(\n  connection: ManagedWebSocketConnection,\n): connection is ManagedWebSocketConnection & TelemetryContextProvider {\n  return \"getTelemetryContext\" in connection && isFunctionValue(connection.getTelemetryContext);\n}\n"],"mappings":"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"}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"ws-registry.js","names":[],"sources":["../../src/stream/ws-registry.ts"],"sourcesContent":["import { type z } from \"zod\";\n\nimport { runtimeTypeOf } from \"../runtime-type\";\nimport { isFunctionValue } from \"../utils/runtime-value\";\nimport { WebSocketAudience, type WebSocketAudience as WebSocketAudienceSpec } from \"./ws-audience\";\nimport { WebSocketAudienceResolver } from \"./ws-audience-resolver\";\nimport { NoopWebSocketClusterBus, type WebSocketClusterBus } from \"./ws-cluster-bus\";\nimport {\n  type ManagedWebSocketConnection,\n  type MaybePromise,\n  type WebSocketFrameConnection,\n  type WebSocketRegistryStats,\n  type WebSocketRoomId,\n  type WebSocketUserId,\n} from \"./ws-core\";\nimport { WebSocketDeliveryEngine, type WebSocketRouteDefinition } from \"./ws-delivery\";\nimport { WebSocketLocalConnectionStore } from \"./ws-local-connection-store\";\nimport { WebSocketPresenceIndex } from \"./ws-presence-index\";\nimport {\n  InMemoryWebSocketPresenceStore,\n  type WebSocketPresenceStore,\n  type WebSocketSessionPresence,\n} from \"./ws-presence-store\";\nimport {\n  type TelemetryContextProvider,\n  NoopWebSocketTelemetryController,\n  type WebSocketTelemetryConnectionContext,\n  type WebSocketTelemetryController,\n} from \"./ws-telemetry\";\n\nexport type {\n  ManagedWebSocketConnection,\n  WebSocketRegistryStats,\n  WebSocketRoomId,\n  WebSocketUserId,\n};\nexport type WebSocketConnectionMeta = WebSocketSessionPresence;\nexport type WebSocketRoomMemberCount = {\n  count: number;\n  // store 조회에 실패해 노드 로컬 수로 대체했으면 true\n  partial: boolean;\n};\n\nconst DEFAULT_DRAIN_TIMEOUT_MS = 5000;\n\ntype StoreMutationOperation =\n  | \"register\"\n  | \"activate\"\n  | \"unregister\"\n  | \"setUserId\"\n  | \"clearUserId\"\n  | \"join\"\n  | \"leave\";\n\nexport type WebSocketRegistryOptions = {\n  // 분산 환경에서 노드 간 라우팅 식별자로 쓰이므로 반드시 호출 측(WebSocketRuntime)에서 결정해 넘긴다\n  nodeId: string;\n  presenceStore?: WebSocketPresenceStore;\n  clusterBus?: WebSocketClusterBus;\n  telemetryController?: WebSocketTelemetryController;\n  // shutdown 시 진행 중인 store mutation과 publish를 기다리는 상한\n  drainTimeoutMs?: number;\n};\n\n/**\n * 노드 로컬 presence를 메모리에 소유하고, 설정된 store에는 세션별 순서대로 replica를 반영한다.\n * mutation과 publish는 호출 시점에 메모리를 동기로 갱신하고, store 실패는 telemetry로만 기록하며 reject하지 않는다.\n */\nexport class WebSocketRegistry {\n  readonly nodeId: string;\n  readonly localConnections = new WebSocketLocalConnectionStore();\n  readonly presenceStore: WebSocketPresenceStore;\n  readonly clusterBus: WebSocketClusterBus;\n  readonly telemetryController: WebSocketTelemetryController;\n  private readonly memory = new WebSocketPresenceIndex();\n  private readonly deliveryEngine: WebSocketDeliveryEngine;\n  private readonly drainTimeoutMs: number;\n  // 세션별 store mutation 큐의 꼬리. 같은 세션의 호출은 이 promise 뒤에 이어 붙어 호출 순서대로 store에 도달한다\n  private readonly mutationQueues = new Map<string, Promise<void>>();\n\n  constructor(options: WebSocketRegistryOptions) {\n    this.nodeId = options.nodeId;\n    this.presenceStore = options.presenceStore ?? new InMemoryWebSocketPresenceStore();\n    this.clusterBus = options.clusterBus ?? new NoopWebSocketClusterBus();\n    this.drainTimeoutMs = options.drainTimeoutMs ?? DEFAULT_DRAIN_TIMEOUT_MS;\n    assertMatchingNodeId(\"presenceStore\", this.presenceStore.nodeId, this.nodeId);\n    assertMatchingNodeId(\"clusterBus\", this.clusterBus.nodeId, this.nodeId);\n    this.telemetryController =\n      options.telemetryController ?? new NoopWebSocketTelemetryController();\n    this.deliveryEngine = new WebSocketDeliveryEngine({\n      nodeId: this.nodeId,\n      localConnections: this.localConnections,\n      resolveLocalSessionIds: (audience) =>\n        this.memory.queryAudience(audience).map((session) => session.sessionId),\n      audienceResolver: new WebSocketAudienceResolver({\n        nodeId: this.nodeId,\n        presenceStore: this.presenceStore,\n      }),\n      clusterBus: this.clusterBus,\n      telemetryController: this.telemetryController,\n    });\n\n    // telemetry는 노드 로컬 메모리만 집계한다. 클러스터 합계를 모든 노드가 보고하면 집계 시 중복되기 때문이다\n    this.telemetryController.registerMetricSource({\n      collect: (_now) => {\n        const stats = this.memory.getStats();\n        const localSnapshot = this.localConnections.getTelemetrySnapshot();\n        return {\n          activeConnections: stats.totalConnections,\n          activeConnectionsByNamespace: stats.byNamespace,\n          roomCount: stats.totalRooms,\n          pendingInboundMessages: localSnapshot.pendingInboundMessages,\n          pendingOutboundMessages: localSnapshot.pendingOutboundMessages,\n          socketBufferedBytes: localSnapshot.socketBufferedBytes,\n        };\n      },\n    });\n  }\n\n  registerRoute(routeKey: string, outEvents: z.ZodObject): void {\n    this.deliveryEngine.registerRoute(routeKey, outEvents);\n  }\n\n  replaceRoutes(routes: WebSocketRouteDefinition[]): void {\n    this.deliveryEngine.replaceRoutes(routes);\n  }\n\n  /**\n   * 연결을 메모리에 즉시 등록하고 store.register가 끝나면 resolve한다.\n   * store가 실패해도 메모리 전용 등록으로 resolve한다.\n   */\n  async register(\n    connection: WebSocketFrameConnection,\n    active: boolean = true,\n  ): Promise<WebSocketConnectionMeta> {\n    const registration = {\n      sessionId: connection.id,\n      nodeId: this.nodeId,\n      namespace: connection.namespace,\n      active,\n      connectedAt: new Date(),\n    };\n    this.localConnections.register(connection);\n    this.memory.register(registration);\n    this.telemetryController.emit({\n      name: \"ws.connection.registered\",\n      level: \"info\",\n      connectionId: connection.id,\n      namespace: connection.namespace,\n      userId: connection.userId,\n      ...getConnectionTelemetryContext(connection),\n    });\n    this.telemetryController.recordMetric({\n      name: \"sonamu.ws.connections\",\n      kind: \"counter\",\n      value: 1,\n      unit: \"1\",\n      tags: { outcome: \"registered\", namespace: connection.namespace },\n      userId: connection.userId,\n    });\n\n    await this.enqueueStoreMutation(connection.id, \"register\", () =>\n      this.presenceStore.register(registration),\n    );\n    // 등록 도중 닫혔으면 메모리에서 이미 빠졌으므로 등록 시점 값을 돌려준다\n    return (\n      this.memory.getConnection(connection.id) ?? {\n        ...registration,\n        rooms: new Set(),\n        lastSeenAt: registration.connectedAt,\n      }\n    );\n  }\n\n  activate(connectionId: string): Promise<void> {\n    if (!this.memory.has(connectionId)) {\n      this.emitMutationSkipped(connectionId, { operation: \"activate\" });\n      return Promise.resolve();\n    }\n\n    this.memory.activate(connectionId);\n    const connection = this.localConnections.getConnection(connectionId);\n    this.telemetryController.emit({\n      name: \"ws.connection.activated\",\n      level: \"info\",\n      connectionId,\n      userId: connection?.userId,\n      ...getConnectionTelemetryContext(connection),\n    });\n    return this.enqueueStoreMutation(connectionId, \"activate\", () =>\n      this.presenceStore.activate(connectionId),\n    );\n  }\n\n  unregister(connectionId: string): Promise<void> {\n    const connection = this.localConnections.getConnection(connectionId);\n    const telemetryContext = getConnectionTelemetryContext(connection);\n    const meta = this.memory.unregister(connectionId);\n    const userId = connection?.userId ?? formatUserId(meta?.userId);\n    this.localConnections.unregister(connectionId);\n    this.telemetryController.emit({\n      name: \"ws.connection.unregistered\",\n      level: \"debug\",\n      connectionId,\n      namespace: meta?.namespace,\n      userId,\n      ...telemetryContext,\n    });\n    if (!meta) {\n      return Promise.resolve();\n    }\n\n    this.telemetryController.recordMetric({\n      name: \"sonamu.ws.connections\",\n      kind: \"counter\",\n      value: 1,\n      unit: \"1\",\n      tags: { outcome: \"unregistered\", namespace: meta.namespace },\n      userId,\n    });\n    // 같은 세션 큐에 이어 붙으므로 진행 중인 register보다 먼저 store에 도달하지 않는다\n    return this.enqueueStoreMutation(connectionId, \"unregister\", () =>\n      this.presenceStore.unregister(connectionId),\n    );\n  }\n\n  // lastSeenAt은 메모리만 갱신한다. store에는 마지막 mutation 시점 값이 남는다\n  touch(connectionId: string): void {\n    this.memory.touch(connectionId);\n  }\n\n  setUserId(connectionId: string, userId: WebSocketUserId): Promise<void> {\n    const meta = this.memory.getConnection(connectionId);\n    if (!meta) {\n      this.emitMutationSkipped(connectionId, { operation: \"setUserId\", userId });\n      return Promise.resolve();\n    }\n\n    this.memory.setUserId(connectionId, userId);\n    this.telemetryController.emit({\n      name: \"ws.user.bound\",\n      level: \"debug\",\n      connectionId,\n      namespace: meta.namespace,\n      userId: String(userId),\n      detail: { userId },\n      ...getConnectionTelemetryContext(this.localConnections.getConnection(connectionId)),\n    });\n    return this.enqueueStoreMutation(connectionId, \"setUserId\", () =>\n      this.presenceStore.setUserId(connectionId, userId),\n    );\n  }\n\n  clearUserId(connectionId: string): Promise<void> {\n    const meta = this.memory.getConnection(connectionId);\n    if (!meta) {\n      this.emitMutationSkipped(connectionId, { operation: \"clearUserId\" });\n      return Promise.resolve();\n    }\n\n    const userId = meta.userId;\n    this.memory.clearUserId(connectionId);\n    this.telemetryController.emit({\n      name: \"ws.user.cleared\",\n      level: \"debug\",\n      connectionId,\n      namespace: meta.namespace,\n      userId: formatUserId(userId),\n      detail: userId !== undefined ? { userId } : undefined,\n      ...getConnectionTelemetryContext(this.localConnections.getConnection(connectionId)),\n    });\n    return this.enqueueStoreMutation(connectionId, \"clearUserId\", () =>\n      this.presenceStore.clearUserId(connectionId),\n    );\n  }\n\n  join(connectionId: string, roomId: WebSocketRoomId): Promise<void> {\n    const meta = this.memory.getConnection(connectionId);\n    if (!meta) {\n      this.emitMutationSkipped(connectionId, { operation: \"join\", roomId });\n      return Promise.resolve();\n    }\n\n    this.memory.join(connectionId, roomId);\n    const connection = this.localConnections.getConnection(connectionId);\n    this.telemetryController.emit({\n      name: \"ws.room.joined\",\n      level: \"debug\",\n      connectionId,\n      namespace: meta.namespace,\n      userId: connection?.userId ?? formatUserId(meta.userId),\n      detail: { roomId },\n      ...getConnectionTelemetryContext(connection),\n    });\n    return this.enqueueStoreMutation(connectionId, \"join\", () =>\n      this.presenceStore.join(connectionId, roomId),\n    );\n  }\n\n  leave(connectionId: string, roomId: WebSocketRoomId): Promise<void> {\n    const meta = this.memory.getConnection(connectionId);\n    if (!meta) {\n      this.emitMutationSkipped(connectionId, { operation: \"leave\", roomId });\n      return Promise.resolve();\n    }\n\n    this.memory.leave(connectionId, roomId);\n    const connection = this.localConnections.getConnection(connectionId);\n    this.telemetryController.emit({\n      name: \"ws.room.left\",\n      level: \"debug\",\n      connectionId,\n      namespace: meta.namespace,\n      userId: connection?.userId ?? formatUserId(meta.userId),\n      detail: { roomId },\n      ...getConnectionTelemetryContext(connection),\n    });\n    return this.enqueueStoreMutation(connectionId, \"leave\", () =>\n      this.presenceStore.leave(connectionId, roomId),\n    );\n  }\n\n  broadcast<Data>(event: string, data: Data, namespace?: string): Promise<void> {\n    return this.publishToAudience(WebSocketAudience.all(namespace), event, data);\n  }\n\n  publishToRoom<Data>(\n    roomId: WebSocketRoomId,\n    event: string,\n    data: Data,\n    namespace?: string,\n  ): Promise<void> {\n    return this.publishToAudience(WebSocketAudience.room(roomId, namespace), event, data);\n  }\n\n  publishToUser<Data>(\n    userId: WebSocketUserId,\n    event: string,\n    data: Data,\n    namespace?: string,\n  ): Promise<void> {\n    return this.publishToAudience(WebSocketAudience.user(userId, namespace), event, data);\n  }\n\n  publishToAudience<Data>(\n    audience: WebSocketAudienceSpec,\n    event: string,\n    data: Data,\n  ): Promise<void> {\n    return this.deliveryEngine.publishToAudience(audience, event, data);\n  }\n\n  // 아래 읽기 API는 노드 로컬 snapshot(복사본)이다\n  getConnection(connectionId: string): WebSocketConnectionMeta | undefined {\n    return this.memory.getConnection(connectionId);\n  }\n\n  getConnectionCount(namespace?: string): number {\n    return this.memory.getConnectionCount(namespace);\n  }\n\n  getRoomMembers(roomId: WebSocketRoomId, namespace?: string): WebSocketConnectionMeta[] {\n    return this.memory.getRoomMembers(roomId, namespace);\n  }\n\n  getStats(): WebSocketRegistryStats {\n    return this.memory.getStats();\n  }\n\n  /**\n   * 클러스터 전체의 활성 방 인원수. store가 실패하면 노드 로컬 수에 partial: true를 붙여 반환하며 reject하지 않는다.\n   */\n  async getRoomMemberCount(\n    roomId: WebSocketRoomId,\n    namespace?: string,\n  ): Promise<WebSocketRoomMemberCount> {\n    try {\n      const count = await callStore(() => this.presenceStore.getRoomMemberCount(roomId, namespace));\n      return { count, partial: false };\n    } catch (cause) {\n      this.telemetryController.emit({\n        name: \"ws.registry.read.failed\",\n        level: \"warn\",\n        detail: { operation: \"getRoomMemberCount\", roomId, errorType: describeError(cause) },\n      });\n      return { count: this.memory.getRoomMemberCount(roomId, namespace), partial: true };\n    }\n  }\n\n  closeAll(code?: number, reason?: string): void {\n    this.localConnections.closeAll(code, reason);\n  }\n\n  /**\n   * 로컬 연결을 닫고, 진행 중인 store mutation과 publish를 drainTimeoutMs까지 기다린 뒤 store와 bus를 종료한다.\n   */\n  async shutdown(code?: number, reason?: string): Promise<void> {\n    this.closeAll(code, reason);\n\n    let timer: ReturnType<typeof setTimeout> | undefined;\n    const deadline = new Promise<void>((resolve) => {\n      timer = setTimeout(resolve, this.drainTimeoutMs);\n    });\n    try {\n      await Promise.race([\n        Promise.all([...this.mutationQueues.values(), this.deliveryEngine.drainPublishes()]),\n        deadline,\n      ]);\n    } finally {\n      clearTimeout(timer);\n    }\n\n    try {\n      await callStore(() => this.presenceStore.shutdown?.());\n    } catch (cause) {\n      this.telemetryController.emit({\n        name: \"ws.registry.shutdown.failed\",\n        level: \"error\",\n        detail: { errorType: describeError(cause) },\n      });\n    }\n    // 구독 해제는 drain이 끝났으므로 즉시 포기할 수 있게 이미 끝난 deadline을 넘긴다\n    await this.deliveryEngine.shutdown(Promise.resolve());\n  }\n\n  /**\n   * 세션별 큐 뒤에 store 호출을 이어 붙인다. 실패는 telemetry로만 기록하고, 반환한 promise는 reject하지 않는다.\n   */\n  private enqueueStoreMutation(\n    sessionId: string,\n    operation: StoreMutationOperation,\n    call: () => MaybePromise<void>,\n  ): Promise<void> {\n    const previous = this.mutationQueues.get(sessionId) ?? Promise.resolve();\n    const next: Promise<void> = previous\n      .then(call)\n      .then(\n        () => undefined,\n        (cause: unknown) => {\n          this.telemetryController.emit({\n            name: \"ws.registry.mutation.failed\",\n            level: \"warn\",\n            connectionId: sessionId,\n            detail: { operation, errorType: describeError(cause) },\n          });\n        },\n      )\n      .then(() => {\n        // 마지막 mutation이 끝나면 큐를 비워 세션 수만큼 promise가 쌓이지 않게 한다\n        if (this.mutationQueues.get(sessionId) === next) {\n          this.mutationQueues.delete(sessionId);\n        }\n      });\n    this.mutationQueues.set(sessionId, next);\n    return next;\n  }\n\n  private emitMutationSkipped(\n    connectionId: string,\n    detail: {\n      operation: \"activate\" | \"setUserId\" | \"clearUserId\" | \"join\" | \"leave\";\n      roomId?: WebSocketRoomId;\n      userId?: WebSocketUserId;\n    },\n  ): void {\n    this.telemetryController.emit({\n      name: \"ws.registry.mutation.skipped\",\n      level: \"debug\",\n      connectionId,\n      detail: { ...detail, reason: \"connectionMissing\" },\n    });\n  }\n}\n\n// store 호출의 동기 throw를 rejection으로 바꾼다\nfunction callStore<T>(call: () => MaybePromise<T>): Promise<T> {\n  return Promise.resolve().then(call);\n}\n\nfunction assertMatchingNodeId(\n  source: \"presenceStore\" | \"clusterBus\",\n  sourceNodeId: string | undefined,\n  nodeId: string,\n): void {\n  if (sourceNodeId !== undefined && sourceNodeId !== nodeId) {\n    throw new Error(\n      `WebSocket ${source}.nodeId (${sourceNodeId}) must match the runtime nodeId (${nodeId}).`,\n    );\n  }\n}\n\nfunction describeError(cause: unknown): string {\n  return cause instanceof Error ? cause.name : runtimeTypeOf(cause);\n}\n\nfunction getConnectionTelemetryContext(\n  connection: ManagedWebSocketConnection | undefined,\n): WebSocketTelemetryConnectionContext {\n  if (!connection || !isTelemetryContextProvider(connection)) {\n    return {};\n  }\n\n  return connection.getTelemetryContext();\n}\n\n// telemetry record의 userId는 string 정규화 — presence는 number | string 그대로 보관함\nfunction formatUserId(userId: WebSocketUserId | undefined): string | undefined {\n  return userId === undefined ? undefined : String(userId);\n}\n\nfunction isTelemetryContextProvider(\n  connection: ManagedWebSocketConnection,\n): connection is ManagedWebSocketConnection & TelemetryContextProvider {\n  return \"getTelemetryContext\" in connection && isFunctionValue(connection.getTelemetryContext);\n}\n"],"mappings":"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"}