sonamu 0.9.4 → 0.9.6

package/dist/stream/ws.js

@@ -0,0 +1,397 @@
+import { __esmMin } from "../_virtual/rolldown_runtime.js";
+import { WebSocketRegistry, init_ws_registry } from "./ws-registry.js";
+import { z as z$1 } from "zod";
+import { randomUUID } from "node:crypto";
+
+//#region src/stream/ws.ts
+function createWebSocketRuntime(options = {}) {
+	return new WebSocketRuntime(options);
+}
+function normalizeMessage(raw) {
+	if (typeof raw === "string") {
+		return raw;
+	}
+	if (raw instanceof Buffer) {
+		return raw.toString("utf-8");
+	}
+	if (raw instanceof ArrayBuffer) {
+		return Buffer.from(raw).toString("utf-8");
+	}
+	if (Array.isArray(raw)) {
+		return Buffer.concat(raw.filter((chunk) => chunk instanceof Buffer)).toString("utf-8");
+	}
+	return JSON.stringify(raw);
+}
+function safeParseEnvelope(raw) {
+	try {
+		const parsed = JSON.parse(raw);
+		const validated = WebSocketEnvelopeSchema.safeParse(parsed);
+		return validated.success ? validated.data : null;
+	} catch {
+		return null;
+	}
+}
+function truncateCloseReason(reason) {
+	if (!reason) {
+		return undefined;
+	}
+	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;
+}
+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 init_ws = __esmMin((() => {
+	init_ws_registry();
+	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;
+	MAX_PENDING_OUTBOUND_MESSAGES = 1e3;
+	MAX_SOCKET_BUFFERED_AMOUNT = 1048576;
+	OUTBOUND_BATCH_SIZE = 50;
+	OUTBOUND_RETRY_DELAY_MS = 5;
+	WebSocketEnvelopeSchema = z$1.object({
+		event: z$1.string(),
+		data: z$1.unknown()
+	});
+	WebSocketRuntime = class {
+		registry;
+		constructor(options = {}) {
+			const registryOptions = {
+				nodeId: options.nodeId,
+				presenceStore: options.presenceStore,
+				clusterBus: options.clusterBus
+			};
+			this.registry = new WebSocketRegistry(registryOptions);
+		}
+		registerConnection(socket, options) {
+			return new WebSocketConnectionImpl(socket, {
+				...options,
+				registry: this.registry
+			});
+		}
+		activateConnection(connectionId) {
+			this.registry.activate(connectionId);
+		}
+		broadcast(event, data, namespace) {
+			this.registry.broadcast(event, data, namespace);
+		}
+		publishToRoom(roomId, event, data, namespace) {
+			this.registry.publishToRoom(roomId, event, data, namespace);
+		}
+		publishToUser(userId, event, data, namespace) {
+			this.registry.publishToUser(userId, event, data, namespace);
+		}
+		publishToAudience(audience, event, data) {
+			this.registry.publishToAudience(audience, event, data);
+		}
+		async shutdown(code = WS_CLOSE_CODE_GOING_AWAY, reason = "Server shutting down") {
+			await this.registry.shutdown(code, reason);
+		}
+	};
+	WebSocketConnectionImpl = class {
+		id = randomUUID();
+		transport = "ws";
+		namespace;
+		closeCallbacks = [];
+		messageHandlers = new Map();
+		pendingMessages = [];
+		pendingOutboundMessages = [];
+		closePromise;
+		resolveClosePromise;
+		heartbeatMs;
+		maxPayload;
+		eventSchemasIn;
+		eventSchemasOut;
+		closedInternal = false;
+		closeStarted = false;
+		awaitingPong = false;
+		heartbeatTimer = null;
+		messageQueue = Promise.resolve();
+		outboundFlushScheduled = false;
+		constructor(socket, options) {
+			this.socket = socket;
+			this.options = options;
+			this.namespace = options.namespace ?? "default";
+			this.heartbeatMs = options.heartbeat ?? 3e4;
+			this.maxPayload = options.maxPayload;
+			this.eventSchemasIn = options.inEvents.shape;
+			this.eventSchemasOut = options.outEvents.shape;
+			let resolveClosePromise;
+			this.closePromise = new Promise((resolve) => {
+				resolveClosePromise = resolve;
+			});
+			this.resolveClosePromise = resolveClosePromise;
+			this.options.registry.register(this, options.active ?? true);
+			this.socket.on("message", this.handleMessage);
+			this.socket.on("close", this.handleClose);
+			this.socket.on("error", this.handleError);
+			this.socket.on("pong", this.handlePong);
+			this.startHeartbeat();
+		}
+		get closed() {
+			return this.closedInternal;
+		}
+		onClose(callback) {
+			this.closeCallbacks.push(callback);
+		}
+		onMessage(event, handler) {
+			const eventKey = String(event);
+			const handlers = this.messageHandlers.get(eventKey) ?? [];
+			handlers.push(handler);
+			this.messageHandlers.set(eventKey, handlers);
+			this.flushPendingMessages(eventKey);
+		}
+		publish(event, data) {
+			this.publishValidated(String(event), data);
+		}
+		publishUntyped(event, data) {
+			this.publishValidated(event, data);
+		}
+		waitForClose() {
+			return this.closePromise;
+		}
+		join(roomId) {
+			this.options.registry.join(this.id, roomId);
+		}
+		leave(roomId) {
+			this.options.registry.leave(this.id, roomId);
+		}
+		setUserId(userId) {
+			this.options.registry.setUserId(this.id, userId);
+		}
+		clearUserId() {
+			this.options.registry.clearUserId(this.id);
+		}
+		close(code, reason) {
+			if (this.closedInternal || this.closeStarted || this.socket.readyState === WS_CLOSED) {
+				return;
+			}
+			this.closeStarted = true;
+			try {
+				this.closeTransport(code, reason);
+			} finally {
+				this.markClosed();
+			}
+		}
+		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.close(WS_CLOSE_CODE_INVALID_FRAME_PAYLOAD_DATA, "Invalid message payload");
+					return;
+				}
+				this.options.registry.touch(this.id);
+				await this.dispatchEnvelope(parsedEnvelope);
+			});
+		};
+		handleClose = () => {
+			this.markClosed();
+		};
+		handleError = () => {
+			this.close(WS_CLOSE_CODE_INTERNAL_ERROR, "WebSocket transport error");
+		};
+		handlePong = () => {
+			this.awaitingPong = false;
+			this.options.registry.touch(this.id);
+		};
+		async dispatchEnvelope(envelope) {
+			const handlers = this.messageHandlers.get(envelope.event);
+			const schema = this.eventSchemasIn[envelope.event];
+			if (!schema) {
+				this.close(WS_CLOSE_CODE_POLICY_VIOLATION, "Unknown event");
+				return;
+			}
+			const parsed = schema.safeParse(envelope.data);
+			if (!parsed.success) {
+				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.pendingMessages.shift();
+				}
+				this.pendingMessages.push(envelope);
+				return;
+			}
+			for (const handler of handlers) {
+				await handler(parsed.data);
+			}
+		}
+		flushPendingMessages(event) {
+			const remaining = [];
+			const toFlush = [];
+			for (const message of this.pendingMessages) {
+				if (message.event !== event) {
+					remaining.push(message);
+					continue;
+				}
+				toFlush.push(message);
+			}
+			this.pendingMessages.length = 0;
+			this.pendingMessages.push(...remaining);
+			for (const message of toFlush) {
+				this.enqueueMessageTask(async () => {
+					await this.dispatchEnvelope(message);
+				});
+			}
+		}
+		publishValidated(event, data) {
+			const schema = this.eventSchemasOut[event];
+			if (!schema) {
+				throw new Error(`Unknown websocket event: ${event}`);
+			}
+			const parsed = schema.safeParse(data);
+			if (!parsed.success) {
+				throw new Error(`Invalid websocket event payload: ${event}`);
+			}
+			if (this.closedInternal || this.socket.readyState !== WS_OPEN) {
+				return;
+			}
+			this.enqueueOutboundMessage(JSON.stringify({
+				event,
+				data: parsed.data
+			}));
+		}
+		markClosed() {
+			if (this.closedInternal) {
+				return;
+			}
+			this.closedInternal = true;
+			this.closeStarted = false;
+			this.stopHeartbeat();
+			this.socket.off("message", this.handleMessage);
+			this.socket.off("close", this.handleClose);
+			this.socket.off("error", this.handleError);
+			this.socket.off("pong", this.handlePong);
+			this.awaitingPong = false;
+			this.pendingMessages.length = 0;
+			this.pendingOutboundMessages.length = 0;
+			this.options.registry.unregister(this.id);
+			for (const callback of this.closeCallbacks.splice(0)) {
+				try {
+					const result = callback();
+					if (isPromiseLike(result)) {
+						void result.catch(() => {});
+					}
+				} catch {}
+			}
+			this.resolveClosePromise();
+		}
+		startHeartbeat() {
+			if (this.heartbeatMs <= 0) {
+				return;
+			}
+			this.heartbeatTimer = setInterval(() => {
+				if (this.closedInternal || this.socket.readyState !== WS_OPEN) {
+					return;
+				}
+				if (this.awaitingPong) {
+					this.close(WS_CLOSE_CODE_GOING_AWAY, "Heartbeat timeout");
+					return;
+				}
+				this.awaitingPong = true;
+				this.socket.ping();
+			}, this.heartbeatMs);
+		}
+		stopHeartbeat() {
+			if (!this.heartbeatTimer) {
+				return;
+			}
+			clearInterval(this.heartbeatTimer);
+			this.heartbeatTimer = null;
+		}
+		closeTransport(code, reason) {
+			try {
+				if (this.socket.readyState === WS_OPEN || this.socket.readyState === WS_CONNECTING) {
+					this.socket.close(code, truncateCloseReason(reason));
+					return;
+				}
+				this.socket.terminate();
+			} catch {
+				try {
+					this.socket.terminate();
+				} catch {}
+			}
+		}
+		enqueueMessageTask(task) {
+			this.messageQueue = this.messageQueue.then(async () => {
+				if (this.closedInternal) {
+					return;
+				}
+				await task();
+			}).catch(() => {
+				this.close(WS_CLOSE_CODE_INTERNAL_ERROR, "Message handling failed");
+			});
+		}
+		enqueueOutboundMessage(payload) {
+			if (this.pendingOutboundMessages.length >= MAX_PENDING_OUTBOUND_MESSAGES) {
+				this.close(WS_CLOSE_CODE_TRY_AGAIN_LATER, "WebSocket backpressure overflow");
+				return;
+			}
+			this.pendingOutboundMessages.push(payload);
+			this.scheduleOutboundFlush();
+		}
+		scheduleOutboundFlush(delayMs = 0) {
+			if (this.outboundFlushScheduled || this.closedInternal) {
+				return;
+			}
+			this.outboundFlushScheduled = true;
+			const flush = () => {
+				this.outboundFlushScheduled = false;
+				this.flushOutboundMessages();
+			};
+			if (delayMs > 0) {
+				setTimeout(flush, delayMs);
+				return;
+			}
+			setImmediate(flush);
+		}
+		flushOutboundMessages() {
+			if (this.closedInternal || this.socket.readyState !== WS_OPEN) {
+				return;
+			}
+			if (this.socket.bufferedAmount > MAX_SOCKET_BUFFERED_AMOUNT) {
+				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) {
+					break;
+				}
+				try {
+					this.socket.send(payload);
+				} catch {
+					this.close(WS_CLOSE_CODE_INTERNAL_ERROR, "Outbound publish failed");
+					return;
+				}
+				sent += 1;
+				if (this.socket.bufferedAmount > MAX_SOCKET_BUFFERED_AMOUNT) {
+					break;
+				}
+			}
+			if (this.pendingOutboundMessages.length > 0) {
+				this.scheduleOutboundFlush(this.socket.bufferedAmount > MAX_SOCKET_BUFFERED_AMOUNT ? OUTBOUND_RETRY_DELAY_MS : 0);
+			}
+		}
+	};
+}));
+
+//#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":";;;;;;AA+IA,SAAgB,uBAAuB,UAAmC,EAAE,EAAoB;AAC9F,QAAO,IAAI,iBAAiB,QAAQ;;AAiZtC,SAAS,iBAAiB,KAAsB;AAC9C,KAAI,OAAO,QAAQ,UAAU;AAC3B,SAAO;;AAGT,KAAI,eAAe,QAAQ;AACzB,SAAO,IAAI,SAAS,QAAQ;;AAG9B,KAAI,eAAe,aAAa;AAC9B,SAAO,OAAO,KAAK,IAAI,CAAC,SAAS,QAAQ;;AAG3C,KAAI,MAAM,QAAQ,IAAI,EAAE;AACtB,SAAO,OAAO,OAAO,IAAI,QAAQ,UAA2B,iBAAiB,OAAO,CAAC,CAAC,SACpF,QACD;;AAGH,QAAO,KAAK,UAAU,IAAI;;AAG5B,SAAS,kBAAkB,KAAoC;AAC7D,KAAI;EACF,MAAM,SAAS,KAAK,MAAM,IAAI;EAC9B,MAAM,YAAY,wBAAwB,UAAU,OAAO;AAC3D,SAAO,UAAU,UAAU,UAAU,OAAO;SACtC;AACN,SAAO;;;AAKX,SAAS,oBAAoB,QAAqC;AAChE,KAAI,CAAC,QAAQ;AACX,SAAO;;AAGT,QAAO,OAAO,WAAW,QAAQ,QAAQ,IAAI,MACzC,SACA,OAAO,KAAK,OAAO,CAAC,SAAS,GAAG,IAAI,CAAC,SAAS,QAAQ;;AAG5D,SAAS,cAAc,OAAwC;AAC7D,QAAO,OAAO,UAAU,YAAY,UAAU,QAAQ,UAAU,SAAS,WAAW;;;;mBA/jB/D;CAGjB,gBAAgB;CAChB,UAAU;CACV,YAAY;CAEZ,2BAA2B;CAC3B,2CAA2C;CAC3C,iCAAiC;CACjC,gCAAgC;CAChC,+BAA+B;CAC/B,gCAAgC;CAChC,uBAAuB;CACvB,gCAAgC;CAChC,6BAA6B;CAC7B,sBAAsB;CACtB,0BAA0B;CAG1B,0BAA0BA,IAAE,OAAO;EACvC,OAAOA,IAAE,QAAQ;EACjB,MAAMA,IAAE,SAAS;EAClB,CAAC;CAuDW,mBAAb,MAA8B;EAC5B,AAAS;EAET,YAAY,UAAmC,EAAE,EAAE;GACjD,MAAMC,kBAA4C;IAChD,QAAQ,QAAQ;IAChB,eAAe,QAAQ;IACvB,YAAY,QAAQ;IACrB;AACD,QAAK,WAAW,IAAI,kBAAkB,gBAAgB;;EAGxD,mBACE,QACA,SAC4F;AAC5F,UAAO,IAAI,wBAAwB,QAAQ;IACzC,GAAG;IACH,UAAU,KAAK;IAChB,CAAC;;EAGJ,mBAAmB,cAA4B;AAC7C,QAAK,SAAS,SAAS,aAAa;;EAGtC,UAAU,OAAe,MAAe,WAA0B;AAChE,QAAK,SAAS,UAAU,OAAO,MAAM,UAAU;;EAGjD,cAAc,QAAyB,OAAe,MAAe,WAA0B;AAC7F,QAAK,SAAS,cAAc,QAAQ,OAAO,MAAM,UAAU;;EAG7D,cAAc,QAAyB,OAAe,MAAe,WAA0B;AAC7F,QAAK,SAAS,cAAc,QAAQ,OAAO,MAAM,UAAU;;EAG7D,kBAAkB,UAA6B,OAAe,MAAqB;AACjF,QAAK,SAAS,kBAAkB,UAAU,OAAO,KAAK;;EAIxD,MAAM,SACJ,OAAe,0BACf,SAAS,wBACM;AACf,SAAM,KAAK,SAAS,SAAS,MAAM,OAAO;;;CAQxC,0BAAN,MAME;EACA,AAAS,KAAK,YAAY;EAC1B,AAAS,YAAY;EACrB,AAAS;EAET,AAAiB,iBAAiC,EAAE;EACpD,AAAiB,kBAAkB,IAAI,KAA6C;EACpF,AAAiB,kBAAoC,EAAE;EACvD,AAAiB,0BAAoC,EAAE;EACvD,AAAiB;EACjB,AAAiB;EACjB,AAAiB;EACjB,AAAiB;EACjB,AAAiB;EACjB,AAAiB;EAEjB,AAAQ,iBAAiB;EACzB,AAAQ,eAAe;EACvB,AAAQ,eAAe;EACvB,AAAQ,iBAAwD;EAChE,AAAQ,eAA8B,QAAQ,SAAS;EACvD,AAAQ,yBAAyB;EAEjC,YACE,AAAiBC,QACjB,AAAiBC,SACjB;GAFiB;GACA;AAEjB,QAAK,YAAY,QAAQ,aAAa;AACtC,QAAK,cAAc,QAAQ,aAAa;AACxC,QAAK,aAAa,QAAQ;AAC1B,QAAK,iBAAiB,QAAQ,SAAS;AACvC,QAAK,kBAAkB,QAAQ,UAAU;GAEzC,IAAIC;AACJ,QAAK,eAAe,IAAI,SAAe,YAAY;AACjD,0BAAsB;KACtB;AACF,QAAK,sBAAsB;AAE3B,QAAK,QAAQ,SAAS,SAAS,MAAM,QAAQ,UAAU,KAAK;AAC5D,QAAK,OAAO,GAAG,WAAW,KAAK,cAAc;AAC7C,QAAK,OAAO,GAAG,SAAS,KAAK,YAAY;AACzC,QAAK,OAAO,GAAG,SAAS,KAAK,YAAY;AACzC,QAAK,OAAO,GAAG,QAAQ,KAAK,WAAW;AACvC,QAAK,gBAAgB;;EAGvB,IAAI,SAAkB;AACpB,UAAO,KAAK;;EAGd,QAAQ,UAA8B;AACpC,QAAK,eAAe,KAAK,SAAS;;EAGpC,UACE,OACA,SACM;GACN,MAAM,WAAW,OAAO,MAAM;GAC9B,MAAM,WAAW,KAAK,gBAAgB,IAAI,SAAS,IAAI,EAAE;AACzD,YAAS,KAAK,QAAmC;AACjD,QAAK,gBAAgB,IAAI,UAAU,SAAS;AAC5C,QAAK,qBAAqB,SAAS;;EAGrC,QACE,OACA,MACM;AACN,QAAK,iBAAiB,OAAO,MAAM,EAAE,KAAK;;EAG5C,eAAe,OAAe,MAAqB;AACjD,QAAK,iBAAiB,OAAO,KAAK;;EAGpC,eAA8B;AAC5B,UAAO,KAAK;;EAGd,KAAK,QAA+B;AAClC,QAAK,QAAQ,SAAS,KAAK,KAAK,IAAI,OAAO;;EAG7C,MAAM,QAA+B;AACnC,QAAK,QAAQ,SAAS,MAAM,KAAK,IAAI,OAAO;;EAG9C,UAAU,QAA+B;AACvC,QAAK,QAAQ,SAAS,UAAU,KAAK,IAAI,OAAO;;EAGlD,cAAoB;AAClB,QAAK,QAAQ,SAAS,YAAY,KAAK,GAAG;;EAI5C,MAAM,MAAe,QAAuB;AAC1C,OAAI,KAAK,kBAAkB,KAAK,gBAAgB,KAAK,OAAO,eAAe,WAAW;AACpF;;AAGF,QAAK,eAAe;AACpB,OAAI;AACF,SAAK,eAAe,MAAM,OAAO;aACzB;AACR,SAAK,YAAY;;;EAKrB,AAAiB,iBAAiB,QAAiB;AACjD,QAAK,mBAAmB,YAAY;IAClC,MAAM,OAAO,iBAAiB,IAAI;AAClC,QAAI,KAAK,eAAe,aAAa,OAAO,WAAW,KAAK,GAAG,KAAK,YAAY;AAC9E,UAAK,MAAM,+BAA+B,oBAAoB;AAC9D;;IAGF,MAAM,iBAAiB,kBAAkB,KAAK;AAC9C,QAAI,CAAC,gBAAgB;AACnB,UAAK,MAAM,0CAA0C,0BAA0B;AAC/E;;AAGF,SAAK,QAAQ,SAAS,MAAM,KAAK,GAAG;AACpC,UAAM,KAAK,iBAAiB,eAAe;KAC3C;;EAGJ,AAAiB,oBAAoB;AACnC,QAAK,YAAY;;EAInB,AAAiB,oBAAoB;AACnC,QAAK,MAAM,8BAA8B,4BAA4B;;EAGvE,AAAiB,mBAAmB;AAClC,QAAK,eAAe;AACpB,QAAK,QAAQ,SAAS,MAAM,KAAK,GAAG;;EAMtC,MAAc,iBAAiB,UAAyC;GACtE,MAAM,WAAW,KAAK,gBAAgB,IAAI,SAAS,MAAM;GACzD,MAAM,SAAS,KAAK,eAAe,SAAS;AAE5C,OAAI,CAAC,QAAQ;AACX,SAAK,MAAM,gCAAgC,gBAAgB;AAC3D;;GAGF,MAAM,SAAS,OAAO,UAAU,SAAS,KAAK;AAC9C,OAAI,CAAC,OAAO,SAAS;AACnB,SAAK,MAAM,0CAA0C,qBAAqB;AAC1E;;AAGF,OAAI,CAAC,YAAY,SAAS,WAAW,GAAG;AACtC,QAAI,KAAK,gBAAgB,UAAU,sBAAsB;AACvD,UAAK,gBAAgB,OAAO;;AAE9B,SAAK,gBAAgB,KAAK,SAAS;AACnC;;AAGF,QAAK,MAAM,WAAW,UAAU;AAC9B,UAAM,QAAQ,OAAO,KAAK;;;EAI9B,AAAQ,qBAAqB,OAAqB;GAChD,MAAMC,YAA8B,EAAE;GACtC,MAAMC,UAA4B,EAAE;AAEpC,QAAK,MAAM,WAAW,KAAK,iBAAiB;AAC1C,QAAI,QAAQ,UAAU,OAAO;AAC3B,eAAU,KAAK,QAAQ;AACvB;;AAGF,YAAQ,KAAK,QAAQ;;AAGvB,QAAK,gBAAgB,SAAS;AAC9B,QAAK,gBAAgB,KAAK,GAAG,UAAU;AAEvC,QAAK,MAAM,WAAW,SAAS;AAC7B,SAAK,mBAAmB,YAAY;AAClC,WAAM,KAAK,iBAAiB,QAAQ;MACpC;;;EAIN,AAAQ,iBAAiB,OAAe,MAAqB;GAC3D,MAAM,SAAS,KAAK,gBAAgB;AACpC,OAAI,CAAC,QAAQ;AACX,UAAM,IAAI,MAAM,4BAA4B,QAAQ;;GAGtD,MAAM,SAAS,OAAO,UAAU,KAAK;AACrC,OAAI,CAAC,OAAO,SAAS;AACnB,UAAM,IAAI,MAAM,oCAAoC,QAAQ;;AAG9D,OAAI,KAAK,kBAAkB,KAAK,OAAO,eAAe,SAAS;AAC7D;;AAGF,QAAK,uBACH,KAAK,UAAU;IACb;IACA,MAAM,OAAO;IACd,CAAC,CACH;;EAKH,AAAQ,aAAmB;AACzB,OAAI,KAAK,gBAAgB;AACvB;;AAGF,QAAK,iBAAiB;AACtB,QAAK,eAAe;AACpB,QAAK,eAAe;AACpB,QAAK,OAAO,IAAI,WAAW,KAAK,cAAc;AAC9C,QAAK,OAAO,IAAI,SAAS,KAAK,YAAY;AAC1C,QAAK,OAAO,IAAI,SAAS,KAAK,YAAY;AAC1C,QAAK,OAAO,IAAI,QAAQ,KAAK,WAAW;AACxC,QAAK,eAAe;AACpB,QAAK,gBAAgB,SAAS;AAC9B,QAAK,wBAAwB,SAAS;AACtC,QAAK,QAAQ,SAAS,WAAW,KAAK,GAAG;AACzC,QAAK,MAAM,YAAY,KAAK,eAAe,OAAO,EAAE,EAAE;AACpD,QAAI;KACF,MAAM,SAAS,UAAU;AACzB,SAAI,cAAc,OAAO,EAAE;AACzB,WAAK,OAAO,YAAY,GAEtB;;YAEE;;AAIV,QAAK,qBAAqB;;EAI5B,AAAQ,iBAAuB;AAC7B,OAAI,KAAK,eAAe,GAAG;AACzB;;AAGF,QAAK,iBAAiB,kBAAkB;AACtC,QAAI,KAAK,kBAAkB,KAAK,OAAO,eAAe,SAAS;AAC7D;;AAGF,QAAI,KAAK,cAAc;AACrB,UAAK,MAAM,0BAA0B,oBAAoB;AACzD;;AAGF,SAAK,eAAe;AACpB,SAAK,OAAO,MAAM;MACjB,KAAK,YAAY;;EAGtB,AAAQ,gBAAsB;AAC5B,OAAI,CAAC,KAAK,gBAAgB;AACxB;;AAGF,iBAAc,KAAK,eAAe;AAClC,QAAK,iBAAiB;;EAIxB,AAAQ,eAAe,MAAe,QAAuB;AAC3D,OAAI;AACF,QAAI,KAAK,OAAO,eAAe,WAAW,KAAK,OAAO,eAAe,eAAe;AAClF,UAAK,OAAO,MAAM,MAAM,oBAAoB,OAAO,CAAC;AACpD;;AAGF,SAAK,OAAO,WAAW;WACjB;AACN,QAAI;AACF,UAAK,OAAO,WAAW;YACjB;;;EAOZ,AAAQ,mBAAmB,MAAiC;AAC1D,QAAK,eAAe,KAAK,aACtB,KAAK,YAAY;AAChB,QAAI,KAAK,gBAAgB;AACvB;;AAGF,UAAM,MAAM;KACZ,CACD,YAAY;AACX,SAAK,MAAM,8BAA8B,0BAA0B;KACnE;;EAIN,AAAQ,uBAAuB,SAAuB;AACpD,OAAI,KAAK,wBAAwB,UAAU,+BAA+B;AACxE,SAAK,MAAM,+BAA+B,kCAAkC;AAC5E;;AAGF,QAAK,wBAAwB,KAAK,QAAQ;AAC1C,QAAK,uBAAuB;;EAG9B,AAAQ,sBAAsB,UAAkB,GAAS;AACvD,OAAI,KAAK,0BAA0B,KAAK,gBAAgB;AACtD;;AAGF,QAAK,yBAAyB;GAC9B,MAAM,cAAc;AAClB,SAAK,yBAAyB;AAC9B,SAAK,uBAAuB;;AAG9B,OAAI,UAAU,GAAG;AACf,eAAW,OAAO,QAAQ;AAC1B;;AAGF,gBAAa,MAAM;;EAKrB,AAAQ,wBAA8B;AACpC,OAAI,KAAK,kBAAkB,KAAK,OAAO,eAAe,SAAS;AAC7D;;AAGF,OAAI,KAAK,OAAO,iBAAiB,4BAA4B;AAC3D,SAAK,sBAAsB,wBAAwB;AACnD;;GAGF,IAAI,OAAO;AACX,UACE,OAAO,uBACP,KAAK,wBAAwB,SAAS,KACtC,KAAK,OAAO,eAAe,SAC3B;IACA,MAAM,UAAU,KAAK,wBAAwB,OAAO;AACpD,QAAI,CAAC,SAAS;AACZ;;AAGF,QAAI;AACF,UAAK,OAAO,KAAK,QAAQ;YACnB;AACN,UAAK,MAAM,8BAA8B,0BAA0B;AACnE;;AAGF,YAAQ;AACR,QAAI,KAAK,OAAO,iBAAiB,4BAA4B;AAC3D;;;AAIJ,OAAI,KAAK,wBAAwB,SAAS,GAAG;AAC3C,SAAK,sBACH,KAAK,OAAO,iBAAiB,6BAA6B,0BAA0B,EACrF"}

package/dist/syncer/api-parser.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"api-parser.d.ts","sourceRoot":"","sources":["../../src/syncer/api-parser.ts"],"names":[],"mappings":"AAOA,OAAO,EAAE,KAAK,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAGrD,OAAO,EAAE,KAAK,YAAY,EAAE,MAAM,qBAAqB,CAAC;AAExD;;;;;GAKG;AACH,wBAAsB,gBAAgB,CAAC,QAAQ,EAAE,YAAY,GAAG,OAAO,CAAC,WAAW,EAAE,CAAC,CAyGrF"}
+{"version":3,"file":"api-parser.d.ts","sourceRoot":"","sources":["../../src/syncer/api-parser.ts"],"names":[],"mappings":"AAOA,OAAO,EAAE,KAAK,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAIrD,OAAO,EAAE,KAAK,YAAY,EAAE,MAAM,qBAAqB,CAAC;AAexD;;;;;GAKG;AACH,wBAAsB,gBAAgB,CAAC,QAAQ,EAAE,YAAY,GAAG,OAAO,CAAC,WAAW,EAAE,CAAC,CAmHrF"}