@flamingo-stack/openframe-frontend-core 0.0.587-1973.5528.1 → 0.0.587-2000.5532.1

package/src/components/chat/types/component.types.ts

@@ -195,8 +195,6 @@ export interface ChatMessageEnhancedProps extends Omit<HTMLAttributes<HTMLDivEle
    * back to plain text title-only.
    */
   renderEntityCard?: (reference: ChatRef) => ReactNode;
-  /** Enriched references associated with this assistant answer. */
-  refs?: ChatRef[];
   /**
    * Host-provided anchor component for markdown links. When supplied, the
    * `<a>` override in the markdown renderer delegates to this component
@@ -306,8 +304,6 @@ export interface ChatMessageListProps extends HTMLAttributes<HTMLDivElement> {
    *  ChatMessageEnhanced; the host sends the received label as the user's next
    *  message. Omit to render ask cards read-only. */
   onAskSelect?: (label: string) => void;
-  /** Renders content owned by one message directly after that message. */
-  renderAfterMessage?: (message: Message, index: number) => ReactNode;
 }
 
 export interface ChatMessageListRef {

package/src/components/chat/types/message.types.ts

@@ -3,7 +3,6 @@
  * Contains all message structures, segments, and content types
  */
 
-import type { ChatRef } from '../chat-ref.types';
 import type { AssistantType, AuthorType, ChatApprovalStatus, MessageOwner } from './chat.types';
 
 // ========== Message Type Definitions ==========
@@ -11,8 +10,6 @@ import type { AssistantType, AuthorType, ChatApprovalStatus, MessageOwner } from
 export const MESSAGE_TYPE = {
   TEXT: 'TEXT',
   THINKING: 'THINKING',
-  GUIDE: 'GUIDE',
-  SOURCES: 'SOURCES',
   ASK: 'ASK',
   EXECUTING_TOOL: 'EXECUTING_TOOL',
   EXECUTED_TOOL: 'EXECUTED_TOOL',
@@ -49,26 +46,6 @@ export const SCROLL_ANCHOR = { TOP: 'top', BOTTOM: 'bottom' } as const;
 
 export type ScrollAnchor = (typeof SCROLL_ANCHOR)[keyof typeof SCROLL_ANCHOR];
 
-export interface ChatSource {
-  index: number;
-  name: string;
-  path: string;
-  documentType: string;
-  externalUrl?: string;
-  targetPlatform?: string | null;
-  id?: string;
-  items?: Array<{
-    id: string;
-    documentType: string;
-    name: string;
-    externalUrl?: string;
-    targetPlatform?: string | null;
-    path?: string | null;
-  }>;
-  sourceRepo?: string;
-  label?: string;
-}
-
 // ========== Tool Execution Types ==========
 
 export interface ToolExecutionData {
@@ -414,16 +391,6 @@ export interface ThinkingMessageData extends MessageDataBase {
   text?: string;
 }
 
-export interface GuideMessageData extends MessageDataBase {
-  type: 'GUIDE';
-  payload?: Record<string, unknown>;
-}
-
-export interface SourcesMessageData extends MessageDataBase {
-  type: 'SOURCES';
-  payload?: Record<string, unknown>;
-}
-
 /** Persisted `ASK` row (GraphQL `AskData`). `text` is the intro sentence, which
  *  history replays as a text segment ahead of the card — same split the live
  *  `ASK` chunk carries. */
@@ -565,8 +532,6 @@ export interface ContextCompactionEndMessageData extends MessageDataBase {
 export type MessageData =
   | TextMessageData
   | ThinkingMessageData
-  | GuideMessageData
-  | SourcesMessageData
   | AskMessageData
   | ExecutingToolMessageData
   | ExecutedToolMessageData
@@ -611,8 +576,6 @@ export interface ProcessedMessage {
   authorType?: AuthorType;
   timestamp: Date;
   avatar?: string;
-  sources?: ChatSource[];
-  refs?: ChatRef[];
   /** Persisted last-chunk stream sequence carried through from
    *  `HistoricalMessage.lastChunkStreamSeq` (for assistant turns: the MAX
    *  across the grouped rows). Hosts stamp it onto the rendered message's
@@ -635,8 +598,6 @@ export interface Message {
   authorType?: AuthorType;
   timestamp?: Date;
   avatar?: string | null;
-  sources?: ChatSource[];
-  refs?: ChatRef[];
   /** Highest CONTENT chunk streamSeq that composed this message. Stamped on
    *  realtime synthetics so `mergeHistoryWithRealtime` can decide history
    *  coverage per-message (see `MergeableChatMessage.streamSeq`). */

package/src/components/chat/types/unified-chat-state.types.ts

@@ -17,11 +17,12 @@
  */
 
 import type { ChatRef } from '../chat-ref.types';
+import type { ChatSource } from '../hooks/use-sse-chat-adapter';
 import type { ChatAttachment } from '../utils/chat-attachment-markdown';
 import type { AuthorType } from './chat.types';
 import type { DialogItem } from './component.types';
 import type { ChatContextItem } from './context-item.types';
-import type { ChatSource, MessageSegment, ScrollAnchor } from './message.types';
+import type { MessageSegment, ScrollAnchor } from './message.types';
 
 // ─── Per-dialog token usage (Mingo backend telemetry) ────────────────────────
 
@@ -168,11 +169,9 @@ export interface UnifiedChatMessage {
    */
   timestamp?: Date | string | number;
 
-  /** Document citations for a Guide answer over SSE or NATS. */
+  /** Guide/SSE-only: document citations. Undefined in Mingo mode. */
   sources?: ChatSource[];
 
-  refs?: ChatRef[];
-
   /**
    * Per-message viewport-positioning hint. Common to both modes; the
    * message-list reads it to override default tail-on-stream behaviour

package/src/components/chat/utils/__tests__/process-historical-messages-golden.test.ts

@@ -391,60 +391,3 @@ describe('processHistoricalMessages — ASK rows', () => {
     expect(processHistoricalMessages(dialog).messages).toEqual([]);
   });
 });
-
-describe('processHistoricalMessages — Mingo source metadata', () => {
-  it.each(['GUIDE', 'SOURCES'] as const)('restores %s metadata on the same assistant turn', type => {
-    const dialog: HistoricalMessage[] = [
-      {
-        id: 'a1',
-        chatType: 'ADMIN_AI_CHAT',
-        createdAt: '2026-07-19T09:00:05Z',
-        owner: { type: 'ASSISTANT' },
-        messageData: [
-          {
-            type,
-            payload: {
-              sources: [
-                {
-                  index: 1,
-                  name: 'Install agent',
-                  path: 'docs/install.md',
-                  documentType: 'markdown',
-                },
-              ],
-              videos: [
-                {
-                  ref: '[card://video:mux-9b6586b494]',
-                  title: 'Community demo',
-                  url: 'https://stream.mux.com/playback-id.m3u8',
-                  metadata: { videoUrl: 'https://stream.mux.com/playback-id.m3u8' },
-                },
-              ],
-            },
-          },
-          { type: 'TEXT', text: 'Install the agent [1]. [card://video:mux-9b6586b494]' },
-        ],
-      },
-    ];
-
-    expect(processHistoricalMessages(dialog).messages[0]).toMatchObject({
-      role: 'assistant',
-      sources: [
-        {
-          index: 1,
-          name: 'Install agent',
-          path: 'docs/install.md',
-          documentType: 'markdown',
-        },
-      ],
-      refs: [
-        {
-          type: 'video',
-          id: 'mux-9b6586b494',
-          metadata: { videoUrl: 'https://stream.mux.com/playback-id.m3u8' },
-        },
-      ],
-      content: [{ type: 'text', text: 'Install the agent [1]. [card://video:mux-9b6586b494]' }],
-    });
-  });
-});

package/src/components/chat/utils/process-historical-messages.ts

@@ -33,8 +33,7 @@ import {
 } from '../../../chat-protocol/events';
 // One normalizer for ask rows, shared with the live decoder — history and the
 // stream must agree on which options are usable.
-import { decodeNatsChunk, normalizeAskOptions } from '../../../chat-protocol/nats-decoder';
-import type { ChatRef } from '../chat-ref.types';
+import { normalizeAskOptions } from '../../../chat-protocol/nats-decoder';
 import { applyApprovalStatusToSegment } from '../stream/message-mutations';
 import {
   MESSAGE_TYPE,
@@ -47,10 +46,8 @@ import {
   type MessageProcessingOptions,
   type MessageData,
   type MessageOwner,
-  type ChatSource,
 } from '../types';
 import { approvalDisplaysInline } from './approval-display';
-import { mergeChatRefs, mergeChatSources } from './chat-source-metadata';
 import { type MessageSegmentAccumulator, createMessageSegmentAccumulator } from './message-segment-accumulator';
 import { getCommandText } from './tool-call-helpers';
 
@@ -124,10 +121,6 @@ export function decodeHistoricalMessageData(data: MessageData): ChatStreamEvent
       }
       return null;
 
-    case MESSAGE_TYPE.GUIDE:
-    case MESSAGE_TYPE.SOURCES:
-      return decodeNatsChunk({ type: data.type, payload: data.payload });
-
     // Same completeness gate as the live decoder (`decodeNatsChunk`): a
     // persisted row without a question or without options is not a card the
     // user can answer, so it replays as nothing rather than as empty chrome.
@@ -598,8 +591,6 @@ export function processHistoricalMessages(
   // MAX persisted seq across the rows grouped into the current assistant turn
   // — carried onto the flushed message's streamSeq for per-role merge coverage.
   let currentAssistantStreamSeq: number | undefined;
-  let currentAssistantSources: ChatSource[] | undefined;
-  let currentAssistantRefs: ChatRef[] | undefined;
 
   /**
    * Flush the current assistant message to processedMessages.
@@ -617,8 +608,6 @@ export function processHistoricalMessages(
         authorType: assistantType,
         timestamp: currentAssistantTimestamp || new Date(),
         avatar: assistantAvatar,
-        ...(currentAssistantSources ? { sources: currentAssistantSources } : {}),
-        ...(currentAssistantRefs ? { refs: currentAssistantRefs } : {}),
         ...(currentAssistantStreamSeq !== undefined ? { streamSeq: currentAssistantStreamSeq } : {}),
       });
       accumulator.resetSegments();
@@ -634,8 +623,6 @@ export function processHistoricalMessages(
     currentAssistantTimestamp = null;
     lastAssistantId = null;
     currentAssistantStreamSeq = undefined;
-    currentAssistantSources = undefined;
-    currentAssistantRefs = undefined;
   };
 
   messages.forEach((msg, index) => {
@@ -702,11 +689,6 @@ export function processHistoricalMessages(
       messageDataArray.forEach(data => {
         const event = decodeHistoricalMessageData(data);
         if (!event) return;
-        if (event.type === 'sources') {
-          currentAssistantSources = mergeChatSources(currentAssistantSources, event.sources);
-          if (event.refs) currentAssistantRefs = mergeChatRefs(currentAssistantRefs, event.refs);
-          return;
-        }
         applyHistoryEvent(
           event,
           accumulator,

package/src/components/ui/__tests__/data-table-compiler-identity.test.tsx

@@ -0,0 +1,74 @@
+import type { ColumnDef, Table } from '@tanstack/react-table';
+import { render, renderHook, screen } from '@testing-library/react';
+import { memo } from 'react';
+import { describe, expect, it } from 'vitest';
+import { DataTable } from '../data-table';
+import { useDataTable } from '../data-table/use-data-table';
+
+/**
+ * What this pins down: `useDataTable` must hand back a NEW reference on every
+ * render, because `useReactTable` creates one instance for the life of the
+ * component and mutates it in place.
+ *
+ * Everything inside `<DataTable>` reads its rows back out of that instance
+ * through context, so a caller compiled by the React Compiler caches
+ * `<DataTable table={table}>` and its children on the table's identity — which
+ * never changes — and a table that gains rows renders nothing new. On an
+ * infinite-scroll table that is a request loop: the sentinel never moves down,
+ * so `DataTable.InfiniteFooter` keeps asking for the next page.
+ *
+ * `CachedTable` below stands in for that compiled caller. `memo` bails out on
+ * identical props exactly like the compiler's `if ($[n] !== table)` guard.
+ */
+
+interface Row {
+  id: string;
+  name: string;
+}
+
+const COLUMNS: ColumnDef<Row>[] = [{ accessorKey: 'name', header: 'Name', cell: ({ row }) => row.original.name }];
+
+const getRowId = (row: Row) => row.id;
+
+function rows(count: number): Row[] {
+  return Array.from({ length: count }, (_, i) => ({ id: `r${i}`, name: `row-${i}` }));
+}
+
+const CachedTable = memo(function CachedTableImpl({ table }: { table: Table<Row> }) {
+  return (
+    <DataTable table={table}>
+      <DataTable.Body<Row> />
+    </DataTable>
+  );
+});
+
+function TableHost({ data }: { data: Row[] }) {
+  const table = useDataTable<Row>({ data, columns: COLUMNS, getRowId });
+  return <CachedTable table={table} />;
+}
+
+describe('useDataTable identity', () => {
+  it('lets a consumer memoized on the table render rows that arrived later', () => {
+    const { rerender } = render(<TableHost data={rows(2)} />);
+    expect(screen.getAllByText(/^row-\d$/)).toHaveLength(2);
+
+    rerender(<TableHost data={rows(4)} />);
+    expect(screen.getAllByText(/^row-\d$/)).toHaveLength(4);
+  });
+
+  it('forwards reads and writes to the single underlying instance', () => {
+    const { result, rerender } = renderHook(({ data }) => useDataTable<Row>({ data, columns: COLUMNS, getRowId }), {
+      initialProps: { data: rows(3) },
+    });
+
+    const first = result.current;
+    expect(first.getRowModel().rows).toHaveLength(3);
+    // A write through one handle must be visible through the next one.
+    first.setOptions(prev => ({ ...prev, meta: { probed: true } }));
+
+    rerender({ data: rows(5) });
+    expect(result.current).not.toBe(first);
+    expect(result.current.getRowModel().rows).toHaveLength(5);
+    expect(result.current.options.meta).toEqual({ probed: true });
+  });
+});

package/src/components/ui/data-table/use-data-table.ts

@@ -98,7 +98,12 @@ export function useDataTable<T>({
   getFilteredRowModel: getFilteredRowModelOverride,
   ...rest
 }: UseDataTableOptions<T>): Table<T> {
-  return useReactTable<T>({
+  // Opted out of the React Compiler on purpose — see the handle published at the
+  // end of this function. Nothing here is worth memoizing anyway: `setOptions`
+  // runs on every render regardless.
+  'use no memo';
+
+  const table = useReactTable<T>({
     ...rest,
     getCoreRowModel: coreRowModelFactory as TableOptions<T>['getCoreRowModel'],
     getSortedRowModel: clientSideSorting
@@ -110,4 +115,34 @@ export function useDataTable<T>({
     manualSorting: manualSorting ?? !clientSideSorting,
     manualFiltering: manualFiltering ?? !clientSideFiltering,
   });
+
+  // A fresh handle per render, and the reason this hook doesn't just return
+  // `useReactTable`'s value.
+  //
+  // `useReactTable` creates ONE instance for the life of the component and
+  // mutates it in place, so its identity is the same object whether a page of
+  // rows just arrived or nothing happened at all. Every consumer reads rows and
+  // state back out of that instance through context (`DataTable.Body`,
+  // `.Header`, `.RowCount`, `.CursorFooter`) — which worked only because the
+  // caller re-rendered and rebuilt their elements.
+  //
+  // Under the React Compiler it stops working, because the compiler caches on
+  // identity: `<DataTable table={table}>` and its children get cached on
+  // `table`, and inside the compiled `DataTableBody` the entire body —
+  // `table.getRowModel().rows` included — sits behind a `$[n] !== table` guard.
+  // A table that gains rows then renders nothing new. On an infinite-scroll
+  // table that is a loop: the sentinel never moves down, so
+  // `DataTable.InfiniteFooter` asks for the next page forever.
+  //
+  // The proxy forwards every read, write and TanStack mutation to that single
+  // instance, so nothing about the table's behaviour changes — only its
+  // identity, which is what puts it back inside React's reactive graph.
+  //
+  // The `use no memo` at the top of this hook is what keeps it a FRESH handle:
+  // without it the compiler caches this very object on `table` and hands back
+  // the same one forever, i.e. the bug. Keying a `useMemo` on
+  // `getRowModel()`/`getState()` instead is not better — `useReactTable`
+  // rebuilds `options.state` on every render anyway, so it would republish just
+  // as often while reading as though it did not.
+  return new Proxy(table, {});
 }

package/src/components/ui/hover-dropdown.tsx

@@ -106,7 +106,6 @@ export function HoverDropdown({
 }: HoverDropdownProps) {
   const [open, setOpen] = useState(false);
   const timeoutRef = useRef<ReturnType<typeof setTimeout>>(undefined);
-  const clickPinnedRef = useRef(false);
   const containerRef = useRef<HTMLDivElement>(null);
   const panelRef = useRef<HTMLDivElement>(null);
 
@@ -157,22 +156,18 @@ export function HoverDropdown({
   }, []);
 
   const hide = useCallback(() => {
-    if (clickPinnedRef.current) return;
     timeoutRef.current = setTimeout(() => setOpen(false), hideDelay);
   }, [hideDelay]);
 
   // Click handler — touch / mobile (no hover) + desktop users who
-  // expect clicking a chip to open a menu. The first desktop click can arrive
-  // after mouse-enter already opened the panel; pin it open instead of blindly
-  // toggling it closed. A second click closes it. `stopPropagation` prevents the click
+  // expect clicking a chip to open a menu. Toggles the dropdown state
+  // so a second click closes it. `stopPropagation` prevents the click
   // from bubbling to ancestor handlers (the chip's parent message
   // bubble shouldn't react to chip clicks).
   const toggle = useCallback((e: React.MouseEvent) => {
     e.stopPropagation();
     clearTimeout(timeoutRef.current);
-    const pinned = !clickPinnedRef.current;
-    clickPinnedRef.current = pinned;
-    setOpen(pinned);
+    setOpen(prev => !prev);
   }, []);
 
   // Every hook is above this line: an `items` list that goes from empty to

package/dist/chat-protocol/source-metadata.d.ts

@@ -1,5 +0,0 @@
-import type { ChatRef } from '../components/chat/chat-ref.types';
-import type { SourcesEvent } from './events';
-export declare function isSourceMetadataCardRef(ref: ChatRef): boolean;
-export declare function sourceMetadataEvent(payload: unknown): SourcesEvent | null;
-//# sourceMappingURL=source-metadata.d.ts.map

package/dist/chat-protocol/source-metadata.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"source-metadata.d.ts","sourceRoot":"","sources":["../../src/chat-protocol/source-metadata.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,mCAAmC,CAAC;AAEjE,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,UAAU,CAAC;AAK7C,wBAAgB,uBAAuB,CAAC,GAAG,EAAE,OAAO,GAAG,OAAO,CAE7D;AAmLD,wBAAgB,mBAAmB,CAAC,OAAO,EAAE,OAAO,GAAG,YAAY,GAAG,IAAI,CAazE"}