@remember-web/sse 0.1.0-alpha.1

package/src/worker/hub.connection.test.ts

@@ -0,0 +1,1023 @@
+// @vitest-environment node
+import { describe, expect, it, vi } from 'vitest';
+
+import { createWorkerHub, PING_INTERVAL_MS } from './hub';
+import type { TabToWorkerMessage } from './protocol';
+import { TICKET_RESPONSE_TIMEOUT_MS } from './ticketDelegate';
+
+import {
+  FakeEventSource,
+  FakePort as FakeTabPort,
+  kindsOf,
+  lastSource,
+  setupFakeTimers,
+} from '../testing';
+
+const createConnectionHarness = () => {
+  const warnings: string[] = [];
+  const hub = createWorkerHub({
+    eventSource: FakeEventSource as unknown as typeof EventSource,
+    logger: {
+      warn: (message: string) => warnings.push(message),
+      error: () => {},
+    },
+    fetch: (async () =>
+      ({
+        ok: true,
+        status: 204,
+      }) as Response) as unknown as typeof globalThis.fetch,
+  });
+  return { hub, warnings };
+};
+
+const respondTicket = (
+  hub: ReturnType<typeof createWorkerHub>,
+  port: FakeTabPort,
+  ticket: string
+) => {
+  const message: TabToWorkerMessage = {
+    kind: 'ticket-response',
+    ok: true,
+    ticket,
+  };
+  hub.handleMessage(port, message);
+};
+
+setupFakeTimers();
+
+describe('워커 연결 — 첫 init이 연결을 세웁니다', () => {
+  it('첫 init을 받으면 티켓을 탭에 요청하고, 응답이 오면 그 티켓으로 연결합니다', async () => {
+    const { hub } = createConnectionHarness();
+    const port = new FakeTabPort();
+    hub.addPort(port);
+
+    hub.handleMessage(port, {
+      kind: 'init',
+      baseUrl: 'https://sse.example.com',
+    });
+    await vi.advanceTimersByTimeAsync(0);
+    expect(kindsOf(port, 'ticket-request')).toHaveLength(1);
+
+    respondTicket(hub, port, 'ticket-1');
+    await vi.advanceTimersByTimeAsync(0);
+
+    expect(lastSource().url).toBe(
+      'https://sse.example.com/v1/events?ticket=ticket-1'
+    );
+  });
+
+  it('두 번째 탭의 init은 새 연결을 만들지 않습니다 — 연결은 워커에 하나뿐입니다', async () => {
+    const { hub, warnings } = createConnectionHarness();
+    const first = new FakeTabPort();
+    const second = new FakeTabPort();
+    hub.addPort(first);
+    hub.addPort(second);
+
+    hub.handleMessage(first, {
+      kind: 'init',
+      baseUrl: 'https://sse.example.com',
+    });
+    await vi.advanceTimersByTimeAsync(0);
+    respondTicket(hub, first, 'ticket-1');
+    await vi.advanceTimersByTimeAsync(0);
+
+    const ticketRequestsBefore = kindsOf(second, 'ticket-request').length;
+    hub.handleMessage(second, {
+      kind: 'init',
+      baseUrl: 'https://other.example.com',
+    });
+    await vi.advanceTimersByTimeAsync(0);
+
+    expect(FakeEventSource.instances).toHaveLength(1);
+    // 이미 선 연결이 있으므로 티켓을 새로 요청하지 않습니다 — 두 번째 baseUrl도 채택되지 않습니다
+    expect(kindsOf(second, 'ticket-request')).toHaveLength(
+      ticketRequestsBefore
+    );
+    // 채택되지 않았다는 사실은 탭이 알 수 없으므로 로그로 알립니다
+    expect(
+      warnings.some((message) => message.includes('other.example.com'))
+    ).toBe(true);
+  });
+
+  it('티켓은 한 탭에만 요청합니다 — 연결이 하나라 발급도 한 번이면 됩니다', async () => {
+    const { hub } = createConnectionHarness();
+    const tabs = [new FakeTabPort(), new FakeTabPort(), new FakeTabPort()];
+    tabs.forEach((tab) => hub.addPort(tab));
+
+    hub.handleMessage(tabs[0]!, {
+      kind: 'init',
+      baseUrl: 'https://sse.example.com',
+    });
+    await vi.advanceTimersByTimeAsync(0);
+
+    const asked = tabs.filter(
+      (tab) => kindsOf(tab, 'ticket-request').length > 0
+    );
+    expect(asked).toHaveLength(1);
+  });
+
+  it('무응답으로 수거 대상이 된 탭 대신 살아 있는 탭에 티켓을 요청합니다', async () => {
+    const { hub } = createConnectionHarness();
+    const silent = new FakeTabPort();
+    const responsive = new FakeTabPort();
+    hub.addPort(silent);
+    hub.addPort(responsive);
+
+    // 한 주기를 돌려 silent만 무응답으로 남깁니다
+    await vi.advanceTimersByTimeAsync(PING_INTERVAL_MS);
+    hub.handleMessage(responsive, { kind: 'pong' });
+
+    hub.handleMessage(responsive, {
+      kind: 'init',
+      baseUrl: 'https://sse.example.com',
+    });
+    await vi.advanceTimersByTimeAsync(0);
+
+    expect(kindsOf(responsive, 'ticket-request')).toHaveLength(1);
+    expect(kindsOf(silent, 'ticket-request')).toHaveLength(0);
+  });
+});
+
+describe('워커 연결 — 상태와 이벤트를 모든 탭에 전합니다', () => {
+  it('연결 상태 변화를 모든 탭에 알리고, 늦게 합류한 탭에는 현재 상태를 줍니다', async () => {
+    const { hub } = createConnectionHarness();
+    const early = new FakeTabPort();
+    hub.addPort(early);
+
+    hub.handleMessage(early, {
+      kind: 'init',
+      baseUrl: 'https://sse.example.com',
+    });
+    await vi.advanceTimersByTimeAsync(0);
+    respondTicket(hub, early, 'ticket-1');
+    await vi.advanceTimersByTimeAsync(0);
+    lastSource().dispatch('hello');
+
+    expect(early.sent.at(-1)).toEqual({ kind: 'status', status: 'open' });
+
+    const late = new FakeTabPort();
+    hub.addPort(late);
+    expect(late.sent[0]).toEqual({ kind: 'status', status: 'open' });
+  });
+
+  it('구독한 이벤트가 도착하면 모든 탭에 전달합니다', async () => {
+    const { hub } = createConnectionHarness();
+    const first = new FakeTabPort();
+    const second = new FakeTabPort();
+    hub.addPort(first);
+    hub.addPort(second);
+
+    hub.handleMessage(first, {
+      kind: 'init',
+      baseUrl: 'https://sse.example.com',
+    });
+    hub.handleMessage(first, { kind: 'subscribe', event: 'demo.created' });
+    await vi.advanceTimersByTimeAsync(0);
+    respondTicket(hub, first, 'ticket-1');
+    await vi.advanceTimersByTimeAsync(0);
+    lastSource().dispatch('hello');
+
+    lastSource().dispatch('demo.created', '{"id":"a"}');
+
+    const delivered = {
+      kind: 'event',
+      event: 'demo.created',
+      payload: { id: 'a' },
+    };
+    expect(first.sent.at(-1)).toEqual(delivered);
+    expect(second.sent.at(-1)).toEqual(delivered);
+  });
+
+  it('연결이 선 뒤에 등록된 구독도 전달됩니다', async () => {
+    const { hub } = createConnectionHarness();
+    const port = new FakeTabPort();
+    hub.addPort(port);
+
+    hub.handleMessage(port, {
+      kind: 'init',
+      baseUrl: 'https://sse.example.com',
+    });
+    await vi.advanceTimersByTimeAsync(0);
+    respondTicket(hub, port, 'ticket-1');
+    await vi.advanceTimersByTimeAsync(0);
+    lastSource().dispatch('hello');
+
+    hub.handleMessage(port, { kind: 'subscribe', event: 'demo.late' });
+    lastSource().dispatch('demo.late', '{"id":"b"}');
+
+    expect(port.sent.at(-1)).toEqual({
+      kind: 'event',
+      event: 'demo.late',
+      payload: { id: 'b' },
+    });
+  });
+});
+
+describe('워커 연결 — goaway는 모든 탭에 닿습니다', () => {
+  const openConnection = async (
+    hub: ReturnType<typeof createWorkerHub>,
+    port: FakeTabPort
+  ) => {
+    hub.handleMessage(port, {
+      kind: 'init',
+      baseUrl: 'https://sse.example.com',
+    });
+    await vi.advanceTimersByTimeAsync(0);
+    respondTicket(hub, port, 'ticket-1');
+    await vi.advanceTimersByTimeAsync(0);
+    lastSource().dispatch('hello');
+  };
+
+  // 로그아웃 전파가 이 경로에 걸려 있습니다 — 탭이 워커에 알리는 kind 없이 서버 한 번으로 모든 탭이 압니다
+  it('goaway 페이로드를 모든 탭에 그대로 전달합니다', async () => {
+    const { hub } = createConnectionHarness();
+    const first = new FakeTabPort();
+    const second = new FakeTabPort();
+    hub.addPort(first);
+    hub.addPort(second);
+
+    await openConnection(hub, first);
+    lastSource().dispatch(
+      'goaway',
+      JSON.stringify({ reason: 'user_logout', action: 'close' })
+    );
+    await vi.advanceTimersByTimeAsync(0);
+
+    const delivered = {
+      kind: 'event',
+      event: 'goaway',
+      payload: { reason: 'user_logout', action: 'close' },
+    };
+    expect(kindsOf(first, 'event').at(-1)).toEqual(delivered);
+    expect(kindsOf(second, 'event').at(-1)).toEqual(delivered);
+  });
+
+  it('action이 close면 연결을 닫고 모든 탭에 알립니다', async () => {
+    const { hub } = createConnectionHarness();
+    const first = new FakeTabPort();
+    const second = new FakeTabPort();
+    hub.addPort(first);
+    hub.addPort(second);
+
+    await openConnection(hub, first);
+    const source = lastSource();
+    source.dispatch('goaway', JSON.stringify({ action: 'close' }));
+    await vi.advanceTimersByTimeAsync(30_000);
+
+    expect(source.closed).toBe(true);
+    // 티켓 요청이 첫 연결의 1건에 머뭅니다 — 재연결을 시도하지 않았다는 뜻입니다
+    expect(kindsOf(first, 'ticket-request')).toHaveLength(1);
+    expect(kindsOf(first, 'status').at(-1)?.status).toBe('closed');
+    expect(kindsOf(second, 'status').at(-1)?.status).toBe('closed');
+  });
+
+  it('close 뒤 탭이 init을 다시 보내면 연결이 되살아납니다', async () => {
+    const { hub } = createConnectionHarness();
+    const port = new FakeTabPort();
+    hub.addPort(port);
+
+    await openConnection(hub, port);
+    lastSource().dispatch('goaway', JSON.stringify({ action: 'close' }));
+    await vi.advanceTimersByTimeAsync(0);
+
+    hub.handleMessage(port, {
+      kind: 'init',
+      baseUrl: 'https://sse.example.com',
+    });
+    await vi.advanceTimersByTimeAsync(0);
+    respondTicket(hub, port, 'ticket-2');
+    await vi.advanceTimersByTimeAsync(0);
+
+    expect(lastSource().url).toBe(
+      'https://sse.example.com/v1/events?ticket=ticket-2'
+    );
+  });
+
+  // 서버가 세션을 끝낸 것이라 다음 연결은 첫 연결입니다 — 직결 경로(#endSession)와 같은 판정
+  it('close 뒤 되살아난 연결의 첫 hello는 resync를 내지 않습니다', async () => {
+    const { hub } = createConnectionHarness();
+    const port = new FakeTabPort();
+    hub.addPort(port);
+
+    await openConnection(hub, port);
+    lastSource().dispatch(
+      'goaway',
+      JSON.stringify({ reason: 'user_logout', action: 'close' })
+    );
+    await vi.advanceTimersByTimeAsync(0);
+
+    hub.handleMessage(port, {
+      kind: 'init',
+      baseUrl: 'https://sse.example.com',
+    });
+    await vi.advanceTimersByTimeAsync(0);
+    respondTicket(hub, port, 'ticket-2');
+    await vi.advanceTimersByTimeAsync(0);
+    lastSource().dispatch('hello');
+    await vi.advanceTimersByTimeAsync(0);
+
+    const eventNames = kindsOf(port, 'event').map((m) => m.event);
+    expect(eventNames).not.toContain('resync');
+  });
+});
+
+describe('워커 연결 — fatal 사유는 모든 탭에 닿습니다', () => {
+  // 워커 안에서 멈춘 이유를 탭이 알아야 원인별 안내(재로그인·한도)를 가를 수 있습니다
+  it('티켓 발급이 거부되어 멈추면 사유가 티켓을 발급하지 않은 탭에도 전달됩니다', async () => {
+    const { hub } = createConnectionHarness();
+    const requester = new FakeTabPort();
+    const bystander = new FakeTabPort();
+    hub.addPort(requester);
+    hub.addPort(bystander);
+
+    hub.handleMessage(requester, {
+      kind: 'init',
+      baseUrl: 'https://sse.example.com',
+    });
+    await vi.advanceTimersByTimeAsync(0);
+    hub.handleMessage(requester, {
+      kind: 'ticket-response',
+      ok: false,
+      error: { status: 429 },
+    });
+    await vi.advanceTimersByTimeAsync(0);
+
+    const delivered = {
+      kind: 'event',
+      event: 'fatal',
+      payload: { cause: 'rate_limit', status: 429 },
+    };
+    expect(kindsOf(requester, 'event').at(-1)).toEqual(delivered);
+    expect(kindsOf(bystander, 'event').at(-1)).toEqual(delivered);
+  });
+
+  // throw는 postMessage를 건너지 못하므로 탭이 값(cause)으로 실어 보냅니다 — 워커도 직결 경로와 같은 판정을 해야 합니다
+  it('탭의 getAuthToken 실패(auth_callback)가 전달되면 네트워크로 오분류하지 않고 모든 탭에 fatal을 알립니다', async () => {
+    const { hub } = createConnectionHarness();
+    const requester = new FakeTabPort();
+    const bystander = new FakeTabPort();
+    hub.addPort(requester);
+    hub.addPort(bystander);
+
+    hub.handleMessage(requester, {
+      kind: 'init',
+      baseUrl: 'https://sse.example.com',
+    });
+    await vi.advanceTimersByTimeAsync(0);
+    hub.handleMessage(requester, {
+      kind: 'ticket-response',
+      ok: false,
+      error: { cause: 'auth_callback' },
+    });
+    await vi.advanceTimersByTimeAsync(0);
+
+    const delivered = {
+      kind: 'event',
+      event: 'fatal',
+      payload: { cause: 'auth_callback' },
+    };
+    expect(kindsOf(requester, 'event').at(-1)).toEqual(delivered);
+    expect(kindsOf(bystander, 'event').at(-1)).toEqual(delivered);
+
+    // fatal은 재시도하지 않습니다 — 탭에 티켓을 다시 요청하지 않습니다
+    await vi.advanceTimersByTimeAsync(120_000);
+    expect(kindsOf(requester, 'ticket-request')).toHaveLength(1);
+  });
+});
+
+describe('워커 연결 — 네트워크 에러 지속(stalled)은 모든 탭에 닿습니다', () => {
+  it('티켓 발급이 네트워크성으로 연속 5회 실패하면 stalled가 모든 탭에 전달됩니다', async () => {
+    const { hub } = createConnectionHarness();
+    const requester = new FakeTabPort();
+    const bystander = new FakeTabPort();
+    hub.addPort(requester);
+    hub.addPort(bystander);
+
+    const failTicketWithNetworkError = () =>
+      hub.handleMessage(requester, {
+        kind: 'ticket-response',
+        ok: false,
+        error: {},
+      });
+    const stalledCount = (port: FakeTabPort) =>
+      kindsOf(port, 'event').filter((m) => m.event === 'stalled').length;
+
+    hub.handleMessage(requester, {
+      kind: 'init',
+      baseUrl: 'https://sse.example.com',
+    });
+    await vi.advanceTimersByTimeAsync(0);
+    failTicketWithNetworkError();
+    await vi.advanceTimersByTimeAsync(1000);
+    failTicketWithNetworkError();
+    await vi.advanceTimersByTimeAsync(2000);
+    failTicketWithNetworkError();
+    await vi.advanceTimersByTimeAsync(4000);
+    failTicketWithNetworkError();
+    await vi.advanceTimersByTimeAsync(0);
+    expect(stalledCount(requester)).toBe(0);
+
+    await vi.advanceTimersByTimeAsync(8000);
+    failTicketWithNetworkError(); // → 발화
+    await vi.advanceTimersByTimeAsync(0);
+
+    expect(stalledCount(requester)).toBe(1);
+    expect(stalledCount(bystander)).toBe(1);
+  });
+
+  it('탭이 전달한 서버 응답 거부(5xx)도 네트워크성 연속 판정을 끊습니다', async () => {
+    // 기본 백오프면 리셋 후 5회에 30초 대기가 쌓여 탭이 침묵 판정(휴면)됩니다 — 대기를 캡해 판정만 봅니다
+    const hub = createWorkerHub({
+      eventSource: FakeEventSource as unknown as typeof EventSource,
+      backoff: { maxDelayMs: 1000 },
+    });
+    const requester = new FakeTabPort();
+    hub.addPort(requester);
+
+    const failTicketWithNetworkError = () =>
+      hub.handleMessage(requester, {
+        kind: 'ticket-response',
+        ok: false,
+        error: {},
+      });
+    const failTicketWithServerError = () =>
+      hub.handleMessage(requester, {
+        kind: 'ticket-response',
+        ok: false,
+        error: { status: 500 },
+      });
+    const stalledCount = () =>
+      kindsOf(requester, 'event').filter((m) => m.event === 'stalled').length;
+
+    hub.handleMessage(requester, {
+      kind: 'init',
+      baseUrl: 'https://sse.example.com',
+    });
+    await vi.advanceTimersByTimeAsync(0);
+    failTicketWithNetworkError();
+    await vi.advanceTimersByTimeAsync(1000);
+    failTicketWithNetworkError();
+    await vi.advanceTimersByTimeAsync(1000);
+    failTicketWithNetworkError();
+    await vi.advanceTimersByTimeAsync(1000);
+    failTicketWithNetworkError();
+    await vi.advanceTimersByTimeAsync(1000);
+    failTicketWithServerError();
+    await vi.advanceTimersByTimeAsync(1000);
+    failTicketWithNetworkError();
+    await vi.advanceTimersByTimeAsync(0);
+    // 끊기지 않았다면 직전 응답이 네트워크성 5회째라 이미 발화했을 것입니다
+    expect(stalledCount()).toBe(0);
+
+    await vi.advanceTimersByTimeAsync(1000);
+    failTicketWithNetworkError();
+    await vi.advanceTimersByTimeAsync(1000);
+    failTicketWithNetworkError();
+    await vi.advanceTimersByTimeAsync(1000);
+    failTicketWithNetworkError();
+    await vi.advanceTimersByTimeAsync(1000);
+    failTicketWithNetworkError();
+    await vi.advanceTimersByTimeAsync(0);
+    expect(stalledCount()).toBe(1);
+  });
+});
+
+describe('워커 연결 — 마지막 탭이 떠나면 연결을 정리합니다', () => {
+  it('탭이 하나 남아 있으면 연결을 유지합니다', async () => {
+    const { hub } = createConnectionHarness();
+    const leaving = new FakeTabPort();
+    const staying = new FakeTabPort();
+    hub.addPort(leaving);
+    hub.addPort(staying);
+
+    hub.handleMessage(leaving, {
+      kind: 'init',
+      baseUrl: 'https://sse.example.com',
+    });
+    await vi.advanceTimersByTimeAsync(0);
+    respondTicket(hub, leaving, 'ticket-1');
+    await vi.advanceTimersByTimeAsync(0);
+
+    hub.handleMessage(leaving, { kind: 'close' });
+    await vi.advanceTimersByTimeAsync(0);
+
+    expect(lastSource().closed).toBe(false);
+  });
+
+  it('마지막 탭이 떠나면 연결을 닫습니다', async () => {
+    const { hub } = createConnectionHarness();
+    const port = new FakeTabPort();
+    hub.addPort(port);
+
+    hub.handleMessage(port, {
+      kind: 'init',
+      baseUrl: 'https://sse.example.com',
+    });
+    await vi.advanceTimersByTimeAsync(0);
+    respondTicket(hub, port, 'ticket-1');
+    await vi.advanceTimersByTimeAsync(0);
+    const source = lastSource();
+
+    hub.handleMessage(port, { kind: 'close' });
+    await vi.advanceTimersByTimeAsync(0);
+
+    expect(source.closed).toBe(true);
+  });
+
+  it('탭이 침묵해도(crash·frozen) 장부와 연결은 남습니다 — 정리는 브라우저의 워커 회수가 합니다', async () => {
+    const { hub } = createConnectionHarness();
+    const port = new FakeTabPort();
+    hub.addPort(port);
+
+    hub.handleMessage(port, {
+      kind: 'init',
+      baseUrl: 'https://sse.example.com',
+    });
+    await vi.advanceTimersByTimeAsync(0);
+    respondTicket(hub, port, 'ticket-1');
+    await vi.advanceTimersByTimeAsync(0);
+    lastSource().dispatch('hello');
+    const source = lastSource();
+
+    // 탭이 pong을 못 내는 상태가 이어져도 장부에서 빼지 않습니다
+    await vi.advanceTimersByTimeAsync(PING_INTERVAL_MS);
+    await vi.advanceTimersByTimeAsync(PING_INTERVAL_MS);
+
+    expect(hub.tabCount()).toBe(1);
+    expect(source.closed).toBe(false);
+  });
+
+  it('일부 탭이 침묵해도 연결이 유지되고, 침묵한 탭에게도 이벤트가 계속 나갑니다', async () => {
+    const { hub } = createConnectionHarness();
+    const frozen = new FakeTabPort();
+    const responsive = new FakeTabPort();
+    hub.addPort(frozen);
+    hub.addPort(responsive);
+
+    hub.handleMessage(frozen, {
+      kind: 'init',
+      baseUrl: 'https://sse.example.com',
+    });
+    hub.handleMessage(frozen, { kind: 'subscribe', event: 'demo.created' });
+    await vi.advanceTimersByTimeAsync(0);
+    respondTicket(hub, frozen, 'ticket-1');
+    await vi.advanceTimersByTimeAsync(0);
+    const source = lastSource();
+    source.dispatch('hello');
+
+    // 한 탭만 pong이 없는 상태 — 살아 있는 탭은 매 주기 응답합니다
+    await vi.advanceTimersByTimeAsync(PING_INTERVAL_MS);
+    hub.handleMessage(responsive, { kind: 'pong' });
+    await vi.advanceTimersByTimeAsync(PING_INTERVAL_MS);
+    hub.handleMessage(responsive, { kind: 'pong' });
+
+    expect(hub.tabCount()).toBe(2);
+    expect(source.closed).toBe(false);
+
+    source.dispatch('demo.created', '{"id":"a"}');
+    expect(frozen.sent.at(-1)).toEqual({
+      kind: 'event',
+      event: 'demo.created',
+      payload: { id: 'a' },
+    });
+    expect(responsive.sent.at(-1)).toEqual(frozen.sent.at(-1));
+  });
+
+  it('티켓 응답을 기다리던 중 마지막 탭이 떠나면, 새로 합류한 탭은 자기 티켓 요청을 받습니다', async () => {
+    const { hub } = createConnectionHarness();
+    const leaving = new FakeTabPort();
+    hub.addPort(leaving);
+
+    // 티켓 요청만 나간 상태에서 탭이 떠납니다 — 응답은 오지 않았습니다
+    hub.handleMessage(leaving, {
+      kind: 'init',
+      baseUrl: 'https://sse.example.com',
+    });
+    await vi.advanceTimersByTimeAsync(0);
+    hub.handleMessage(leaving, { kind: 'close' });
+
+    const joining = new FakeTabPort();
+    hub.addPort(joining);
+    hub.handleMessage(joining, {
+      kind: 'init',
+      baseUrl: 'https://sse.example.com',
+    });
+    await vi.advanceTimersByTimeAsync(0);
+
+    expect(kindsOf(joining, 'ticket-request')).toHaveLength(1);
+  });
+
+  it('티켓 응답을 기다리는 중 다른 탭이 합류해도, 진행 중인 발급이 끊기지 않습니다', async () => {
+    const { hub } = createConnectionHarness();
+    const first = new FakeTabPort();
+    hub.addPort(first);
+
+    // 티켓 요청만 나가고 아직 응답이 없는 상태입니다
+    hub.handleMessage(first, {
+      kind: 'init',
+      baseUrl: 'https://sse.example.com',
+    });
+    await vi.advanceTimersByTimeAsync(0);
+
+    // 이 시점에 두 번째 탭이 합류합니다 — 첫 탭의 발급은 계속 유효해야 합니다
+    const joining = new FakeTabPort();
+    hub.addPort(joining);
+    hub.handleMessage(joining, {
+      kind: 'init',
+      baseUrl: 'https://sse.example.com',
+    });
+    await vi.advanceTimersByTimeAsync(0);
+
+    respondTicket(hub, first, 'ticket-1');
+    await vi.advanceTimersByTimeAsync(0);
+
+    expect(lastSource().url).toBe(
+      'https://sse.example.com/v1/events?ticket=ticket-1'
+    );
+  });
+
+  it('형식이 어긋난 ticket-response를 받아도 연결 루프가 멈추지 않고 다시 시도합니다', async () => {
+    const { hub } = createConnectionHarness();
+    const port = new FakeTabPort();
+    hub.addPort(port);
+
+    hub.handleMessage(port, {
+      kind: 'init',
+      baseUrl: 'https://sse.example.com',
+    });
+    await vi.advanceTimersByTimeAsync(0);
+
+    // error가 null이면 코어가 status를 꺼내다 예외를 냅니다 — 경계에서 걸러야 합니다
+    hub.handleMessage(port, {
+      kind: 'ticket-response',
+      ok: false,
+      error: null,
+    } as unknown as TabToWorkerMessage);
+    await vi.advanceTimersByTimeAsync(0);
+
+    // 걸러진 응답은 왕복을 끝내지 않으므로, 시간 제한이 끝내고 재시도로 이어집니다
+    await vi.advanceTimersByTimeAsync(TICKET_RESPONSE_TIMEOUT_MS);
+    await vi.advanceTimersByTimeAsync(10_000);
+
+    expect(kindsOf(port, 'ticket-request').length).toBeGreaterThan(1);
+
+    respondTicket(hub, port, 'ticket-2');
+    await vi.advanceTimersByTimeAsync(0);
+
+    expect(lastSource().url).toBe(
+      'https://sse.example.com/v1/events?ticket=ticket-2'
+    );
+  });
+
+  it('탭이 남아 있는 채 연결이 fatal이 되어도, 정리 후 다시 connect한 탭이 연결을 되살립니다', async () => {
+    const { hub } = createConnectionHarness();
+    const recovering = new FakeTabPort();
+    const staying = new FakeTabPort();
+    hub.addPort(recovering);
+    hub.addPort(staying);
+
+    // 티켓 발급이 429로 거부되어 연결이 fatal로 멈춥니다
+    hub.handleMessage(recovering, {
+      kind: 'init',
+      baseUrl: 'https://sse.example.com',
+    });
+    await vi.advanceTimersByTimeAsync(0);
+    hub.handleMessage(recovering, {
+      kind: 'ticket-response',
+      ok: false,
+      error: { status: 429 },
+    });
+    await vi.advanceTimersByTimeAsync(0);
+    expect(staying.sent).toContainEqual({ kind: 'status', status: 'fatal' });
+
+    // 소비처가 계약대로 정리 후 재시도 — 다른 탭이 남아 있어도 되살아나야 합니다
+    hub.handleMessage(recovering, { kind: 'close' });
+    const rejoining = new FakeTabPort();
+    hub.addPort(rejoining);
+    hub.handleMessage(rejoining, {
+      kind: 'init',
+      baseUrl: 'https://sse.example.com',
+    });
+    await vi.advanceTimersByTimeAsync(0);
+    respondTicket(hub, rejoining, 'ticket-2');
+    await vi.advanceTimersByTimeAsync(0);
+
+    expect(lastSource().url).toBe(
+      'https://sse.example.com/v1/events?ticket=ticket-2'
+    );
+
+    // 교체 과정의 closed는 워커 내부 사정이라 탭에 새지 않습니다
+    const seen = staying.sent
+      .filter((message) => message.kind === 'status')
+      .map((message) => (message as { status: string }).status);
+    expect(seen).not.toContain('closed');
+  });
+
+  it('연결이 정리된 뒤 합류한 탭은 idle 스냅샷을 받습니다 — 낡은 open을 물려받지 않게', async () => {
+    const { hub } = createConnectionHarness();
+    const first = new FakeTabPort();
+    hub.addPort(first);
+
+    hub.handleMessage(first, {
+      kind: 'init',
+      baseUrl: 'https://sse.example.com',
+    });
+    await vi.advanceTimersByTimeAsync(0);
+    respondTicket(hub, first, 'ticket-1');
+    await vi.advanceTimersByTimeAsync(0);
+    lastSource().dispatch('hello');
+    expect(first.sent.at(-1)).toEqual({ kind: 'status', status: 'open' });
+
+    hub.handleMessage(first, { kind: 'close' });
+    await vi.advanceTimersByTimeAsync(0);
+
+    // init을 보내지 않는 탭도 있습니다 — 스냅샷만 받고 기다리는 동안 open으로 보이면 안 됩니다
+    const joining = new FakeTabPort();
+    hub.addPort(joining);
+
+    expect(joining.sent[0]).toEqual({ kind: 'status', status: 'idle' });
+  });
+
+  it('close 없이 재init만으로도 죽은 연결을 교체합니다', async () => {
+    const { hub } = createConnectionHarness();
+    const port = new FakeTabPort();
+    hub.addPort(port);
+
+    hub.handleMessage(port, {
+      kind: 'init',
+      baseUrl: 'https://sse.example.com',
+    });
+    await vi.advanceTimersByTimeAsync(0);
+    hub.handleMessage(port, {
+      kind: 'ticket-response',
+      ok: false,
+      error: { status: 429 },
+    });
+    await vi.advanceTimersByTimeAsync(0);
+
+    // close를 보내지 않고 다시 init만 보냅니다 — fatal 연결이 교체되어야 합니다
+    hub.handleMessage(port, {
+      kind: 'init',
+      baseUrl: 'https://sse.example.com',
+    });
+    await vi.advanceTimersByTimeAsync(0);
+    respondTicket(hub, port, 'ticket-2');
+    await vi.advanceTimersByTimeAsync(0);
+
+    expect(lastSource().url).toBe(
+      'https://sse.example.com/v1/events?ticket=ticket-2'
+    );
+  });
+
+  it('탭이 모두 떠난 뒤 합류한 탭은 첫 연결로 취급돼 resync를 받지 않습니다', async () => {
+    const { hub } = createConnectionHarness();
+    const leaving = new FakeTabPort();
+    hub.addPort(leaving);
+
+    hub.handleMessage(leaving, {
+      kind: 'init',
+      baseUrl: 'https://sse.example.com',
+    });
+    await vi.advanceTimersByTimeAsync(0);
+    respondTicket(hub, leaving, 'ticket-1');
+    await vi.advanceTimersByTimeAsync(0);
+    lastSource().dispatch('hello');
+    hub.handleMessage(leaving, { kind: 'close' });
+    await vi.advanceTimersByTimeAsync(0);
+
+    const fresh = new FakeTabPort();
+    hub.addPort(fresh);
+    hub.handleMessage(fresh, {
+      kind: 'init',
+      baseUrl: 'https://sse.example.com',
+    });
+    await vi.advanceTimersByTimeAsync(0);
+    respondTicket(hub, fresh, 'ticket-2');
+    await vi.advanceTimersByTimeAsync(0);
+    lastSource().dispatch('hello');
+    await vi.advanceTimersByTimeAsync(0);
+
+    expect(kindsOf(fresh, 'event')).toHaveLength(0);
+  });
+
+  it('탭이 모두 떠났다가 다시 합류하면 연결을 새로 세웁니다', async () => {
+    const { hub } = createConnectionHarness();
+    const first = new FakeTabPort();
+    hub.addPort(first);
+
+    hub.handleMessage(first, {
+      kind: 'init',
+      baseUrl: 'https://sse.example.com',
+    });
+    await vi.advanceTimersByTimeAsync(0);
+    respondTicket(hub, first, 'ticket-1');
+    await vi.advanceTimersByTimeAsync(0);
+    hub.handleMessage(first, { kind: 'close' });
+    await vi.advanceTimersByTimeAsync(0);
+
+    const second = new FakeTabPort();
+    hub.addPort(second);
+    hub.handleMessage(second, {
+      kind: 'init',
+      baseUrl: 'https://sse.example.com',
+    });
+    await vi.advanceTimersByTimeAsync(0);
+    respondTicket(hub, second, 'ticket-2');
+    await vi.advanceTimersByTimeAsync(0);
+
+    expect(FakeEventSource.instances).toHaveLength(2);
+    expect(lastSource().url).toBe(
+      'https://sse.example.com/v1/events?ticket=ticket-2'
+    );
+  });
+
+  // 무응답이 크래시인지 얼어붙은 것인지 알 수 없으니, 끊었다가 되살리는 대신 그대로 둡니다
+  // 티켓을 받아줄 탭이 없으면 재시도가 성공할 수 없습니다 — 멈추지 않으면 워커가 영영 헛돕니다
+  it('전원이 확정 침묵한 채 연결이 끊기면 재수립을 반복하지 않고 접습니다', async () => {
+    const { hub } = createConnectionHarness();
+    const port = new FakeTabPort();
+    hub.addPort(port);
+
+    hub.handleMessage(port, {
+      kind: 'init',
+      baseUrl: 'https://sse.example.com',
+    });
+    await vi.advanceTimersByTimeAsync(0);
+    respondTicket(hub, port, 'ticket-1');
+    await vi.advanceTimersByTimeAsync(0);
+    lastSource().dispatch('hello');
+
+    // 두 주기 무응답 — 판정이 확정됩니다. 장부에는 남습니다
+    await vi.advanceTimersByTimeAsync(PING_INTERVAL_MS);
+    await vi.advanceTimersByTimeAsync(PING_INTERVAL_MS);
+    expect(hub.tabCount()).toBe(1);
+    const requestsBefore = kindsOf(port, 'ticket-request').length;
+
+    lastSource().error();
+    await vi.advanceTimersByTimeAsync(300_000);
+
+    expect(FakeEventSource.instances).toHaveLength(1);
+    // frozen 탭의 큐에 요청이 쌓이지 않았어야 합니다
+    expect(kindsOf(port, 'ticket-request')).toHaveLength(requestsBefore);
+    // ping 주기 하나만 남아야 합니다 — 티켓 대기·백오프 타이머가 남아 있으면 헛돌고 있다는 뜻입니다
+    expect(vi.getTimerCount()).toBe(1);
+  });
+
+  it('pong만으로는 접힌 연결이 다시 서지 않습니다 — init이 다시 엽니다', async () => {
+    const { hub } = createConnectionHarness();
+    const port = new FakeTabPort();
+    hub.addPort(port);
+
+    hub.handleMessage(port, {
+      kind: 'init',
+      baseUrl: 'https://sse.example.com',
+    });
+    await vi.advanceTimersByTimeAsync(0);
+    respondTicket(hub, port, 'ticket-1');
+    await vi.advanceTimersByTimeAsync(0);
+    lastSource().dispatch('hello');
+
+    // 확정 침묵 + 끊김 → 휴면
+    await vi.advanceTimersByTimeAsync(PING_INTERVAL_MS);
+    await vi.advanceTimersByTimeAsync(PING_INTERVAL_MS);
+    lastSource().error();
+    await vi.advanceTimersByTimeAsync(60_000);
+    expect(FakeEventSource.instances).toHaveLength(1);
+
+    // 깨어난 탭은 큐에 쌓인 ping에 먼저 pong부터 답합니다 — 이것만으로 열리면 안 됩니다
+    hub.handleMessage(port, { kind: 'pong' });
+    await vi.advanceTimersByTimeAsync(0);
+    expect(FakeEventSource.instances).toHaveLength(1);
+
+    hub.handleMessage(port, {
+      kind: 'init',
+      baseUrl: 'https://sse.example.com',
+    });
+    await vi.advanceTimersByTimeAsync(0);
+    respondTicket(hub, port, 'ticket-2');
+    await vi.advanceTimersByTimeAsync(0);
+
+    expect(FakeEventSource.instances).toHaveLength(2);
+  });
+
+  it('침묵으로 접힌 연결도 깨어난 탭의 init이 다시 세우고, resync가 나갑니다', async () => {
+    const { hub } = createConnectionHarness();
+    const port = new FakeTabPort();
+    hub.addPort(port);
+
+    hub.handleMessage(port, {
+      kind: 'init',
+      baseUrl: 'https://sse.example.com',
+    });
+    await vi.advanceTimersByTimeAsync(0);
+    respondTicket(hub, port, 'ticket-1');
+    await vi.advanceTimersByTimeAsync(0);
+    lastSource().dispatch('hello');
+
+    await vi.advanceTimersByTimeAsync(PING_INTERVAL_MS);
+    await vi.advanceTimersByTimeAsync(PING_INTERVAL_MS);
+    lastSource().error();
+    await vi.advanceTimersByTimeAsync(60_000);
+    expect(FakeEventSource.instances).toHaveLength(1);
+
+    hub.handleMessage(port, {
+      kind: 'init',
+      baseUrl: 'https://sse.example.com',
+    });
+    await vi.advanceTimersByTimeAsync(0);
+    respondTicket(hub, port, 'ticket-2');
+    await vi.advanceTimersByTimeAsync(0);
+    lastSource().dispatch('hello');
+    await vi.advanceTimersByTimeAsync(0);
+
+    expect(FakeEventSource.instances).toHaveLength(2);
+    // 세션이 이어진 재수립입니다 — 자리를 비운 사이를 소비처가 메울 수 있어야 합니다
+    expect(kindsOf(port, 'event').map((m) => m.event)).toEqual(['resync']);
+  });
+
+  // 무응답 후보뿐이어도 판정 전이면 물어봅니다 — 여기서 접으면 아직 살아 있을 탭을 두고 연결이 죽습니다
+  it('한 주기 무응답(판정 전)이면 아직 티켓을 물어봅니다', async () => {
+    const { hub } = createConnectionHarness();
+    const port = new FakeTabPort();
+    hub.addPort(port);
+
+    hub.handleMessage(port, {
+      kind: 'init',
+      baseUrl: 'https://sse.example.com',
+    });
+    await vi.advanceTimersByTimeAsync(0);
+    respondTicket(hub, port, 'ticket-1');
+    await vi.advanceTimersByTimeAsync(0);
+    lastSource().dispatch('hello');
+
+    // pong 없이 한 주기 — 아직 확정 침묵이 아닙니다
+    await vi.advanceTimersByTimeAsync(PING_INTERVAL_MS);
+    expect(hub.tabCount()).toBe(1);
+    const before = kindsOf(port, 'ticket-request').length;
+
+    lastSource().error();
+    await vi.advanceTimersByTimeAsync(2000);
+
+    expect(kindsOf(port, 'ticket-request').length).toBeGreaterThan(before);
+  });
+
+  it('침묵했던 탭의 init은 살아 있는 연결을 건드리지 않습니다', async () => {
+    const { hub } = createConnectionHarness();
+    const freezing = new FakeTabPort();
+    hub.addPort(freezing);
+
+    hub.handleMessage(freezing, {
+      kind: 'init',
+      baseUrl: 'https://sse.example.com',
+    });
+    await vi.advanceTimersByTimeAsync(0);
+    respondTicket(hub, freezing, 'ticket-1');
+    await vi.advanceTimersByTimeAsync(0);
+    lastSource().dispatch('hello');
+    const source = lastSource();
+
+    await vi.advanceTimersByTimeAsync(PING_INTERVAL_MS);
+    await vi.advanceTimersByTimeAsync(PING_INTERVAL_MS);
+    expect(source.closed).toBe(false);
+
+    hub.handleMessage(freezing, {
+      kind: 'init',
+      baseUrl: 'https://sse.example.com',
+    });
+    await vi.advanceTimersByTimeAsync(0);
+
+    // 티켓을 다시 받지 않았다는 증거 — 첫 연결이 그대로 이어집니다
+    expect(FakeEventSource.instances).toHaveLength(1);
+  });
+});
+
+describe('워커 연결 — 재수립 통지', () => {
+  it('재수립하면 탭에 resync를 보냅니다', async () => {
+    const { hub } = createConnectionHarness();
+    const port = new FakeTabPort();
+    hub.addPort(port);
+
+    hub.handleMessage(port, {
+      kind: 'init',
+      baseUrl: 'https://sse.example.com',
+    });
+    await vi.advanceTimersByTimeAsync(0);
+    respondTicket(hub, port, 'ticket-1');
+    await vi.advanceTimersByTimeAsync(0);
+    lastSource().dispatch('hello');
+
+    const resyncMessages = () =>
+      kindsOf(port, 'event').filter(
+        (message) => 'event' in message && message.event === 'resync'
+      );
+    expect(resyncMessages()).toHaveLength(0);
+
+    lastSource().error();
+    await vi.advanceTimersByTimeAsync(1000);
+    respondTicket(hub, port, 'ticket-2');
+    await vi.advanceTimersByTimeAsync(0);
+    lastSource().dispatch('hello');
+
+    expect(resyncMessages()).toHaveLength(1);
+  });
+});