sonamu 0.11.16 → 0.12.0

package/dist/stream/ws-cluster-bus.d.ts

@@ -1,18 +1,23 @@
 import { type WebSocketAudience } from "./ws-audience";
+import { type MaybePromise } from "./ws-core";
+/**
+ * 노드 간 publish envelope. 원본 data 대신 발행 노드가 route별로 한 번 검증·인코딩한 frame을 싣는다.
+ * 수신 노드는 자기 메모리로 audience를 해석하고, 각 연결의 route frame을 재검증 없이 그대로 보낸다.
+ */
 export type WebSocketClusterEnvelope = {
     id: string;
     sourceNodeId: string;
-    targetNodeIds?: string[];
-    namespace?: string;
+    targetNodeIds: string[];
     audience: WebSocketAudience;
     event: string;
-    data: unknown;
+    frames: Record<string, string>;
     emittedAt: number;
 };
 export type WebSocketClusterEnvelopeHandler = (envelope: WebSocketClusterEnvelope) => void | Promise<void>;
 export interface WebSocketClusterBus {
+    readonly nodeId?: string;
     publish(envelope: WebSocketClusterEnvelope): void | Promise<void>;
-    subscribe(handler: WebSocketClusterEnvelopeHandler): () => void;
+    subscribe(handler: WebSocketClusterEnvelopeHandler): MaybePromise<() => void>;
     shutdown(): void | Promise<void>;
 }
 export declare class NoopWebSocketClusterBus implements WebSocketClusterBus {

package/dist/stream/ws-cluster-bus.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ws-cluster-bus.d.ts","sourceRoot":"","sources":["../../src/stream/ws-cluster-bus.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,iBAAiB,EAAE,MAAM,eAAe,CAAC;AAEvD,MAAM,MAAM,wBAAwB,GAAG;IACrC,EAAE,EAAE,MAAM,CAAC;IACX,YAAY,EAAE,MAAM,CAAC;IACrB,aAAa,CAAC,EAAE,MAAM,EAAE,CAAC;IACzB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,QAAQ,EAAE,iBAAiB,CAAC;IAC5B,KAAK,EAAE,MAAM,CAAC;IACd,IAAI,EAAE,OAAO,CAAC;IACd,SAAS,EAAE,MAAM,CAAC;CACnB,CAAC;AAEF,MAAM,MAAM,+BAA+B,GAAG,CAC5C,QAAQ,EAAE,wBAAwB,KAC/B,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;AAE1B,MAAM,WAAW,mBAAmB;IAClC,OAAO,CAAC,QAAQ,EAAE,wBAAwB,GAAG,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAClE,SAAS,CAAC,OAAO,EAAE,+BAA+B,GAAG,MAAM,IAAI,CAAC;IAChE,QAAQ,IAAI,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;CAClC;AAED,qBAAa,uBAAwB,YAAW,mBAAmB;IACjE,OAAO,CAAC,SAAS,EAAE,wBAAwB,GAAG,IAAI,CAAG;IAErD,SAAS,CAAC,QAAQ,EAAE,+BAA+B,GAAG,MAAM,IAAI,CAE/D;IAED,QAAQ,IAAI,IAAI,CAAG;CACpB"}
+{"version":3,"file":"ws-cluster-bus.d.ts","sourceRoot":"","sources":["../../src/stream/ws-cluster-bus.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,iBAAiB,EAAE,MAAM,eAAe,CAAC;AACvD,OAAO,EAAE,KAAK,YAAY,EAAE,MAAM,WAAW,CAAC;AAE9C;;;GAGG;AACH,MAAM,MAAM,wBAAwB,GAAG;IACrC,EAAE,EAAE,MAAM,CAAC;IACX,YAAY,EAAE,MAAM,CAAC;IACrB,aAAa,EAAE,MAAM,EAAE,CAAC;IACxB,QAAQ,EAAE,iBAAiB,CAAC;IAC5B,KAAK,EAAE,MAAM,CAAC;IAEd,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAC/B,SAAS,EAAE,MAAM,CAAC;CACnB,CAAC;AAEF,MAAM,MAAM,+BAA+B,GAAG,CAC5C,QAAQ,EAAE,wBAAwB,KAC/B,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;AAE1B,MAAM,WAAW,mBAAmB;IAElC,QAAQ,CAAC,MAAM,CAAC,EAAE,MAAM,CAAC;IACzB,OAAO,CAAC,QAAQ,EAAE,wBAAwB,GAAG,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAElE,SAAS,CAAC,OAAO,EAAE,+BAA+B,GAAG,YAAY,CAAC,MAAM,IAAI,CAAC,CAAC;IAC9E,QAAQ,IAAI,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;CAClC;AAED,qBAAa,uBAAwB,YAAW,mBAAmB;IACjE,OAAO,CAAC,SAAS,EAAE,wBAAwB,GAAG,IAAI,CAAG;IAErD,SAAS,CAAC,QAAQ,EAAE,+BAA+B,GAAG,MAAM,IAAI,CAE/D;IAED,QAAQ,IAAI,IAAI,CAAG;CACpB"}

package/dist/stream/ws-cluster-bus.js

@@ -14,4 +14,4 @@ var init_ws_cluster_bus = __esmMin((() => {
 init_ws_cluster_bus();
 export { NoopWebSocketClusterBus, init_ws_cluster_bus };
 
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoid3MtY2x1c3Rlci1idXMuanMiLCJuYW1lcyI6W10sInNvdXJjZXMiOlsiLi4vLi4vc3JjL3N0cmVhbS93cy1jbHVzdGVyLWJ1cy50cyJdLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyB0eXBlIFdlYlNvY2tldEF1ZGllbmNlIH0gZnJvbSBcIi4vd3MtYXVkaWVuY2VcIjtcblxuZXhwb3J0IHR5cGUgV2ViU29ja2V0Q2x1c3RlckVudmVsb3BlID0ge1xuICBpZDogc3RyaW5nO1xuICBzb3VyY2VOb2RlSWQ6IHN0cmluZztcbiAgdGFyZ2V0Tm9kZUlkcz86IHN0cmluZ1tdO1xuICBuYW1lc3BhY2U/OiBzdHJpbmc7XG4gIGF1ZGllbmNlOiBXZWJTb2NrZXRBdWRpZW5jZTtcbiAgZXZlbnQ6IHN0cmluZztcbiAgZGF0YTogdW5rbm93bjtcbiAgZW1pdHRlZEF0OiBudW1iZXI7XG59O1xuXG5leHBvcnQgdHlwZSBXZWJTb2NrZXRDbHVzdGVyRW52ZWxvcGVIYW5kbGVyID0gKFxuICBlbnZlbG9wZTogV2ViU29ja2V0Q2x1c3RlckVudmVsb3BlLFxuKSA9PiB2b2lkIHwgUHJvbWlzZTx2b2lkPjtcblxuZXhwb3J0IGludGVyZmFjZSBXZWJTb2NrZXRDbHVzdGVyQnVzIHtcbiAgcHVibGlzaChlbnZlbG9wZTogV2ViU29ja2V0Q2x1c3RlckVudmVsb3BlKTogdm9pZCB8IFByb21pc2U8dm9pZD47XG4gIHN1YnNjcmliZShoYW5kbGVyOiBXZWJTb2NrZXRDbHVzdGVyRW52ZWxvcGVIYW5kbGVyKTogKCkgPT4gdm9pZDtcbiAgc2h1dGRvd24oKTogdm9pZCB8IFByb21pc2U8dm9pZD47XG59XG5cbmV4cG9ydCBjbGFzcyBOb29wV2ViU29ja2V0Q2x1c3RlckJ1cyBpbXBsZW1lbnRzIFdlYlNvY2tldENsdXN0ZXJCdXMge1xuICBwdWJsaXNoKF9lbnZlbG9wZTogV2ViU29ja2V0Q2x1c3RlckVudmVsb3BlKTogdm9pZCB7fVxuXG4gIHN1YnNjcmliZShfaGFuZGxlcjogV2ViU29ja2V0Q2x1c3RlckVudmVsb3BlSGFuZGxlcik6ICgpID0+IHZvaWQge1xuICAgIHJldHVybiAoKSA9PiB7fTtcbiAgfVxuXG4gIHNodXRkb3duKCk6IHZvaWQge31cbn1cbiJdLCJtYXBwaW5ncyI6Ijs7OztDQXVCYSwwQkFBYixNQUFvRTtFQUNsRSxRQUFRLFdBQTJDLENBQUM7RUFFcEQsVUFBVSxVQUF1RDtHQUMvRCxhQUFhLENBQUM7RUFDaEI7RUFFQSxXQUFpQixDQUFDO0NBQ3BCIn0=
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

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

@@ -1,5 +1,7 @@
+import { type z } from "zod";
 export type WebSocketUserId = number | string;
 export type WebSocketRoomId = string;
+export type MaybePromise<T> = T | Promise<T>;
 export interface ManagedWebSocketConnection {
     id: string;
     namespace: string;
@@ -8,6 +10,14 @@ export interface ManagedWebSocketConnection {
     publishUntyped<Data>(event: string, data: Data): void;
     close(code?: number, reason?: string): void;
 }
+/**
+ * registry가 소유하는 로컬 연결. 인코딩된 frame을 그대로 보내는 경로와 route 식별자를 가진다.
+ */
+export interface WebSocketFrameConnection extends ManagedWebSocketConnection {
+    readonly routeKey?: string;
+    readonly outEvents: z.ZodObject;
+    sendFrame(event: string, frame: string): void;
+}
 export type WebSocketRegistryStats = {
     totalConnections: number;
     totalRooms: number;

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

@@ -1 +1 @@
-{"version":3,"file":"ws-core.d.ts","sourceRoot":"","sources":["../../src/stream/ws-core.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,eAAe,GAAG,MAAM,GAAG,MAAM,CAAC;AAC9C,MAAM,MAAM,eAAe,GAAG,MAAM,CAAC;AAErC,MAAM,WAAW,0BAA0B;IACzC,EAAE,EAAE,MAAM,CAAC;IACX,SAAS,EAAE,MAAM,CAAC;IAClB,MAAM,EAAE,OAAO,CAAC;IAEhB,QAAQ,CAAC,MAAM,CAAC,EAAE,MAAM,CAAC;IACzB,cAAc,CAAC,IAAI,EAAE,KAAK,EAAE,MAAM,EAAE,IAAI,EAAE,IAAI,GAAG,IAAI,CAAC;IACtD,KAAK,CAAC,IAAI,CAAC,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;CAC7C;AAED,MAAM,MAAM,sBAAsB,GAAG;IACnC,gBAAgB,EAAE,MAAM,CAAC;IACzB,UAAU,EAAE,MAAM,CAAC;IACnB,WAAW,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CACrC,CAAC"}
+{"version":3,"file":"ws-core.d.ts","sourceRoot":"","sources":["../../src/stream/ws-core.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,CAAC,EAAE,MAAM,KAAK,CAAC;AAE7B,MAAM,MAAM,eAAe,GAAG,MAAM,GAAG,MAAM,CAAC;AAC9C,MAAM,MAAM,eAAe,GAAG,MAAM,CAAC;AACrC,MAAM,MAAM,YAAY,CAAC,CAAC,IAAI,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,CAAC;AAE7C,MAAM,WAAW,0BAA0B;IACzC,EAAE,EAAE,MAAM,CAAC;IACX,SAAS,EAAE,MAAM,CAAC;IAClB,MAAM,EAAE,OAAO,CAAC;IAEhB,QAAQ,CAAC,MAAM,CAAC,EAAE,MAAM,CAAC;IACzB,cAAc,CAAC,IAAI,EAAE,KAAK,EAAE,MAAM,EAAE,IAAI,EAAE,IAAI,GAAG,IAAI,CAAC;IACtD,KAAK,CAAC,IAAI,CAAC,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;CAC7C;AAED;;GAEG;AACH,MAAM,WAAW,wBAAyB,SAAQ,0BAA0B;IAE1E,QAAQ,CAAC,QAAQ,CAAC,EAAE,MAAM,CAAC;IAE3B,QAAQ,CAAC,SAAS,EAAE,CAAC,CAAC,SAAS,CAAC;IAChC,SAAS,CAAC,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,IAAI,CAAC;CAC/C;AAED,MAAM,MAAM,sBAAsB,GAAG;IACnC,gBAAgB,EAAE,MAAM,CAAC;IACzB,UAAU,EAAE,MAAM,CAAC;IACnB,WAAW,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CACrC,CAAC"}

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

@@ -1,32 +1,58 @@
+import { type z } from "zod";
 import { type WebSocketAudience } from "./ws-audience";
 import { type WebSocketAudienceResolver } from "./ws-audience-resolver";
 import { type WebSocketClusterBus } from "./ws-cluster-bus";
 import { type WebSocketLocalConnectionStore } from "./ws-local-connection-store";
 import { type WebSocketTelemetryController } from "./ws-telemetry";
+export type WebSocketRouteDefinition = {
+    routeKey: string;
+    outEvents: z.ZodObject;
+};
 export declare class WebSocketDeliveryEngine {
     private readonly options;
     private readonly pendingFanOutJobs;
     private fanOutFlushScheduled;
-    private readonly unsubscribe;
+    private readonly routes;
+    private publishQueue;
+    private readonly subscription;
+    private stopped;
     private readonly telemetry;
     private readonly unregisterMetricSource;
     constructor(options: {
         nodeId: string;
         localConnections: WebSocketLocalConnectionStore;
+        resolveLocalSessionIds: (audience: WebSocketAudience) => string[];
         audienceResolver: WebSocketAudienceResolver;
         clusterBus: WebSocketClusterBus;
         telemetryController?: WebSocketTelemetryController;
     });
-    publishToAudience<Data>(audience: WebSocketAudience, event: string, data: Data): void;
-    shutdown(): Promise<void>;
+    registerRoute(routeKey: string, outEvents: z.ZodObject): void;
+    replaceRoutes(routes: WebSocketRouteDefinition[]): void;
+    /**
+     * 발행 노드에서 route별로 한 번 검증·인코딩하고, 로컬 fan-out은 즉시 큐에 넣는다.
+     * 원격 라우팅과 cluster publish는 노드 단위 직렬 큐에서 처리한다. 반환한 promise는 reject하지 않는다.
+     */
+    publishToAudience<Data>(audience: WebSocketAudience, event: string, data: Data): Promise<void>;
+    drainPublishes(): Promise<void>;
+    /**
+     * 구독을 해제하고 cluster bus를 종료한다. 구독이 deadline까지 끝나지 않으면 늦게 끝날 때 해제한다.
+     */
+    shutdown(deadline: Promise<void>): Promise<void>;
     getTelemetrySnapshot(): {
         pendingFanOutJobs: number;
         pendingFanOutTargets: number;
     };
+    private subscribe;
+    private safeUnsubscribe;
+    private resolveRemoteNodeIds;
+    private publishRemote;
     private handleClusterEnvelope;
+    private emitPublishRejected;
+    private emitRouteFailed;
+    private emitFanOutResolved;
     private enqueueFanOut;
     private scheduleFanOutFlush;
     private flushFanOutJobs;
-    private safePublish;
+    private safeSend;
 }
 //# sourceMappingURL=ws-delivery.d.ts.map

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

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

package/dist/stream/ws-delivery.js

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

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

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

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

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