@zhin.js/client 1.1.3 → 1.1.5

package/client/segments.ts

@@ -0,0 +1,39 @@
+import type { MessageSegment } from './types.js';
+
+/** IM 可见段白名单（与 core segment-contract/delivery 对齐） */
+const IM_VISIBLE_TYPES = new Set([
+  'text', 'mention', 'image', 'video', 'audio', 'voice', 'record', 'file',
+  'face', 'reply', 'forward', 'link', 'dice', 'rps', 'markdown', 'html',
+  'qrcode', 'tts', 'keyboard', 'action',
+]);
+
+const AI_ONLY_TYPES = new Set(['thinking', 'tool_call']);
+
+function isSegmentLike(value: unknown): value is MessageSegment {
+  return (
+    typeof value === 'object'
+    && value !== null
+    && typeof (value as MessageSegment).type === 'string'
+    && 'data' in value
+  );
+}
+
+/**
+ * Inbox / 用户 IM 视图：仅展示 IM-visible 段（剔除 thinking、tool_call）。
+ * Agent 面板应使用全量 segments，勿调用此函数。
+ */
+export function segmentsForImDelivery(segments: readonly unknown[]): MessageSegment[] {
+  const out: MessageSegment[] = [];
+  for (const item of segments) {
+    if (!isSegmentLike(item)) continue;
+    if (AI_ONLY_TYPES.has(item.type)) continue;
+    if (!IM_VISIBLE_TYPES.has(item.type)) continue;
+    out.push(item);
+  }
+  return out;
+}
+
+/** Agent 面板全量 segments（identity，便于双视图 API 对称） */
+export function segmentsForAgentPanel(segments: readonly MessageSegment[]): MessageSegment[] {
+  return [...segments];
+}

package/client/types.ts

@@ -1,8 +1,9 @@
-// 消息段类型定义 - 客户端版本
+// 消息段类型定义 - 客户端版本（对齐 core Segment SSOT）
 export interface MessageSegment {
-  /** record：如 ICQQ 语音等，展示时按音频处理 */
-  type: 'text' | 'image' | 'at' | 'face' | 'video' | 'audio' | 'record' | 'file' | 'reply'
-  data: Record<string, any>
+  /** record：如 ICQQ 语音等，展示时按音频处理；thinking/tool_call 仅 agent 面板展示 */
+  type: 'text' | 'mention' | 'at' | 'image' | 'face' | 'video' | 'audio' | 'record' | 'file' | 'reply' | 'forward' | 'keyboard' | 'action' | 'thinking' | 'tool_call' | string
+  data: Record<string, unknown>
+  platform?: Record<string, unknown>
 }
 
 // 消息元素别名（兼容不同命名习惯）
@@ -10,4 +11,3 @@ export type MessageElement = MessageSegment
 
 // 发送内容类型
 export type SendContent = MessageSegment | MessageSegment[] | string
-

package/client/websocket/hooks.test.ts

@@ -0,0 +1,21 @@
+import { describe, expect, it } from "vitest";
+
+import { resolveKeyedValue } from "./hooks.js";
+
+describe("resolveKeyedValue (useConfig stale-state guard)", () => {
+  it("returns the value when the entry key matches", () => {
+    const entry = { key: "plugin-a", value: { foo: 1 } };
+    expect(resolveKeyedValue(entry, "plugin-a")).toEqual({ foo: 1 });
+  });
+
+  it("treats a previous plugin's leftover state as empty after pluginName switches", () => {
+    // 回归：旧实现中 config state 跨 pluginName 残留，ready(config != null) 永远为真，
+    // 切换插件后不再自动加载新配置。
+    const stale = { key: "plugin-a", value: { foo: 1 } };
+    expect(resolveKeyedValue(stale, "plugin-b")).toBeNull();
+  });
+
+  it("returns null when nothing has been loaded", () => {
+    expect(resolveKeyedValue(null, "plugin-a")).toBeNull();
+  });
+});

package/client/websocket/hooks.ts

@@ -1,7 +1,25 @@
-import { useCallback, useEffect, useMemo, useState } from "react";
+import { useCallback, useEffect, useMemo, useRef, useState } from "react";
 import { getWebSocketManager } from "./instance";
 import type { UseWebSocketOptions } from "./types";
 
+/**
+ * 每次连接会话只对同一 key 自动加载一次：失败后不再零退避死循环
+ * （旧行为：加载失败 → 状态保持空 → effect 反复立即重试，打爆 /api/console/request）。
+ * 断连后重置；key 变化（如 pluginName 切换）视为新目标重新尝试；手动重试走各 hook 返回的 load 函数。
+ */
+function useAutoLoadOnce(connected: boolean, key: unknown, ready: boolean, fire: () => void) {
+  const attemptedRef = useRef<unknown>(undefined);
+  useEffect(() => {
+    if (!connected) {
+      attemptedRef.current = undefined;
+      return;
+    }
+    if (ready || attemptedRef.current === key) return;
+    attemptedRef.current = key;
+    fire();
+  });
+}
+
 export function useWebSocket(options: UseWebSocketOptions = {}) {
   const { autoConnect = true } = options;
   const wsManager = getWebSocketManager();
@@ -26,14 +44,28 @@ export function useWebSocket(options: UseWebSocketOptions = {}) {
   return { connected, connect, disconnect, send, sendRequest, manager: wsManager };
 }
 
+/**
+ * 按 key 绑定异步加载结果：key（如 pluginName）切换后，旧 key 的残留值视为 null，
+ * 避免 useConfig 的 ready 判断（config != null）被上一插件的 state 挡住而不再加载新配置。
+ * @internal
+ */
+export function resolveKeyedValue<T>(
+  entry: { readonly key: string; readonly value: T } | null,
+  key: string,
+): T | null {
+  return entry && entry.key === key ? entry.value : null;
+}
+
 export function useConfig(pluginName: string, options?: { autoLoad?: boolean; autoLoadSchema?: boolean }) {
   const { autoLoad = true, autoLoadSchema = true } = options ?? {};
   const wsManager = getWebSocketManager();
   const [connected, setConnected] = useState(wsManager.isConnected());
-  const [config, setConfigState] = useState<unknown>(null);
-  const [schema, setSchemaState] = useState<unknown>(null);
+  const [configEntry, setConfigEntry] = useState<{ key: string; value: unknown } | null>(null);
+  const [schemaEntry, setSchemaEntry] = useState<{ key: string; value: unknown } | null>(null);
   const [loading, setLoading] = useState(false);
   const [error, setError] = useState<string | null>(null);
+  const config = resolveKeyedValue(configEntry, pluginName);
+  const schema = resolveKeyedValue(schemaEntry, pluginName);
 
   useEffect(() => wsManager.onConnectionChange(setConnected), [wsManager]);
 
@@ -42,7 +74,7 @@ export function useConfig(pluginName: string, options?: { autoLoad?: boolean; au
     setError(null);
     try {
       const result = await wsManager.getConfig(pluginName);
-      setConfigState(result);
+      setConfigEntry({ key: pluginName, value: result });
       return result;
     } catch (e) {
       setError(e instanceof Error ? e.message : "Unknown error");
@@ -71,20 +103,19 @@ export function useConfig(pluginName: string, options?: { autoLoad?: boolean; au
   const getSchema = useCallback(async () => {
     try {
       const result = await wsManager.getSchema(pluginName);
-      if (result) setSchemaState(result);
+      if (result) setSchemaEntry({ key: pluginName, value: result });
       return result;
     } catch (e) {
       throw e;
     }
   }, [pluginName, wsManager]);
 
-  useEffect(() => {
-    if (connected && autoLoad && !config && !loading) getConfig().catch(() => {});
-  }, [connected, autoLoad, config, loading, getConfig]);
-
-  useEffect(() => {
-    if (connected && autoLoadSchema && !schema) getSchema().catch(() => {});
-  }, [connected, autoLoadSchema, schema, getSchema]);
+  useAutoLoadOnce(connected, `config:${pluginName}`, !autoLoad || config != null || loading, () => {
+    getConfig().catch(() => {});
+  });
+  useAutoLoadOnce(connected, `schema:${pluginName}`, !autoLoadSchema || schema != null, () => {
+    getSchema().catch(() => {});
+  });
 
   return useMemo(
     () => ({ config, schema, loading, error, connected, getConfig, setConfig, getSchema }),
@@ -136,9 +167,9 @@ export function useConfigYaml() {
     [wsManager],
   );
 
-  useEffect(() => {
-    if (connected && !yaml && !loading) load().catch(() => {});
-  }, [connected, yaml, loading, load]);
+  useAutoLoadOnce(connected, "config-yaml", !!yaml || loading, () => {
+    load().catch(() => {});
+  });
 
   return useMemo(() => ({ yaml, pluginKeys, loading, error, load, save }), [yaml, pluginKeys, loading, error, load, save]);
 }
@@ -173,9 +204,9 @@ export function useFiles() {
     [wsManager],
   );
 
-  useEffect(() => {
-    if (connected && tree.length === 0 && !loading) loadTree().catch(() => {});
-  }, [connected, tree.length, loading, loadTree]);
+  useAutoLoadOnce(connected, "file-tree", tree.length > 0 || loading, () => {
+    loadTree().catch(() => {});
+  });
 
   return useMemo(() => ({ tree, loading, error, loadTree, readFile, saveFile }), [tree, loading, error, loadTree, readFile, saveFile]);
 }
@@ -217,9 +248,9 @@ export function useEnvFiles() {
     [wsManager],
   );
 
-  useEffect(() => {
-    if (connected && files.length === 0 && !loading) listFiles().catch(() => {});
-  }, [connected, files.length, loading, listFiles]);
+  useAutoLoadOnce(connected, "env-files", files.length > 0 || loading, () => {
+    listFiles().catch(() => {});
+  });
 
   return useMemo(
     () => ({ files, loading, error, listFiles, getFile, saveFile }),
@@ -275,12 +306,10 @@ export function useDatabase() {
   const kvDelete = useCallback(async (table: string, key: string) => wsManager.kvDelete(table, key), [wsManager]);
   const kvEntries = useCallback(async (table: string) => wsManager.kvGetEntries(table), [wsManager]);
 
-  useEffect(() => {
-    if (connected && !info && !loading) {
-      loadInfo().catch(() => {});
-      loadTables().catch(() => {});
-    }
-  }, [connected, info, loading, loadInfo, loadTables]);
+  useAutoLoadOnce(connected, "db-info", info != null || loading, () => {
+    loadInfo().catch(() => {});
+    loadTables().catch(() => {});
+  });
 
   return useMemo(
     () => ({ info, tables, loading, error, loadInfo, loadTables, dropTable, select, insert, update, remove, kvGet, kvSet, kvDelete, kvEntries }),

package/client/websocket/index.ts

@@ -1,5 +1,10 @@
 export * from "./types";
-export { WebSocketManager } from "./manager";
+export {
+  WebSocketManager,
+  type ConsoleEventListener,
+  type ConsoleEventRecoveryGap,
+  type ConsoleEventRecoveryGapListener,
+} from "./manager";
 export { getWebSocketManager, destroyWebSocketManager, resetWebSocketManager } from "./instance";
 export { useWebSocket, useConfig, useConfigYaml, useFiles, useEnvFiles, useDatabase } from "./hooks";
 import { getWebSocketManager } from "./instance";

package/client/websocket/manager.test.ts

@@ -0,0 +1,349 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+
+const mockApplyConsoleEvent = vi.fn(async () => undefined);
+
+vi.mock("../persistence/idb-store.js", () => ({
+  applyConsoleEvent: (...args: unknown[]) => mockApplyConsoleEvent(...args),
+}));
+
+import { WebSocketManager } from "./manager.js";
+import { ConnectionState, type WebSocketMessage } from "./types.js";
+
+function mockStorage(map: Record<string, string> = {}): Storage {
+  return {
+    getItem: (key: string) => map[key] ?? null,
+    setItem: (key: string, value: string) => {
+      map[key] = value;
+    },
+    removeItem: (key: string) => {
+      delete map[key];
+    },
+    clear: () => {
+      for (const key of Object.keys(map)) delete map[key];
+    },
+    key: () => null,
+    length: 0,
+  };
+}
+
+function installBrowserGlobals(storage: Storage = mockStorage()) {
+  const win = {
+    location: { origin: "http://localhost:5173", protocol: "http:", host: "localhost:5173" },
+    __ZHIN_API_TOKEN: undefined as string | undefined,
+    dispatchEvent: vi.fn(),
+  };
+  vi.stubGlobal("window", win);
+  vi.stubGlobal("localStorage", storage);
+  vi.stubGlobal("sessionStorage", mockStorage());
+  return { win, storage };
+}
+
+function sseResponse(status = 200, body?: ReadableStream<Uint8Array> | null) {
+  return {
+    ok: status >= 200 && status < 300,
+    status,
+    body: body === undefined
+      ? new ReadableStream<Uint8Array>({
+        start(controller) {
+          // Keep the stream open until abort; tests control lifecycle via disconnect().
+          void controller;
+        },
+      })
+      : body,
+    json: async () => ({}),
+  } as Response;
+}
+
+function eventHistoryResponse(items: unknown[] = [], runtimeId = 'runtime-test', latestEventId?: number) {
+  const inferredLatest = (items.at(-1) as { eventId?: number } | undefined)?.eventId ?? 0;
+  return {
+    ok: true,
+    status: 200,
+    json: async () => ({
+      success: true,
+      data: {
+        runtimeId,
+        items,
+        oldestAvailableEventId: items.length ? 1 : null,
+        latestEventId: latestEventId ?? inferredLatest,
+        nextAfter: inferredLatest,
+        hasMore: false,
+        gap: false,
+      },
+    }),
+  } as Response;
+}
+
+function mockConsoleTransport(sse: () => Response | Promise<Response>) {
+  return vi.fn(async (input: RequestInfo | URL, _init?: RequestInit) => {
+    return String(input).includes('/api/events/history') ? eventHistoryResponse() : await sse();
+  });
+}
+
+describe("WebSocketManager REST/SSE transport", () => {
+  beforeEach(() => {
+    vi.useFakeTimers();
+    mockApplyConsoleEvent.mockClear();
+  });
+
+  afterEach(() => {
+    vi.useRealTimers();
+    vi.unstubAllGlobals();
+    vi.restoreAllMocks();
+  });
+
+  it("connects SSE without a token (local Host with empty TokenRegistry)", async () => {
+    installBrowserGlobals();
+    const fetchMock = mockConsoleTransport(() => sseResponse(200));
+    vi.stubGlobal("fetch", fetchMock);
+
+    const manager = new WebSocketManager({ reconnectInterval: 100, maxReconnectAttempts: 3 });
+    const states: boolean[] = [];
+    manager.onConnectionChange((c) => states.push(c));
+    manager.connect();
+
+    await vi.advanceTimersByTimeAsync(0);
+    await Promise.resolve();
+    await Promise.resolve();
+
+    expect(fetchMock).toHaveBeenCalled();
+    const sseCall = fetchMock.mock.calls.find(([input]) => !String(input).includes('/history'))!;
+    const init = sseCall[1] as RequestInit;
+    const headers = init.headers as Record<string, string>;
+    expect(headers.Accept).toBe("text/event-stream");
+    expect(headers.Authorization).toBeUndefined();
+    expect(manager.getState()).toBe(ConnectionState.CONNECTED);
+    expect(manager.isConnected()).toBe(true);
+    manager.disconnect();
+  });
+
+  it("sends Authorization when a token is stored", async () => {
+    installBrowserGlobals(mockStorage({ zhin_api_token: "secret" }));
+    const fetchMock = mockConsoleTransport(() => sseResponse(200));
+    vi.stubGlobal("fetch", fetchMock);
+
+    const manager = new WebSocketManager();
+    manager.connect();
+    await vi.advanceTimersByTimeAsync(0);
+    await Promise.resolve();
+    await Promise.resolve();
+
+    const sseCall = fetchMock.mock.calls.find(([input]) => !String(input).includes('/history'))!;
+    const init = sseCall[1] as RequestInit;
+    expect((init.headers as Record<string, string>).Authorization).toBe("Bearer secret");
+    manager.disconnect();
+  });
+
+  it("reconnects after a transient SSE failure (no ERROR deadlock)", async () => {
+    installBrowserGlobals();
+    let sseCalls = 0;
+    const fetchMock = mockConsoleTransport(() => {
+      sseCalls += 1;
+      if (sseCalls === 1) return sseResponse(503, null);
+      return sseResponse(200);
+    });
+    vi.stubGlobal("fetch", fetchMock);
+
+    const manager = new WebSocketManager({
+      reconnectInterval: 100,
+      maxReconnectAttempts: 5,
+    });
+    manager.connect();
+
+    // First attempt fails → RECONNECTING
+    await vi.advanceTimersByTimeAsync(0);
+    await Promise.resolve();
+    await Promise.resolve();
+    expect(manager.getState()).toBe(ConnectionState.RECONNECTING);
+    expect(sseCalls).toBe(1);
+
+    // scheduleReconnect delay = 100 * attempt(1) = 100ms
+    await vi.advanceTimersByTimeAsync(100);
+    await Promise.resolve();
+    await Promise.resolve();
+
+    expect(sseCalls).toBeGreaterThanOrEqual(2);
+    expect(manager.getState()).toBe(ConnectionState.CONNECTED);
+    manager.disconnect();
+  });
+
+  it("sendRequest posts without Authorization when no token is stored", async () => {
+    installBrowserGlobals();
+    const fetchMock = vi.fn(async () => ({
+      ok: true,
+      status: 200,
+      json: async () => ({ success: true, data: { yaml: "http:\n  port: 1\n" } }),
+    } as Response));
+    vi.stubGlobal("fetch", fetchMock);
+
+    const manager = new WebSocketManager();
+    const data = await manager.getConfigYaml();
+    expect(data.yaml).toContain("port");
+    const init = fetchMock.mock.calls[0]![1] as RequestInit;
+    expect((init.headers as Record<string, string>).Authorization).toBeUndefined();
+    expect(init.method).toBe("POST");
+  });
+
+  it("sendRequest includes Bearer token when present", async () => {
+    installBrowserGlobals(mockStorage({ zhin_api_token: "t" }));
+    const fetchMock = vi.fn(async () => ({
+      ok: true,
+      status: 200,
+      json: async () => ({ success: true, data: { ok: true } }),
+    } as Response));
+    vi.stubGlobal("fetch", fetchMock);
+
+    const manager = new WebSocketManager();
+    await manager.setConfig("sandbox", { endpoints: [] });
+    const init = fetchMock.mock.calls[0]![1] as RequestInit;
+    expect((init.headers as Record<string, string>).Authorization).toBe("Bearer t");
+  });
+
+  it("normalizes legacy endpoint push names and payload aliases before callbacks", async () => {
+    installBrowserGlobals();
+    const received: WebSocketMessage[] = [];
+    const manager = new WebSocketManager({}, {
+      onMessage: (message) => received.push(message),
+    });
+
+    (manager as unknown as { handleMessage(event: MessageEvent): void }).handleMessage({
+      data: '{"type":"endpoint:message","data":{"$adapter":"sandbox","endpoint":"bot"}}',
+    } as MessageEvent);
+    await Promise.resolve();
+
+    expect(received).toEqual([expect.objectContaining({
+      type: "message.receive",
+      data: expect.objectContaining({ adapter: "sandbox", endpointKey: "bot" }),
+    })]);
+    expect(mockApplyConsoleEvent).toHaveBeenCalledWith(expect.objectContaining({
+      type: "message.receive",
+    }));
+  });
+
+  it("stops reconnecting after maxReconnectAttempts", async () => {
+    installBrowserGlobals();
+    const fetchMock = mockConsoleTransport(() => sseResponse(500, null));
+    vi.stubGlobal("fetch", fetchMock);
+
+    const manager = new WebSocketManager({
+      reconnectInterval: 10,
+      maxReconnectAttempts: 2,
+    });
+    manager.connect();
+
+    for (let i = 0; i < 6; i++) {
+      await vi.advanceTimersByTimeAsync(50);
+      await Promise.resolve();
+      await Promise.resolve();
+    }
+
+    expect(manager.getState()).toBe(ConnectionState.ERROR);
+    const sseCalls = fetchMock.mock.calls.filter(([input]) => !String(input).includes('/history'));
+    expect(sseCalls.length).toBeLessThanOrEqual(3);
+    manager.disconnect();
+  });
+
+  it('recovers typed history before live SSE and preserves event metadata', async () => {
+    installBrowserGlobals();
+    const encoder = new TextEncoder();
+    const stream = new ReadableStream<Uint8Array>({
+      start(controller) {
+        controller.enqueue(encoder.encode([
+          'id: 2',
+          'event: message.receive',
+          'runtime: runtime-a',
+          'timestamp: 200',
+          'data: {"adapter":"sandbox","endpointKey":"bot","content":"live"}',
+          '',
+          '',
+        ].join('\n')));
+      },
+    });
+    const historyEvent = {
+      runtimeId: 'runtime-a', eventId: 1, type: 'message.receive', timestamp: 100,
+      data: { adapter: 'sandbox', endpointKey: 'bot', content: 'history' },
+    };
+    const fetchMock = vi.fn(async (input: RequestInfo | URL) => (
+      String(input).includes('/history')
+        ? eventHistoryResponse([historyEvent], 'runtime-a')
+        : sseResponse(200, stream)
+    ));
+    vi.stubGlobal('fetch', fetchMock);
+    const received: Array<{ eventId: number; delivery?: string }> = [];
+    const manager = new WebSocketManager();
+    manager.onConsoleEvent('message.receive', (event) => received.push({ eventId: event.eventId, delivery: event.delivery }));
+    manager.connect();
+    await vi.advanceTimersByTimeAsync(0);
+    await Promise.resolve();
+    await Promise.resolve();
+
+    expect(received).toEqual([
+      { eventId: 1, delivery: 'history' },
+      { eventId: 2, delivery: 'live' },
+    ]);
+    expect(mockApplyConsoleEvent).toHaveBeenCalledTimes(2);
+    manager.disconnect();
+  });
+
+  it('keeps an in-memory cursor when localStorage is unavailable', async () => {
+    const storage = mockStorage();
+    storage.setItem = () => { throw new Error('storage disabled'); };
+    installBrowserGlobals(storage);
+    const historyEvent = {
+      runtimeId: 'runtime-a', eventId: 1, type: 'message.receive', timestamp: 100,
+      data: { adapter: 'sandbox', endpointKey: 'bot', content: 'history' },
+    };
+    const fetchMock = vi.fn(async (input: RequestInfo | URL) => {
+      const after = new URL(String(input)).searchParams.get('after');
+      return after === '1'
+        ? eventHistoryResponse([], 'runtime-a', 1)
+        : eventHistoryResponse([historyEvent], 'runtime-a', 1);
+    });
+    vi.stubGlobal('fetch', fetchMock);
+    const received: number[] = [];
+    const manager = new WebSocketManager();
+    manager.onConsoleEvent('message.receive', (event) => received.push(event.eventId));
+    const recover = manager as unknown as { recoverEventHistory(signal: AbortSignal): Promise<void> };
+    await recover.recoverEventHistory(new AbortController().signal);
+    await recover.recoverEventHistory(new AbortController().signal);
+
+    expect(received).toEqual([1]);
+    expect(fetchMock.mock.calls[1]?.[0]).toContain('after=1');
+  });
+
+  it('exposes a typed recovery gap instead of silently treating it as complete', async () => {
+    installBrowserGlobals();
+    const response = eventHistoryResponse([], 'runtime-new', 9);
+    const originalJson = response.json;
+    response.json = async () => {
+      const body = await originalJson() as { data: Record<string, unknown> };
+      return { ...body, data: { ...body.data, gap: true, oldestAvailableEventId: 8 } };
+    };
+    vi.stubGlobal('fetch', vi.fn(async () => response));
+    const manager = new WebSocketManager();
+    const gaps: unknown[] = [];
+    manager.onConsoleEventRecoveryGap((gap) => gaps.push(gap));
+    const recover = manager as unknown as { recoverEventHistory(signal: AbortSignal): Promise<void> };
+    await recover.recoverEventHistory(new AbortController().signal);
+
+    expect(gaps).toEqual([expect.objectContaining({
+      page: expect.objectContaining({ runtimeId: 'runtime-new', gap: true }),
+    })]);
+  });
+
+  it('does not persist a cursor past an inbox event that failed durable storage', async () => {
+    const stored: Record<string, string> = {};
+    installBrowserGlobals(mockStorage(stored));
+    mockApplyConsoleEvent.mockRejectedValueOnce(new Error('IndexedDB unavailable'));
+    const historyEvent = {
+      runtimeId: 'runtime-a', eventId: 1, type: 'message.receive', timestamp: 100,
+      data: { adapter: 'sandbox', endpointKey: 'bot', content: 'history' },
+    };
+    vi.stubGlobal('fetch', vi.fn(async () => eventHistoryResponse([historyEvent], 'runtime-a', 1)));
+    const manager = new WebSocketManager();
+    const recover = manager as unknown as { recoverEventHistory(signal: AbortSignal): Promise<void> };
+    await recover.recoverEventHistory(new AbortController().signal);
+
+    expect(Object.keys(stored).filter((key) => key.includes('event-cursor'))).toEqual([]);
+  });
+});