sonamu 0.11.16 → 0.13.0

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

@@ -1 +1 @@
-{"version":3,"file":"ws-delivery.d.ts","sourceRoot":"","sources":["../../src/stream/ws-delivery.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,KAAK,iBAAiB,EAAE,MAAM,eAAe,CAAC;AACvD,OAAO,EAAE,KAAK,yBAAyB,EAAE,MAAM,wBAAwB,CAAC;AACxE,OAAO,EAAE,KAAK,mBAAmB,EAAiC,MAAM,kBAAkB,CAAC;AAE3F,OAAO,EAAE,KAAK,6BAA6B,EAAE,MAAM,6BAA6B,CAAC;AACjF,OAAO,EAEL,KAAK,4BAA4B,EAClC,MAAM,gBAAgB,CAAC;AAKxB,qBAAa,uBAAuB;IAahC,OAAO,CAAC,QAAQ,CAAC,OAAO;IAZ1B,OAAO,CAAC,QAAQ,CAAC,iBAAiB,CAK1B;IACR,OAAO,CAAC,oBAAoB,CAAS;IACrC,OAAO,CAAC,QAAQ,CAAC,WAAW,CAAa;IACzC,OAAO,CAAC,QAAQ,CAAC,SAAS,CAA+B;IACzD,OAAO,CAAC,QAAQ,CAAC,sBAAsB,CAAa;IAEpD,YACmB,OAAO,EAAE;QACxB,MAAM,EAAE,MAAM,CAAC;QACf,gBAAgB,EAAE,6BAA6B,CAAC;QAChD,gBAAgB,EAAE,yBAAyB,CAAC;QAC5C,UAAU,EAAE,mBAAmB,CAAC;QAChC,mBAAmB,CAAC,EAAE,4BAA4B,CAAC;KACpD,EASF;IAED,iBAAiB,CAAC,IAAI,EAAE,QAAQ,EAAE,iBAAiB,EAAE,KAAK,EAAE,MAAM,EAAE,IAAI,EAAE,IAAI,GAAG,IAAI,CAwEpF;IAEK,QAAQ,IAAI,OAAO,CAAC,IAAI,CAAC,CAI9B;IAED,oBAAoB;;;MAWnB;IAED,OAAO,CAAC,qBAAqB;IA+C7B,OAAO,CAAC,aAAa;IAuBrB,OAAO,CAAC,mBAAmB;IAY3B,OAAO,CAAC,eAAe;IA8CvB,OAAO,CAAC,WAAW;CAqBpB"}
+{"version":3,"file":"ws-delivery.d.ts","sourceRoot":"","sources":["../../src/stream/ws-delivery.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,KAAK,CAAC,EAAE,MAAM,KAAK,CAAC;AAG7B,OAAO,EAAE,KAAK,iBAAiB,EAAE,MAAM,eAAe,CAAC;AACvD,OAAO,EAAE,KAAK,yBAAyB,EAAE,MAAM,wBAAwB,CAAC;AACxE,OAAO,EAAE,KAAK,mBAAmB,EAAiC,MAAM,kBAAkB,CAAC;AAG3F,OAAO,EAAE,KAAK,6BAA6B,EAAE,MAAM,6BAA6B,CAAC;AACjF,OAAO,EAEL,KAAK,4BAA4B,EAClC,MAAM,gBAAgB,CAAC;AAKxB,MAAM,MAAM,wBAAwB,GAAG;IACrC,QAAQ,EAAE,MAAM,CAAC;IACjB,SAAS,EAAE,CAAC,CAAC,SAAS,CAAC;CACxB,CAAC;AAeF,qBAAa,uBAAuB;IAahC,OAAO,CAAC,QAAQ,CAAC,OAAO;IAZ1B,OAAO,CAAC,QAAQ,CAAC,iBAAiB,CAAmB;IACrD,OAAO,CAAC,oBAAoB,CAAS;IAErC,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAkC;IAEzD,OAAO,CAAC,YAAY,CAAoC;IACxD,OAAO,CAAC,QAAQ,CAAC,YAAY,CAAmC;IAChE,OAAO,CAAC,OAAO,CAAS;IACxB,OAAO,CAAC,QAAQ,CAAC,SAAS,CAA+B;IACzD,OAAO,CAAC,QAAQ,CAAC,sBAAsB,CAAa;IAEpD,YACmB,OAAO,EAAE;QACxB,MAAM,EAAE,MAAM,CAAC;QACf,gBAAgB,EAAE,6BAA6B,CAAC;QAEhD,sBAAsB,EAAE,CAAC,QAAQ,EAAE,iBAAiB,KAAK,MAAM,EAAE,CAAC;QAClE,gBAAgB,EAAE,yBAAyB,CAAC;QAC5C,UAAU,EAAE,mBAAmB,CAAC;QAChC,mBAAmB,CAAC,EAAE,4BAA4B,CAAC;KACpD,EAOF;IAED,aAAa,CAAC,QAAQ,EAAE,MAAM,EAAE,SAAS,EAAE,CAAC,CAAC,SAAS,GAAG,IAAI,CAE5D;IAED,aAAa,CAAC,MAAM,EAAE,wBAAwB,EAAE,GAAG,IAAI,CAKtD;IAED;;;OAGG;IACH,iBAAiB,CAAC,IAAI,EAAE,QAAQ,EAAE,iBAAiB,EAAE,KAAK,EAAE,MAAM,EAAE,IAAI,EAAE,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CA+E7F;IAGK,cAAc,IAAI,OAAO,CAAC,IAAI,CAAC,CAEpC;IAED;;OAEG;IACG,QAAQ,CAAC,QAAQ,EAAE,OAAO,CAAC,IAAI,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC,CAsBrD;IAED,oBAAoB;;;MAWnB;IAGD,OAAO,CAAC,SAAS;IAoBjB,OAAO,CAAC,eAAe;IAavB,OAAO,CAAC,oBAAoB;YAUd,aAAa;IA8D3B,OAAO,CAAC,qBAAqB;IA4D7B,OAAO,CAAC,mBAAmB;IAQ3B,OAAO,CAAC,eAAe;IAQvB,OAAO,CAAC,kBAAkB;IAmB1B,OAAO,CAAC,aAAa;IAkBrB,OAAO,CAAC,mBAAmB;IAY3B,OAAO,CAAC,eAAe;IA8CvB,OAAO,CAAC,QAAQ;CAkBjB"}

package/dist/stream/ws-delivery.js

@@ -1,66 +1,181 @@
 import { __esmMin } from "../_virtual/_rolldown/runtime.js";
 import { init_runtime_type, runtimeTypeOf } from "../runtime-type.js";
+import { encodeWebSocketFrame, init_ws_frame } from "./ws-frame.js";
 import { NoopWebSocketTelemetryController, init_ws_telemetry } from "./ws-telemetry.js";
 import { randomUUID } from "node:crypto";
-//#region src/stream/ws-delivery.ts
+// src/stream/ws-delivery.ts
+function getOwnFrame(frames, routeKey) {
+	return Object.hasOwn(frames, routeKey) ? frames[routeKey] : void 0;
+}
+function describeError(cause) {
+	return cause instanceof Error ? cause.name : runtimeTypeOf(cause);
+}
 var FAN_OUT_BATCH_SIZE, WebSocketDeliveryEngine;
 var init_ws_delivery = __esmMin((() => {
 	init_runtime_type();
+	init_ws_frame();
 	init_ws_telemetry();
 	FAN_OUT_BATCH_SIZE = 250;
 	WebSocketDeliveryEngine = class {
 		options;
 		pendingFanOutJobs = [];
 		fanOutFlushScheduled = false;
-		unsubscribe;
+		routes = /* @__PURE__ */ new Map();
+		publishQueue = Promise.resolve();
+		subscription;
+		stopped = false;
 		telemetry;
 		unregisterMetricSource;
 		constructor(options) {
 			this.options = options;
 			this.telemetry = this.options.telemetryController ?? new NoopWebSocketTelemetryController();
-			this.unsubscribe = this.options.clusterBus.subscribe((envelope) => {
-				this.handleClusterEnvelope(envelope);
-			});
+			this.subscription = this.subscribe();
 			this.unregisterMetricSource = this.telemetry.registerMetricSource({ collect: () => this.getTelemetrySnapshot() });
 		}
+		registerRoute(routeKey, outEvents) {
+			this.routes.set(routeKey, outEvents);
+		}
+		replaceRoutes(routes) {
+			this.routes.clear();
+			for (const route of routes) this.routes.set(route.routeKey, route.outEvents);
+		}
+		/**
+		* 발행 노드에서 route별로 한 번 검증·인코딩하고, 로컬 fan-out은 즉시 큐에 넣는다.
+		* 원격 라우팅과 cluster publish는 노드 단위 직렬 큐에서 처리한다. 반환한 promise는 reject하지 않는다.
+		*/
 		publishToAudience(audience, event, data) {
-			const routingPlan = this.options.audienceResolver.resolve(audience);
-			const localTargets = this.options.localConnections.getConnections(routingPlan.localSessionIds);
-			this.telemetry.emit({
-				name: "ws.fanout.resolved",
-				level: "debug",
-				detail: {
-					localTargetCount: localTargets.length,
-					remoteNodeCount: routingPlan.remoteNodeIds.length
+			try {
+				let declared = false;
+				let rejected = false;
+				const record = (encoding) => {
+					if (encoding.status !== "unknownEvent") declared = true;
+					if (encoding.status === "invalidPayload") rejected = true;
+				};
+				const routeFrames = {};
+				for (const [routeKey, outEvents] of this.routes) {
+					const encoding = encodeWebSocketFrame(outEvents, event, data);
+					record(encoding);
+					if (encoding.status === "encoded") routeFrames[routeKey] = encoding.frame;
+				}
+				const fallbackEncodings = /* @__PURE__ */ new Map();
+				const localTargets = [];
+				for (const connection of this.options.localConnections.getConnections(this.options.resolveLocalSessionIds(audience))) {
+					let frame;
+					if (connection.routeKey !== void 0 && this.routes.has(connection.routeKey)) frame = getOwnFrame(routeFrames, connection.routeKey);
+					else {
+						let encoding = fallbackEncodings.get(connection.outEvents);
+						if (!encoding) {
+							encoding = encodeWebSocketFrame(connection.outEvents, event, data);
+							fallbackEncodings.set(connection.outEvents, encoding);
+							record(encoding);
+						}
+						frame = encoding.status === "encoded" ? encoding.frame : void 0;
+					}
+					if (frame !== void 0) localTargets.push({
+						connection,
+						frame
+					});
 				}
+				if (!declared) this.emitPublishRejected(event, "unknownEvent");
+				else if (rejected) this.emitPublishRejected(event, "invalidPayload");
+				this.enqueueFanOut(localTargets, event);
+				if (Object.keys(routeFrames).length === 0) {
+					this.emitFanOutResolved(audience, localTargets.length, 0);
+					return Promise.resolve();
+				}
+				const routing = this.resolveRemoteNodeIds(audience, event);
+				const task = this.publishQueue.then(() => routing).then((remoteNodeIds) => this.publishRemote(audience, event, routeFrames, localTargets.length, remoteNodeIds)).catch((cause) => {
+					this.emitRouteFailed(event, audience, cause);
+				});
+				this.publishQueue = task;
+				return task;
+			} catch (cause) {
+				this.emitRouteFailed(event, audience, cause);
+				return Promise.resolve();
+			}
+		}
+		async drainPublishes() {
+			await Promise.all([this.publishQueue, this.subscription]);
+		}
+		/**
+		* 구독을 해제하고 cluster bus를 종료한다. 구독이 deadline까지 끝나지 않으면 늦게 끝날 때 해제한다.
+		*/
+		async shutdown(deadline) {
+			this.stopped = true;
+			this.unregisterMetricSource();
+			const unsubscribe = await Promise.race([this.subscription, deadline.then(() => null)]);
+			if (unsubscribe === null) this.subscription.then((lateUnsubscribe) => {
+				this.safeUnsubscribe(lateUnsubscribe);
 			});
-			this.telemetry.recordMetric({
-				name: "sonamu.ws.fanout.targets",
-				kind: "histogram",
-				value: localTargets.length + routingPlan.remoteNodeIds.length,
-				unit: "1",
-				tags: { audience_type: audience.type }
+			else this.safeUnsubscribe(unsubscribe);
+			try {
+				await Promise.resolve().then(() => this.options.clusterBus.shutdown());
+			} catch (cause) {
+				this.telemetry.emit({
+					name: "ws.cluster.shutdown.failed",
+					level: "error",
+					detail: { errorType: describeError(cause) }
+				});
+			}
+		}
+		getTelemetrySnapshot() {
+			let pendingFanOutTargets = 0;
+			for (const job of this.pendingFanOutJobs) pendingFanOutTargets += Math.max(job.targets.length - job.cursor, 0);
+			return {
+				pendingFanOutJobs: this.pendingFanOutJobs.length,
+				pendingFanOutTargets
+			};
+		}
+		subscribe() {
+			return Promise.resolve().then(() => this.options.clusterBus.subscribe((envelope) => {
+				this.handleClusterEnvelope(envelope);
+			})).then((unsubscribe) => unsubscribe, (cause) => {
+				this.telemetry.emit({
+					name: "ws.cluster.subscribe.failed",
+					level: "error",
+					detail: { errorType: describeError(cause) }
+				});
 			});
-			this.enqueueFanOut(localTargets, event, data);
-			if (routingPlan.remoteNodeIds.length === 0) return;
+		}
+		safeUnsubscribe(unsubscribe) {
+			try {
+				unsubscribe?.();
+			} catch (cause) {
+				this.telemetry.emit({
+					name: "ws.cluster.unsubscribe.failed",
+					level: "error",
+					detail: { errorType: describeError(cause) }
+				});
+			}
+		}
+		resolveRemoteNodeIds(audience, event) {
+			return this.options.audienceResolver.resolveRemoteNodeIds(audience).catch((cause) => {
+				this.emitRouteFailed(event, audience, cause);
+			});
+		}
+		async publishRemote(audience, event, frames, localTargetCount, resolvedNodeIds) {
+			const remoteNodeIds = resolvedNodeIds ?? [];
+			this.emitFanOutResolved(audience, localTargetCount, remoteNodeIds.length);
+			if (remoteNodeIds.length === 0) return;
 			const envelope = {
 				id: randomUUID(),
 				sourceNodeId: this.options.nodeId,
-				targetNodeIds: routingPlan.remoteNodeIds,
+				targetNodeIds: remoteNodeIds,
 				audience,
 				event,
-				data,
+				frames,
 				emittedAt: Date.now()
 			};
 			const publishStartedAt = performance.now();
-			Promise.resolve(this.options.clusterBus.publish(envelope)).then(() => {
+			try {
+				await Promise.resolve().then(() => this.options.clusterBus.publish(envelope));
 				const durationMs = performance.now() - publishStartedAt;
 				this.telemetry.emit({
 					name: "ws.cluster.envelope.published",
 					level: "debug",
 					detail: {
 						event,
-						targetNodeCount: routingPlan.remoteNodeIds.length
+						targetNodeCount: remoteNodeIds.length
 					}
 				});
 				this.telemetry.recordSpan({
@@ -70,10 +185,10 @@ var init_ws_delivery = __esmMin((() => {
 					status: "unset",
 					attributes: {
 						event,
-						targetNodeCount: routingPlan.remoteNodeIds.length
+						targetNodeCount: remoteNodeIds.length
 					}
 				});
-			}).catch((cause) => {
+			} catch (cause) {
 				const durationMs = performance.now() - publishStartedAt;
 				this.telemetry.emit({
 					name: "ws.cluster.envelope.failed",
@@ -86,24 +201,12 @@ var init_ws_delivery = __esmMin((() => {
 					durationMs,
 					status: "error",
 					attributes: { event },
-					errorType: cause instanceof Error ? cause.name : runtimeTypeOf(cause)
+					errorType: describeError(cause)
 				});
-			});
-		}
-		async shutdown() {
-			this.unregisterMetricSource();
-			this.unsubscribe();
-			await this.options.clusterBus.shutdown();
-		}
-		getTelemetrySnapshot() {
-			let pendingFanOutTargets = 0;
-			for (const job of this.pendingFanOutJobs) pendingFanOutTargets += Math.max(job.targets.length - job.cursor, 0);
-			return {
-				pendingFanOutJobs: this.pendingFanOutJobs.length,
-				pendingFanOutTargets
-			};
+			}
 		}
 		handleClusterEnvelope(envelope) {
+			if (this.stopped) return;
 			if (envelope.sourceNodeId === this.options.nodeId) {
 				this.telemetry.emit({
 					name: "ws.cluster.envelope.ignored",
@@ -115,7 +218,7 @@ var init_ws_delivery = __esmMin((() => {
 				});
 				return;
 			}
-			if (envelope.targetNodeIds && envelope.targetNodeIds.length > 0 && !envelope.targetNodeIds.includes(this.options.nodeId)) {
+			if (envelope.targetNodeIds.length > 0 && !envelope.targetNodeIds.includes(this.options.nodeId)) {
 				this.telemetry.emit({
 					name: "ws.cluster.envelope.ignored",
 					level: "debug",
@@ -135,9 +238,15 @@ var init_ws_delivery = __esmMin((() => {
 					sourceNodeId: envelope.sourceNodeId
 				}
 			});
-			const routingPlan = this.options.audienceResolver.resolve(envelope.audience);
-			const localTargets = this.options.localConnections.getConnections(routingPlan.localSessionIds);
-			this.enqueueFanOut(localTargets, envelope.event, envelope.data);
+			const localTargets = [];
+			for (const connection of this.options.localConnections.getConnections(this.options.resolveLocalSessionIds(envelope.audience))) {
+				const frame = connection.routeKey === void 0 ? void 0 : getOwnFrame(envelope.frames, connection.routeKey);
+				if (frame !== void 0) localTargets.push({
+					connection,
+					frame
+				});
+			}
+			this.enqueueFanOut(localTargets, envelope.event);
 			this.telemetry.recordSpan({
 				operationName: "ws.cluster.receive",
 				kind: "consumer",
@@ -150,12 +259,49 @@ var init_ws_delivery = __esmMin((() => {
 				}
 			});
 		}
-		enqueueFanOut(targets, event, data) {
+		emitPublishRejected(event, reason) {
+			this.telemetry.emit({
+				name: "ws.publish.rejected",
+				level: "error",
+				detail: {
+					event,
+					reason
+				}
+			});
+		}
+		emitRouteFailed(event, audience, cause) {
+			this.telemetry.emit({
+				name: "ws.fanout.route.failed",
+				level: "error",
+				detail: {
+					event,
+					audienceType: audience.type,
+					errorType: describeError(cause)
+				}
+			});
+		}
+		emitFanOutResolved(audience, localTargetCount, remoteNodeCount) {
+			this.telemetry.emit({
+				name: "ws.fanout.resolved",
+				level: "debug",
+				detail: {
+					localTargetCount,
+					remoteNodeCount
+				}
+			});
+			this.telemetry.recordMetric({
+				name: "sonamu.ws.fanout.targets",
+				kind: "histogram",
+				value: localTargetCount + remoteNodeCount,
+				unit: "1",
+				tags: { audience_type: audience.type }
+			});
+		}
+		enqueueFanOut(targets, event) {
 			if (targets.length === 0) return;
 			this.pendingFanOutJobs.push({
 				targets,
 				event,
-				data,
 				cursor: 0
 			});
 			this.telemetry.emit({
@@ -185,7 +331,7 @@ var init_ws_delivery = __esmMin((() => {
 				while (this.pendingFanOutJobs.length > 0 && processed < FAN_OUT_BATCH_SIZE) {
 					const job = this.pendingFanOutJobs[0];
 					while (job.cursor < job.targets.length && processed < FAN_OUT_BATCH_SIZE) {
-						this.safePublish(job.targets[job.cursor], job.event, job.data);
+						this.safeSend(job.targets[job.cursor], job.event);
 						job.cursor += 1;
 						processed += 1;
 					}
@@ -193,7 +339,7 @@ var init_ws_delivery = __esmMin((() => {
 				}
 			} catch (error) {
 				status = "error";
-				errorType = error instanceof Error ? error.name : runtimeTypeOf(error);
+				errorType = describeError(error);
 				throw error;
 			} finally {
 				const durationMs = performance.now() - startedAt;
@@ -213,9 +359,10 @@ var init_ws_delivery = __esmMin((() => {
 				if (this.pendingFanOutJobs.length > 0) this.scheduleFanOutFlush();
 			}
 		}
-		safePublish(connection, event, data) {
+		safeSend(target, event) {
+			const { connection, frame } = target;
 			try {
-				if (!connection.closed) connection.publishUntyped(event, data);
+				if (!connection.closed) connection.sendFrame(event, frame);
 			} catch {
 				this.telemetry.emit({
 					name: "ws.fanout.publish.failed",
@@ -230,8 +377,7 @@ var init_ws_delivery = __esmMin((() => {
 		}
 	};
 }));
-//#endregion
 init_ws_delivery();
 export { WebSocketDeliveryEngine, init_ws_delivery };
 
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"ws-delivery.js","names":[],"sources":["../../src/stream/ws-delivery.ts"],"sourcesContent":["import { randomUUID } from \"node:crypto\";\n\nimport { runtimeTypeOf } from \"../runtime-type\";\nimport { type WebSocketAudience } from \"./ws-audience\";\nimport { type WebSocketAudienceResolver } from \"./ws-audience-resolver\";\nimport { type WebSocketClusterBus, type WebSocketClusterEnvelope } from \"./ws-cluster-bus\";\nimport { type ManagedWebSocketConnection } from \"./ws-core\";\nimport { type WebSocketLocalConnectionStore } from \"./ws-local-connection-store\";\nimport {\n  NoopWebSocketTelemetryController,\n  type WebSocketTelemetryController,\n} from \"./ws-telemetry\";\n\n// fan-out을 event loop tick 단위로 나눠 한 번에 긴 동기 루프를 만들지 않게 함\nconst FAN_OUT_BATCH_SIZE = 250;\n\nexport class WebSocketDeliveryEngine {\n  private readonly pendingFanOutJobs: Array<{\n    targets: ManagedWebSocketConnection[];\n    event: string;\n    data: unknown;\n    cursor: number;\n  }> = [];\n  private fanOutFlushScheduled = false;\n  private readonly unsubscribe: () => void;\n  private readonly telemetry: WebSocketTelemetryController;\n  private readonly unregisterMetricSource: () => void;\n\n  constructor(\n    private readonly options: {\n      nodeId: string;\n      localConnections: WebSocketLocalConnectionStore;\n      audienceResolver: WebSocketAudienceResolver;\n      clusterBus: WebSocketClusterBus;\n      telemetryController?: WebSocketTelemetryController;\n    },\n  ) {\n    this.telemetry = this.options.telemetryController ?? new NoopWebSocketTelemetryController();\n    this.unsubscribe = this.options.clusterBus.subscribe((envelope) => {\n      this.handleClusterEnvelope(envelope);\n    });\n    this.unregisterMetricSource = this.telemetry.registerMetricSource({\n      collect: () => this.getTelemetrySnapshot(),\n    });\n  }\n\n  publishToAudience<Data>(audience: WebSocketAudience, event: string, data: Data): void {\n    const routingPlan = this.options.audienceResolver.resolve(audience);\n    const localTargets = this.options.localConnections.getConnections(routingPlan.localSessionIds);\n\n    this.telemetry.emit({\n      name: \"ws.fanout.resolved\",\n      level: \"debug\",\n      detail: {\n        localTargetCount: localTargets.length,\n        remoteNodeCount: routingPlan.remoteNodeIds.length,\n      },\n    });\n    this.telemetry.recordMetric({\n      name: \"sonamu.ws.fanout.targets\",\n      kind: \"histogram\",\n      value: localTargets.length + routingPlan.remoteNodeIds.length,\n      unit: \"1\",\n      tags: { audience_type: audience.type },\n    });\n\n    this.enqueueFanOut(localTargets, event, data);\n\n    if (routingPlan.remoteNodeIds.length === 0) {\n      return;\n    }\n\n    const envelope: WebSocketClusterEnvelope = {\n      id: randomUUID(),\n      sourceNodeId: this.options.nodeId,\n      targetNodeIds: routingPlan.remoteNodeIds,\n      audience,\n      event,\n      data,\n      emittedAt: Date.now(),\n    };\n\n    const publishStartedAt = performance.now();\n    Promise.resolve(this.options.clusterBus.publish(envelope))\n      .then(() => {\n        const durationMs = performance.now() - publishStartedAt;\n        this.telemetry.emit({\n          name: \"ws.cluster.envelope.published\",\n          level: \"debug\",\n          detail: { event, targetNodeCount: routingPlan.remoteNodeIds.length },\n        });\n        this.telemetry.recordSpan({\n          operationName: \"ws.cluster.publish\",\n          kind: \"producer\",\n          durationMs,\n          status: \"unset\",\n          attributes: {\n            event,\n            targetNodeCount: routingPlan.remoteNodeIds.length,\n          },\n        });\n      })\n      .catch((cause: unknown) => {\n        const durationMs = performance.now() - publishStartedAt;\n        this.telemetry.emit({\n          name: \"ws.cluster.envelope.failed\",\n          level: \"error\",\n          detail: { event },\n        });\n        this.telemetry.recordSpan({\n          operationName: \"ws.cluster.publish\",\n          kind: \"producer\",\n          durationMs,\n          status: \"error\",\n          attributes: { event },\n          errorType: cause instanceof Error ? cause.name : runtimeTypeOf(cause),\n        });\n      });\n  }\n\n  async shutdown(): Promise<void> {\n    this.unregisterMetricSource();\n    this.unsubscribe();\n    await this.options.clusterBus.shutdown();\n  }\n\n  getTelemetrySnapshot() {\n    let pendingFanOutTargets = 0;\n\n    for (const job of this.pendingFanOutJobs) {\n      pendingFanOutTargets += Math.max(job.targets.length - job.cursor, 0);\n    }\n\n    return {\n      pendingFanOutJobs: this.pendingFanOutJobs.length,\n      pendingFanOutTargets,\n    };\n  }\n\n  private handleClusterEnvelope(envelope: WebSocketClusterEnvelope): void {\n    if (envelope.sourceNodeId === this.options.nodeId) {\n      this.telemetry.emit({\n        name: \"ws.cluster.envelope.ignored\",\n        level: \"debug\",\n        detail: { reason: \"selfSource\", event: envelope.event },\n      });\n      return;\n    }\n\n    if (\n      envelope.targetNodeIds &&\n      envelope.targetNodeIds.length > 0 &&\n      !envelope.targetNodeIds.includes(this.options.nodeId)\n    ) {\n      this.telemetry.emit({\n        name: \"ws.cluster.envelope.ignored\",\n        level: \"debug\",\n        detail: { reason: \"targetMismatch\", event: envelope.event },\n      });\n      return;\n    }\n\n    const startedAt = performance.now();\n    this.telemetry.emit({\n      name: \"ws.cluster.envelope.received\",\n      level: \"debug\",\n      detail: { event: envelope.event, sourceNodeId: envelope.sourceNodeId },\n    });\n\n    const routingPlan = this.options.audienceResolver.resolve(envelope.audience);\n    const localTargets = this.options.localConnections.getConnections(routingPlan.localSessionIds);\n    this.enqueueFanOut(localTargets, envelope.event, envelope.data);\n\n    this.telemetry.recordSpan({\n      operationName: \"ws.cluster.receive\",\n      kind: \"consumer\",\n      durationMs: performance.now() - startedAt,\n      status: \"unset\",\n      attributes: {\n        event: envelope.event,\n        sourceNodeId: envelope.sourceNodeId,\n        localTargetCount: localTargets.length,\n      },\n    });\n  }\n\n  private enqueueFanOut<Data>(\n    targets: ManagedWebSocketConnection[],\n    event: string,\n    data: Data,\n  ): void {\n    if (targets.length === 0) {\n      return;\n    }\n\n    this.pendingFanOutJobs.push({\n      targets,\n      event,\n      data,\n      cursor: 0,\n    });\n    this.telemetry.emit({\n      name: \"ws.fanout.enqueued\",\n      level: \"debug\",\n      detail: { targetCount: targets.length, event },\n    });\n    this.scheduleFanOutFlush();\n  }\n\n  private scheduleFanOutFlush(): void {\n    if (this.fanOutFlushScheduled) {\n      return;\n    }\n\n    this.fanOutFlushScheduled = true;\n    setImmediate(() => {\n      this.fanOutFlushScheduled = false;\n      this.flushFanOutJobs();\n    });\n  }\n\n  private flushFanOutJobs(): void {\n    const startedAt = performance.now();\n    let processed = 0;\n    let status: \"unset\" | \"error\" = \"unset\";\n    let errorType: string | undefined;\n\n    try {\n      while (this.pendingFanOutJobs.length > 0 && processed < FAN_OUT_BATCH_SIZE) {\n        const job = this.pendingFanOutJobs[0];\n\n        while (job.cursor < job.targets.length && processed < FAN_OUT_BATCH_SIZE) {\n          this.safePublish(job.targets[job.cursor], job.event, job.data);\n          job.cursor += 1;\n          processed += 1;\n        }\n\n        if (job.cursor >= job.targets.length) {\n          this.pendingFanOutJobs.shift();\n        }\n      }\n    } catch (error) {\n      status = \"error\";\n      errorType = error instanceof Error ? error.name : runtimeTypeOf(error);\n      throw error;\n    } finally {\n      const durationMs = performance.now() - startedAt;\n      this.telemetry.emit({\n        name: \"ws.fanout.flushed\",\n        level: \"debug\",\n        detail: { processedCount: processed },\n      });\n      this.telemetry.recordSpan({\n        operationName: \"ws.fanout.dispatch\",\n        kind: \"internal\",\n        durationMs,\n        status,\n        attributes: { processedCount: processed },\n        errorType,\n      });\n\n      if (this.pendingFanOutJobs.length > 0) {\n        this.scheduleFanOutFlush();\n      }\n    }\n  }\n\n  private safePublish<Data>(\n    connection: ManagedWebSocketConnection,\n    event: string,\n    data: Data,\n  ): void {\n    try {\n      if (!connection.closed) {\n        connection.publishUntyped(event, data);\n      }\n    } catch {\n      this.telemetry.emit({\n        name: \"ws.fanout.publish.failed\",\n        level: \"error\",\n        connectionId: connection.id,\n        namespace: connection.namespace,\n        userId: connection.userId,\n        detail: { event },\n      });\n      connection.close(1011, \"WebSocket publish failed\");\n    }\n  }\n}\n"],"mappings":"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"}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"ws-delivery.js","names":[],"sources":["../../src/stream/ws-delivery.ts"],"sourcesContent":["import { randomUUID } from \"node:crypto\";\n\nimport { type z } from \"zod\";\n\nimport { runtimeTypeOf } from \"../runtime-type\";\nimport { type WebSocketAudience } from \"./ws-audience\";\nimport { type WebSocketAudienceResolver } from \"./ws-audience-resolver\";\nimport { type WebSocketClusterBus, type WebSocketClusterEnvelope } from \"./ws-cluster-bus\";\nimport { type WebSocketFrameConnection } from \"./ws-core\";\nimport { encodeWebSocketFrame, type WebSocketFrameEncoding } from \"./ws-frame\";\nimport { type WebSocketLocalConnectionStore } from \"./ws-local-connection-store\";\nimport {\n  NoopWebSocketTelemetryController,\n  type WebSocketTelemetryController,\n} from \"./ws-telemetry\";\n\n// fan-out을 event loop tick 단위로 나눠 한 번에 긴 동기 루프를 만들지 않게 함\nconst FAN_OUT_BATCH_SIZE = 250;\n\nexport type WebSocketRouteDefinition = {\n  routeKey: string;\n  outEvents: z.ZodObject;\n};\n\ntype FanOutTarget = {\n  connection: WebSocketFrameConnection;\n  frame: string;\n};\n\ntype FanOutJob = {\n  targets: FanOutTarget[];\n  event: string;\n  cursor: number;\n};\n\ntype Unsubscribe = () => void;\n\nexport class WebSocketDeliveryEngine {\n  private readonly pendingFanOutJobs: FanOutJob[] = [];\n  private fanOutFlushScheduled = false;\n  // routeKey → outEvents. 모든 노드가 같은 route 집합을 등록하므로 routeKey는 클러스터 전체에서 일관된다\n  private readonly routes = new Map<string, z.ZodObject>();\n  // 노드 단위 직렬 publish 큐. 앞선 publish의 라우팅이 느려도 원격 envelope 순서가 뒤바뀌지 않는다\n  private publishQueue: Promise<void> = Promise.resolve();\n  private readonly subscription: Promise<Unsubscribe | undefined>;\n  private stopped = false;\n  private readonly telemetry: WebSocketTelemetryController;\n  private readonly unregisterMetricSource: () => void;\n\n  constructor(\n    private readonly options: {\n      nodeId: string;\n      localConnections: WebSocketLocalConnectionStore;\n      // registry 메모리 기준으로 audience에 속한 로컬 활성 세션 ID를 반환한다\n      resolveLocalSessionIds: (audience: WebSocketAudience) => string[];\n      audienceResolver: WebSocketAudienceResolver;\n      clusterBus: WebSocketClusterBus;\n      telemetryController?: WebSocketTelemetryController;\n    },\n  ) {\n    this.telemetry = this.options.telemetryController ?? new NoopWebSocketTelemetryController();\n    this.subscription = this.subscribe();\n    this.unregisterMetricSource = this.telemetry.registerMetricSource({\n      collect: () => this.getTelemetrySnapshot(),\n    });\n  }\n\n  registerRoute(routeKey: string, outEvents: z.ZodObject): void {\n    this.routes.set(routeKey, outEvents);\n  }\n\n  replaceRoutes(routes: WebSocketRouteDefinition[]): void {\n    this.routes.clear();\n    for (const route of routes) {\n      this.routes.set(route.routeKey, route.outEvents);\n    }\n  }\n\n  /**\n   * 발행 노드에서 route별로 한 번 검증·인코딩하고, 로컬 fan-out은 즉시 큐에 넣는다.\n   * 원격 라우팅과 cluster publish는 노드 단위 직렬 큐에서 처리한다. 반환한 promise는 reject하지 않는다.\n   */\n  publishToAudience<Data>(audience: WebSocketAudience, event: string, data: Data): Promise<void> {\n    try {\n      let declared = false;\n      let rejected = false;\n      const record = (encoding: WebSocketFrameEncoding) => {\n        if (encoding.status !== \"unknownEvent\") {\n          declared = true;\n        }\n        if (encoding.status === \"invalidPayload\") {\n          rejected = true;\n        }\n      };\n\n      // 이벤트를 선언한 route마다 한 번만 검증·인코딩한다. 원격 수신자도 이 frame을 그대로 받는다\n      const routeFrames: Record<string, string> = {};\n      for (const [routeKey, outEvents] of this.routes) {\n        const encoding = encodeWebSocketFrame(outEvents, event, data);\n        record(encoding);\n        if (encoding.status === \"encoded\") {\n          routeFrames[routeKey] = encoding.frame;\n        }\n      }\n\n      // route table에 없는 로컬 연결은 자기 스키마로 인코딩한다(스키마 객체당 한 번)\n      const fallbackEncodings = new Map<z.ZodObject, WebSocketFrameEncoding>();\n      const localTargets: FanOutTarget[] = [];\n      for (const connection of this.options.localConnections.getConnections(\n        this.options.resolveLocalSessionIds(audience),\n      )) {\n        let frame: string | undefined;\n        if (connection.routeKey !== undefined && this.routes.has(connection.routeKey)) {\n          frame = getOwnFrame(routeFrames, connection.routeKey);\n        } else {\n          let encoding = fallbackEncodings.get(connection.outEvents);\n          if (!encoding) {\n            encoding = encodeWebSocketFrame(connection.outEvents, event, data);\n            fallbackEncodings.set(connection.outEvents, encoding);\n            record(encoding);\n          }\n          frame = encoding.status === \"encoded\" ? encoding.frame : undefined;\n        }\n\n        // 이벤트를 선언하지 않았거나 검증에 실패한 route의 연결은 닫지 않고 건너뛴다\n        if (frame !== undefined) {\n          localTargets.push({ connection, frame });\n        }\n      }\n\n      if (!declared) {\n        this.emitPublishRejected(event, \"unknownEvent\");\n      } else if (rejected) {\n        this.emitPublishRejected(event, \"invalidPayload\");\n      }\n\n      this.enqueueFanOut(localTargets, event);\n\n      if (Object.keys(routeFrames).length === 0) {\n        this.emitFanOutResolved(audience, localTargets.length, 0);\n        return Promise.resolve();\n      }\n\n      // 원격 라우팅(store 조회)은 앞선 publish를 기다리지 않고 지금 바로 시작한다. store가 멈춰도 버스트 비용이 N×T가 아닌 약 T다.\n      // 반면 envelope 발행은 노드 단위 큐에 이어 붙여 publish 순서를 지킨다. 뒤 publish의 라우팅이 먼저 끝나도 앞 발행을 기다린다\n      const routing = this.resolveRemoteNodeIds(audience, event);\n      const task = this.publishQueue\n        .then(() => routing)\n        .then((remoteNodeIds) =>\n          this.publishRemote(audience, event, routeFrames, localTargets.length, remoteNodeIds),\n        )\n        .catch((cause: unknown) => {\n          this.emitRouteFailed(event, audience, cause);\n        });\n      this.publishQueue = task;\n      return task;\n    } catch (cause) {\n      // 스키마 transform 예외 등 예상하지 못한 실패도 호출자에게 reject로 새지 않게 한다\n      this.emitRouteFailed(event, audience, cause);\n      return Promise.resolve();\n    }\n  }\n\n  // 진행 중인 publish(원격 포함)와 구독 시도가 모두 끝나면 resolve한다\n  async drainPublishes(): Promise<void> {\n    await Promise.all([this.publishQueue, this.subscription]);\n  }\n\n  /**\n   * 구독을 해제하고 cluster bus를 종료한다. 구독이 deadline까지 끝나지 않으면 늦게 끝날 때 해제한다.\n   */\n  async shutdown(deadline: Promise<void>): Promise<void> {\n    this.stopped = true;\n    this.unregisterMetricSource();\n\n    const unsubscribe = await Promise.race([this.subscription, deadline.then(() => null)]);\n    if (unsubscribe === null) {\n      this.subscription.then((lateUnsubscribe) => {\n        this.safeUnsubscribe(lateUnsubscribe);\n      });\n    } else {\n      this.safeUnsubscribe(unsubscribe);\n    }\n\n    try {\n      await Promise.resolve().then(() => this.options.clusterBus.shutdown());\n    } catch (cause) {\n      this.telemetry.emit({\n        name: \"ws.cluster.shutdown.failed\",\n        level: \"error\",\n        detail: { errorType: describeError(cause) },\n      });\n    }\n  }\n\n  getTelemetrySnapshot() {\n    let pendingFanOutTargets = 0;\n\n    for (const job of this.pendingFanOutJobs) {\n      pendingFanOutTargets += Math.max(job.targets.length - job.cursor, 0);\n    }\n\n    return {\n      pendingFanOutJobs: this.pendingFanOutJobs.length,\n      pendingFanOutTargets,\n    };\n  }\n\n  // 구독 실패는 로컬 전용 동작으로 수렴시키고 telemetry만 남긴다\n  private subscribe(): Promise<Unsubscribe | undefined> {\n    return Promise.resolve()\n      .then(() =>\n        this.options.clusterBus.subscribe((envelope) => {\n          this.handleClusterEnvelope(envelope);\n        }),\n      )\n      .then(\n        (unsubscribe) => unsubscribe,\n        (cause: unknown) => {\n          this.telemetry.emit({\n            name: \"ws.cluster.subscribe.failed\",\n            level: \"error\",\n            detail: { errorType: describeError(cause) },\n          });\n          return undefined;\n        },\n      );\n  }\n\n  private safeUnsubscribe(unsubscribe: Unsubscribe | undefined): void {\n    try {\n      unsubscribe?.();\n    } catch (cause) {\n      this.telemetry.emit({\n        name: \"ws.cluster.unsubscribe.failed\",\n        level: \"error\",\n        detail: { errorType: describeError(cause) },\n      });\n    }\n  }\n\n  // 라우팅 실패는 여기서 telemetry로 바꿔 undefined를 돌려준다. 즉시 catch를 붙이므로 큐 차례를 기다리는 동안에도 unhandled rejection이 생기지 않는다\n  private resolveRemoteNodeIds(\n    audience: WebSocketAudience,\n    event: string,\n  ): Promise<string[] | undefined> {\n    return this.options.audienceResolver.resolveRemoteNodeIds(audience).catch((cause: unknown) => {\n      this.emitRouteFailed(event, audience, cause);\n      return undefined;\n    });\n  }\n\n  private async publishRemote(\n    audience: WebSocketAudience,\n    event: string,\n    frames: Record<string, string>,\n    localTargetCount: number,\n    resolvedNodeIds: string[] | undefined,\n  ): Promise<void> {\n    // 라우팅 실패(undefined) 시 로컬 전달은 이미 끝났으므로 이 publish의 원격 envelope만 건너뛴다\n    const remoteNodeIds = resolvedNodeIds ?? [];\n    this.emitFanOutResolved(audience, localTargetCount, remoteNodeIds.length);\n    if (remoteNodeIds.length === 0) {\n      return;\n    }\n\n    const envelope: WebSocketClusterEnvelope = {\n      id: randomUUID(),\n      sourceNodeId: this.options.nodeId,\n      targetNodeIds: remoteNodeIds,\n      audience,\n      event,\n      frames,\n      emittedAt: Date.now(),\n    };\n\n    const publishStartedAt = performance.now();\n    try {\n      await Promise.resolve().then(() => this.options.clusterBus.publish(envelope));\n      const durationMs = performance.now() - publishStartedAt;\n      this.telemetry.emit({\n        name: \"ws.cluster.envelope.published\",\n        level: \"debug\",\n        detail: { event, targetNodeCount: remoteNodeIds.length },\n      });\n      this.telemetry.recordSpan({\n        operationName: \"ws.cluster.publish\",\n        kind: \"producer\",\n        durationMs,\n        status: \"unset\",\n        attributes: {\n          event,\n          targetNodeCount: remoteNodeIds.length,\n        },\n      });\n    } catch (cause) {\n      const durationMs = performance.now() - publishStartedAt;\n      this.telemetry.emit({\n        name: \"ws.cluster.envelope.failed\",\n        level: \"error\",\n        detail: { event },\n      });\n      this.telemetry.recordSpan({\n        operationName: \"ws.cluster.publish\",\n        kind: \"producer\",\n        durationMs,\n        status: \"error\",\n        attributes: { event },\n        errorType: describeError(cause),\n      });\n    }\n  }\n\n  // 수신 노드는 store 없이 자기 메모리로 audience를 해석하고, 각 연결의 route frame을 재검증 없이 그대로 보낸다\n  private handleClusterEnvelope(envelope: WebSocketClusterEnvelope): void {\n    if (this.stopped) {\n      return;\n    }\n\n    if (envelope.sourceNodeId === this.options.nodeId) {\n      this.telemetry.emit({\n        name: \"ws.cluster.envelope.ignored\",\n        level: \"debug\",\n        detail: { reason: \"selfSource\", event: envelope.event },\n      });\n      return;\n    }\n\n    if (\n      envelope.targetNodeIds.length > 0 &&\n      !envelope.targetNodeIds.includes(this.options.nodeId)\n    ) {\n      this.telemetry.emit({\n        name: \"ws.cluster.envelope.ignored\",\n        level: \"debug\",\n        detail: { reason: \"targetMismatch\", event: envelope.event },\n      });\n      return;\n    }\n\n    const startedAt = performance.now();\n    this.telemetry.emit({\n      name: \"ws.cluster.envelope.received\",\n      level: \"debug\",\n      detail: { event: envelope.event, sourceNodeId: envelope.sourceNodeId },\n    });\n\n    const localTargets: FanOutTarget[] = [];\n    for (const connection of this.options.localConnections.getConnections(\n      this.options.resolveLocalSessionIds(envelope.audience),\n    )) {\n      const frame =\n        connection.routeKey === undefined\n          ? undefined\n          : getOwnFrame(envelope.frames, connection.routeKey);\n      if (frame !== undefined) {\n        localTargets.push({ connection, frame });\n      }\n    }\n    this.enqueueFanOut(localTargets, envelope.event);\n\n    this.telemetry.recordSpan({\n      operationName: \"ws.cluster.receive\",\n      kind: \"consumer\",\n      durationMs: performance.now() - startedAt,\n      status: \"unset\",\n      attributes: {\n        event: envelope.event,\n        sourceNodeId: envelope.sourceNodeId,\n        localTargetCount: localTargets.length,\n      },\n    });\n  }\n\n  private emitPublishRejected(event: string, reason: \"unknownEvent\" | \"invalidPayload\"): void {\n    this.telemetry.emit({\n      name: \"ws.publish.rejected\",\n      level: \"error\",\n      detail: { event, reason },\n    });\n  }\n\n  private emitRouteFailed(event: string, audience: WebSocketAudience, cause: unknown): void {\n    this.telemetry.emit({\n      name: \"ws.fanout.route.failed\",\n      level: \"error\",\n      detail: { event, audienceType: audience.type, errorType: describeError(cause) },\n    });\n  }\n\n  private emitFanOutResolved(\n    audience: WebSocketAudience,\n    localTargetCount: number,\n    remoteNodeCount: number,\n  ): void {\n    this.telemetry.emit({\n      name: \"ws.fanout.resolved\",\n      level: \"debug\",\n      detail: { localTargetCount, remoteNodeCount },\n    });\n    this.telemetry.recordMetric({\n      name: \"sonamu.ws.fanout.targets\",\n      kind: \"histogram\",\n      value: localTargetCount + remoteNodeCount,\n      unit: \"1\",\n      tags: { audience_type: audience.type },\n    });\n  }\n\n  private enqueueFanOut(targets: FanOutTarget[], event: string): void {\n    if (targets.length === 0) {\n      return;\n    }\n\n    this.pendingFanOutJobs.push({\n      targets,\n      event,\n      cursor: 0,\n    });\n    this.telemetry.emit({\n      name: \"ws.fanout.enqueued\",\n      level: \"debug\",\n      detail: { targetCount: targets.length, event },\n    });\n    this.scheduleFanOutFlush();\n  }\n\n  private scheduleFanOutFlush(): void {\n    if (this.fanOutFlushScheduled) {\n      return;\n    }\n\n    this.fanOutFlushScheduled = true;\n    setImmediate(() => {\n      this.fanOutFlushScheduled = false;\n      this.flushFanOutJobs();\n    });\n  }\n\n  private flushFanOutJobs(): void {\n    const startedAt = performance.now();\n    let processed = 0;\n    let status: \"unset\" | \"error\" = \"unset\";\n    let errorType: string | undefined;\n\n    try {\n      while (this.pendingFanOutJobs.length > 0 && processed < FAN_OUT_BATCH_SIZE) {\n        const job = this.pendingFanOutJobs[0];\n\n        while (job.cursor < job.targets.length && processed < FAN_OUT_BATCH_SIZE) {\n          this.safeSend(job.targets[job.cursor], job.event);\n          job.cursor += 1;\n          processed += 1;\n        }\n\n        if (job.cursor >= job.targets.length) {\n          this.pendingFanOutJobs.shift();\n        }\n      }\n    } catch (error) {\n      status = \"error\";\n      errorType = describeError(error);\n      throw error;\n    } finally {\n      const durationMs = performance.now() - startedAt;\n      this.telemetry.emit({\n        name: \"ws.fanout.flushed\",\n        level: \"debug\",\n        detail: { processedCount: processed },\n      });\n      this.telemetry.recordSpan({\n        operationName: \"ws.fanout.dispatch\",\n        kind: \"internal\",\n        durationMs,\n        status,\n        attributes: { processedCount: processed },\n        errorType,\n      });\n\n      if (this.pendingFanOutJobs.length > 0) {\n        this.scheduleFanOutFlush();\n      }\n    }\n  }\n\n  private safeSend(target: FanOutTarget, event: string): void {\n    const { connection, frame } = target;\n    try {\n      if (!connection.closed) {\n        connection.sendFrame(event, frame);\n      }\n    } catch {\n      this.telemetry.emit({\n        name: \"ws.fanout.publish.failed\",\n        level: \"error\",\n        connectionId: connection.id,\n        namespace: connection.namespace,\n        userId: connection.userId,\n        detail: { event },\n      });\n      connection.close(1011, \"WebSocket publish failed\");\n    }\n  }\n}\n\n// 원격에서 온 frames는 prototype 키를 무시하고 자기 속성만 읽는다\nfunction getOwnFrame(frames: Record<string, string>, routeKey: string): string | undefined {\n  return Object.hasOwn(frames, routeKey) ? frames[routeKey] : undefined;\n}\n\nfunction describeError(cause: unknown): string {\n  return cause instanceof Error ? cause.name : runtimeTypeOf(cause);\n}\n"],"mappings":"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"}

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

@@ -0,0 +1,15 @@
+import { type z } from "zod";
+export type WebSocketFrameEncoding = {
+    status: "encoded";
+    frame: string;
+} | {
+    status: "unknownEvent";
+} | {
+    status: "invalidPayload";
+};
+/**
+ * outEvents 스키마로 payload를 검증하고 `{event, data}` frame 문자열로 인코딩한다.
+ * 같은 스키마로 인코딩한 frame은 로컬·원격 수신자 모두에게 같은 바이트로 전달된다.
+ */
+export declare function encodeWebSocketFrame<Data>(outEvents: z.ZodObject, event: string, data: Data): WebSocketFrameEncoding;
+//# sourceMappingURL=ws-frame.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"ws-frame.d.ts","sourceRoot":"","sources":["../../src/stream/ws-frame.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,CAAC,EAAE,MAAM,KAAK,CAAC;AAE7B,MAAM,MAAM,sBAAsB,GAC9B;IAAE,MAAM,EAAE,SAAS,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,GACpC;IAAE,MAAM,EAAE,cAAc,CAAA;CAAE,GAC1B;IAAE,MAAM,EAAE,gBAAgB,CAAA;CAAE,CAAC;AAEjC;;;GAGG;AACH,wBAAgB,oBAAoB,CAAC,IAAI,EACvC,SAAS,EAAE,CAAC,CAAC,SAAS,EACtB,KAAK,EAAE,MAAM,EACb,IAAI,EAAE,IAAI,GACT,sBAAsB,CAkBxB"}

package/dist/stream/ws-frame.js

@@ -0,0 +1,28 @@
+import { __esmMin } from "../_virtual/_rolldown/runtime.js";
+// src/stream/ws-frame.ts
+/**
+* outEvents 스키마로 payload를 검증하고 `{event, data}` frame 문자열로 인코딩한다.
+* 같은 스키마로 인코딩한 frame은 로컬·원격 수신자 모두에게 같은 바이트로 전달된다.
+*/
+function encodeWebSocketFrame(outEvents, event, data) {
+	const schema = getEventSchema(outEvents, event);
+	if (!schema) return { status: "unknownEvent" };
+	const parsed = schema.safeParse(data);
+	if (!parsed.success) return { status: "invalidPayload" };
+	return {
+		status: "encoded",
+		frame: JSON.stringify({
+			event,
+			data: parsed.data
+		})
+	};
+}
+function getEventSchema(outEvents, event) {
+	const eventSchemas = outEvents["shape"];
+	return Object.hasOwn(eventSchemas, event) ? eventSchemas[event] : void 0;
+}
+var init_ws_frame = __esmMin((() => {}));
+init_ws_frame();
+export { encodeWebSocketFrame, init_ws_frame };
+
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/dist/stream/ws-local-connection-store.d.ts

@@ -1,11 +1,11 @@
-import { type ManagedWebSocketConnection } from "./ws-core";
+import { type WebSocketFrameConnection } from "./ws-core";
 import { type WebSocketTelemetryConnectionSnapshot } from "./ws-telemetry";
 export declare class WebSocketLocalConnectionStore {
     private readonly connections;
-    register(connection: ManagedWebSocketConnection): void;
+    register(connection: WebSocketFrameConnection): void;
     unregister(connectionId: string): void;
-    getConnection(connectionId: string): ManagedWebSocketConnection | undefined;
-    getConnections(connectionIds: string[]): ManagedWebSocketConnection[];
+    getConnection(connectionId: string): WebSocketFrameConnection | undefined;
+    getConnections(connectionIds: string[]): WebSocketFrameConnection[];
     getTelemetrySnapshot(): WebSocketTelemetryConnectionSnapshot;
     closeAll(code?: number, reason?: string): void;
 }

package/dist/stream/ws-local-connection-store.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ws-local-connection-store.d.ts","sourceRoot":"","sources":["../../src/stream/ws-local-connection-store.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,KAAK,0BAA0B,EAAE,MAAM,WAAW,CAAC;AAC5D,OAAO,EACL,KAAK,oCAAoC,EAE1C,MAAM,gBAAgB,CAAC;AAExB,qBAAa,6BAA6B;IACxC,OAAO,CAAC,QAAQ,CAAC,WAAW,CAAiD;IAE7E,QAAQ,CAAC,UAAU,EAAE,0BAA0B,GAAG,IAAI,CAErD;IAED,UAAU,CAAC,YAAY,EAAE,MAAM,GAAG,IAAI,CAErC;IAED,aAAa,CAAC,YAAY,EAAE,MAAM,GAAG,0BAA0B,GAAG,SAAS,CAE1E;IAED,cAAc,CAAC,aAAa,EAAE,MAAM,EAAE,GAAG,0BAA0B,EAAE,CAmBpE;IAED,oBAAoB,IAAI,oCAAoC,CAmB3D;IAED,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,MAAM,GAAG,IAAI,CAI7C;CACF"}
+{"version":3,"file":"ws-local-connection-store.d.ts","sourceRoot":"","sources":["../../src/stream/ws-local-connection-store.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,KAAK,wBAAwB,EAAE,MAAM,WAAW,CAAC;AAC1D,OAAO,EACL,KAAK,oCAAoC,EAE1C,MAAM,gBAAgB,CAAC;AAExB,qBAAa,6BAA6B;IACxC,OAAO,CAAC,QAAQ,CAAC,WAAW,CAA+C;IAE3E,QAAQ,CAAC,UAAU,EAAE,wBAAwB,GAAG,IAAI,CAEnD;IAED,UAAU,CAAC,YAAY,EAAE,MAAM,GAAG,IAAI,CAErC;IAED,aAAa,CAAC,YAAY,EAAE,MAAM,GAAG,wBAAwB,GAAG,SAAS,CAExE;IAED,cAAc,CAAC,aAAa,EAAE,MAAM,EAAE,GAAG,wBAAwB,EAAE,CAmBlE;IAED,oBAAoB,IAAI,oCAAoC,CAmB3D;IAED,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,MAAM,GAAG,IAAI,CAK7C;CACF"}

package/dist/stream/ws-local-connection-store.js

@@ -1,6 +1,6 @@
 import { __esmMin } from "../_virtual/_rolldown/runtime.js";
 import { init_runtime_value, isFunctionValue } from "../utils/runtime-value.js";
-//#region src/stream/ws-local-connection-store.ts
+// src/stream/ws-local-connection-store.ts
 function isTelemetryInspectableConnection(connection) {
 	return "getTelemetrySnapshot" in connection && isFunctionValue(connection.getTelemetrySnapshot);
 }
@@ -46,12 +46,11 @@ var init_ws_local_connection_store = __esmMin((() => {
 			return snapshot;
 		}
 		closeAll(code, reason) {
-			for (const connection of this.connections.values()) connection.close(code, reason);
+			for (const connection of Array.from(this.connections.values())) connection.close(code, reason);
 		}
 	};
 }));
-//#endregion
 init_ws_local_connection_store();
 export { WebSocketLocalConnectionStore, init_ws_local_connection_store };
 
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,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
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/dist/stream/ws-presence-index.d.ts

@@ -0,0 +1,36 @@
+import { type WebSocketAudience } from "./ws-audience";
+import { type WebSocketRegistryStats, type WebSocketRoomId, type WebSocketUserId } from "./ws-core";
+import { type WebSocketPresenceRegistration, type WebSocketSessionPresence } from "./ws-presence-store";
+/**
+ * 동기 presence 인덱스. registry의 노드 로컬 메모리와 in-memory store가 함께 쓴다.
+ * 외부로 내보내는 presence는 항상 복사본이다.
+ */
+export declare class WebSocketPresenceIndex {
+    private readonly sessions;
+    private readonly rooms;
+    private readonly users;
+    has(sessionId: string): boolean;
+    register(input: WebSocketPresenceRegistration): void;
+    activate(sessionId: string): void;
+    unregister(sessionId: string): WebSocketSessionPresence | undefined;
+    touch(sessionId: string): void;
+    setUserId(sessionId: string, userId: WebSocketUserId): void;
+    clearUserId(sessionId: string): void;
+    join(sessionId: string, roomId: WebSocketRoomId): void;
+    leave(sessionId: string, roomId: WebSocketRoomId): void;
+    getConnection(sessionId: string): WebSocketSessionPresence | undefined;
+    getConnectionCount(namespace?: string): number;
+    getRoomMembers(roomId: WebSocketRoomId, namespace?: string): WebSocketSessionPresence[];
+    getRoomMemberCount(roomId: WebSocketRoomId, namespace?: string): number;
+    getStats(): WebSocketRegistryStats;
+    /**
+     * audience에 해당하는 활성 세션을 중복 없이 반환한다. 반환값은 내부 상태를 노출하지 않도록 ID와 노드 ID만 담는다.
+     */
+    queryAudience(audience: WebSocketAudience): Array<{
+        sessionId: string;
+        nodeId: string;
+    }>;
+    private collectAudience;
+    private getBoundSessions;
+}
+//# sourceMappingURL=ws-presence-index.d.ts.map