@zhin.js/client 2.1.9 → 2.1.11

package/client/message-content/markdown.ts

@@ -0,0 +1,247 @@
+export type MarkdownInline =
+  | { readonly type: 'text'; readonly value: string }
+  | { readonly type: 'strong' | 'emphasis' | 'strike' | 'code'; readonly value: string }
+  | { readonly type: 'link'; readonly value: string; readonly href: string };
+
+export type MarkdownBlock =
+  | { readonly type: 'heading'; readonly level: number; readonly content: MarkdownInline[] }
+  | { readonly type: 'paragraph' | 'quote'; readonly content: MarkdownInline[] }
+  | { readonly type: 'list'; readonly ordered: boolean; readonly items: ReadonlyArray<{ readonly content: MarkdownInline[]; readonly checked?: boolean }> }
+  | { readonly type: 'code'; readonly language: string; readonly value: string; readonly closed: boolean }
+  | { readonly type: 'table'; readonly header: ReadonlyArray<MarkdownInline[]>; readonly rows: ReadonlyArray<ReadonlyArray<MarkdownInline[]>> }
+  | { readonly type: 'rule' };
+
+export type CodeTokenKind = 'plain' | 'comment' | 'string' | 'number' | 'keyword' | 'literal';
+
+export interface CodeToken {
+  readonly kind: CodeTokenKind;
+  readonly value: string;
+}
+
+// Excluding another opening bracket from link labels prevents the regexp
+// engine from rescanning an attacker-controlled run of `[` characters.
+const INLINE_PATTERN = /(`[^`\n]+`)|(\*\*[^*\n]+\*\*|__[^_\n]+__)|(~~[^~\n]+~~)|(\*[^*\n]+\*|_[^_\n]+_)|(\[[^\[\]\n]+\]\([^\s()]+(?:\s+"[^"\n]*")?\))|(https?:\/\/[^\s<>()]+)/g;
+const TABLE_DIVIDER = /^\s*\|?\s*:?-{3,}:?\s*(?:\|\s*:?-{3,}:?\s*)+\|?\s*$/;
+
+export function isSafeMarkdownHref(href: string): boolean {
+  const value = href.trim();
+  if (!value) return false;
+  if (/^(https?:|mailto:)/i.test(value)) return true;
+  return /^(\/|#|\.\/|\.\.\/)/.test(value);
+}
+
+export function parseMarkdownInline(value: string): MarkdownInline[] {
+  const tokens: MarkdownInline[] = [];
+  let cursor = 0;
+  let match: RegExpExecArray | null;
+  INLINE_PATTERN.lastIndex = 0;
+
+  while ((match = INLINE_PATTERN.exec(value)) !== null) {
+    if (match.index > cursor) tokens.push({ type: 'text', value: value.slice(cursor, match.index) });
+    const raw = match[0];
+    if (match[1]) {
+      tokens.push({ type: 'code', value: raw.slice(1, -1) });
+    } else if (match[2]) {
+      tokens.push({ type: 'strong', value: raw.slice(2, -2) });
+    } else if (match[3]) {
+      tokens.push({ type: 'strike', value: raw.slice(2, -2) });
+    } else if (match[4]) {
+      tokens.push({ type: 'emphasis', value: raw.slice(1, -1) });
+    } else if (match[5]) {
+      const parsed = raw.match(/^\[([^\[\]]+)\]\(([^\s()]+)(?:\s+"[^"\n]*")?\)$/);
+      if (parsed && isSafeMarkdownHref(parsed[2])) {
+        tokens.push({ type: 'link', value: parsed[1], href: parsed[2] });
+      } else {
+        tokens.push({ type: 'text', value: raw });
+      }
+    } else if (match[6]) {
+      tokens.push({ type: 'link', value: raw, href: raw });
+    }
+    cursor = INLINE_PATTERN.lastIndex;
+  }
+
+  if (cursor < value.length) tokens.push({ type: 'text', value: value.slice(cursor) });
+  const merged: MarkdownInline[] = [];
+  for (const token of tokens) {
+    const previous = merged.at(-1);
+    if (token.type === 'text' && previous?.type === 'text') {
+      merged[merged.length - 1] = { type: 'text', value: previous.value + token.value };
+    } else {
+      merged.push(token);
+    }
+  }
+  return merged.length > 0 ? merged : [{ type: 'text', value }];
+}
+
+function splitTableRow(line: string): string[] {
+  return line
+    .trim()
+    .replace(/^\|/, '')
+    .replace(/\|$/, '')
+    .split(/(?<!\\)\|/)
+    .map((cell) => cell.trim().replace(/\\\|/g, '|'));
+}
+
+function startsBlock(lines: readonly string[], index: number): boolean {
+  const line = lines[index] ?? '';
+  return /^(?:```|~~~|#{1,6}\s+|>\s?|\s*(?:[-+*]|\d+[.)])\s+|\s*(?:-{3,}|\*{3,}|_{3,})\s*$)/.test(line)
+    || (line.includes('|') && TABLE_DIVIDER.test(lines[index + 1] ?? ''));
+}
+
+export function parseMarkdown(value: string): MarkdownBlock[] {
+  const lines = value.replace(/\r\n?/g, '\n').split('\n');
+  const blocks: MarkdownBlock[] = [];
+  let index = 0;
+
+  while (index < lines.length) {
+    const line = lines[index];
+    if (!line.trim()) {
+      index += 1;
+      continue;
+    }
+
+    const fence = line.match(/^\s*(```|~~~)\s*([^\s`]*)?.*$/);
+    if (fence) {
+      const marker = fence[1];
+      const language = (fence[2] ?? '').toLowerCase();
+      const code: string[] = [];
+      let closed = false;
+      index += 1;
+      while (index < lines.length) {
+        if (lines[index].trim() === marker) {
+          closed = true;
+          index += 1;
+          break;
+        }
+        code.push(lines[index]);
+        index += 1;
+      }
+      blocks.push({ type: 'code', language, value: code.join('\n'), closed });
+      continue;
+    }
+
+    const heading = line.match(/^(#{1,6})\s+(.+)$/);
+    if (heading) {
+      blocks.push({ type: 'heading', level: heading[1].length, content: parseMarkdownInline(heading[2]) });
+      index += 1;
+      continue;
+    }
+
+    if (/^\s*(?:-{3,}|\*{3,}|_{3,})\s*$/.test(line)) {
+      blocks.push({ type: 'rule' });
+      index += 1;
+      continue;
+    }
+
+    if (/^>\s?/.test(line)) {
+      const quoted: string[] = [];
+      while (index < lines.length && /^>\s?/.test(lines[index])) {
+        quoted.push(lines[index].replace(/^>\s?/, ''));
+        index += 1;
+      }
+      blocks.push({ type: 'quote', content: parseMarkdownInline(quoted.join('\n')) });
+      continue;
+    }
+
+    const listMatch = line.match(/^\s*([-+*]|\d+[.)])\s+(.+)$/);
+    if (listMatch) {
+      const ordered = /^\d/.test(listMatch[1]);
+      const items: Array<{ content: MarkdownInline[]; checked?: boolean }> = [];
+      while (index < lines.length) {
+        const item = lines[index].match(/^\s*([-+*]|\d+[.)])\s+(.+)$/);
+        if (!item || /^\d/.test(item[1]) !== ordered) break;
+        const task = item[2].match(/^\[([ xX])\]\s+(.+)$/);
+        items.push({
+          content: parseMarkdownInline(task ? task[2] : item[2]),
+          ...(task ? { checked: task[1].toLowerCase() === 'x' } : {}),
+        });
+        index += 1;
+      }
+      blocks.push({ type: 'list', ordered, items });
+      continue;
+    }
+
+    if (line.includes('|') && TABLE_DIVIDER.test(lines[index + 1] ?? '')) {
+      const header = splitTableRow(line).map(parseMarkdownInline);
+      const rows: MarkdownInline[][][] = [];
+      index += 2;
+      while (index < lines.length && lines[index].includes('|') && lines[index].trim()) {
+        rows.push(splitTableRow(lines[index]).map(parseMarkdownInline));
+        index += 1;
+      }
+      blocks.push({ type: 'table', header, rows });
+      continue;
+    }
+
+    const paragraph = [line];
+    index += 1;
+    while (index < lines.length && lines[index].trim() && !startsBlock(lines, index)) {
+      paragraph.push(lines[index]);
+      index += 1;
+    }
+    blocks.push({ type: 'paragraph', content: parseMarkdownInline(paragraph.join('\n')) });
+  }
+
+  return blocks;
+}
+
+const KEYWORDS: Record<string, ReadonlySet<string>> = {
+  javascript: new Set(['async', 'await', 'break', 'case', 'catch', 'class', 'const', 'continue', 'default', 'delete', 'do', 'else', 'export', 'extends', 'finally', 'for', 'from', 'function', 'if', 'import', 'in', 'instanceof', 'let', 'new', 'of', 'return', 'static', 'switch', 'throw', 'try', 'typeof', 'var', 'void', 'while', 'yield']),
+  typescript: new Set(['abstract', 'any', 'as', 'asserts', 'async', 'await', 'boolean', 'break', 'case', 'catch', 'class', 'const', 'continue', 'declare', 'default', 'delete', 'do', 'else', 'enum', 'export', 'extends', 'finally', 'for', 'from', 'function', 'if', 'implements', 'import', 'in', 'infer', 'instanceof', 'interface', 'keyof', 'let', 'namespace', 'never', 'new', 'number', 'object', 'of', 'readonly', 'return', 'satisfies', 'static', 'string', 'switch', 'symbol', 'throw', 'try', 'type', 'typeof', 'undefined', 'unknown', 'var', 'void', 'while', 'yield']),
+  python: new Set(['and', 'as', 'assert', 'async', 'await', 'break', 'class', 'continue', 'def', 'del', 'elif', 'else', 'except', 'finally', 'for', 'from', 'global', 'if', 'import', 'in', 'is', 'lambda', 'nonlocal', 'not', 'or', 'pass', 'raise', 'return', 'try', 'while', 'with', 'yield']),
+  shell: new Set(['case', 'do', 'done', 'elif', 'else', 'esac', 'export', 'fi', 'for', 'function', 'if', 'in', 'local', 'then', 'while']),
+  css: new Set(['@import', '@media', '@supports', 'and', 'important', 'not', 'only']),
+};
+
+const LANGUAGE_ALIASES: Record<string, string> = {
+  js: 'javascript', jsx: 'javascript', mjs: 'javascript', cjs: 'javascript',
+  ts: 'typescript', tsx: 'typescript', mts: 'typescript', cts: 'typescript',
+  py: 'python', bash: 'shell', sh: 'shell', zsh: 'shell', jsonc: 'json',
+};
+
+export function highlightCodeLine(line: string, language = ''): CodeToken[] {
+  const normalized = LANGUAGE_ALIASES[language] ?? language;
+  const keywords = KEYWORDS[normalized] ?? KEYWORDS.javascript;
+  const tokens: CodeToken[] = [];
+  let index = 0;
+
+  const push = (kind: CodeTokenKind, value: string) => {
+    if (value) tokens.push({ kind, value });
+  };
+
+  while (index < line.length) {
+    const rest = line.slice(index);
+    const comment = normalized === 'python' || normalized === 'shell'
+      ? rest.match(/^#.*/)
+      : rest.match(/^\/\/.*|^\/\*.*?\*\//);
+    if (comment) {
+      push('comment', comment[0]);
+      index += comment[0].length;
+      continue;
+    }
+    const string = rest.match(/^(?:"(?:\\.|[^"\\])*"|'(?:\\.|[^'\\])*'|`(?:\\.|[^`\\])*`)/);
+    if (string) {
+      push('string', string[0]);
+      index += string[0].length;
+      continue;
+    }
+    const number = rest.match(/^(?:0x[\da-f]+|\d+(?:\.\d+)?(?:e[+-]?\d+)?)/i);
+    if (number) {
+      push('number', number[0]);
+      index += number[0].length;
+      continue;
+    }
+    const word = rest.match(/^[A-Za-z_$@][\w$-]*/);
+    if (word) {
+      const literal = /^(?:true|false|null|undefined|None|True|False)$/.test(word[0]);
+      push(literal ? 'literal' : keywords.has(word[0]) ? 'keyword' : 'plain', word[0]);
+      index += word[0].length;
+      continue;
+    }
+    const plain = rest.match(/^[^A-Za-z_$@'"`\d/#]+/) ?? rest.match(/^./);
+    push('plain', plain?.[0] ?? '');
+    index += plain?.[0].length ?? 1;
+  }
+
+  return tokens;
+}

package/client/persistence/idb-store.test.ts

@@ -108,6 +108,17 @@ describe("applyConsoleEvent inbox record ids", () => {
     expect(new Set(rows.map((r) => r.id)).size).toBe(2);
   });
 
+  it('deduplicates the same resumable event across history and live delivery', async () => {
+    const event = { ...PUSH, runtimeId: 'runtime-a', eventId: 7, timestamp: 1700000000000 };
+    await applyConsoleEvent(event);
+    await applyConsoleEvent(event);
+
+    const rows = await idbListInbox('icqq', 'bot-1', 'message');
+    expect(rows).toHaveLength(1);
+    expect(rows[0]?.id).toBe('runtime-a:7');
+    expect(rows[0]?.updatedAt).toBe(1700000000000);
+  });
+
   it("reads legacy records that only carry endpointKey (camelCase)", async () => {
     // 旧版（DB v1 时代）记录只有 endpointKey 字段，升级后仍需能被列出
     const { idbPutInbox } = await import("./idb-store.js");

package/client/persistence/idb-store.ts

@@ -66,13 +66,29 @@ export async function idbListInbox(
   );
 }
 
-export async function applyConsoleEvent(event: { type: string; data?: unknown }): Promise<void> {
+export async function applyConsoleEvent(event: {
+  type: string;
+  data?: unknown;
+  runtimeId?: string;
+  eventId?: number;
+  timestamp?: number;
+}): Promise<void> {
   const parsed = parseConsoleInboxEvent(event);
   if (!parsed) return;
-  const updatedAt = Date.now();
+  const updatedAt = typeof event.timestamp === 'number' && Number.isFinite(event.timestamp)
+    ? event.timestamp
+    : Date.now();
+  const resumableId = typeof event.runtimeId === 'string'
+    && event.runtimeId
+    && Number.isSafeInteger(event.eventId)
+    && (event.eventId ?? 0) > 0
+    ? `${event.runtimeId}:${event.eventId}`
+    : null;
   await idbPutInbox({
-    // 追加自增+随机后缀：同毫秒同会话的两条事件不会因主键相同而互相覆盖
-    id: `${parsed.adapter}:${parsed.endpointKey}:${parsed.type}:${updatedAt}:${inboxEventSeq++}:${Math.random().toString(36).slice(2, 8)}`,
+    // Resumable Host events are idempotent across history/live redelivery.
+    // Legacy/unsequenced sources retain collision-safe append ids.
+    id: resumableId
+      ?? `${parsed.adapter}:${parsed.endpointKey}:${parsed.type}:${updatedAt}:${inboxEventSeq++}:${Math.random().toString(36).slice(2, 8)}`,
     adapter: parsed.adapter,
     endpoint_id: parsed.endpointKey,
     kind: parsed.kind,

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

@@ -54,6 +54,32 @@ function sseResponse(status = 200, body?: ReadableStream<Uint8Array> | null) {
   } 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();
@@ -68,7 +94,7 @@ describe("WebSocketManager REST/SSE transport", () => {
 
   it("connects SSE without a token (local Host with empty TokenRegistry)", async () => {
     installBrowserGlobals();
-    const fetchMock = vi.fn(async () => sseResponse(200));
+    const fetchMock = mockConsoleTransport(() => sseResponse(200));
     vi.stubGlobal("fetch", fetchMock);
 
     const manager = new WebSocketManager({ reconnectInterval: 100, maxReconnectAttempts: 3 });
@@ -81,7 +107,8 @@ describe("WebSocketManager REST/SSE transport", () => {
     await Promise.resolve();
 
     expect(fetchMock).toHaveBeenCalled();
-    const init = fetchMock.mock.calls[0]![1] as RequestInit;
+    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();
@@ -92,7 +119,7 @@ describe("WebSocketManager REST/SSE transport", () => {
 
   it("sends Authorization when a token is stored", async () => {
     installBrowserGlobals(mockStorage({ zhin_api_token: "secret" }));
-    const fetchMock = vi.fn(async () => sseResponse(200));
+    const fetchMock = mockConsoleTransport(() => sseResponse(200));
     vi.stubGlobal("fetch", fetchMock);
 
     const manager = new WebSocketManager();
@@ -101,17 +128,18 @@ describe("WebSocketManager REST/SSE transport", () => {
     await Promise.resolve();
     await Promise.resolve();
 
-    const init = fetchMock.mock.calls[0]![1] as RequestInit;
+    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 calls = 0;
-    const fetchMock = vi.fn(async () => {
-      calls += 1;
-      if (calls === 1) return sseResponse(503, null);
+    let sseCalls = 0;
+    const fetchMock = mockConsoleTransport(() => {
+      sseCalls += 1;
+      if (sseCalls === 1) return sseResponse(503, null);
       return sseResponse(200);
     });
     vi.stubGlobal("fetch", fetchMock);
@@ -127,14 +155,14 @@ describe("WebSocketManager REST/SSE transport", () => {
     await Promise.resolve();
     await Promise.resolve();
     expect(manager.getState()).toBe(ConnectionState.RECONNECTING);
-    expect(calls).toBe(1);
+    expect(sseCalls).toBe(1);
 
     // scheduleReconnect delay = 100 * attempt(1) = 100ms
     await vi.advanceTimersByTimeAsync(100);
     await Promise.resolve();
     await Promise.resolve();
 
-    expect(calls).toBeGreaterThanOrEqual(2);
+    expect(sseCalls).toBeGreaterThanOrEqual(2);
     expect(manager.getState()).toBe(ConnectionState.CONNECTED);
     manager.disconnect();
   });
@@ -194,7 +222,7 @@ describe("WebSocketManager REST/SSE transport", () => {
 
   it("stops reconnecting after maxReconnectAttempts", async () => {
     installBrowserGlobals();
-    const fetchMock = vi.fn(async () => sseResponse(500, null));
+    const fetchMock = mockConsoleTransport(() => sseResponse(500, null));
     vi.stubGlobal("fetch", fetchMock);
 
     const manager = new WebSocketManager({
@@ -210,7 +238,112 @@ describe("WebSocketManager REST/SSE transport", () => {
     }
 
     expect(manager.getState()).toBe(ConnectionState.ERROR);
-    expect(fetchMock.mock.calls.length).toBeLessThanOrEqual(3);
+    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([]);
+  });
 });