@gencow/core 0.1.24 → 0.1.26

package/src/__tests__/load.test.ts

@@ -7,370 +7,383 @@
  */
 
 import { describe, it, expect } from "bun:test";
-import {
-    buildRealtimeCtx,
-    subscribe,
-    registerClient,
-    deregisterClient,
-} from "../reactive";
-import type { GencowCtx } from "../reactive";
+import { buildRealtimeCtx, subscribe, registerClient, deregisterClient } from "../reactive.js";
+import type { GencowCtx } from "../reactive.js";
 
 // ─── Mock WSContext ───────────────────────────────────────────────────────────
 
 function makeMockWs(id = 0) {
-    let sendCount = 0;
-    let lastPayloadBytes = 0;
-    return {
-        send: (msg: string) => {
-            sendCount++;
-            lastPayloadBytes = msg.length;
-        },
-        readyState: 1,
-        id,
-        get sendCount() { return sendCount; },
-        get lastPayloadBytes() { return lastPayloadBytes; },
-    } as any;
+  let sendCount = 0;
+  let lastPayloadBytes = 0;
+  return {
+    send: (msg: string) => {
+      sendCount++;
+      lastPayloadBytes = msg.length;
+    },
+    readyState: 1,
+    id,
+    get sendCount() {
+      return sendCount;
+    },
+    get lastPayloadBytes() {
+      return lastPayloadBytes;
+    },
+  } as any;
 }
 
 // 메시지 타입을 추적하는 WS (비교 테스트용)
 function makeTrackedWs(id = 0) {
-    type Msg = { type: string; hasData: boolean };
-    const received: Msg[] = [];
-    return {
-        send: (msg: string) => {
-            const parsed = JSON.parse(msg);
-            received.push({
-                type: parsed.type,
-                hasData: parsed.data !== undefined,
-            });
-        },
-        readyState: 1,
-        id,
-        get received() { return received; },
-        get sendCount() { return received.length; },
-    } as any;
+  type Msg = { type: string; hasData: boolean };
+  const received: Msg[] = [];
+  return {
+    send: (msg: string) => {
+      const parsed = JSON.parse(msg);
+      received.push({
+        type: parsed.type,
+        hasData: parsed.data !== undefined,
+      });
+    },
+    readyState: 1,
+    id,
+    get received() {
+      return received;
+    },
+    get sendCount() {
+      return received.length;
+    },
+  } as any;
 }
 
-const wait = (ms: number) => new Promise(r => setTimeout(r, ms));
+const wait = (ms: number) => new Promise((r) => setTimeout(r, ms));
 
 function makeUniqueKey(prefix: string) {
-    return `${prefix}.${Math.random().toString(36).slice(2)}`;
+  return `${prefix}.${Math.random().toString(36).slice(2)}`;
 }
 
 // ─── 1. 다수 구독자 throughput ────────────────────────────────────────────────
 
 describe("[Load] 다수 구독자 emit 처리량", () => {
-    it("1,000명 구독자에게 emit이 150ms 이내에 완료된다", async () => {
-        const N = 1_000;
-        const key = makeUniqueKey("load1k");
-        const clients = Array.from({ length: N }, (_, i) => makeMockWs(i));
-        clients.forEach(ws => subscribe(key, ws));
-
-        const rt = buildRealtimeCtx();
-        const start = performance.now();
-        rt.emit(key, [{ id: 1, title: "Task 1" }]);
-        await wait(60);
-        const elapsed = performance.now() - start;
-
-        console.log(`[throughput]  1,000 subscribers → ${elapsed.toFixed(1)}ms`);
-        expect(clients.filter(ws => ws.sendCount === 1).length).toBe(N);
-        expect(elapsed).toBeLessThan(150);
-        clients.forEach(ws => deregisterClient(ws));
-    });
-
-    it("5,000명 구독자에게 emit이 300ms 이내에 완료된다", async () => {
-        const N = 5_000;
-        const key = makeUniqueKey("load5k");
-        const clients = Array.from({ length: N }, (_, i) => makeMockWs(i));
-        clients.forEach(ws => subscribe(key, ws));
-
-        const rt = buildRealtimeCtx();
-        const start = performance.now();
-        rt.emit(key, [{ id: 1 }]);
-        await wait(60);
-        const elapsed = performance.now() - start;
-
-        console.log(`[throughput]  5,000 subscribers → ${elapsed.toFixed(1)}ms`);
-        expect(clients.filter(ws => ws.sendCount === 1).length).toBe(N);
-        expect(elapsed).toBeLessThan(300);
-        clients.forEach(ws => deregisterClient(ws));
-    });
-
-    it("10,000명 구독자에게 emit이 500ms 이내에 완료된다", async () => {
-        const N = 10_000;
-        const key = makeUniqueKey("load10k");
-        const clients = Array.from({ length: N }, (_, i) => makeMockWs(i));
-        clients.forEach(ws => subscribe(key, ws));
-
-        const rt = buildRealtimeCtx();
-        const start = performance.now();
-        rt.emit(key, [{ id: 1 }]);
-        await wait(60);
-        const elapsed = performance.now() - start;
-
-        console.log(`[throughput] 10,000 subscribers → ${elapsed.toFixed(1)}ms`);
-        expect(clients.filter(ws => ws.sendCount === 1).length).toBe(N);
-        expect(elapsed).toBeLessThan(500);
-        clients.forEach(ws => deregisterClient(ws));
-    });
-
-    it("50,000명 구독자에게 emit이 2,000ms 이내에 완료된다", async () => {
-        const N = 50_000;
-        const key = makeUniqueKey("load50k");
-        const clients = Array.from({ length: N }, (_, i) => makeMockWs(i));
-        clients.forEach(ws => subscribe(key, ws));
-
-        const rt = buildRealtimeCtx();
-        const start = performance.now();
-        rt.emit(key, [{ id: 1 }]);
-        await wait(60);
-        const elapsed = performance.now() - start;
-
-        console.log(`[throughput] 50,000 subscribers → ${elapsed.toFixed(1)}ms`);
-        expect(clients.filter(ws => ws.sendCount === 1).length).toBe(N);
-        expect(elapsed).toBeLessThan(2_000);
-        clients.forEach(ws => deregisterClient(ws));
-    });
-
-    it("100,000명 구독자에게 emit이 5,000ms 이내에 완료된다", async () => {
-        const N = 100_000;
-        const key = makeUniqueKey("load100k");
-        const clients = Array.from({ length: N }, (_, i) => makeMockWs(i));
-        clients.forEach(ws => subscribe(key, ws));
-
-        const rt = buildRealtimeCtx();
-        const start = performance.now();
-        rt.emit(key, [{ id: 1 }]);
-        await wait(60);
-        const elapsed = performance.now() - start;
-
-        console.log(`[throughput]100,000 subscribers → ${elapsed.toFixed(1)}ms`);
-        expect(clients.filter(ws => ws.sendCount === 1).length).toBe(N);
-        expect(elapsed).toBeLessThan(5_000);
-        clients.forEach(ws => deregisterClient(ws));
-    });
+  it("1,000명 구독자에게 emit이 150ms 이내에 완료된다", async () => {
+    const N = 1_000;
+    const key = makeUniqueKey("load1k");
+    const clients = Array.from({ length: N }, (_, i) => makeMockWs(i));
+    clients.forEach((ws) => subscribe(key, ws));
+
+    const rt = buildRealtimeCtx();
+    const start = performance.now();
+    rt.emit(key, [{ id: 1, title: "Task 1" }]);
+    await wait(60);
+    const elapsed = performance.now() - start;
+
+    console.log(`[throughput]  1,000 subscribers → ${elapsed.toFixed(1)}ms`);
+    expect(clients.filter((ws) => ws.sendCount === 1).length).toBe(N);
+    expect(elapsed).toBeLessThan(150);
+    clients.forEach((ws) => deregisterClient(ws));
+  });
+
+  it("5,000명 구독자에게 emit이 300ms 이내에 완료된다", async () => {
+    const N = 5_000;
+    const key = makeUniqueKey("load5k");
+    const clients = Array.from({ length: N }, (_, i) => makeMockWs(i));
+    clients.forEach((ws) => subscribe(key, ws));
+
+    const rt = buildRealtimeCtx();
+    const start = performance.now();
+    rt.emit(key, [{ id: 1 }]);
+    await wait(60);
+    const elapsed = performance.now() - start;
+
+    console.log(`[throughput]  5,000 subscribers → ${elapsed.toFixed(1)}ms`);
+    expect(clients.filter((ws) => ws.sendCount === 1).length).toBe(N);
+    expect(elapsed).toBeLessThan(300);
+    clients.forEach((ws) => deregisterClient(ws));
+  });
+
+  it("10,000명 구독자에게 emit이 500ms 이내에 완료된다", async () => {
+    const N = 10_000;
+    const key = makeUniqueKey("load10k");
+    const clients = Array.from({ length: N }, (_, i) => makeMockWs(i));
+    clients.forEach((ws) => subscribe(key, ws));
+
+    const rt = buildRealtimeCtx();
+    const start = performance.now();
+    rt.emit(key, [{ id: 1 }]);
+    await wait(60);
+    const elapsed = performance.now() - start;
+
+    console.log(`[throughput] 10,000 subscribers → ${elapsed.toFixed(1)}ms`);
+    expect(clients.filter((ws) => ws.sendCount === 1).length).toBe(N);
+    expect(elapsed).toBeLessThan(500);
+    clients.forEach((ws) => deregisterClient(ws));
+  });
+
+  it("50,000명 구독자에게 emit이 2,000ms 이내에 완료된다", async () => {
+    const N = 50_000;
+    const key = makeUniqueKey("load50k");
+    const clients = Array.from({ length: N }, (_, i) => makeMockWs(i));
+    clients.forEach((ws) => subscribe(key, ws));
+
+    const rt = buildRealtimeCtx();
+    const start = performance.now();
+    rt.emit(key, [{ id: 1 }]);
+    await wait(60);
+    const elapsed = performance.now() - start;
+
+    console.log(`[throughput] 50,000 subscribers → ${elapsed.toFixed(1)}ms`);
+    expect(clients.filter((ws) => ws.sendCount === 1).length).toBe(N);
+    expect(elapsed).toBeLessThan(2_000);
+    clients.forEach((ws) => deregisterClient(ws));
+  });
+
+  it("100,000명 구독자에게 emit이 5,000ms 이내에 완료된다", async () => {
+    const N = 100_000;
+    const key = makeUniqueKey("load100k");
+    const clients = Array.from({ length: N }, (_, i) => makeMockWs(i));
+    clients.forEach((ws) => subscribe(key, ws));
+
+    const rt = buildRealtimeCtx();
+    const start = performance.now();
+    rt.emit(key, [{ id: 1 }]);
+    await wait(60);
+    const elapsed = performance.now() - start;
+
+    console.log(`[throughput]100,000 subscribers → ${elapsed.toFixed(1)}ms`);
+    expect(clients.filter((ws) => ws.sendCount === 1).length).toBe(N);
+    expect(elapsed).toBeLessThan(5_000);
+    clients.forEach((ws) => deregisterClient(ws));
+  });
 });
 
 // ─── 2. 동시 다수 queryKey emit 처리량 ─────────────────────────────────────
 
 describe("[Load] 동시 다수 queryKey emit", () => {
-    it("100개 queryKey × 100명 구독자 emit을 200ms 이내에 처리한다", async () => {
-        const KEYS = 100;
-        const SUBS_PER_KEY = 100;
-        const keyMap: { key: string; clients: any[] }[] = [];
-
-        for (let k = 0; k < KEYS; k++) {
-            const key = makeUniqueKey(`multi.${k}`);
-            const clients = Array.from({ length: SUBS_PER_KEY }, (_, i) => makeMockWs(k * 1000 + i));
-            clients.forEach(ws => subscribe(key, ws));
-            keyMap.push({ key, clients });
-        }
-
-        const rt = buildRealtimeCtx();
-        const start = performance.now();
-        for (const { key } of keyMap) {
-            rt.emit(key, [{ id: Math.random() }]);
-        }
-        await wait(80);
-        const elapsed = performance.now() - start;
-
-        console.log(`[multi-key] 100 keys × 100 subs → ${elapsed.toFixed(1)}ms`);
-
-        const totalReceived = keyMap.reduce(
-            (acc, { clients }) => acc + clients.filter(ws => ws.sendCount === 1).length,
-            0
-        );
-        expect(totalReceived).toBe(KEYS * SUBS_PER_KEY);
-        expect(elapsed).toBeLessThan(200);
-
-        keyMap.forEach(({ clients }) => clients.forEach(ws => deregisterClient(ws)));
-    });
+  it("100개 queryKey × 100명 구독자 emit을 200ms 이내에 처리한다", async () => {
+    const KEYS = 100;
+    const SUBS_PER_KEY = 100;
+    const keyMap: { key: string; clients: any[] }[] = [];
+
+    for (let k = 0; k < KEYS; k++) {
+      const key = makeUniqueKey(`multi.${k}`);
+      const clients = Array.from({ length: SUBS_PER_KEY }, (_, i) => makeMockWs(k * 1000 + i));
+      clients.forEach((ws) => subscribe(key, ws));
+      keyMap.push({ key, clients });
+    }
+
+    const rt = buildRealtimeCtx();
+    const start = performance.now();
+    for (const { key } of keyMap) {
+      rt.emit(key, [{ id: Math.random() }]);
+    }
+    await wait(80);
+    const elapsed = performance.now() - start;
+
+    console.log(`[multi-key] 100 keys × 100 subs → ${elapsed.toFixed(1)}ms`);
+
+    const totalReceived = keyMap.reduce(
+      (acc, { clients }) => acc + clients.filter((ws) => ws.sendCount === 1).length,
+      0,
+    );
+    expect(totalReceived).toBe(KEYS * SUBS_PER_KEY);
+    expect(elapsed).toBeLessThan(200);
+
+    keyMap.forEach(({ clients }) => clients.forEach((ws) => deregisterClient(ws)));
+  });
 });
 
 // ─── 3. debounce 효율 ────────────────────────────────────────────────────────
 
 describe("[Load] 빠른 연속 emit debounce 효율", () => {
-    it("50ms 이내 100번 연속 emit은 단 1회만 전송된다", async () => {
-        const key = makeUniqueKey("debounce.stress");
-        const ws = makeMockWs();
-        subscribe(key, ws);
-
-        const rt = buildRealtimeCtx();
-        for (let i = 0; i < 100; i++) {
-            rt.emit(key, [{ id: i, title: `Task ${i}` }]);
-        }
-        await wait(80);
-
-        console.log(`[debounce] 100 rapid emits → ${ws.sendCount} actual sends`);
-        expect(ws.sendCount).toBe(1);
-
-        deregisterClient(ws);
-    });
-
-    it("debounce 효율: 1,000번 emit → 전송 횟수 감소율 99% 이상", async () => {
-        const key = makeUniqueKey("debounce.efficiency");
-        const ws = makeMockWs();
-        subscribe(key, ws);
-
-        const rt = buildRealtimeCtx();
-        const RAPID = 1_000;
-        const emitStart = performance.now();
-        for (let i = 0; i < RAPID; i++) {
-            rt.emit(key, Array.from({ length: 10 }, (_, j) => ({ id: j, value: i })));
-        }
-        const emitTime = performance.now() - emitStart;
-        await wait(80);
-
-        const reductionRate = ((RAPID - ws.sendCount) / RAPID) * 100;
-        console.log(`[debounce] emits: ${RAPID}, sends: ${ws.sendCount}, reduction: ${reductionRate.toFixed(1)}%, loop: ${emitTime.toFixed(1)}ms`);
-
-        expect(reductionRate).toBeGreaterThanOrEqual(99);
-        expect(ws.sendCount).toBe(1);
-        expect(emitTime).toBeLessThan(100);
-
-        deregisterClient(ws);
-    });
+  it("50ms 이내 100번 연속 emit은 단 1회만 전송된다", async () => {
+    const key = makeUniqueKey("debounce.stress");
+    const ws = makeMockWs();
+    subscribe(key, ws);
+
+    const rt = buildRealtimeCtx();
+    for (let i = 0; i < 100; i++) {
+      rt.emit(key, [{ id: i, title: `Task ${i}` }]);
+    }
+    await wait(80);
+
+    console.log(`[debounce] 100 rapid emits → ${ws.sendCount} actual sends`);
+    expect(ws.sendCount).toBe(1);
+
+    deregisterClient(ws);
+  });
+
+  it("debounce 효율: 1,000번 emit → 전송 횟수 감소율 99% 이상", async () => {
+    const key = makeUniqueKey("debounce.efficiency");
+    const ws = makeMockWs();
+    subscribe(key, ws);
+
+    const rt = buildRealtimeCtx();
+    const RAPID = 1_000;
+    const emitStart = performance.now();
+    for (let i = 0; i < RAPID; i++) {
+      rt.emit(
+        key,
+        Array.from({ length: 10 }, (_, j) => ({ id: j, value: i })),
+      );
+    }
+    const emitTime = performance.now() - emitStart;
+    await wait(80);
+
+    const reductionRate = ((RAPID - ws.sendCount) / RAPID) * 100;
+    console.log(
+      `[debounce] emits: ${RAPID}, sends: ${ws.sendCount}, reduction: ${reductionRate.toFixed(1)}%, loop: ${emitTime.toFixed(1)}ms`,
+    );
+
+    expect(reductionRate).toBeGreaterThanOrEqual(99);
+    expect(ws.sendCount).toBe(1);
+    expect(emitTime).toBeLessThan(100);
+
+    deregisterClient(ws);
+  });
 });
 
 // ─── 4. connect/disconnect 반복 안정성 ─────────────────────────────────────
 
 describe("[Load] 클라이언트 connect/disconnect 안정성", () => {
-    it("10,000번 connect/disconnect 반복 후 메모리 안정적이다", () => {
-        const CYCLES = 10_000;
-        const key = makeUniqueKey("churn.list");
-        const before = process.memoryUsage().heapUsed;
-
-        for (let i = 0; i < CYCLES; i++) {
-            const ws = makeMockWs(i);
-            registerClient(ws);
-            subscribe(key, ws);
-            deregisterClient(ws);
-        }
-
-        const after = process.memoryUsage().heapUsed;
-        const diffMB = (after - before) / 1024 / 1024;
-        console.log(`[churn] 10k connect/disconnect → heap diff: ${diffMB.toFixed(2)}MB`);
-
-        expect(diffMB).toBeLessThan(50);
-    });
-
-    it("zombie ws(send throw)는 emit 후 자동 정리되고 이후 정상 클라이언트는 영향 없다", async () => {
-        const key = makeUniqueKey("dead.cleanup");
-        let throwCount = 0;
-
-        const zombieWs = {
-            send: () => { throwCount++; throw new Error("WebSocket closed"); },
-            readyState: 3,
-        } as any;
-        subscribe(key, zombieWs);
-
-        const rt = buildRealtimeCtx();
-        rt.emit(key, [{ id: 1 }]);
-        await wait(80);
-        expect(throwCount).toBe(1);
-
-        // zombie 정리 후 정상 클라이언트 추가
-        const normalWs = makeMockWs();
-        subscribe(key, normalWs);
-
-        const rt2 = buildRealtimeCtx();
-        rt2.emit(key, [{ id: 2 }]);
-        await wait(80);
-
-        expect(normalWs.sendCount).toBe(1);
-        deregisterClient(normalWs);
-    });
+  it("10,000번 connect/disconnect 반복 후 메모리 안정적이다", () => {
+    const CYCLES = 10_000;
+    const key = makeUniqueKey("churn.list");
+    const before = process.memoryUsage().heapUsed;
+
+    for (let i = 0; i < CYCLES; i++) {
+      const ws = makeMockWs(i);
+      registerClient(ws);
+      subscribe(key, ws);
+      deregisterClient(ws);
+    }
+
+    const after = process.memoryUsage().heapUsed;
+    const diffMB = (after - before) / 1024 / 1024;
+    console.log(`[churn] 10k connect/disconnect → heap diff: ${diffMB.toFixed(2)}MB`);
+
+    expect(diffMB).toBeLessThan(50);
+  });
+
+  it("zombie ws(send throw)는 emit 후 자동 정리되고 이후 정상 클라이언트는 영향 없다", async () => {
+    const key = makeUniqueKey("dead.cleanup");
+    let throwCount = 0;
+
+    const zombieWs = {
+      send: () => {
+        throwCount++;
+        throw new Error("WebSocket closed");
+      },
+      readyState: 3,
+    } as any;
+    subscribe(key, zombieWs);
+
+    const rt = buildRealtimeCtx();
+    rt.emit(key, [{ id: 1 }]);
+    await wait(80);
+    expect(throwCount).toBe(1);
+
+    // zombie 정리 후 정상 클라이언트 추가
+    const normalWs = makeMockWs();
+    subscribe(key, normalWs);
+
+    const rt2 = buildRealtimeCtx();
+    rt2.emit(key, [{ id: 2 }]);
+    await wait(80);
+
+    expect(normalWs.sendCount).toBe(1);
+    deregisterClient(normalWs);
+  });
 });
 
 // ─── 5. 대용량 페이로드 성능 ─────────────────────────────────────────────────
 
 describe("[Load] 대용량 페이로드 emit 성능", () => {
-    it("10,000행 데이터셋을 100명 구독자에게 500ms 이내에 전송한다", async () => {
-        const N_ROWS = 10_000;
-        const N_SUBS = 100;
-        const key = makeUniqueKey("large.payload");
-
-        const largeDataset = Array.from({ length: N_ROWS }, (_, i) => ({
-            id: i,
-            title: `Task ${i}`,
-            description: `Description for task ${i} to simulate real content length`,
-            done: i % 2 === 0,
-            createdAt: new Date().toISOString(),
-            tags: ["alpha", "beta", "gamma"],
-        }));
-
-        const clients = Array.from({ length: N_SUBS }, (_, i) => makeMockWs(i));
-        clients.forEach(ws => subscribe(key, ws));
-
-        const rt = buildRealtimeCtx();
-        const start = performance.now();
-        rt.emit(key, largeDataset);
-        await wait(80);
-        const elapsed = performance.now() - start;
-
-        const payloadKB = clients[0]?.lastPayloadBytes / 1024;
-        console.log(`[large payload] ${N_ROWS} rows × ${N_SUBS} subs → ${elapsed.toFixed(1)}ms, payload: ${payloadKB.toFixed(1)}KB`);
-
-        const received = clients.filter(ws => ws.sendCount === 1).length;
-        expect(received).toBe(N_SUBS);
-        expect(elapsed).toBeLessThan(500);
-
-        clients.forEach(ws => deregisterClient(ws));
-    });
+  it("10,000행 데이터셋을 100명 구독자에게 500ms 이내에 전송한다", async () => {
+    const N_ROWS = 10_000;
+    const N_SUBS = 100;
+    const key = makeUniqueKey("large.payload");
+
+    const largeDataset = Array.from({ length: N_ROWS }, (_, i) => ({
+      id: i,
+      title: `Task ${i}`,
+      description: `Description for task ${i} to simulate real content length`,
+      done: i % 2 === 0,
+      createdAt: new Date().toISOString(),
+      tags: ["alpha", "beta", "gamma"],
+    }));
+
+    const clients = Array.from({ length: N_SUBS }, (_, i) => makeMockWs(i));
+    clients.forEach((ws) => subscribe(key, ws));
+
+    const rt = buildRealtimeCtx();
+    const start = performance.now();
+    rt.emit(key, largeDataset);
+    await wait(80);
+    const elapsed = performance.now() - start;
+
+    const payloadKB = clients[0]?.lastPayloadBytes / 1024;
+    console.log(
+      `[large payload] ${N_ROWS} rows × ${N_SUBS} subs → ${elapsed.toFixed(1)}ms, payload: ${payloadKB.toFixed(1)}KB`,
+    );
+
+    const received = clients.filter((ws) => ws.sendCount === 1).length;
+    expect(received).toBe(N_SUBS);
+    expect(elapsed).toBeLessThan(500);
+
+    clients.forEach((ws) => deregisterClient(ws));
+  });
 });
 
 // ─── 6. emit broadcast 확장성 (컨넥튰드 클라이언트 기반) ─────────────────────────
 
 describe("[Load] emit broadcast 확장성", () => {
-    it("1,000개 구독자에게 emit이 50ms 이내에 완료된다", async () => {
-        const N = 1_000;
-        const key = makeUniqueKey("broadcast1k");
-        const clients = Array.from({ length: N }, (_, i) => makeMockWs(i));
-        clients.forEach(ws => subscribe(key, ws));
+  it("1,000개 구독자에게 emit이 50ms 이내에 완료된다", async () => {
+    const N = 1_000;
+    const key = makeUniqueKey("broadcast1k");
+    const clients = Array.from({ length: N }, (_, i) => makeMockWs(i));
+    clients.forEach((ws) => subscribe(key, ws));
 
-        const start = performance.now();
-        buildRealtimeCtx().emit(key, [{ id: 1 }, { id: 2 }]);
-        await wait(60);
-        const elapsed = performance.now() - start;
+    const start = performance.now();
+    buildRealtimeCtx().emit(key, [{ id: 1 }, { id: 2 }]);
+    await wait(60);
+    const elapsed = performance.now() - start;
 
-        console.log(`[broadcast] 1,000 subscribers → ${elapsed.toFixed(1)}ms`);
+    console.log(`[broadcast] 1,000 subscribers → ${elapsed.toFixed(1)}ms`);
 
-        const received = clients.filter(ws => ws.sendCount === 1).length;
-        expect(received).toBe(N);
-        expect(elapsed).toBeLessThan(100); // emit has 50ms debounce
+    const received = clients.filter((ws) => ws.sendCount === 1).length;
+    expect(received).toBe(N);
+    expect(elapsed).toBeLessThan(100); // emit has 50ms debounce
 
-        clients.forEach(ws => deregisterClient(ws));
-    });
+    clients.forEach((ws) => deregisterClient(ws));
+  });
 });
 
 // ─── 7. Push emit 포맷 검증 ───────────────────────────────────────────────
 
 describe("[Load] Push emit 포맷 검증", () => {
-    it("emit(push)은 query:updated+data를 실제 페이로드와 함께 전달한다", async () => {
-        const N_SUBS = 500;
-        const keyPush = makeUniqueKey("compare.push");
+  it("emit(push)은 query:updated+data를 실제 페이로드와 함께 전달한다", async () => {
+    const N_SUBS = 500;
+    const keyPush = makeUniqueKey("compare.push");
 
-        // push: 구독 클라이언트 (query:updated 수신 예상)
-        const pushClients = Array.from({ length: N_SUBS }, (_, i) => makeTrackedWs(i));
-        pushClients.forEach(ws => subscribe(keyPush, ws));
+    // push: 구독 클라이언트 (query:updated 수신 예상)
+    const pushClients = Array.from({ length: N_SUBS }, (_, i) => makeTrackedWs(i));
+    pushClients.forEach((ws) => subscribe(keyPush, ws));
 
-        const data = Array.from({ length: 100 }, (_, i) => ({ id: i, title: `T${i}` }));
+    const data = Array.from({ length: 100 }, (_, i) => ({ id: i, title: `T${i}` }));
 
-        // Push path: emit → 50ms debounce → query:updated 전송
-        const pushStart = performance.now();
-        buildRealtimeCtx().emit(keyPush, data);
-        await wait(80);
-        const pushElapsed = performance.now() - pushStart;
+    // Push path: emit → 50ms debounce → query:updated 전송
+    const pushStart = performance.now();
+    buildRealtimeCtx().emit(keyPush, data);
+    await wait(80);
+    const pushElapsed = performance.now() - pushStart;
 
-        const pushWithData = pushClients.filter(ws =>
-            ws.received.some((m: any) => m.type === "query:updated" && m.hasData)
-        ).length;
+    const pushWithData = pushClients.filter((ws) =>
+      ws.received.some((m: any) => m.type === "query:updated" && m.hasData),
+    ).length;
 
-        console.log(`[push] ${pushElapsed.toFixed(1)}ms → ${pushWithData}/${N_SUBS} with data (query:updated)`);
+    console.log(`[push] ${pushElapsed.toFixed(1)}ms → ${pushWithData}/${N_SUBS} with data (query:updated)`);
 
-        // 핵심 검증
-        expect(pushWithData).toBe(N_SUBS);       // 500/500이 data 포함 메시지 수신
+    // 핵심 검증
+    expect(pushWithData).toBe(N_SUBS); // 500/500이 data 포함 메시지 수신
 
-        pushClients.forEach(ws => deregisterClient(ws));
-    });
+    pushClients.forEach((ws) => deregisterClient(ws));
+  });
 });