@sybilion/uilib 1.3.87 → 1.3.89

package/src/contexts/chatPersistence.ts

@@ -1,7 +1,8 @@
-import type {
-  Chat,
-  Message,
-  UserTextFileAttachment,
+import {
+  type Chat,
+  type Message,
+  MessageRole,
+  type UserTextFileAttachment,
 } from '#uilib/components/ui/Chat/Chat.types';
 import { stripJsonDashboardFences } from '#uilib/lib/dashboard-spec/stripJsonDashboardFences';
 import { LS } from '@homecode/ui';
@@ -9,7 +10,7 @@ import { LS } from '@homecode/ui';
 /** Ephemeral scopes (e.g. /reports/new draft) — keep only the latest session in LS. */
 const EPHEMERAL_SCOPE_MARKERS = ['__reports_new_draft__'] as const;
 
-function isEphemeralChatScope(scopeId: string): boolean {
+export function isEphemeralChatScope(scopeId: string): boolean {
   return EPHEMERAL_SCOPE_MARKERS.some(marker => scopeId.endsWith(marker));
 }
 
@@ -33,7 +34,10 @@ function stripAttachmentForPersistence(
 }
 
 export function stripMessageForPersistence(message: Message): Message {
-  const text = stripJsonDashboardFences(message.text);
+  const text =
+    message.role === MessageRole.ASSISTANT
+      ? message.text
+      : stripJsonDashboardFences(message.text);
   const next: Message = { ...message, text };
   if (message.inProgress) {
     delete next.inProgress;
@@ -60,6 +64,18 @@ function chatsForScopePersistence(scopeId: string, chats: Chat[]): Chat[] {
   return stripChatsForPersistence(scopeChats);
 }
 
+export function persistSessionToLS(chat: Chat): void {
+  const payload = stripChatsForPersistence([chat])[0];
+  if (!payload) return;
+  const sessionKey = `chat-session-${chat.session_id}`;
+  try {
+    LS.set(sessionKey, payload);
+  } catch (error) {
+    if (!isQuotaExceededError(error)) throw error;
+  }
+}
+
+/** @deprecated Legacy scope blob — prefer session + scope index via chatSessionStorage. */
 export function persistChatsToLS(scopeId: string, chats: Chat[]): void {
   const chatsKey = `chats-${scopeId}`;
   const payload = chatsForScopePersistence(scopeId, chats);

package/src/contexts/chatSessionStorage.test.ts

@@ -0,0 +1,125 @@
+import { MessageRole } from '#uilib/components/ui/Chat/Chat.types';
+import type { Chat } from '#uilib/components/ui/Chat/Chat.types';
+
+import {
+  countSessionReferences,
+  deleteSessionBlob,
+  hydrateChatsForScope,
+  linkSessionToScope,
+  loadScopeIndex,
+  loadSession,
+  migrateLegacyScope,
+  persistSession,
+  removeSessionFromScope,
+} from './chatSessionStorage';
+
+const USER_ID = 42;
+const DATASET_SCOPE = `${USER_ID}-dataset-1`;
+const REPORT_SCOPE = `${USER_ID}-chats-report-r1`;
+const SESSION_A = 'session-a';
+const SESSION_B = 'session-b';
+
+function makeChat(sessionId: string, messageCount: number): Chat {
+  const messages = Array.from({ length: messageCount }, (_, index) => ({
+    id: `${sessionId}-msg-${index}`,
+    role: MessageRole.USER,
+    text: `message-${index}`,
+    timestamp: index,
+  }));
+  return { session_id: sessionId, name: '', messages };
+}
+
+describe('chatSessionStorage migration', () => {
+  beforeEach(() => {
+    window.localStorage.clear();
+  });
+
+  it('migrates legacy chats-* into session blobs and scope index', () => {
+    const legacyChats = [makeChat(SESSION_A, 2), makeChat(SESSION_B, 1)];
+    window.localStorage.setItem(
+      `chats-${DATASET_SCOPE}`,
+      JSON.stringify(legacyChats),
+    );
+    window.localStorage.setItem(
+      `chat-current-id-${DATASET_SCOPE}`,
+      JSON.stringify(SESSION_B),
+    );
+
+    migrateLegacyScope(DATASET_SCOPE);
+
+    expect(window.localStorage.getItem(`chats-${DATASET_SCOPE}`)).toBeNull();
+    expect(
+      window.localStorage.getItem(`chat-current-id-${DATASET_SCOPE}`),
+    ).toBeNull();
+
+    const index = loadScopeIndex(DATASET_SCOPE);
+    expect(index?.sessionIds).toEqual([SESSION_A, SESSION_B]);
+    expect(index?.currentSessionId).toBe(SESSION_B);
+    expect(loadSession(SESSION_A)?.messages).toHaveLength(2);
+    expect(loadSession(SESSION_B)?.messages).toHaveLength(1);
+  });
+
+  it('keeps the richer session blob when duplicate ids exist during migration', () => {
+    const sparse = makeChat(SESSION_A, 1);
+    const rich = makeChat(SESSION_A, 4);
+    window.localStorage.setItem(
+      `chats-${DATASET_SCOPE}`,
+      JSON.stringify([sparse, rich]),
+    );
+
+    migrateLegacyScope(DATASET_SCOPE);
+
+    expect(loadSession(SESSION_A)?.messages).toHaveLength(4);
+  });
+});
+
+describe('chatSessionStorage shared sessions', () => {
+  beforeEach(() => {
+    window.localStorage.clear();
+  });
+
+  it('shares one session blob across two scopes', () => {
+    persistSession(makeChat(SESSION_A, 1));
+    linkSessionToScope(DATASET_SCOPE, SESSION_A, { makeCurrent: true });
+    linkSessionToScope(REPORT_SCOPE, SESSION_A, { makeCurrent: true });
+
+    const datasetChats = hydrateChatsForScope(DATASET_SCOPE);
+    expect(datasetChats[0]?.messages).toHaveLength(1);
+
+    const session = loadSession(SESSION_A);
+    if (!session) throw new Error('expected session');
+    persistSession({
+      ...session,
+      messages: [
+        ...session.messages,
+        {
+          id: 'follow-up',
+          role: MessageRole.ASSISTANT,
+          text: 'merged',
+          timestamp: 99,
+        },
+      ],
+    });
+
+    const reportChats = hydrateChatsForScope(REPORT_SCOPE);
+    expect(reportChats[0]?.messages).toHaveLength(2);
+    expect(reportChats[0]?.messages[1]?.text).toBe('merged');
+  });
+
+  it('keeps session blob until the last scope reference is removed', () => {
+    persistSession(makeChat(SESSION_A, 1));
+    linkSessionToScope(DATASET_SCOPE, SESSION_A);
+    linkSessionToScope(REPORT_SCOPE, SESSION_A);
+
+    expect(countSessionReferences(USER_ID, SESSION_A)).toBe(2);
+
+    removeSessionFromScope(DATASET_SCOPE, SESSION_A);
+    expect(loadSession(SESSION_A)).not.toBeNull();
+    expect(countSessionReferences(USER_ID, SESSION_A)).toBe(1);
+
+    removeSessionFromScope(REPORT_SCOPE, SESSION_A);
+    expect(countSessionReferences(USER_ID, SESSION_A)).toBe(0);
+    deleteSessionBlob(SESSION_A);
+    expect(loadSession(SESSION_A)).toBeNull();
+  });
+});

package/src/contexts/chatSessionStorage.ts

@@ -0,0 +1,321 @@
+import type { Chat } from '#uilib/components/ui/Chat/Chat.types';
+import { LS } from '@homecode/ui';
+
+import {
+  isEphemeralChatScope,
+  safeLsSet,
+  stripChatsForPersistence,
+} from './chatPersistence';
+
+export type ChatScopeIndex = {
+  currentSessionId: string | null;
+  sessionIds: string[];
+};
+
+export const CHAT_SCOPE_IDS_REGISTRY_KEY = 'chat-scope-ids';
+
+const SESSION_PREFIX = 'chat-session-';
+const SCOPE_PREFIX = 'chat-scope-';
+const CHATS_PREFIX = 'chats-';
+const CHAT_CURRENT_ID_PREFIX = 'chat-current-id-';
+
+function getSessionKey(sessionId: string): string {
+  return `${SESSION_PREFIX}${sessionId}`;
+}
+
+function getScopeKey(scopeId: string): string {
+  return `${SCOPE_PREFIX}${scopeId}`;
+}
+
+function getLegacyChatsKey(scopeId: string): string {
+  return `${CHATS_PREFIX}${scopeId}`;
+}
+
+function getLegacyCurrentIdKey(scopeId: string): string {
+  return `${CHAT_CURRENT_ID_PREFIX}${scopeId}`;
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === 'object' && value !== null;
+}
+
+function isChat(value: unknown): value is Chat {
+  if (!isRecord(value)) return false;
+  return (
+    typeof value.session_id === 'string' &&
+    typeof value.name === 'string' &&
+    Array.isArray(value.messages)
+  );
+}
+
+function isChatScopeIndex(value: unknown): value is ChatScopeIndex {
+  if (!isRecord(value)) return false;
+  const { currentSessionId, sessionIds } = value;
+  if (currentSessionId !== null && typeof currentSessionId !== 'string') {
+    return false;
+  }
+  if (!Array.isArray(sessionIds)) return false;
+  return sessionIds.every(id => typeof id === 'string');
+}
+
+function trimScopeIndexForPersistence(
+  scopeId: string,
+  index: ChatScopeIndex,
+): ChatScopeIndex {
+  if (!isEphemeralChatScope(scopeId)) return index;
+  const current = index.currentSessionId ?? index.sessionIds[0] ?? null;
+  if (!current) return { currentSessionId: null, sessionIds: [] };
+  return { currentSessionId: current, sessionIds: [current] };
+}
+
+function mergeSessionChat(existing: Chat | null, incoming: Chat): Chat {
+  if (!existing) return incoming;
+  return incoming.messages.length >= existing.messages.length
+    ? incoming
+    : existing;
+}
+
+export function loadSession(sessionId: string): Chat | null {
+  const raw = LS.get(getSessionKey(sessionId));
+  return isChat(raw) ? raw : null;
+}
+
+export function persistSession(chat: Chat): void {
+  const [stripped] = stripChatsForPersistence([chat]);
+  safeLsSet(getSessionKey(chat.session_id), stripped);
+}
+
+export function deleteSessionBlob(sessionId: string): void {
+  LS.remove(getSessionKey(sessionId));
+}
+
+export function loadScopeIndex(scopeId: string): ChatScopeIndex | null {
+  const raw = LS.get(getScopeKey(scopeId));
+  return isChatScopeIndex(raw) ? raw : null;
+}
+
+export function persistScopeIndex(
+  scopeId: string,
+  index: ChatScopeIndex,
+): void {
+  safeLsSet(getScopeKey(scopeId), trimScopeIndexForPersistence(scopeId, index));
+}
+
+export function addScopeIdToRegistry(scopeId: string): void {
+  const raw = LS.get(CHAT_SCOPE_IDS_REGISTRY_KEY);
+  const registry = Array.isArray(raw) ? [...raw] : [];
+  if (!registry.includes(scopeId)) {
+    safeLsSet(CHAT_SCOPE_IDS_REGISTRY_KEY, [...registry, scopeId]);
+  }
+}
+
+export function discoverScopeIdsFromLS(): Set<string> {
+  const scopeIds = new Set<string>();
+  const registryRaw = LS.get(CHAT_SCOPE_IDS_REGISTRY_KEY);
+  const registry = Array.isArray(registryRaw) ? registryRaw : [];
+  registry.forEach((id: unknown) => {
+    if (typeof id === 'string' && id) scopeIds.add(id);
+  });
+  try {
+    for (let i = 0; i < window.localStorage.length; i++) {
+      const key = window.localStorage.key(i);
+      if (!key) continue;
+      if (key.startsWith(SCOPE_PREFIX)) {
+        const scopeId = key.slice(SCOPE_PREFIX.length);
+        if (scopeId) scopeIds.add(scopeId);
+      } else if (key.startsWith(CHATS_PREFIX)) {
+        const scopeId = key.slice(CHATS_PREFIX.length);
+        if (scopeId) scopeIds.add(scopeId);
+      }
+    }
+  } catch {
+    // ignore
+  }
+  return scopeIds;
+}
+
+export function scopeIdsForUser(userId: number, all: Set<string>): Set<string> {
+  const prefix = `${userId}-`;
+  const out = new Set<string>();
+  for (const id of all) {
+    if (id.startsWith(prefix)) out.add(id);
+  }
+  return out;
+}
+
+export function hasLegacyScopeData(scopeId: string): boolean {
+  const legacyRaw = LS.get(getLegacyChatsKey(scopeId));
+  return Array.isArray(legacyRaw) && legacyRaw.length > 0;
+}
+
+export function migrateLegacyScope(scopeId: string): ChatScopeIndex | null {
+  const legacyRaw = LS.get(getLegacyChatsKey(scopeId));
+  const legacyChats = Array.isArray(legacyRaw) ? legacyRaw : [];
+  const chats: Chat[] = [];
+  legacyChats.forEach(item => {
+    if (isChat(item)) chats.push(item);
+  });
+  if (chats.length === 0) return loadScopeIndex(scopeId);
+
+  const savedCurrentRaw = LS.get(getLegacyCurrentIdKey(scopeId));
+  const savedCurrentId =
+    typeof savedCurrentRaw === 'string' && savedCurrentRaw !== ''
+      ? savedCurrentRaw
+      : undefined;
+  const currentSessionId = savedCurrentId ?? chats[0]?.session_id ?? null;
+  const sessionIds = chats.map(chat => chat.session_id);
+
+  chats.forEach(chat => {
+    const existing = loadSession(chat.session_id);
+    persistSession(mergeSessionChat(existing, chat));
+  });
+
+  const index: ChatScopeIndex = { currentSessionId, sessionIds };
+  persistScopeIndex(scopeId, index);
+  addScopeIdToRegistry(scopeId);
+  LS.remove(getLegacyChatsKey(scopeId));
+  LS.remove(getLegacyCurrentIdKey(scopeId));
+  return index;
+}
+
+export type LinkSessionToScopeOptions = {
+  makeCurrent?: boolean;
+};
+
+export function linkSessionToScope(
+  scopeId: string,
+  sessionId: string,
+  options?: LinkSessionToScopeOptions,
+): ChatScopeIndex {
+  addScopeIdToRegistry(scopeId);
+  const existing = loadScopeIndex(scopeId) ?? {
+    currentSessionId: null,
+    sessionIds: [],
+  };
+  const sessionIds = existing.sessionIds.includes(sessionId)
+    ? existing.sessionIds
+    : [sessionId, ...existing.sessionIds];
+  const makeCurrent = options?.makeCurrent !== false;
+  const index: ChatScopeIndex = {
+    sessionIds,
+    currentSessionId: makeCurrent ? sessionId : existing.currentSessionId,
+  };
+  persistScopeIndex(scopeId, index);
+  return index;
+}
+
+export function hydrateChatsForScope(scopeId: string): Chat[] {
+  const index = loadScopeIndex(scopeId);
+  if (!index) return [];
+  return index.sessionIds
+    .map(sessionId => loadSession(sessionId))
+    .filter((chat): chat is Chat => chat != null);
+}
+
+export function countSessionReferences(
+  userId: number,
+  sessionId: string,
+): number {
+  const scopeIds = scopeIdsForUser(userId, discoverScopeIdsFromLS());
+  let count = 0;
+  for (const scopeId of scopeIds) {
+    const index = loadScopeIndex(scopeId);
+    if (index?.sessionIds.includes(sessionId)) count += 1;
+  }
+  return count;
+}
+
+export function removeSessionFromScope(
+  scopeId: string,
+  sessionId: string,
+): ChatScopeIndex | null {
+  const existing = loadScopeIndex(scopeId);
+  if (!existing) return null;
+  const sessionIds = existing.sessionIds.filter(id => id !== sessionId);
+  if (sessionIds.length === existing.sessionIds.length) return existing;
+
+  let nextCurrent = existing.currentSessionId;
+  if (nextCurrent === sessionId) {
+    const deletedIndex = existing.sessionIds.indexOf(sessionId);
+    nextCurrent =
+      deletedIndex > 0
+        ? existing.sessionIds[deletedIndex - 1]
+        : (sessionIds[0] ?? null);
+  }
+
+  const index: ChatScopeIndex = {
+    currentSessionId: nextCurrent,
+    sessionIds,
+  };
+  persistScopeIndex(scopeId, index);
+  return index;
+}
+
+export function renameSessionId(
+  userId: number,
+  oldId: string,
+  newId: string,
+): void {
+  if (oldId === newId) return;
+  const chat = loadSession(oldId);
+  if (!chat) return;
+  persistSession({ ...chat, session_id: newId });
+  LS.remove(getSessionKey(oldId));
+
+  const scopeIds = scopeIdsForUser(userId, discoverScopeIdsFromLS());
+  for (const scopeId of scopeIds) {
+    const index = loadScopeIndex(scopeId);
+    if (!index?.sessionIds.includes(oldId)) continue;
+    const sessionIds = index.sessionIds.map(id => (id === oldId ? newId : id));
+    const currentSessionId =
+      index.currentSessionId === oldId ? newId : index.currentSessionId;
+    persistScopeIndex(scopeId, { currentSessionId, sessionIds });
+  }
+}
+
+export function loadChatsFromSessionStorage(userId: number): {
+  chats: Record<string, Chat[]>;
+  currentChatId: Record<string, string | null>;
+} {
+  const chats: Record<string, Chat[]> = {};
+  const currentChatId: Record<string, string | null> = {};
+  const scopeIds = scopeIdsForUser(userId, discoverScopeIdsFromLS());
+
+  for (const scopeId of scopeIds) {
+    if (hasLegacyScopeData(scopeId)) {
+      migrateLegacyScope(scopeId);
+    }
+    const index = loadScopeIndex(scopeId);
+    if (!index || index.sessionIds.length === 0) continue;
+    chats[scopeId] = hydrateChatsForScope(scopeId);
+    currentChatId[scopeId] =
+      index.currentSessionId ?? chats[scopeId][0]?.session_id ?? null;
+  }
+
+  return { chats, currentChatId };
+}
+
+/** Alias used by ChatProvider mount hydration. */
+export const loadAllScopesForUser = loadChatsFromSessionStorage;
+
+export function isSessionReferencedByScopes(
+  sessionId: string,
+  excludeScopeId: string | null,
+  userId: number,
+): boolean {
+  const scopeIds = scopeIdsForUser(userId, discoverScopeIdsFromLS());
+  for (const scopeId of scopeIds) {
+    if (excludeScopeId && scopeId === excludeScopeId) continue;
+    const index = loadScopeIndex(scopeId);
+    if (index?.sessionIds.includes(sessionId)) return true;
+  }
+  return false;
+}
+
+export function renameSessionIdInStorage(
+  oldId: string,
+  newId: string,
+  userId: number,
+): void {
+  renameSessionId(userId, oldId, newId);
+}

package/src/lib/dashboard-spec/jsonDashboardFence.ts

@@ -0,0 +1,98 @@
+const FENCE_OPEN = /```\s*json-dashboard\s*/i;
+
+export function hasJsonDashboardFenceInText(text: string): boolean {
+  return FENCE_OPEN.test(text);
+}
+
+/** Unescape literal `\n` sequences when the agent double-encodes newlines. */
+export function normalizeJsonDashboardChatText(text: string): string {
+  if (!text.includes('\\n')) return text;
+  if (!FENCE_OPEN.test(text)) return text;
+  // Real newlines mean the fence is already formatted; unescaping would
+  // corrupt `\n` inside JSON string values (e.g. markdown code fences).
+  if (text.includes('\n')) return text;
+  return text.replace(/\\n/g, '\n').replace(/\\t/g, '\t');
+}
+
+function findCompleteJsonEnd(text: string, contentStart: number): number {
+  let lastValidEnd = -1;
+  for (let i = contentStart + 1; i <= text.length; i++) {
+    const candidate = text.slice(contentStart, i);
+    if (!candidate.trim()) continue;
+    try {
+      JSON.parse(candidate);
+      lastValidEnd = i;
+    } catch {
+      // keep extending until JSON is complete
+    }
+  }
+  return lastValidEnd;
+}
+
+function findJsonDashboardContentEnd(
+  text: string,
+  contentStart: number,
+): number {
+  const jsonEnd = findCompleteJsonEnd(text, contentStart);
+  if (jsonEnd < 0) return -1;
+
+  const afterJson = text.slice(jsonEnd);
+  const fenceIdx = afterJson.indexOf('```');
+  if (fenceIdx >= 0) {
+    return jsonEnd + fenceIdx;
+  }
+
+  const tail = text.slice(contentStart).trim();
+  if (tail.length > 0) {
+    try {
+      JSON.parse(tail);
+      return text.length;
+    } catch {
+      return jsonEnd;
+    }
+  }
+  return jsonEnd;
+}
+
+export function jsonDashboardFenceBounds(
+  text: string,
+): { contentStart: number; contentEnd: number } | null {
+  const prepared = normalizeJsonDashboardChatText(text);
+  const startMatch = prepared.match(FENCE_OPEN);
+  if (!startMatch || startMatch.index === undefined) return null;
+  const contentStart = startMatch.index + startMatch[0].length;
+  const contentEnd = findJsonDashboardContentEnd(prepared, contentStart);
+  if (contentEnd < 0 || contentEnd <= contentStart) return null;
+  return { contentStart, contentEnd };
+}
+
+function jsonDashboardFenceSpan(
+  text: string,
+): { start: number; end: number } | null {
+  const prepared = normalizeJsonDashboardChatText(text);
+  const startMatch = prepared.match(FENCE_OPEN);
+  if (!startMatch || startMatch.index === undefined) return null;
+  const contentStart = startMatch.index + startMatch[0].length;
+  const closingFenceStart = findJsonDashboardContentEnd(prepared, contentStart);
+  if (closingFenceStart < 0) {
+    return { start: startMatch.index, end: prepared.length };
+  }
+  const end =
+    closingFenceStart < prepared.length &&
+    prepared.startsWith('```', closingFenceStart)
+      ? closingFenceStart + 3
+      : closingFenceStart;
+  return { start: startMatch.index, end };
+}
+
+/** Removes fenced json-dashboard blocks (used before persisting chat messages). */
+export function stripJsonDashboardFences(text: string): string {
+  let result = normalizeJsonDashboardChatText(text);
+  while (true) {
+    const span = jsonDashboardFenceSpan(result);
+    if (!span) break;
+    result = result.slice(0, span.start) + result.slice(span.end);
+  }
+  result = result.replace(/\n{3,}/g, '\n\n');
+  return result.trim();
+}

package/src/lib/dashboard-spec/stripJsonDashboardFences.test.ts

@@ -0,0 +1,84 @@
+import { stripJsonDashboardFences } from './stripJsonDashboardFences';
+
+describe('stripJsonDashboardFences', () => {
+  it('removes a closed json-dashboard fence', () => {
+    const text = 'Summary\n```json-dashboard\n{"tiles":[]}\n```';
+    expect(stripJsonDashboardFences(text)).toBe('Summary');
+  });
+
+  it('removes multiple closed fences', () => {
+    const text = [
+      'Intro',
+      '```json-dashboard',
+      '{"a":1}',
+      '```',
+      'Middle',
+      '```json-dashboard',
+      '{"b":2}',
+      '```',
+      'Outro',
+    ].join('\n');
+    expect(stripJsonDashboardFences(text)).toBe('Intro\n\nMiddle\n\nOutro');
+  });
+
+  it('strips from an unclosed fence to end of text', () => {
+    const text = 'Summary\n```json-dashboard\n{"tiles":[]}';
+    expect(stripJsonDashboardFences(text)).toBe('Summary');
+  });
+
+  it('strips fence with space after backticks', () => {
+    const text = 'Summary\n``` json-dashboard\n{"tiles":[]}\n```';
+    expect(stripJsonDashboardFences(text)).toBe('Summary');
+  });
+
+  it('preserves trailing markdown fences after dashboard block', () => {
+    const text = [
+      'Here is the layout:',
+      '```json-dashboard',
+      '{"tiles":[]}',
+      '```',
+      '',
+      '```sql',
+      'SELECT 1',
+      '```',
+    ].join('\n');
+    expect(stripJsonDashboardFences(text)).toBe(
+      ['Here is the layout:', '', '```sql', 'SELECT 1', '```'].join('\n'),
+    );
+  });
+
+  it('strips dashboard block when json contains markdown code fences', () => {
+    const spec = {
+      schemaVersion: 1,
+      tiles: [
+        {
+          id: 't1',
+          widget: 'markdown',
+          bindings: {
+            content: 'Example:\n```sql\nSELECT 1\n```\nMore text',
+          },
+        },
+      ],
+    };
+    const text = [
+      '```json-dashboard',
+      JSON.stringify(spec),
+      '```',
+      '',
+      'Kenya Protest',
+      '',
+      'Geopolitical Risk',
+    ].join('\n');
+    expect(stripJsonDashboardFences(text)).toBe(
+      ['Kenya Protest', '', 'Geopolitical Risk'].join('\n'),
+    );
+  });
+
+  it('normalizes literal escaped newlines in follow-up responses', () => {
+    const text =
+      '```json-dashboard\\n{"tiles":[]}\\n```\\n\\nKenya Protest\\n\\nFunny summary';
+    expect(stripJsonDashboardFences(text)).toBe(
+      ['Kenya Protest', '', 'Funny summary'].join('\n'),
+    );
+  });
+});

package/src/lib/dashboard-spec/stripJsonDashboardFences.ts

@@ -1,6 +1,5 @@
-const FENCE_STRIP = /```json-dashboard\s*[\s\S]*?```/gi;
-
-/** Removes fenced json-dashboard blocks (used before persisting chat messages). */
-export function stripJsonDashboardFences(text: string): string {
-  return text.replace(FENCE_STRIP, '').trim();
-}
+export {
+  hasJsonDashboardFenceInText,
+  normalizeJsonDashboardChatText,
+  stripJsonDashboardFences,
+} from './jsonDashboardFence';

package/dist/esm/lib/dashboard-spec/stripJsonDashboardFences.js

@@ -1,7 +0,0 @@
-const FENCE_STRIP = /```json-dashboard\s*[\s\S]*?```/gi;
-/** Removes fenced json-dashboard blocks (used before persisting chat messages). */
-function stripJsonDashboardFences(text) {
-    return text.replace(FENCE_STRIP, '').trim();
-}
-
-export { stripJsonDashboardFences };