sonamu 0.9.8 → 0.9.10

package/dist/stream/ws.js

@@ -1,7 +1,10 @@
 import { __esmMin } from "../_virtual/rolldown_runtime.js";
+import { generateSpanId, init_ws_telemetry_trace, parseTraceParent } from "./ws-telemetry-trace.js";
+import { createWebSocketTelemetryController, init_ws_telemetry, isPromiseLike } from "./ws-telemetry.js";
 import { WebSocketRegistry, init_ws_registry } from "./ws-registry.js";
 import { z as z$1 } from "zod";
 import { randomUUID } from "node:crypto";
+import { hostname } from "node:os";
 
 //#region src/stream/ws.ts
 function createWebSocketRuntime(options = {}) {
@@ -37,19 +40,22 @@ function truncateCloseReason(reason) {
 	}
 	return Buffer.byteLength(reason, "utf-8") <= 123 ? reason : Buffer.from(reason).subarray(0, 123).toString("utf-8");
 }
-function isPromiseLike(value) {
-	return typeof value === "object" && value !== null && "then" in value && "catch" in value;
+function deriveLifetimeStatus(code) {
+	if (code === undefined) return "unset";
+	if (code === 1e3 || code === 1001) return "ok";
+	return "error";
 }
-var WS_CONNECTING, WS_OPEN, WS_CLOSED, WS_CLOSE_CODE_GOING_AWAY, WS_CLOSE_CODE_INVALID_FRAME_PAYLOAD_DATA, WS_CLOSE_CODE_POLICY_VIOLATION, WS_CLOSE_CODE_MESSAGE_TOO_BIG, WS_CLOSE_CODE_INTERNAL_ERROR, WS_CLOSE_CODE_TRY_AGAIN_LATER, MAX_PENDING_MESSAGES, MAX_PENDING_OUTBOUND_MESSAGES, MAX_SOCKET_BUFFERED_AMOUNT, OUTBOUND_BATCH_SIZE, OUTBOUND_RETRY_DELAY_MS, WebSocketEnvelopeSchema, WebSocketRuntime, WebSocketConnectionImpl;
+var WS_CONNECTING, WS_OPEN, WS_CLOSED, WS_CLOSE_CODE_GOING_AWAY, WS_CLOSE_CODE_INVALID_FRAME_PAYLOAD_DATA, WS_CLOSE_CODE_POLICY_VIOLATION, WS_CLOSE_CODE_INTERNAL_ERROR, WS_CLOSE_CODE_TRY_AGAIN_LATER, MAX_PENDING_MESSAGES, MAX_PENDING_OUTBOUND_MESSAGES, MAX_SOCKET_BUFFERED_AMOUNT, OUTBOUND_BATCH_SIZE, OUTBOUND_RETRY_DELAY_MS, WebSocketEnvelopeSchema, WebSocketRuntime, WebSocketConnectionImpl;
 var init_ws = __esmMin((() => {
 	init_ws_registry();
+	init_ws_telemetry();
+	init_ws_telemetry_trace();
 	WS_CONNECTING = 0;
 	WS_OPEN = 1;
 	WS_CLOSED = 3;
 	WS_CLOSE_CODE_GOING_AWAY = 1001;
 	WS_CLOSE_CODE_INVALID_FRAME_PAYLOAD_DATA = 1007;
 	WS_CLOSE_CODE_POLICY_VIOLATION = 1008;
-	WS_CLOSE_CODE_MESSAGE_TOO_BIG = 1009;
 	WS_CLOSE_CODE_INTERNAL_ERROR = 1011;
 	WS_CLOSE_CODE_TRY_AGAIN_LATER = 1013;
 	MAX_PENDING_MESSAGES = 100;
@@ -59,22 +65,34 @@ var init_ws = __esmMin((() => {
 	OUTBOUND_RETRY_DELAY_MS = 5;
 	WebSocketEnvelopeSchema = z$1.object({
 		event: z$1.string(),
-		data: z$1.unknown()
+		data: z$1.unknown(),
+		meta: z$1.object({
+			traceparent: z$1.string().optional(),
+			tracestate: z$1.string().optional()
+		}).optional()
 	});
 	WebSocketRuntime = class {
 		registry;
+		telemetryController;
 		constructor(options = {}) {
+			const resolvedNodeId = options.nodeId ?? `${hostname()}-${process.pid}`;
+			this.telemetryController = createWebSocketTelemetryController(options.telemetry, {
+				runtimeId: randomUUID(),
+				nodeId: resolvedNodeId
+			});
 			const registryOptions = {
-				nodeId: options.nodeId,
+				nodeId: resolvedNodeId,
 				presenceStore: options.presenceStore,
-				clusterBus: options.clusterBus
+				clusterBus: options.clusterBus,
+				telemetryController: this.telemetryController
 			};
 			this.registry = new WebSocketRegistry(registryOptions);
 		}
 		registerConnection(socket, options) {
 			return new WebSocketConnectionImpl(socket, {
 				...options,
-				registry: this.registry
+				registry: this.registry,
+				telemetryController: this.telemetryController
 			});
 		}
 		activateConnection(connectionId) {
@@ -94,6 +112,7 @@ var init_ws = __esmMin((() => {
 		}
 		async shutdown(code = WS_CLOSE_CODE_GOING_AWAY, reason = "Server shutting down") {
 			await this.registry.shutdown(code, reason);
+			await this.telemetryController.shutdown();
 		}
 	};
 	WebSocketConnectionImpl = class {
@@ -107,9 +126,17 @@ var init_ws = __esmMin((() => {
 		closePromise;
 		resolveClosePromise;
 		heartbeatMs;
-		maxPayload;
 		eventSchemasIn;
 		eventSchemasOut;
+		connectionTraceId;
+		connectionSpanId;
+		connectionParentSpanId;
+		connectionSampled;
+		connectionStartedAt = performance.now();
+		_userId;
+		get userId() {
+			return this._userId;
+		}
 		closedInternal = false;
 		closeStarted = false;
 		awaitingPong = false;
@@ -121,7 +148,10 @@ var init_ws = __esmMin((() => {
 			this.options = options;
 			this.namespace = options.namespace ?? "default";
 			this.heartbeatMs = options.heartbeat ?? 3e4;
-			this.maxPayload = options.maxPayload;
+			this.connectionTraceId = options.traceId;
+			this.connectionSpanId = options.spanId;
+			this.connectionParentSpanId = options.parentSpanId;
+			this.connectionSampled = options.sampled;
 			this.eventSchemasIn = options.inEvents.shape;
 			this.eventSchemasOut = options.outEvents.shape;
 			let resolveClosePromise;
@@ -165,11 +195,62 @@ var init_ws = __esmMin((() => {
 			this.options.registry.leave(this.id, roomId);
 		}
 		setUserId(userId) {
+			this._userId = String(userId);
 			this.options.registry.setUserId(this.id, userId);
 		}
 		clearUserId() {
+			this._userId = undefined;
 			this.options.registry.clearUserId(this.id);
 		}
+		getTelemetrySnapshot() {
+			return {
+				pendingInboundMessages: this.pendingMessages.length,
+				pendingOutboundMessages: this.pendingOutboundMessages.length,
+				socketBufferedBytes: this.socket.readyState === WS_OPEN ? this.socket.bufferedAmount : 0
+			};
+		}
+		getTelemetryContext() {
+			return {
+				traceId: this.connectionTraceId,
+				spanId: this.connectionSpanId,
+				parentSpanId: this.connectionParentSpanId,
+				sampled: this.connectionSampled
+			};
+		}
+		telemetryFields() {
+			return {
+				connectionId: this.id,
+				namespace: this.namespace,
+				userId: this._userId,
+				traceId: this.connectionTraceId,
+				spanId: this.connectionSpanId,
+				parentSpanId: this.connectionParentSpanId,
+				sampled: this.connectionSampled
+			};
+		}
+		emitInboundRejected(reason, event) {
+			const fields = this.telemetryFields();
+			this.options.telemetryController.emit({
+				name: "ws.message.rejected",
+				level: "warn",
+				...fields,
+				detail: event !== undefined ? {
+					reason,
+					event
+				} : { reason }
+			});
+			this.options.telemetryController.recordMetric({
+				name: "sonamu.ws.messages",
+				kind: "counter",
+				value: 1,
+				unit: "1",
+				tags: {
+					direction: "inbound",
+					outcome: "rejected"
+				},
+				...fields
+			});
+		}
 		close(code, reason) {
 			if (this.closedInternal || this.closeStarted || this.socket.readyState === WS_CLOSED) {
 				return;
@@ -178,27 +259,32 @@ var init_ws = __esmMin((() => {
 			try {
 				this.closeTransport(code, reason);
 			} finally {
-				this.markClosed();
+				this.markClosed(code, reason);
 			}
 		}
 		handleMessage = (raw) => {
 			this.enqueueMessageTask(async () => {
 				const text = normalizeMessage(raw);
-				if (this.maxPayload !== undefined && Buffer.byteLength(text) > this.maxPayload) {
-					this.close(WS_CLOSE_CODE_MESSAGE_TOO_BIG, "Message too large");
-					return;
-				}
 				const parsedEnvelope = safeParseEnvelope(text);
 				if (!parsedEnvelope) {
+					this.emitInboundRejected("invalidPayload");
 					this.close(WS_CLOSE_CODE_INVALID_FRAME_PAYLOAD_DATA, "Invalid message payload");
 					return;
 				}
+				this.options.telemetryController.emit({
+					name: "ws.message.received",
+					level: "debug",
+					...this.telemetryFields(),
+					detail: { event: parsedEnvelope.event },
+					payload: parsedEnvelope.data
+				});
 				this.options.registry.touch(this.id);
 				await this.dispatchEnvelope(parsedEnvelope);
 			});
 		};
-		handleClose = () => {
-			this.markClosed();
+		handleClose = (code, reason) => {
+			const reasonText = typeof reason === "string" ? reason : reason?.toString();
+			this.markClosed(code, reasonText);
 		};
 		handleError = () => {
 			this.close(WS_CLOSE_CODE_INTERNAL_ERROR, "WebSocket transport error");
@@ -207,27 +293,108 @@ var init_ws = __esmMin((() => {
 			this.awaitingPong = false;
 			this.options.registry.touch(this.id);
 		};
+		resolveMessageTraceContext(envelope) {
+			const messageSpanId = generateSpanId();
+			if (this.options.telemetryController.getTraceOptions().propagateMessageTrace && envelope.meta?.traceparent) {
+				const parsed = parseTraceParent(envelope.meta.traceparent);
+				if (parsed) {
+					return {
+						traceId: parsed.traceId,
+						spanId: messageSpanId,
+						parentSpanId: parsed.parentId,
+						sampled: parsed.sampled
+					};
+				}
+				this.options.telemetryController.emit({
+					name: "ws.trace.invalid",
+					level: "debug",
+					...this.telemetryFields(),
+					detail: {
+						source: "message",
+						traceparent: envelope.meta.traceparent
+					}
+				});
+			}
+			return {
+				traceId: this.connectionTraceId,
+				spanId: messageSpanId,
+				parentSpanId: this.connectionSpanId ?? this.connectionParentSpanId,
+				sampled: this.connectionSampled
+			};
+		}
 		async dispatchEnvelope(envelope) {
 			const handlers = this.messageHandlers.get(envelope.event);
 			const schema = this.eventSchemasIn[envelope.event];
 			if (!schema) {
+				this.emitInboundRejected("unknownEvent", envelope.event);
 				this.close(WS_CLOSE_CODE_POLICY_VIOLATION, "Unknown event");
 				return;
 			}
 			const parsed = schema.safeParse(envelope.data);
 			if (!parsed.success) {
+				this.emitInboundRejected("invalidData", envelope.event);
 				this.close(WS_CLOSE_CODE_INVALID_FRAME_PAYLOAD_DATA, "Invalid event data");
 				return;
 			}
 			if (!handlers || handlers.length === 0) {
 				if (this.pendingMessages.length >= MAX_PENDING_MESSAGES) {
+					this.options.telemetryController.emit({
+						name: "ws.message.buffer.dropped",
+						level: "warn",
+						...this.telemetryFields(),
+						detail: { event: envelope.event }
+					});
 					this.pendingMessages.shift();
 				}
 				this.pendingMessages.push(envelope);
+				this.options.telemetryController.emit({
+					name: "ws.message.buffered",
+					level: "debug",
+					...this.telemetryFields(),
+					detail: { event: envelope.event }
+				});
 				return;
 			}
-			for (const handler of handlers) {
-				await handler(parsed.data);
+			const traceCtx = this.resolveMessageTraceContext(envelope);
+			const messageTraceFields = {
+				connectionId: this.id,
+				namespace: this.namespace,
+				userId: this._userId,
+				traceId: traceCtx.traceId,
+				spanId: traceCtx.spanId,
+				parentSpanId: traceCtx.parentSpanId,
+				sampled: traceCtx.sampled
+			};
+			try {
+				for (const handler of handlers) {
+					await handler(parsed.data, traceCtx);
+				}
+				this.options.telemetryController.emit({
+					name: "ws.message.dispatched",
+					level: "debug",
+					...messageTraceFields,
+					detail: { event: envelope.event }
+				});
+				this.options.telemetryController.recordMetric({
+					name: "sonamu.ws.messages",
+					kind: "counter",
+					value: 1,
+					unit: "1",
+					tags: {
+						direction: "inbound",
+						event: envelope.event,
+						outcome: "accepted"
+					},
+					...messageTraceFields
+				});
+			} catch (error) {
+				this.options.telemetryController.emit({
+					name: "ws.message.failed",
+					level: "error",
+					...messageTraceFields,
+					detail: { event: envelope.event }
+				});
+				throw error;
 			}
 		}
 		flushPendingMessages(event) {
@@ -251,27 +418,69 @@ var init_ws = __esmMin((() => {
 		publishValidated(event, data) {
 			const schema = this.eventSchemasOut[event];
 			if (!schema) {
+				this.options.telemetryController.emit({
+					name: "ws.publish.rejected",
+					level: "error",
+					...this.telemetryFields(),
+					detail: {
+						event,
+						reason: "unknownEvent"
+					}
+				});
 				throw new Error(`Unknown websocket event: ${event}`);
 			}
 			const parsed = schema.safeParse(data);
 			if (!parsed.success) {
+				this.options.telemetryController.emit({
+					name: "ws.publish.rejected",
+					level: "error",
+					...this.telemetryFields(),
+					detail: {
+						event,
+						reason: "invalidPayload"
+					}
+				});
 				throw new Error(`Invalid websocket event payload: ${event}`);
 			}
 			if (this.closedInternal || this.socket.readyState !== WS_OPEN) {
+				this.options.telemetryController.emit({
+					name: "ws.publish.dropped",
+					level: "debug",
+					...this.telemetryFields(),
+					detail: {
+						event,
+						reason: "connectionClosed"
+					}
+				});
 				return;
 			}
 			this.enqueueOutboundMessage(JSON.stringify({
 				event,
 				data: parsed.data
-			}));
+			}), event, parsed.data);
 		}
-		markClosed() {
+		markClosed(code, _reason) {
 			if (this.closedInternal) {
 				return;
 			}
 			this.closedInternal = true;
 			this.closeStarted = false;
 			this.stopHeartbeat();
+			const fields = this.telemetryFields();
+			this.options.telemetryController.emit({
+				name: "ws.connection.closed",
+				level: "info",
+				...fields
+			});
+			if (this.options.telemetryController.getTraceOptions().recordConnectionLifetimeSpan) {
+				this.options.telemetryController.recordSpan({
+					operationName: "ws.connection.lifetime",
+					kind: "server",
+					durationMs: performance.now() - this.connectionStartedAt,
+					status: deriveLifetimeStatus(code),
+					...fields
+				});
+			}
 			this.socket.off("message", this.handleMessage);
 			this.socket.off("close", this.handleClose);
 			this.socket.off("error", this.handleError);
@@ -299,6 +508,11 @@ var init_ws = __esmMin((() => {
 					return;
 				}
 				if (this.awaitingPong) {
+					this.options.telemetryController.emit({
+						name: "ws.heartbeat.timeout",
+						level: "warn",
+						...this.telemetryFields()
+					});
 					this.close(WS_CLOSE_CODE_GOING_AWAY, "Heartbeat timeout");
 					return;
 				}
@@ -336,12 +550,27 @@ var init_ws = __esmMin((() => {
 				this.close(WS_CLOSE_CODE_INTERNAL_ERROR, "Message handling failed");
 			});
 		}
-		enqueueOutboundMessage(payload) {
+		enqueueOutboundMessage(payload, event, data) {
 			if (this.pendingOutboundMessages.length >= MAX_PENDING_OUTBOUND_MESSAGES) {
+				this.options.telemetryController.emit({
+					name: "ws.backpressure.overflow",
+					level: "error",
+					...this.telemetryFields()
+				});
 				this.close(WS_CLOSE_CODE_TRY_AGAIN_LATER, "WebSocket backpressure overflow");
 				return;
 			}
-			this.pendingOutboundMessages.push(payload);
+			this.pendingOutboundMessages.push({
+				payload,
+				event
+			});
+			this.options.telemetryController.emit({
+				name: "ws.publish.queued",
+				level: "debug",
+				...this.telemetryFields(),
+				detail: { event },
+				payload: data
+			});
 			this.scheduleOutboundFlush();
 		}
 		scheduleOutboundFlush(delayMs = 0) {
@@ -364,18 +593,68 @@ var init_ws = __esmMin((() => {
 				return;
 			}
 			if (this.socket.bufferedAmount > MAX_SOCKET_BUFFERED_AMOUNT) {
+				this.options.telemetryController.emit({
+					name: "ws.backpressure.delayed",
+					level: "warn",
+					...this.telemetryFields()
+				});
 				this.scheduleOutboundFlush(OUTBOUND_RETRY_DELAY_MS);
 				return;
 			}
 			let sent = 0;
 			while (sent < OUTBOUND_BATCH_SIZE && this.pendingOutboundMessages.length > 0 && this.socket.readyState === WS_OPEN) {
-				const payload = this.pendingOutboundMessages.shift();
-				if (!payload) {
+				const next = this.pendingOutboundMessages.shift();
+				if (!next) {
 					break;
 				}
+				const { payload, event } = next;
+				const startedAt = performance.now();
+				const fields = this.telemetryFields();
 				try {
 					this.socket.send(payload);
-				} catch {
+					const durationMs = performance.now() - startedAt;
+					this.options.telemetryController.emit({
+						name: "ws.publish.sent",
+						level: "debug",
+						...fields,
+						detail: { event }
+					});
+					this.options.telemetryController.recordSpan({
+						operationName: "ws.publish.send",
+						kind: "producer",
+						durationMs,
+						status: "unset",
+						...fields,
+						attributes: { event }
+					});
+					this.options.telemetryController.recordMetric({
+						name: "sonamu.ws.publishes",
+						kind: "counter",
+						value: 1,
+						unit: "1",
+						tags: {
+							outcome: "sent",
+							event
+						},
+						...fields
+					});
+				} catch (error) {
+					const durationMs = performance.now() - startedAt;
+					this.options.telemetryController.emit({
+						name: "ws.publish.failed",
+						level: "error",
+						...fields,
+						detail: { event }
+					});
+					this.options.telemetryController.recordSpan({
+						operationName: "ws.publish.send",
+						kind: "producer",
+						durationMs,
+						status: "error",
+						...fields,
+						attributes: { event },
+						errorType: error instanceof Error ? error.name : typeof error
+					});
 					this.close(WS_CLOSE_CODE_INTERNAL_ERROR, "Outbound publish failed");
 					return;
 				}
@@ -394,4 +673,4 @@ var init_ws = __esmMin((() => {
 //#endregion
 init_ws();
 export { WebSocketRuntime, createWebSocketRuntime, init_ws };
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"ws.js","names":["z","registryOptions: WebSocketRegistryOptions","socket: WebSocket","options: WebSocketConnectionOptions<TOutSchema, TInSchema>","resolveClosePromise!: () => void","remaining: ParsedEnvelope[]","toFlush: ParsedEnvelope[]"],"sources":["../../src/stream/ws.ts"],"sourcesContent":["import { randomUUID } from \"node:crypto\";\n\nimport { type WebSocket } from \"ws\";\nimport { z } from \"zod\";\n\nimport { type WebSocketAudience } from \"./ws-audience\";\nimport { type WebSocketClusterBus } from \"./ws-cluster-bus\";\nimport { type WebSocketPresenceStore } from \"./ws-presence-store\";\nimport {\n  type ManagedWebSocketConnection,\n  WebSocketRegistry,\n  type WebSocketRegistryOptions,\n  type WebSocketRoomId,\n  type WebSocketUserId,\n} from \"./ws-registry\";\n\n// transport-level 상수와 queue threshold를 한 파일에 모아 lifecycle/backpressure 정책을 중앙화함\nconst WS_CONNECTING = 0;\nconst WS_OPEN = 1;\nconst WS_CLOSED = 3;\n// RFC 6455 close codes used by Sonamu's WebSocket runtime.\nconst WS_CLOSE_CODE_GOING_AWAY = 1001;\nconst WS_CLOSE_CODE_INVALID_FRAME_PAYLOAD_DATA = 1007;\nconst WS_CLOSE_CODE_POLICY_VIOLATION = 1008;\nconst WS_CLOSE_CODE_MESSAGE_TOO_BIG = 1009;\nconst WS_CLOSE_CODE_INTERNAL_ERROR = 1011;\nconst WS_CLOSE_CODE_TRY_AGAIN_LATER = 1013;\nconst MAX_PENDING_MESSAGES = 100;\nconst MAX_PENDING_OUTBOUND_MESSAGES = 1_000;\nconst MAX_SOCKET_BUFFERED_AMOUNT = 1_048_576;\nconst OUTBOUND_BATCH_SIZE = 50;\nconst OUTBOUND_RETRY_DELAY_MS = 5;\n\n// envelope을 `{event, data}` 형태로 고정해 server handler와 generated client가 같은 framing contract를 쓰게 함\nconst WebSocketEnvelopeSchema = z.object({\n  event: z.string(),\n  data: z.unknown(),\n});\n\ntype MessageHandler<T> = (data: T) => void | Promise<void>;\ntype CloseHandler = () => void | Promise<void>;\n\nexport type WebSocketEventMap = Record<string, unknown>;\n\ntype InferWebSocketEventMap<TSchema extends z.ZodRawShape> = z.infer<z.ZodObject<TSchema>>;\n\nexport type WebSocketOutEvents<TOut extends WebSocketEventMap = WebSocketEventMap> = TOut;\n\nexport type WebSocketInEvents<TIn extends WebSocketEventMap = WebSocketEventMap> = TIn;\n\nexport interface WebSocketConnection<\n  TOut extends WebSocketEventMap = WebSocketEventMap,\n  TIn extends WebSocketEventMap = WebSocketEventMap,\n> extends ManagedWebSocketConnection {\n  transport: \"ws\";\n  onClose(callback: CloseHandler): void;\n  onMessage<K extends keyof WebSocketInEvents<TIn>>(\n    event: K,\n    handler: MessageHandler<WebSocketInEvents<TIn>[K]>,\n  ): void;\n  publish<K extends keyof WebSocketOutEvents<TOut>>(\n    event: K,\n    data: WebSocketOutEvents<TOut>[K],\n  ): void;\n  waitForClose(): Promise<void>;\n  join(roomId: WebSocketRoomId): void;\n  leave(roomId: WebSocketRoomId): void;\n  setUserId(userId: WebSocketUserId): void;\n  clearUserId(): void;\n}\n\nexport type AnyWebSocketConnection = WebSocketConnection<WebSocketEventMap, WebSocketEventMap>;\n\ntype ParsedEnvelope = z.infer<typeof WebSocketEnvelopeSchema>;\n\ntype WebSocketConnectionOptions<TOut extends z.ZodRawShape, TIn extends z.ZodRawShape> = {\n  namespace?: string;\n  heartbeat?: number;\n  maxPayload?: number;\n  active?: boolean;\n  outEvents: z.ZodObject<TOut>;\n  inEvents: z.ZodObject<TIn>;\n  registry: WebSocketRegistry;\n};\n\nexport type WebSocketRuntimeOptions = {\n  nodeId?: string;\n  presenceStore?: WebSocketPresenceStore;\n  clusterBus?: WebSocketClusterBus;\n};\n\n// registry를 소유하고 connection 생성/shutdown을 담당함. Sonamu 애플리케이션 수명주기와 같이 움직이도록 설계함\nexport class WebSocketRuntime {\n  readonly registry: WebSocketRegistry;\n\n  constructor(options: WebSocketRuntimeOptions = {}) {\n    const registryOptions: WebSocketRegistryOptions = {\n      nodeId: options.nodeId,\n      presenceStore: options.presenceStore,\n      clusterBus: options.clusterBus,\n    };\n    this.registry = new WebSocketRegistry(registryOptions);\n  }\n\n  registerConnection<TOutSchema extends z.ZodRawShape, TInSchema extends z.ZodRawShape>(\n    socket: WebSocket,\n    options: Omit<WebSocketConnectionOptions<TOutSchema, TInSchema>, \"registry\">,\n  ): WebSocketConnection<InferWebSocketEventMap<TOutSchema>, InferWebSocketEventMap<TInSchema>> {\n    return new WebSocketConnectionImpl(socket, {\n      ...options,\n      registry: this.registry,\n    });\n  }\n\n  activateConnection(connectionId: string): void {\n    this.registry.activate(connectionId);\n  }\n\n  broadcast(event: string, data: unknown, namespace?: string): void {\n    this.registry.broadcast(event, data, namespace);\n  }\n\n  publishToRoom(roomId: WebSocketRoomId, event: string, data: unknown, namespace?: string): void {\n    this.registry.publishToRoom(roomId, event, data, namespace);\n  }\n\n  publishToUser(userId: WebSocketUserId, event: string, data: unknown, namespace?: string): void {\n    this.registry.publishToUser(userId, event, data, namespace);\n  }\n\n  publishToAudience(audience: WebSocketAudience, event: string, data: unknown): void {\n    this.registry.publishToAudience(audience, event, data);\n  }\n\n  // 프로세스 종료 시 살아있는 연결이 남지 않도록 registry를 순회해 일괄 종료함\n  async shutdown(\n    code: number = WS_CLOSE_CODE_GOING_AWAY,\n    reason = \"Server shutting down\",\n  ): Promise<void> {\n    await this.registry.shutdown(code, reason);\n  }\n}\n\nexport function createWebSocketRuntime(options: WebSocketRuntimeOptions = {}): WebSocketRuntime {\n  return new WebSocketRuntime(options);\n}\n\nclass WebSocketConnectionImpl<\n  TOutSchema extends z.ZodRawShape,\n  TInSchema extends z.ZodRawShape,\n> implements WebSocketConnection<\n  InferWebSocketEventMap<TOutSchema>,\n  InferWebSocketEventMap<TInSchema>\n> {\n  readonly id = randomUUID();\n  readonly transport = \"ws\";\n  readonly namespace: string;\n\n  private readonly closeCallbacks: CloseHandler[] = [];\n  private readonly messageHandlers = new Map<string, Array<MessageHandler<unknown>>>();\n  private readonly pendingMessages: ParsedEnvelope[] = [];\n  private readonly pendingOutboundMessages: string[] = [];\n  private readonly closePromise: Promise<void>;\n  private readonly resolveClosePromise: () => void;\n  private readonly heartbeatMs: number;\n  private readonly maxPayload?: number;\n  private readonly eventSchemasIn: Record<string, z.ZodTypeAny>;\n  private readonly eventSchemasOut: Record<string, z.ZodTypeAny>;\n\n  private closedInternal = false;\n  private closeStarted = false;\n  private awaitingPong = false;\n  private heartbeatTimer: ReturnType<typeof setInterval> | null = null;\n  private messageQueue: Promise<void> = Promise.resolve();\n  private outboundFlushScheduled = false;\n\n  constructor(\n    private readonly socket: WebSocket,\n    private readonly options: WebSocketConnectionOptions<TOutSchema, TInSchema>,\n  ) {\n    this.namespace = options.namespace ?? \"default\";\n    this.heartbeatMs = options.heartbeat ?? 30000;\n    this.maxPayload = options.maxPayload;\n    this.eventSchemasIn = options.inEvents.shape as unknown as Record<string, z.ZodTypeAny>;\n    this.eventSchemasOut = options.outEvents.shape as unknown as Record<string, z.ZodTypeAny>;\n\n    let resolveClosePromise!: () => void;\n    this.closePromise = new Promise<void>((resolve) => {\n      resolveClosePromise = resolve;\n    });\n    this.resolveClosePromise = resolveClosePromise;\n\n    this.options.registry.register(this, options.active ?? true);\n    this.socket.on(\"message\", this.handleMessage);\n    this.socket.on(\"close\", this.handleClose);\n    this.socket.on(\"error\", this.handleError);\n    this.socket.on(\"pong\", this.handlePong);\n    this.startHeartbeat();\n  }\n\n  get closed(): boolean {\n    return this.closedInternal;\n  }\n\n  onClose(callback: CloseHandler): void {\n    this.closeCallbacks.push(callback);\n  }\n\n  onMessage<K extends keyof InferWebSocketEventMap<TInSchema>>(\n    event: K,\n    handler: MessageHandler<InferWebSocketEventMap<TInSchema>[K]>,\n  ): void {\n    const eventKey = String(event);\n    const handlers = this.messageHandlers.get(eventKey) ?? [];\n    handlers.push(handler as MessageHandler<unknown>);\n    this.messageHandlers.set(eventKey, handlers);\n    this.flushPendingMessages(eventKey);\n  }\n\n  publish<K extends keyof InferWebSocketEventMap<TOutSchema>>(\n    event: K,\n    data: InferWebSocketEventMap<TOutSchema>[K],\n  ): void {\n    this.publishValidated(String(event), data);\n  }\n\n  publishUntyped(event: string, data: unknown): void {\n    this.publishValidated(event, data);\n  }\n\n  waitForClose(): Promise<void> {\n    return this.closePromise;\n  }\n\n  join(roomId: WebSocketRoomId): void {\n    this.options.registry.join(this.id, roomId);\n  }\n\n  leave(roomId: WebSocketRoomId): void {\n    this.options.registry.leave(this.id, roomId);\n  }\n\n  setUserId(userId: WebSocketUserId): void {\n    this.options.registry.setUserId(this.id, userId);\n  }\n\n  clearUserId(): void {\n    this.options.registry.clearUserId(this.id);\n  }\n\n  // transport 종료 도중 예외가 나도 markClosed가 반드시 실행되도록 try/finally로 감쌈\n  close(code?: number, reason?: string): void {\n    if (this.closedInternal || this.closeStarted || this.socket.readyState === WS_CLOSED) {\n      return;\n    }\n\n    this.closeStarted = true;\n    try {\n      this.closeTransport(code, reason);\n    } finally {\n      this.markClosed();\n    }\n  }\n\n  // 인바운드 메시지를 순차 처리 큐에 올림. payload size → envelope 파싱 순으로 transport 레벨 검증을 우선 수행함\n  private readonly handleMessage = (raw: unknown) => {\n    this.enqueueMessageTask(async () => {\n      const text = normalizeMessage(raw);\n      if (this.maxPayload !== undefined && Buffer.byteLength(text) > this.maxPayload) {\n        this.close(WS_CLOSE_CODE_MESSAGE_TOO_BIG, \"Message too large\");\n        return;\n      }\n\n      const parsedEnvelope = safeParseEnvelope(text);\n      if (!parsedEnvelope) {\n        this.close(WS_CLOSE_CODE_INVALID_FRAME_PAYLOAD_DATA, \"Invalid message payload\");\n        return;\n      }\n\n      this.options.registry.touch(this.id);\n      await this.dispatchEnvelope(parsedEnvelope);\n    });\n  };\n\n  private readonly handleClose = () => {\n    this.markClosed();\n  };\n\n  // 소켓이 transport error를 emit하면 즉시 1011 close로 수렴시켜 상태 누락을 막음\n  private readonly handleError = () => {\n    this.close(WS_CLOSE_CODE_INTERNAL_ERROR, \"WebSocket transport error\");\n  };\n\n  private readonly handlePong = () => {\n    this.awaitingPong = false;\n    this.options.registry.touch(this.id);\n  };\n\n  // event 존재 여부 → schema 검증 → handler 실행 순으로 분기함\n  // handler가 아직 등록되지 않은 초기 메시지는 버퍼에 보관했다가 onMessage 등록 시 flush함\n  // handler는 `await`으로 순차 실행해 한 connection 안의 메시지 순서를 보장함\n  private async dispatchEnvelope(envelope: ParsedEnvelope): Promise<void> {\n    const handlers = this.messageHandlers.get(envelope.event);\n    const schema = this.eventSchemasIn[envelope.event];\n\n    if (!schema) {\n      this.close(WS_CLOSE_CODE_POLICY_VIOLATION, \"Unknown event\");\n      return;\n    }\n\n    const parsed = schema.safeParse(envelope.data);\n    if (!parsed.success) {\n      this.close(WS_CLOSE_CODE_INVALID_FRAME_PAYLOAD_DATA, \"Invalid event data\");\n      return;\n    }\n\n    if (!handlers || handlers.length === 0) {\n      if (this.pendingMessages.length >= MAX_PENDING_MESSAGES) {\n        this.pendingMessages.shift();\n      }\n      this.pendingMessages.push(envelope);\n      return;\n    }\n\n    for (const handler of handlers) {\n      await handler(parsed.data);\n    }\n  }\n\n  private flushPendingMessages(event: string): void {\n    const remaining: ParsedEnvelope[] = [];\n    const toFlush: ParsedEnvelope[] = [];\n\n    for (const message of this.pendingMessages) {\n      if (message.event !== event) {\n        remaining.push(message);\n        continue;\n      }\n\n      toFlush.push(message);\n    }\n\n    this.pendingMessages.length = 0;\n    this.pendingMessages.push(...remaining);\n\n    for (const message of toFlush) {\n      this.enqueueMessageTask(async () => {\n        await this.dispatchEnvelope(message);\n      });\n    }\n  }\n\n  private publishValidated(event: string, data: unknown): void {\n    const schema = this.eventSchemasOut[event];\n    if (!schema) {\n      throw new Error(`Unknown websocket event: ${event}`);\n    }\n\n    const parsed = schema.safeParse(data);\n    if (!parsed.success) {\n      throw new Error(`Invalid websocket event payload: ${event}`);\n    }\n\n    if (this.closedInternal || this.socket.readyState !== WS_OPEN) {\n      return;\n    }\n\n    this.enqueueOutboundMessage(\n      JSON.stringify({\n        event,\n        data: parsed.data,\n      }),\n    );\n  }\n\n  // listener 해제 / heartbeat 중단 / pending queue 비움 / registry unregister / onClose 실행 / waitForClose resolve 을 한 곳에 모아 원자적으로 처리함\n  // async onClose가 reject해도 unhandled rejection으로 새지 않도록 catch로 격리함\n  private markClosed(): void {\n    if (this.closedInternal) {\n      return;\n    }\n\n    this.closedInternal = true;\n    this.closeStarted = false;\n    this.stopHeartbeat();\n    this.socket.off(\"message\", this.handleMessage);\n    this.socket.off(\"close\", this.handleClose);\n    this.socket.off(\"error\", this.handleError);\n    this.socket.off(\"pong\", this.handlePong);\n    this.awaitingPong = false;\n    this.pendingMessages.length = 0;\n    this.pendingOutboundMessages.length = 0;\n    this.options.registry.unregister(this.id);\n    for (const callback of this.closeCallbacks.splice(0)) {\n      try {\n        const result = callback();\n        if (isPromiseLike(result)) {\n          void result.catch(() => {\n            // async close callbacks must not escape as unhandled rejections\n          });\n        }\n      } catch {\n        // close callbacks must not block transport cleanup\n      }\n    }\n    this.resolveClosePromise();\n  }\n\n  // pong이 오지 않은 상태에서 다음 tick이 오면 timeout close로 처리해 zombie connection을 정리함\n  private startHeartbeat(): void {\n    if (this.heartbeatMs <= 0) {\n      return;\n    }\n\n    this.heartbeatTimer = setInterval(() => {\n      if (this.closedInternal || this.socket.readyState !== WS_OPEN) {\n        return;\n      }\n\n      if (this.awaitingPong) {\n        this.close(WS_CLOSE_CODE_GOING_AWAY, \"Heartbeat timeout\");\n        return;\n      }\n\n      this.awaitingPong = true;\n      this.socket.ping();\n    }, this.heartbeatMs);\n  }\n\n  private stopHeartbeat(): void {\n    if (!this.heartbeatTimer) {\n      return;\n    }\n\n    clearInterval(this.heartbeatTimer);\n    this.heartbeatTimer = null;\n  }\n\n  // close가 실패해도 terminate 폴백까지 시도하고, 끝내 실패하면 markClosed에 상태 정리를 위임함\n  private closeTransport(code?: number, reason?: string): void {\n    try {\n      if (this.socket.readyState === WS_OPEN || this.socket.readyState === WS_CONNECTING) {\n        this.socket.close(code, truncateCloseReason(reason));\n        return;\n      }\n\n      this.socket.terminate();\n    } catch {\n      try {\n        this.socket.terminate();\n      } catch {\n        // transport is already broken; state cleanup is handled by markClosed()\n      }\n    }\n  }\n\n  // 인바운드 handler를 promise chain으로 serialize 하고, handler 예외는 connection-local 1011 close로 축소함\n  private enqueueMessageTask(task: () => Promise<void>): void {\n    this.messageQueue = this.messageQueue\n      .then(async () => {\n        if (this.closedInternal) {\n          return;\n        }\n\n        await task();\n      })\n      .catch(() => {\n        this.close(WS_CLOSE_CODE_INTERNAL_ERROR, \"Message handling failed\");\n      });\n  }\n\n  // queue가 한계에 도달하면 1013으로 닫아 느린 소비자가 메모리를 끝없이 잡아먹지 못하게 함\n  private enqueueOutboundMessage(payload: string): void {\n    if (this.pendingOutboundMessages.length >= MAX_PENDING_OUTBOUND_MESSAGES) {\n      this.close(WS_CLOSE_CODE_TRY_AGAIN_LATER, \"WebSocket backpressure overflow\");\n      return;\n    }\n\n    this.pendingOutboundMessages.push(payload);\n    this.scheduleOutboundFlush();\n  }\n\n  private scheduleOutboundFlush(delayMs: number = 0): void {\n    if (this.outboundFlushScheduled || this.closedInternal) {\n      return;\n    }\n\n    this.outboundFlushScheduled = true;\n    const flush = () => {\n      this.outboundFlushScheduled = false;\n      this.flushOutboundMessages();\n    };\n\n    if (delayMs > 0) {\n      setTimeout(flush, delayMs);\n      return;\n    }\n\n    setImmediate(flush);\n  }\n\n  // bufferedAmount가 임계치를 넘으면 flush를 미뤄 socket 내부 큐가 터지지 않도록 backpressure를 존중함\n  // 한 번에 배치 단위로만 send해 동기 루프가 이벤트 루프를 장시간 점유하지 않게 함\n  private flushOutboundMessages(): void {\n    if (this.closedInternal || this.socket.readyState !== WS_OPEN) {\n      return;\n    }\n\n    if (this.socket.bufferedAmount > MAX_SOCKET_BUFFERED_AMOUNT) {\n      this.scheduleOutboundFlush(OUTBOUND_RETRY_DELAY_MS);\n      return;\n    }\n\n    let sent = 0;\n    while (\n      sent < OUTBOUND_BATCH_SIZE &&\n      this.pendingOutboundMessages.length > 0 &&\n      this.socket.readyState === WS_OPEN\n    ) {\n      const payload = this.pendingOutboundMessages.shift();\n      if (!payload) {\n        break;\n      }\n\n      try {\n        this.socket.send(payload);\n      } catch {\n        this.close(WS_CLOSE_CODE_INTERNAL_ERROR, \"Outbound publish failed\");\n        return;\n      }\n\n      sent += 1;\n      if (this.socket.bufferedAmount > MAX_SOCKET_BUFFERED_AMOUNT) {\n        break;\n      }\n    }\n\n    if (this.pendingOutboundMessages.length > 0) {\n      this.scheduleOutboundFlush(\n        this.socket.bufferedAmount > MAX_SOCKET_BUFFERED_AMOUNT ? OUTBOUND_RETRY_DELAY_MS : 0,\n      );\n    }\n  }\n}\n\nfunction normalizeMessage(raw: unknown): string {\n  if (typeof raw === \"string\") {\n    return raw;\n  }\n\n  if (raw instanceof Buffer) {\n    return raw.toString(\"utf-8\");\n  }\n\n  if (raw instanceof ArrayBuffer) {\n    return Buffer.from(raw).toString(\"utf-8\");\n  }\n\n  if (Array.isArray(raw)) {\n    return Buffer.concat(raw.filter((chunk): chunk is Buffer => chunk instanceof Buffer)).toString(\n      \"utf-8\",\n    );\n  }\n\n  return JSON.stringify(raw);\n}\n\nfunction safeParseEnvelope(raw: string): ParsedEnvelope | null {\n  try {\n    const parsed = JSON.parse(raw) as unknown;\n    const validated = WebSocketEnvelopeSchema.safeParse(parsed);\n    return validated.success ? validated.data : null;\n  } catch {\n    return null;\n  }\n}\n\n// RFC 6455가 close frame reason을 123 byte로 제한하므로 초과분은 잘라 전송 실패를 방지함\nfunction truncateCloseReason(reason?: string): string | undefined {\n  if (!reason) {\n    return undefined;\n  }\n\n  return Buffer.byteLength(reason, \"utf-8\") <= 123\n    ? reason\n    : Buffer.from(reason).subarray(0, 123).toString(\"utf-8\");\n}\n\nfunction isPromiseLike(value: unknown): value is Promise<void> {\n  return typeof value === \"object\" && value !== null && \"then\" in value && \"catch\" in value;\n}\n"],"mappings":"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"}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"ws.js","names":["z","registryOptions: WebSocketRegistryOptions","socket: WebSocket","options: WebSocketConnectionOptions<TOutSchema, TInSchema>","resolveClosePromise!: () => void","remaining: ParsedEnvelope[]","toFlush: ParsedEnvelope[]"],"sources":["../../src/stream/ws.ts"],"sourcesContent":["import { randomUUID } from \"node:crypto\";\nimport { hostname } from \"node:os\";\n\nimport { type WebSocket } from \"ws\";\nimport { z } from \"zod\";\n\nimport { type WebSocketAudience } from \"./ws-audience\";\nimport { type WebSocketClusterBus } from \"./ws-cluster-bus\";\nimport { type WebSocketPresenceStore } from \"./ws-presence-store\";\nimport {\n  type ManagedWebSocketConnection,\n  WebSocketRegistry,\n  type WebSocketRegistryOptions,\n  type WebSocketRoomId,\n  type WebSocketUserId,\n} from \"./ws-registry\";\nimport {\n  type TelemetryContextProvider,\n  type WebSocketTelemetryConnectionSnapshot,\n  type WebSocketTelemetryConnectionContext,\n  type WebSocketTelemetryController,\n  type WebSocketTelemetryOptions,\n  type TelemetryInspectableConnection,\n  createWebSocketTelemetryController,\n  isPromiseLike,\n} from \"./ws-telemetry\";\nimport { parseTraceParent, generateSpanId } from \"./ws-telemetry-trace\";\n\n// transport-level 상수와 queue threshold를 한 파일에 모아 lifecycle/backpressure 정책을 중앙화함\nconst WS_CONNECTING = 0;\nconst WS_OPEN = 1;\nconst WS_CLOSED = 3;\n// RFC 6455 close codes used by Sonamu's WebSocket runtime.\nconst WS_CLOSE_CODE_GOING_AWAY = 1001;\nconst WS_CLOSE_CODE_INVALID_FRAME_PAYLOAD_DATA = 1007;\nconst WS_CLOSE_CODE_POLICY_VIOLATION = 1008;\nconst WS_CLOSE_CODE_INTERNAL_ERROR = 1011;\nconst WS_CLOSE_CODE_TRY_AGAIN_LATER = 1013;\nconst MAX_PENDING_MESSAGES = 100;\nconst MAX_PENDING_OUTBOUND_MESSAGES = 1_000;\nconst MAX_SOCKET_BUFFERED_AMOUNT = 1_048_576;\nconst OUTBOUND_BATCH_SIZE = 50;\nconst OUTBOUND_RETRY_DELAY_MS = 5;\n\n// envelope을 `{event, data}` 형태로 고정해 server handler와 generated client가 같은 framing contract를 쓰게 함\n// meta는 optional이므로 기존 `{event, data}` 메시지도 그대로 파싱됨 (backward-compatible)\nconst WebSocketEnvelopeSchema = z.object({\n  event: z.string(),\n  data: z.unknown(),\n  meta: z\n    .object({\n      traceparent: z.string().optional(),\n      tracestate: z.string().optional(),\n    })\n    .optional(),\n});\n\ntype MessageHandler<T> = (\n  data: T,\n  telemetryContext?: WebSocketTelemetryConnectionContext,\n) => void | Promise<void>;\ntype CloseHandler = () => void | Promise<void>;\n\nexport type WebSocketEventMap = Record<string, unknown>;\n\ntype InferWebSocketEventMap<TSchema extends z.ZodRawShape> = z.infer<z.ZodObject<TSchema>>;\n\nexport type WebSocketOutEvents<TOut extends WebSocketEventMap = WebSocketEventMap> = TOut;\n\nexport type WebSocketInEvents<TIn extends WebSocketEventMap = WebSocketEventMap> = TIn;\n\nexport interface WebSocketConnection<\n  TOut extends WebSocketEventMap = WebSocketEventMap,\n  TIn extends WebSocketEventMap = WebSocketEventMap,\n> extends ManagedWebSocketConnection {\n  transport: \"ws\";\n  onClose(callback: CloseHandler): void;\n  onMessage<K extends keyof WebSocketInEvents<TIn>>(\n    event: K,\n    handler: MessageHandler<WebSocketInEvents<TIn>[K]>,\n  ): void;\n  publish<K extends keyof WebSocketOutEvents<TOut>>(\n    event: K,\n    data: WebSocketOutEvents<TOut>[K],\n  ): void;\n  waitForClose(): Promise<void>;\n  join(roomId: WebSocketRoomId): void;\n  leave(roomId: WebSocketRoomId): void;\n  setUserId(userId: WebSocketUserId): void;\n  clearUserId(): void;\n}\n\nexport type AnyWebSocketConnection = WebSocketConnection<WebSocketEventMap, WebSocketEventMap>;\n\ntype ParsedEnvelope = z.infer<typeof WebSocketEnvelopeSchema>;\n\ntype WebSocketConnectionOptions<TOut extends z.ZodRawShape, TIn extends z.ZodRawShape> = {\n  namespace?: string;\n  heartbeat?: number;\n  active?: boolean;\n  outEvents: z.ZodObject<TOut>;\n  inEvents: z.ZodObject<TIn>;\n  registry: WebSocketRegistry;\n  telemetryController: WebSocketTelemetryController;\n  traceId?: string;\n  spanId?: string;\n  parentSpanId?: string;\n  sampled?: boolean;\n};\n\nexport type WebSocketRuntimeOptions = {\n  nodeId?: string;\n  presenceStore?: WebSocketPresenceStore;\n  clusterBus?: WebSocketClusterBus;\n  telemetry?: boolean | WebSocketTelemetryOptions;\n};\n\n// registry를 소유하고 connection 생성/shutdown을 담당함. Sonamu 애플리케이션 수명주기와 같이 움직이도록 설계함\nexport class WebSocketRuntime {\n  readonly registry: WebSocketRegistry;\n  readonly telemetryController: WebSocketTelemetryController;\n\n  constructor(options: WebSocketRuntimeOptions = {}) {\n    // 분산 환경에서 노드 간 충돌을 막기 위해 hostname + pid로 디폴트 식별자를 만든다.\n    // 같은 호스트에 여러 프로세스가 떠 있어도 pid로 구분되며, 로그/메트릭에서도 식별이 쉬움\n    const resolvedNodeId = options.nodeId ?? `${hostname()}-${process.pid}`;\n    this.telemetryController = createWebSocketTelemetryController(options.telemetry, {\n      runtimeId: randomUUID(),\n      nodeId: resolvedNodeId,\n    });\n    const registryOptions: WebSocketRegistryOptions = {\n      nodeId: resolvedNodeId,\n      presenceStore: options.presenceStore,\n      clusterBus: options.clusterBus,\n      telemetryController: this.telemetryController,\n    };\n    this.registry = new WebSocketRegistry(registryOptions);\n  }\n\n  registerConnection<TOutSchema extends z.ZodRawShape, TInSchema extends z.ZodRawShape>(\n    socket: WebSocket,\n    options: Omit<\n      WebSocketConnectionOptions<TOutSchema, TInSchema>,\n      \"registry\" | \"telemetryController\"\n    >,\n  ): WebSocketConnection<InferWebSocketEventMap<TOutSchema>, InferWebSocketEventMap<TInSchema>> {\n    return new WebSocketConnectionImpl(socket, {\n      ...options,\n      registry: this.registry,\n      telemetryController: this.telemetryController,\n    });\n  }\n\n  activateConnection(connectionId: string): void {\n    this.registry.activate(connectionId);\n  }\n\n  broadcast(event: string, data: unknown, namespace?: string): void {\n    this.registry.broadcast(event, data, namespace);\n  }\n\n  publishToRoom(roomId: WebSocketRoomId, event: string, data: unknown, namespace?: string): void {\n    this.registry.publishToRoom(roomId, event, data, namespace);\n  }\n\n  publishToUser(userId: WebSocketUserId, event: string, data: unknown, namespace?: string): void {\n    this.registry.publishToUser(userId, event, data, namespace);\n  }\n\n  publishToAudience(audience: WebSocketAudience, event: string, data: unknown): void {\n    this.registry.publishToAudience(audience, event, data);\n  }\n\n  // 프로세스 종료 시 살아있는 연결이 남지 않도록 registry를 순회해 일괄 종료함\n  async shutdown(\n    code: number = WS_CLOSE_CODE_GOING_AWAY,\n    reason = \"Server shutting down\",\n  ): Promise<void> {\n    await this.registry.shutdown(code, reason);\n    await this.telemetryController.shutdown();\n  }\n}\n\nexport function createWebSocketRuntime(options: WebSocketRuntimeOptions = {}): WebSocketRuntime {\n  return new WebSocketRuntime(options);\n}\n\nclass WebSocketConnectionImpl<TOutSchema extends z.ZodRawShape, TInSchema extends z.ZodRawShape>\n  implements\n    WebSocketConnection<InferWebSocketEventMap<TOutSchema>, InferWebSocketEventMap<TInSchema>>,\n    TelemetryInspectableConnection,\n    TelemetryContextProvider\n{\n  readonly id = randomUUID();\n  readonly transport = \"ws\";\n  readonly namespace: string;\n\n  private readonly closeCallbacks: CloseHandler[] = [];\n  private readonly messageHandlers = new Map<string, Array<MessageHandler<unknown>>>();\n  private readonly pendingMessages: ParsedEnvelope[] = [];\n  private readonly pendingOutboundMessages: Array<{ payload: string; event: string }> = [];\n  private readonly closePromise: Promise<void>;\n  private readonly resolveClosePromise: () => void;\n  private readonly heartbeatMs: number;\n  private readonly eventSchemasIn: Record<string, z.ZodTypeAny>;\n  private readonly eventSchemasOut: Record<string, z.ZodTypeAny>;\n\n  private readonly connectionTraceId?: string;\n  private readonly connectionSpanId?: string;\n  private readonly connectionParentSpanId?: string;\n  private readonly connectionSampled?: boolean;\n  private readonly connectionStartedAt = performance.now();\n\n  // connection 수명 동안 유지되는 식별자. setUserId/clearUserId로 업데이트되며 emit hot path에서 매번 registry lookup하지 않도록 캐시함\n  private _userId?: string;\n\n  get userId(): string | undefined {\n    return this._userId;\n  }\n\n  private closedInternal = false;\n  private closeStarted = false;\n  private awaitingPong = false;\n  private heartbeatTimer: ReturnType<typeof setInterval> | null = null;\n  private messageQueue: Promise<void> = Promise.resolve();\n  private outboundFlushScheduled = false;\n\n  constructor(\n    private readonly socket: WebSocket,\n    private readonly options: WebSocketConnectionOptions<TOutSchema, TInSchema>,\n  ) {\n    this.namespace = options.namespace ?? \"default\";\n    this.heartbeatMs = options.heartbeat ?? 30000;\n    this.connectionTraceId = options.traceId;\n    this.connectionSpanId = options.spanId;\n    this.connectionParentSpanId = options.parentSpanId;\n    this.connectionSampled = options.sampled;\n    this.eventSchemasIn = options.inEvents.shape as unknown as Record<string, z.ZodTypeAny>;\n    this.eventSchemasOut = options.outEvents.shape as unknown as Record<string, z.ZodTypeAny>;\n\n    let resolveClosePromise!: () => void;\n    this.closePromise = new Promise<void>((resolve) => {\n      resolveClosePromise = resolve;\n    });\n    this.resolveClosePromise = resolveClosePromise;\n\n    this.options.registry.register(this, options.active ?? true);\n    this.socket.on(\"message\", this.handleMessage);\n    this.socket.on(\"close\", this.handleClose);\n    this.socket.on(\"error\", this.handleError);\n    this.socket.on(\"pong\", this.handlePong);\n    this.startHeartbeat();\n  }\n\n  get closed(): boolean {\n    return this.closedInternal;\n  }\n\n  onClose(callback: CloseHandler): void {\n    this.closeCallbacks.push(callback);\n  }\n\n  onMessage<K extends keyof InferWebSocketEventMap<TInSchema>>(\n    event: K,\n    handler: MessageHandler<InferWebSocketEventMap<TInSchema>[K]>,\n  ): void {\n    const eventKey = String(event);\n    const handlers = this.messageHandlers.get(eventKey) ?? [];\n    handlers.push(handler as MessageHandler<unknown>);\n    this.messageHandlers.set(eventKey, handlers);\n    this.flushPendingMessages(eventKey);\n  }\n\n  publish<K extends keyof InferWebSocketEventMap<TOutSchema>>(\n    event: K,\n    data: InferWebSocketEventMap<TOutSchema>[K],\n  ): void {\n    this.publishValidated(String(event), data);\n  }\n\n  publishUntyped(event: string, data: unknown): void {\n    this.publishValidated(event, data);\n  }\n\n  waitForClose(): Promise<void> {\n    return this.closePromise;\n  }\n\n  join(roomId: WebSocketRoomId): void {\n    this.options.registry.join(this.id, roomId);\n  }\n\n  leave(roomId: WebSocketRoomId): void {\n    this.options.registry.leave(this.id, roomId);\n  }\n\n  setUserId(userId: WebSocketUserId): void {\n    this._userId = String(userId);\n    this.options.registry.setUserId(this.id, userId);\n  }\n\n  clearUserId(): void {\n    this._userId = undefined;\n    this.options.registry.clearUserId(this.id);\n  }\n\n  getTelemetrySnapshot(): WebSocketTelemetryConnectionSnapshot {\n    return {\n      pendingInboundMessages: this.pendingMessages.length,\n      pendingOutboundMessages: this.pendingOutboundMessages.length,\n      socketBufferedBytes: this.socket.readyState === WS_OPEN ? this.socket.bufferedAmount : 0,\n    };\n  }\n\n  getTelemetryContext(): WebSocketTelemetryConnectionContext {\n    return {\n      traceId: this.connectionTraceId,\n      spanId: this.connectionSpanId,\n      parentSpanId: this.connectionParentSpanId,\n      sampled: this.connectionSampled,\n    };\n  }\n\n  // 모든 telemetry emit site가 공유하는 connection-level field 묶음.\n  // 향후 connection-scoped 식별자(e.g. tenantId)가 추가될 때 한 곳만 손대면 됨\n  private telemetryFields() {\n    return {\n      connectionId: this.id,\n      namespace: this.namespace,\n      userId: this._userId,\n      traceId: this.connectionTraceId,\n      spanId: this.connectionSpanId,\n      parentSpanId: this.connectionParentSpanId,\n      sampled: this.connectionSampled,\n    };\n  }\n\n  private emitInboundRejected(reason: string, event?: string): void {\n    const fields = this.telemetryFields();\n    this.options.telemetryController.emit({\n      name: \"ws.message.rejected\",\n      level: \"warn\",\n      ...fields,\n      detail: event !== undefined ? { reason, event } : { reason },\n    });\n    this.options.telemetryController.recordMetric({\n      name: \"sonamu.ws.messages\",\n      kind: \"counter\",\n      value: 1,\n      unit: \"1\",\n      tags: { direction: \"inbound\", outcome: \"rejected\" },\n      ...fields,\n    });\n  }\n\n  // transport 종료 도중 예외가 나도 markClosed가 반드시 실행되도록 try/finally로 감쌈\n  close(code?: number, reason?: string): void {\n    if (this.closedInternal || this.closeStarted || this.socket.readyState === WS_CLOSED) {\n      return;\n    }\n\n    this.closeStarted = true;\n    try {\n      this.closeTransport(code, reason);\n    } finally {\n      this.markClosed(code, reason);\n    }\n  }\n\n  // 인바운드 메시지를 순차 처리 큐에 올림. Sonamu envelope 검증 수행\n  private readonly handleMessage = (raw: unknown) => {\n    this.enqueueMessageTask(async () => {\n      const text = normalizeMessage(raw);\n      const parsedEnvelope = safeParseEnvelope(text);\n      if (!parsedEnvelope) {\n        this.emitInboundRejected(\"invalidPayload\");\n        this.close(WS_CLOSE_CODE_INVALID_FRAME_PAYLOAD_DATA, \"Invalid message payload\");\n        return;\n      }\n\n      this.options.telemetryController.emit({\n        name: \"ws.message.received\",\n        level: \"debug\",\n        ...this.telemetryFields(),\n        detail: { event: parsedEnvelope.event },\n        payload: parsedEnvelope.data,\n      });\n      this.options.registry.touch(this.id);\n      await this.dispatchEnvelope(parsedEnvelope);\n    });\n  };\n\n  private readonly handleClose = (code?: number, reason?: Buffer | string) => {\n    const reasonText = typeof reason === \"string\" ? reason : reason?.toString();\n    this.markClosed(code, reasonText);\n  };\n\n  // 소켓이 transport error를 emit하면 즉시 1011 close로 수렴시켜 상태 누락을 막음\n  private readonly handleError = () => {\n    this.close(WS_CLOSE_CODE_INTERNAL_ERROR, \"WebSocket transport error\");\n  };\n\n  private readonly handlePong = () => {\n    this.awaitingPong = false;\n    this.options.registry.touch(this.id);\n  };\n\n  // envelope의 meta.traceparent로부터 trace context를 추출함\n  // invalid traceparent는 연결을 거부하지 않고 debug 레벨 경고만 emit함\n  private resolveMessageTraceContext(\n    envelope: ParsedEnvelope,\n  ): WebSocketTelemetryConnectionContext {\n    const messageSpanId = generateSpanId();\n\n    if (\n      this.options.telemetryController.getTraceOptions().propagateMessageTrace &&\n      envelope.meta?.traceparent\n    ) {\n      const parsed = parseTraceParent(envelope.meta.traceparent);\n      if (parsed) {\n        return {\n          traceId: parsed.traceId,\n          spanId: messageSpanId,\n          parentSpanId: parsed.parentId,\n          sampled: parsed.sampled,\n        };\n      }\n      // invalid traceparent: warn but do not reject\n      this.options.telemetryController.emit({\n        name: \"ws.trace.invalid\",\n        level: \"debug\",\n        ...this.telemetryFields(),\n        detail: { source: \"message\", traceparent: envelope.meta.traceparent },\n      });\n    }\n\n    return {\n      traceId: this.connectionTraceId,\n      spanId: messageSpanId,\n      parentSpanId: this.connectionSpanId ?? this.connectionParentSpanId,\n      sampled: this.connectionSampled,\n    };\n  }\n\n  // event 존재 여부 → schema 검증 → handler 실행 순으로 분기함\n  // handler가 아직 등록되지 않은 초기 메시지는 버퍼에 보관했다가 onMessage 등록 시 flush함\n  // handler는 `await`으로 순차 실행해 한 connection 안의 메시지 순서를 보장함\n  private async dispatchEnvelope(envelope: ParsedEnvelope): Promise<void> {\n    const handlers = this.messageHandlers.get(envelope.event);\n    const schema = this.eventSchemasIn[envelope.event];\n\n    if (!schema) {\n      this.emitInboundRejected(\"unknownEvent\", envelope.event);\n      this.close(WS_CLOSE_CODE_POLICY_VIOLATION, \"Unknown event\");\n      return;\n    }\n\n    const parsed = schema.safeParse(envelope.data);\n    if (!parsed.success) {\n      this.emitInboundRejected(\"invalidData\", envelope.event);\n      this.close(WS_CLOSE_CODE_INVALID_FRAME_PAYLOAD_DATA, \"Invalid event data\");\n      return;\n    }\n\n    if (!handlers || handlers.length === 0) {\n      if (this.pendingMessages.length >= MAX_PENDING_MESSAGES) {\n        this.options.telemetryController.emit({\n          name: \"ws.message.buffer.dropped\",\n          level: \"warn\",\n          ...this.telemetryFields(),\n          detail: { event: envelope.event },\n        });\n        this.pendingMessages.shift();\n      }\n      this.pendingMessages.push(envelope);\n      this.options.telemetryController.emit({\n        name: \"ws.message.buffered\",\n        level: \"debug\",\n        ...this.telemetryFields(),\n        detail: { event: envelope.event },\n      });\n      return;\n    }\n\n    const traceCtx = this.resolveMessageTraceContext(envelope);\n    // message-level trace는 connection-level trace를 override함. userId / connectionId / namespace는 그대로 유지\n    const messageTraceFields = {\n      connectionId: this.id,\n      namespace: this.namespace,\n      userId: this._userId,\n      traceId: traceCtx.traceId,\n      spanId: traceCtx.spanId,\n      parentSpanId: traceCtx.parentSpanId,\n      sampled: traceCtx.sampled,\n    };\n    try {\n      for (const handler of handlers) {\n        await handler(parsed.data, traceCtx);\n      }\n      this.options.telemetryController.emit({\n        name: \"ws.message.dispatched\",\n        level: \"debug\",\n        ...messageTraceFields,\n        detail: { event: envelope.event },\n      });\n      this.options.telemetryController.recordMetric({\n        name: \"sonamu.ws.messages\",\n        kind: \"counter\",\n        value: 1,\n        unit: \"1\",\n        tags: { direction: \"inbound\", event: envelope.event, outcome: \"accepted\" },\n        ...messageTraceFields,\n      });\n    } catch (error) {\n      this.options.telemetryController.emit({\n        name: \"ws.message.failed\",\n        level: \"error\",\n        ...messageTraceFields,\n        detail: { event: envelope.event },\n      });\n      throw error;\n    }\n  }\n\n  private flushPendingMessages(event: string): void {\n    const remaining: ParsedEnvelope[] = [];\n    const toFlush: ParsedEnvelope[] = [];\n\n    for (const message of this.pendingMessages) {\n      if (message.event !== event) {\n        remaining.push(message);\n        continue;\n      }\n\n      toFlush.push(message);\n    }\n\n    this.pendingMessages.length = 0;\n    this.pendingMessages.push(...remaining);\n\n    for (const message of toFlush) {\n      this.enqueueMessageTask(async () => {\n        await this.dispatchEnvelope(message);\n      });\n    }\n  }\n\n  private publishValidated(event: string, data: unknown): void {\n    const schema = this.eventSchemasOut[event];\n    if (!schema) {\n      this.options.telemetryController.emit({\n        name: \"ws.publish.rejected\",\n        level: \"error\",\n        ...this.telemetryFields(),\n        detail: { event, reason: \"unknownEvent\" },\n      });\n      throw new Error(`Unknown websocket event: ${event}`);\n    }\n\n    const parsed = schema.safeParse(data);\n    if (!parsed.success) {\n      this.options.telemetryController.emit({\n        name: \"ws.publish.rejected\",\n        level: \"error\",\n        ...this.telemetryFields(),\n        detail: { event, reason: \"invalidPayload\" },\n      });\n      throw new Error(`Invalid websocket event payload: ${event}`);\n    }\n\n    if (this.closedInternal || this.socket.readyState !== WS_OPEN) {\n      this.options.telemetryController.emit({\n        name: \"ws.publish.dropped\",\n        level: \"debug\",\n        ...this.telemetryFields(),\n        detail: { event, reason: \"connectionClosed\" },\n      });\n      return;\n    }\n\n    this.enqueueOutboundMessage(\n      JSON.stringify({\n        event,\n        data: parsed.data,\n      }),\n      event,\n      parsed.data,\n    );\n  }\n\n  // listener 해제 / heartbeat 중단 / pending queue 비움 / registry unregister / onClose 실행 / waitForClose resolve 을 한 곳에 모아 원자적으로 처리함\n  // async onClose가 reject해도 unhandled rejection으로 새지 않도록 catch로 격리함\n  private markClosed(code?: number, _reason?: string): void {\n    if (this.closedInternal) {\n      return;\n    }\n\n    this.closedInternal = true;\n    this.closeStarted = false;\n    this.stopHeartbeat();\n    const fields = this.telemetryFields();\n    this.options.telemetryController.emit({\n      name: \"ws.connection.closed\",\n      level: \"info\",\n      ...fields,\n    });\n    if (this.options.telemetryController.getTraceOptions().recordConnectionLifetimeSpan) {\n      this.options.telemetryController.recordSpan({\n        operationName: \"ws.connection.lifetime\",\n        kind: \"server\",\n        durationMs: performance.now() - this.connectionStartedAt,\n        status: deriveLifetimeStatus(code),\n        ...fields,\n      });\n    }\n    this.socket.off(\"message\", this.handleMessage);\n    this.socket.off(\"close\", this.handleClose);\n    this.socket.off(\"error\", this.handleError);\n    this.socket.off(\"pong\", this.handlePong);\n    this.awaitingPong = false;\n    this.pendingMessages.length = 0;\n    this.pendingOutboundMessages.length = 0;\n    this.options.registry.unregister(this.id);\n    for (const callback of this.closeCallbacks.splice(0)) {\n      try {\n        const result = callback();\n        if (isPromiseLike(result)) {\n          void result.catch(() => {\n            // async close callbacks must not escape as unhandled rejections\n          });\n        }\n      } catch {\n        // close callbacks must not block transport cleanup\n      }\n    }\n    this.resolveClosePromise();\n  }\n\n  // pong이 오지 않은 상태에서 다음 tick이 오면 timeout close로 처리해 zombie connection을 정리함\n  private startHeartbeat(): void {\n    if (this.heartbeatMs <= 0) {\n      return;\n    }\n\n    this.heartbeatTimer = setInterval(() => {\n      if (this.closedInternal || this.socket.readyState !== WS_OPEN) {\n        return;\n      }\n\n      if (this.awaitingPong) {\n        this.options.telemetryController.emit({\n          name: \"ws.heartbeat.timeout\",\n          level: \"warn\",\n          ...this.telemetryFields(),\n        });\n        this.close(WS_CLOSE_CODE_GOING_AWAY, \"Heartbeat timeout\");\n        return;\n      }\n\n      this.awaitingPong = true;\n      this.socket.ping();\n    }, this.heartbeatMs);\n  }\n\n  private stopHeartbeat(): void {\n    if (!this.heartbeatTimer) {\n      return;\n    }\n\n    clearInterval(this.heartbeatTimer);\n    this.heartbeatTimer = null;\n  }\n\n  // close가 실패해도 terminate 폴백까지 시도하고, 끝내 실패하면 markClosed에 상태 정리를 위임함\n  private closeTransport(code?: number, reason?: string): void {\n    try {\n      if (this.socket.readyState === WS_OPEN || this.socket.readyState === WS_CONNECTING) {\n        this.socket.close(code, truncateCloseReason(reason));\n        return;\n      }\n\n      this.socket.terminate();\n    } catch {\n      try {\n        this.socket.terminate();\n      } catch {\n        // transport is already broken; state cleanup is handled by markClosed()\n      }\n    }\n  }\n\n  // 인바운드 handler를 promise chain으로 serialize 하고, handler 예외는 connection-local 1011 close로 축소함\n  private enqueueMessageTask(task: () => Promise<void>): void {\n    this.messageQueue = this.messageQueue\n      .then(async () => {\n        if (this.closedInternal) {\n          return;\n        }\n\n        await task();\n      })\n      .catch(() => {\n        this.close(WS_CLOSE_CODE_INTERNAL_ERROR, \"Message handling failed\");\n      });\n  }\n\n  // queue가 한계에 도달하면 1013으로 닫아 느린 소비자가 메모리를 끝없이 잡아먹지 못하게 함\n  // data 인자는 telemetry payload preview 용도로만 사용하며 pendingOutboundMessages에는 저장하지 않음 (큐 메모리 보호)\n  private enqueueOutboundMessage(payload: string, event: string, data: unknown): void {\n    if (this.pendingOutboundMessages.length >= MAX_PENDING_OUTBOUND_MESSAGES) {\n      this.options.telemetryController.emit({\n        name: \"ws.backpressure.overflow\",\n        level: \"error\",\n        ...this.telemetryFields(),\n      });\n      this.close(WS_CLOSE_CODE_TRY_AGAIN_LATER, \"WebSocket backpressure overflow\");\n      return;\n    }\n\n    this.pendingOutboundMessages.push({ payload, event });\n    this.options.telemetryController.emit({\n      name: \"ws.publish.queued\",\n      level: \"debug\",\n      ...this.telemetryFields(),\n      detail: { event },\n      payload: data,\n    });\n    this.scheduleOutboundFlush();\n  }\n\n  private scheduleOutboundFlush(delayMs: number = 0): void {\n    if (this.outboundFlushScheduled || this.closedInternal) {\n      return;\n    }\n\n    this.outboundFlushScheduled = true;\n    const flush = () => {\n      this.outboundFlushScheduled = false;\n      this.flushOutboundMessages();\n    };\n\n    if (delayMs > 0) {\n      setTimeout(flush, delayMs);\n      return;\n    }\n\n    setImmediate(flush);\n  }\n\n  // bufferedAmount가 임계치를 넘으면 flush를 미뤄 socket 내부 큐가 터지지 않도록 backpressure를 존중함\n  // 한 번에 배치 단위로만 send해 동기 루프가 이벤트 루프를 장시간 점유하지 않게 함\n  private flushOutboundMessages(): void {\n    if (this.closedInternal || this.socket.readyState !== WS_OPEN) {\n      return;\n    }\n\n    if (this.socket.bufferedAmount > MAX_SOCKET_BUFFERED_AMOUNT) {\n      this.options.telemetryController.emit({\n        name: \"ws.backpressure.delayed\",\n        level: \"warn\",\n        ...this.telemetryFields(),\n      });\n      this.scheduleOutboundFlush(OUTBOUND_RETRY_DELAY_MS);\n      return;\n    }\n\n    let sent = 0;\n    while (\n      sent < OUTBOUND_BATCH_SIZE &&\n      this.pendingOutboundMessages.length > 0 &&\n      this.socket.readyState === WS_OPEN\n    ) {\n      const next = this.pendingOutboundMessages.shift();\n      if (!next) {\n        break;\n      }\n      const { payload, event } = next;\n\n      const startedAt = performance.now();\n      const fields = this.telemetryFields();\n      try {\n        this.socket.send(payload);\n        const durationMs = performance.now() - startedAt;\n        this.options.telemetryController.emit({\n          name: \"ws.publish.sent\",\n          level: \"debug\",\n          ...fields,\n          detail: { event },\n        });\n        this.options.telemetryController.recordSpan({\n          operationName: \"ws.publish.send\",\n          kind: \"producer\",\n          durationMs,\n          status: \"unset\",\n          ...fields,\n          attributes: { event },\n        });\n        this.options.telemetryController.recordMetric({\n          name: \"sonamu.ws.publishes\",\n          kind: \"counter\",\n          value: 1,\n          unit: \"1\",\n          tags: { outcome: \"sent\", event },\n          ...fields,\n        });\n      } catch (error) {\n        const durationMs = performance.now() - startedAt;\n        this.options.telemetryController.emit({\n          name: \"ws.publish.failed\",\n          level: \"error\",\n          ...fields,\n          detail: { event },\n        });\n        this.options.telemetryController.recordSpan({\n          operationName: \"ws.publish.send\",\n          kind: \"producer\",\n          durationMs,\n          status: \"error\",\n          ...fields,\n          attributes: { event },\n          errorType: error instanceof Error ? error.name : typeof error,\n        });\n        this.close(WS_CLOSE_CODE_INTERNAL_ERROR, \"Outbound publish failed\");\n        return;\n      }\n\n      sent += 1;\n      if (this.socket.bufferedAmount > MAX_SOCKET_BUFFERED_AMOUNT) {\n        break;\n      }\n    }\n\n    if (this.pendingOutboundMessages.length > 0) {\n      this.scheduleOutboundFlush(\n        this.socket.bufferedAmount > MAX_SOCKET_BUFFERED_AMOUNT ? OUTBOUND_RETRY_DELAY_MS : 0,\n      );\n    }\n  }\n}\n\nfunction normalizeMessage(raw: unknown): string {\n  if (typeof raw === \"string\") {\n    return raw;\n  }\n\n  if (raw instanceof Buffer) {\n    return raw.toString(\"utf-8\");\n  }\n\n  if (raw instanceof ArrayBuffer) {\n    return Buffer.from(raw).toString(\"utf-8\");\n  }\n\n  if (Array.isArray(raw)) {\n    return Buffer.concat(raw.filter((chunk): chunk is Buffer => chunk instanceof Buffer)).toString(\n      \"utf-8\",\n    );\n  }\n\n  return JSON.stringify(raw);\n}\n\nfunction safeParseEnvelope(raw: string): ParsedEnvelope | null {\n  try {\n    const parsed = JSON.parse(raw) as unknown;\n    const validated = WebSocketEnvelopeSchema.safeParse(parsed);\n    return validated.success ? validated.data : null;\n  } catch {\n    return null;\n  }\n}\n\n// RFC 6455가 close frame reason을 123 byte로 제한하므로 초과분은 잘라 전송 실패를 방지함\nfunction truncateCloseReason(reason?: string): string | undefined {\n  if (!reason) {\n    return undefined;\n  }\n\n  return Buffer.byteLength(reason, \"utf-8\") <= 123\n    ? reason\n    : Buffer.from(reason).subarray(0, 123).toString(\"utf-8\");\n}\n\n// connection lifetime span의 status를 close code 기준으로 분기함 (1000/1001 정상 종료, 그 외 known code error, code 미상은 unset)\nfunction deriveLifetimeStatus(code: number | undefined): \"ok\" | \"error\" | \"unset\" {\n  if (code === undefined) return \"unset\";\n  if (code === 1000 || code === 1001) return \"ok\";\n  return \"error\";\n}\n"],"mappings":"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"}