@flamingo-stack/openframe-frontend-core 0.0.490-1506.3944.1 → 0.0.490

package/src/chat-protocol/ip-normalize.ts

@@ -1,146 +0,0 @@
-/**
- * `normalizeIpForBucketKey` — THE cross-repo normalizer for turning a raw
- * client-IP candidate (`x-forwarded-for` hop, socket remote address, proxy
- * header) into a stable rate-limit / dedup bucket key.
- *
- * WHY IT LIVES HERE: producer and consumer sit in DIFFERENT repos (the app
- * emits the candidate, the hub buckets it) and each had grown its own
- * normalizer. They disagreed — one unwrapped `::ffff:1.2.3.4` to the bare
- * IPv4 and stripped `%zone`, the other kept the zone and only lower-cased the
- * mapped form — so ONE visitor could land in TWO buckets depending on which
- * side normalized. Both repos already depend on this package, and
- * `./chat-protocol` is its server-safe subpath (no React, no browser APIs),
- * so this is the one place both sides can share.
- *
- * Contract:
- *   - input longer than `IP_BUCKET_KEY_MAX_LENGTH` → `null` (an unbounded
- *     header must never become an unbounded map key);
- *   - `[…]` brackets and a trailing `]:port` are stripped, as is a bare
- *     `:port` on an IPv4 (`203.0.113.4:8080`) — an unbracketed IPv6 with a
- *     bare port stays ambiguous and is not stripped;
- *   - a `%zone` suffix is stripped (link-local scope is per-host, not part of
- *     the peer's identity);
- *   - IPv4-mapped IPv6 (`::ffff:203.0.113.4`) collapses to the bare IPv4, so
- *     the same peer buckets identically over either stack;
- *   - IPv6 is lower-cased;
- *   - IPv4 octets are range-checked and REJECTED when zero-padded (`.04`
- *     would otherwise bucket separately from `.4`), and IPv6 is
- *     charset/shape-checked (one `::` at most, ≤8 groups, an embedded IPv4
- *     only in the last group, no dangling separator); anything else returns
- *     `null` rather than a junk bucket key.
- *
- * It does NOT canonicalize IPv6 zero-compression (`2001:db8::1` vs
- * `2001:0db8:0:0:0:0:0:1`) — peers do not spell their own address two ways
- * within one deployment, and a full expander is more surface than the bucket
- * key warrants.
- */
-
-/** Longest accepted candidate. A full IPv6 + zone fits well inside this. */
-export const IP_BUCKET_KEY_MAX_LENGTH = 64
-
-function isIpv4(value: string): boolean {
-  const parts = value.split('.')
-  if (parts.length !== 4) return false
-  for (const part of parts) {
-    if (!/^\d{1,3}$/.test(part)) return false
-    // Leading zeros are a SECOND spelling of the same address (`203.0.113.04`),
-    // so accepting them verbatim splits one peer across two buckets. Reject
-    // rather than canonicalize: no legitimate emitter zero-pads, and some
-    // resolvers read a `0`-prefixed octet as octal, i.e. it is not even
-    // reliably the same address.
-    if (part.length > 1 && part.startsWith('0')) return false
-    if (Number(part) > 255) return false
-  }
-  return true
-}
-
-function isIpv6(value: string): boolean {
-  if (!value.includes(':')) return false
-  // Charset gate first: hex digits, separators, and the dots of a trailing
-  // embedded IPv4. Anything else (a hostname, a header injection) is out.
-  if (!/^[0-9a-f:.]+$/.test(value)) return false
-  if (value.includes(':::')) return false
-  // A dangling separator (`2001:db8::1:`) leaves an EMPTY trailing group that
-  // is not part of a `::` compression — malformed, not an address.
-  if (value.endsWith(':') && !value.endsWith('::')) return false
-  if (value.startsWith(':') && !value.startsWith('::')) return false
-  const compressions = value.split('::').length - 1
-  if (compressions > 1) return false
-  const groups = value.split(':')
-  if (groups.length > 8) return false
-  for (let i = 0; i < groups.length; i += 1) {
-    const group = groups[i]
-    if (group === '') continue
-    if (group.includes('.')) {
-      // An embedded IPv4 occupies the LAST two groups; anywhere else
-      // (`1.2.3.4::1`) it is malformed.
-      if (i !== groups.length - 1) return false
-      if (!isIpv4(group)) return false
-      continue
-    }
-    if (!/^[0-9a-f]{1,4}$/.test(group)) return false
-  }
-  // Uncompressed form must be exactly 8 groups (a trailing embedded IPv4
-  // occupies two, so 7 written groups is also complete).
-  if (compressions === 0) {
-    const embedsIpv4 = groups[groups.length - 1]?.includes('.') ?? false
-    if (groups.length !== (embedsIpv4 ? 7 : 8)) return false
-  }
-  return true
-}
-
-/**
- * Normalize one IP candidate to its canonical bucket key, or `null` when the
- * value is not a usable address.
- */
-export function normalizeIpForBucketKey(value: string): string | null {
-  if (typeof value !== 'string') return null
-  let candidate = value.trim()
-  if (candidate === '' || candidate.length > IP_BUCKET_KEY_MAX_LENGTH) return null
-
-  // `[2001:db8::1]` / `[::1]:443` — the bracketed forms a proxy emits so the
-  // port is unambiguous.
-  if (candidate.startsWith('[')) {
-    const close = candidate.indexOf(']')
-    if (close === -1) return null
-    const trailer = candidate.slice(close + 1)
-    if (trailer !== '' && !/^:\d{1,5}$/.test(trailer)) return null
-    candidate = candidate.slice(1, close)
-  }
-
-  // `%eth0` / `%25eth0` scope id — host-local, never part of peer identity.
-  const zone = candidate.indexOf('%')
-  if (zone !== -1) candidate = candidate.slice(0, zone)
-  if (candidate === '') return null
-
-  // UNBRACKETED `203.0.113.4:8080` — Azure App Service / Front Door and several
-  // CDNs write the client hop that way. Rejecting it left the caller with NO
-  // candidate at all, collapsing every visitor into the single egress bucket:
-  // exactly the silent regression this module exists to prevent. Stripped ONLY
-  // when the remainder is a valid IPv4; an unbracketed IPv6 with a bare port
-  // (`::1:443`) is genuinely ambiguous — `:443` is equally a final group — so
-  // that shape is left to the IPv6 path.
-  const portSplit = candidate.lastIndexOf(':')
-  if (portSplit > 0 && /^\d{1,5}$/.test(candidate.slice(portSplit + 1))) {
-    const head = candidate.slice(0, portSplit)
-    if (isIpv4(head)) candidate = head
-  }
-
-  if (isIpv4(candidate)) return candidate
-
-  const lowered = candidate.toLowerCase()
-
-  // IPv4-mapped IPv6 → the bare IPv4 (same peer, one bucket). EVERY spelling
-  // is handled: the compressed `::ffff:1.2.3.4` that dual-stack listeners
-  // actually emit, the written-out `0:0:0:0:0:ffff:1.2.3.4` that a hop doing
-  // its own (non-compressing) formatting can produce, and the ZERO-PADDED
-  // `0000:0000:0000:0000:0000:ffff:1.2.3.4` that a fixed-width formatter
-  // produces — leading zeros in an IPv6 group are purely cosmetic, so all
-  // three name the same peer. Matching only some of them would split one peer
-  // across two buckets — the exact failure this module exists to prevent.
-  const mapped = /^(?:(?:0{1,4}:){5}|::)ffff:(\d{1,3}(?:\.\d{1,3}){3})$/.exec(lowered)
-  if (mapped) return isIpv4(mapped[1]) ? mapped[1] : null
-
-  if (isIpv6(lowered)) return lowered
-  return null
-}

package/src/chat-protocol/nats-decoder.ts

@@ -1,252 +0,0 @@
-/**
- * NATS chunk → normalized `ChatStreamEvent` decoder.
- *
- * THE live NATS reading path — the ONLY chunk parser in the codebase. Every
- * consumer (this lib's `useNatsChatAdapter`, the hub, the product app) feeds
- * raw chunks through `decodeNatsChunk` into `createChatStreamReducer`. The
- * legacy `components/chat/utils/chunk-parser.ts` (`parseChunkToAction`) that
- * this module superseded was DELETED — do not reintroduce a second decoder.
- *
- * Chunks map onto the transport-agnostic event union, with the JetStream
- * `streamSeq` lifted into the `seq` envelope (the reducer's idempotency gate
- * keys off it).
- *
- * Behavior is pinned by `__tests__/nats-decoder-golden.test.ts`.
- *
- * Server-safe: no React, no browser APIs.
- */
-
-import { MESSAGE_TYPE } from '../components/chat/types/message.types'
-import type { ApprovalToolCall, ChatStreamEvent } from './events'
-
-/** Minimal structural view of a NATS chunk (see `ChunkData` in
- *  `src/components/chat/types/network.types.ts`). */
-type NatsChunk = Record<string, any>
-
-/** Coerce the wire's `toolCalls[]` into the batch-approval shape, dropping
- *  non-object entries and defaulting every field. */
-function normalizeToolCalls(raw: unknown): ApprovalToolCall[] {
-  if (!Array.isArray(raw)) return []
-  return raw
-    .filter((item): item is Record<string, any> => !!item && typeof item === 'object')
-    .map((item) => ({
-      toolExecutionRequestId: String(item.toolExecutionRequestId ?? ''),
-      toolName: String(item.toolName ?? ''),
-      toolTitle: typeof item.toolTitle === 'string' ? item.toolTitle : undefined,
-      toolExplanation:
-        typeof item.toolExplanation === 'string' ? item.toolExplanation : undefined,
-      toolType: typeof item.toolType === 'string' ? item.toolType : undefined,
-      requiresApproval: item.requiresApproval === true,
-      approvalType: typeof item.approvalType === 'string' ? item.approvalType : null,
-      toolCallArguments:
-        item.toolCallArguments && typeof item.toolCallArguments === 'object'
-          ? (item.toolCallArguments as Record<string, any>)
-          : null,
-    }))
-}
-
-/**
- * Parse one raw NATS chunk into a normalized event. Returns `null` for
- * unknown/malformed chunks — an unrecognized `type`, a missing required
- * field, or a non-object payload are all tolerated as no-ops rather than
- * throwing, so a backend that adds a chunk type can't break the stream.
- */
-export function decodeNatsChunk(chunk: unknown): ChatStreamEvent | null {
-  if (!chunk || typeof chunk !== 'object') return null
-
-  const data = chunk as NatsChunk
-  const type = String(data.type || '')
-  // JetStream stream sequence → the generic `seq` envelope.
-  const seq: { seq?: number } =
-    typeof data.streamSeq === 'number' ? { seq: data.streamSeq } : {}
-
-  switch (type) {
-    case MESSAGE_TYPE.MESSAGE_START:
-      return { type: 'turn-start', ...seq }
-
-    case MESSAGE_TYPE.MESSAGE_END:
-      return { type: 'turn-end', ...seq }
-
-    case MESSAGE_TYPE.AI_METADATA: {
-      const providerName = data.providerName || data.provider
-      if (typeof data.modelName === 'string' && typeof providerName === 'string') {
-        return {
-          type: 'metadata',
-          modelLabel: data.modelDisplayName,
-          modelName: data.modelName,
-          provider: providerName,
-          contextWindowMaxTokens:
-            typeof data.contextWindow === 'number' ? data.contextWindow : 0,
-          ...seq,
-        }
-      }
-      return null
-    }
-
-    case MESSAGE_TYPE.TEXT:
-      if (typeof data.text === 'string') {
-        return { type: 'text-delta', text: data.text, ...seq }
-      }
-      return null
-
-    case MESSAGE_TYPE.THINKING:
-      if (typeof data.text === 'string') {
-        return { type: 'thinking-delta', text: data.text, ...seq }
-      }
-      return null
-
-    case MESSAGE_TYPE.EXECUTING_TOOL:
-      return {
-        type: 'tool-execution',
-        data: {
-          type: 'EXECUTING_TOOL',
-          integratedToolType: data.integratedToolType || '',
-          toolFunction: data.toolFunction || '',
-          toolTitle: typeof data.title === 'string' ? data.title : undefined,
-          parameters: data.parameters,
-          toolExecutionRequestId:
-            typeof data.toolExecutionRequestId === 'string'
-              ? data.toolExecutionRequestId
-              : undefined,
-        },
-        ...seq,
-      }
-
-    case MESSAGE_TYPE.EXECUTED_TOOL:
-      return {
-        type: 'tool-execution',
-        data: {
-          type: 'EXECUTED_TOOL',
-          integratedToolType: data.integratedToolType || '',
-          toolFunction: data.toolFunction || '',
-          toolTitle: typeof data.title === 'string' ? data.title : undefined,
-          parameters: data.parameters,
-          result: data.result,
-          success: data.success,
-          toolExecutionRequestId:
-            typeof data.toolExecutionRequestId === 'string'
-              ? data.toolExecutionRequestId
-              : undefined,
-        },
-        ...seq,
-      }
-
-    case MESSAGE_TYPE.APPROVAL_REQUEST: {
-      const requestId = data.approvalRequestId || data.approval_request_id || ''
-      const approvalType = data.approvalType || 'USER'
-      const toolCalls = normalizeToolCalls(data.toolCalls)
-
-      if (toolCalls.length > 0) {
-        return { type: 'approval-request', requestId, approvalType, toolCalls, ...seq }
-      }
-
-      return {
-        type: 'approval-request',
-        requestId,
-        approvalType,
-        command: data.command || '',
-        explanation: data.explanation,
-        ...seq,
-      }
-    }
-
-    case MESSAGE_TYPE.APPROVAL_RESULT: {
-      // Realtime chunks carry the resolver's name as `displayName`; the
-      // persisted GraphQL message exposes the same value as
-      // `resolvedByName`. Accept either so realtime and history-replay
-      // render "by {name}" identically.
-      const resolvedByName =
-        typeof data.resolvedByName === 'string'
-          ? data.resolvedByName
-          : typeof data.displayName === 'string'
-            ? data.displayName
-            : undefined
-      return {
-        type: 'approval-resolved',
-        requestId: data.approvalRequestId || data.approval_request_id || '',
-        status: data.approved === true ? 'approved' : 'rejected',
-        approvalType: data.approvalType || 'CLIENT',
-        resolvedByName,
-        ...seq,
-      }
-    }
-
-    case MESSAGE_TYPE.ERROR:
-      return {
-        type: 'error',
-        title: data.error || 'An error occurred',
-        details: data.details,
-        ...seq,
-      }
-
-    case MESSAGE_TYPE.MESSAGE_REQUEST:
-      return {
-        type: 'participant',
-        kind: 'message-request',
-        text: String(data.text || ''),
-        ownerType: typeof data.ownerType === 'string' ? data.ownerType : undefined,
-        displayName: typeof data.displayName === 'string' ? data.displayName : undefined,
-        userId: typeof data.userId === 'string' ? data.userId : undefined,
-        // Wire shape carries no label; fall back to the id (parity with
-        // the history path in `process-historical-messages.ts`).
-        contextItems: Array.isArray(data.contextItems)
-          ? (data.contextItems as Array<{ type?: unknown; id?: unknown }>)
-              .filter((it) => typeof it?.type === 'string' && typeof it?.id === 'string')
-              .map((it) => ({
-                type: it.type as string,
-                id: it.id as string,
-                label: it.id as string,
-              }))
-          : undefined,
-        ...seq,
-      }
-
-    case MESSAGE_TYPE.TOKEN_USAGE:
-      return {
-        type: 'token-usage',
-        inputTokensSize: data.inputTokensSize ?? 0,
-        outputTokensSize: data.outputTokensSize ?? 0,
-        totalTokensSize: data.totalTokensSize ?? 0,
-        contextSize: data.contextSize ?? 0,
-        ...seq,
-      }
-
-    case MESSAGE_TYPE.CONTEXT_COMPACTION_START:
-      return { type: 'compaction', phase: 'start', ...seq }
-
-    case MESSAGE_TYPE.CONTEXT_COMPACTION_END:
-      return {
-        type: 'compaction',
-        phase: 'end',
-        summary: typeof data.text === 'string' ? data.text : undefined,
-        ...seq,
-      }
-
-    case MESSAGE_TYPE.SYSTEM:
-      if (typeof data.text === 'string') {
-        return { type: 'participant', kind: 'system', text: data.text, ...seq }
-      }
-      return null
-
-    case MESSAGE_TYPE.DIRECT_MESSAGE:
-      if (typeof data.text === 'string') {
-        return {
-          type: 'participant',
-          kind: 'direct-message',
-          text: data.text,
-          ownerType: typeof data.ownerType === 'string' ? data.ownerType : undefined,
-          displayName:
-            typeof data.displayName === 'string' ? data.displayName : undefined,
-          userId: typeof data.userId === 'string' ? data.userId : undefined,
-          ...seq,
-        }
-      }
-      return null
-
-    case MESSAGE_TYPE.DIALOG_CLOSED:
-      return { type: 'dialog-closed', ...seq }
-
-    default:
-      return null
-  }
-}

package/src/components/chat/__tests__/chat-message-streaming-memo.test.tsx

@@ -1,207 +0,0 @@
-/**
- * REGRESSION: `ChatMessageEnhanced` must hand the markdown engine a
- * REFERENTIALLY STABLE `componentOverrides` map across a streamed turn.
- *
- * The engine memoizes each COMPLETED block (`StreamingBlockRenderer`) on its
- * `components` prop identity. `ChatMessageEnhanced` is the sole production
- * caller, and it used to defeat that memo one level up: `cardComponentOverrides`
- * listed `renderingPlan` in its deps, `renderingPlan` is memoized on `segments`,
- * and the stream reducer replaces `segments` on EVERY text delta. So the
- * override map got a new identity per token → the engine's `components` memo
- * re-created → every completed block re-parsed on every token.
- *
- * The engine's own streaming test cannot catch this: it passes a module-scope
- * stable override map. This test drives the real component with the real
- * per-delta `content` churn a reducer produces, and asserts at the SEAM (the
- * props the component hands the renderer) rather than through the engine's
- * internals — the two are separately owned.
- */
-
-import React from 'react'
-import { describe, it, expect, vi } from 'vitest'
-import { render } from '@testing-library/react'
-import type { MessageSegment } from '../types'
-import type { ChatRef } from '../chat-ref.types'
-
-/** Every `componentOverrides` / `additionalRemarkPlugins` identity the
- *  component handed the markdown renderer, in render order. */
-const seenOverrides: unknown[] = []
-const seenPlugins: unknown[] = []
-
-vi.mock('../../ui/markdown/simple-markdown-renderer', () => ({
-  SimpleMarkdownRenderer: ({
-    content,
-    componentOverrides,
-    additionalRemarkPlugins,
-  }: {
-    content: string
-    componentOverrides?: unknown
-    additionalRemarkPlugins?: unknown
-  }) => {
-    seenOverrides.push(componentOverrides)
-    seenPlugins.push(additionalRemarkPlugins)
-    return <div data-testid="md">{content}</div>
-  },
-}))
-
-import { ChatMessageEnhanced } from '../chat-message-enhanced'
-
-function NavLinkAnchor({ href, children }: React.AnchorHTMLAttributes<HTMLAnchorElement>) {
-  return <a href={href}>{children}</a>
-}
-const CHAT_REFS: Record<string, ChatRef> = {}
-const renderMention = () => null
-
-/** Fresh array per call — the reducer replaces `segments` on every delta. */
-const segmentsFor = (tail: string): MessageSegment[] => [
-  { type: 'text', text: `First paragraph, already complete.\n\n${tail}` },
-]
-
-describe('ChatMessageEnhanced — override identity across a streamed turn', () => {
-  it('keeps componentOverrides + remark plugins referentially stable per token', () => {
-    seenOverrides.length = 0
-    seenPlugins.length = 0
-
-    const props = {
-      role: 'assistant' as const,
-      isTyping: true,
-      chatRefs: CHAT_REFS,
-      renderMention,
-      NavLinkAnchor,
-    }
-
-    const view = render(<ChatMessageEnhanced {...props} content={segmentsFor('Tail')} />)
-    expect(seenOverrides.length).toBeGreaterThan(0)
-    const firstOverrides = seenOverrides[0]
-    const firstPlugins = seenPlugins[0]
-    expect(firstOverrides).toBeTruthy()
-
-    let tail = 'Tail'
-    for (let i = 0; i < 10; i += 1) {
-      tail += ` token${i}`
-      view.rerender(<ChatMessageEnhanced {...props} content={segmentsFor(tail)} />)
-    }
-
-    // ONE identity for the whole turn. Before the fix this produced a fresh
-    // object on each of the 11 renders.
-    expect(new Set(seenOverrides).size).toBe(1)
-    expect(seenOverrides.every((o) => o === firstOverrides)).toBe(true)
-    expect(new Set(seenPlugins).size).toBe(1)
-    expect(seenPlugins.every((p) => p === firstPlugins)).toBe(true)
-
-    // Sanity: the tail really did stream through.
-    expect(view.container.textContent).toContain('token9')
-  })
-
-  it('still resolves card markers through the CURRENT plan (ref-read, not closure)', () => {
-    seenOverrides.length = 0
-    const refs: Record<string, ChatRef> = {
-      'blog:abc': { type: 'blog', id: 'abc', title: 'Resolved Title', url: null },
-    }
-    render(
-      <ChatMessageEnhanced
-        role="assistant"
-        content={[{ type: 'text', text: 'See [card://blog:abc] for more.' }]}
-        chatRefs={refs}
-        NavLinkAnchor={NavLinkAnchor}
-      />,
-    )
-    const overrides = seenOverrides[0] as { a: React.FC<{ href: string; children?: React.ReactNode }> }
-    const out = render(<>{overrides.a({ href: 'card://blog:abc', children: 'x' })}</>)
-    expect(out.container.textContent).toBe('Resolved Title')
-  })
-
-  /**
-   * REGRESSION (round 3): a ref that resolves AFTER the message finished
-   * streaming must still reach the pill. The override reads `chatRefs`
-   * through a ref, so its own closure is fine — but the markdown engine
-   * memoizes completed blocks on the override map's IDENTITY. With
-   * `chatRefs` excluded from the override memo's deps entirely, the map kept
-   * its old identity, the engine bailed, and the marker rendered its raw-id
-   * fallback permanently.
-   */
-  it('gives componentOverrides a NEW identity when the ref set grows (completed message)', () => {
-    seenOverrides.length = 0
-    const content: MessageSegment[] = [{ type: 'text', text: 'See [card://blog:late] for more.' }]
-    const emptyRefs: Record<string, ChatRef> = {}
-    const props = {
-      role: 'assistant' as const,
-      isTyping: false,
-      content,
-      NavLinkAnchor,
-    }
-
-    const view = render(<ChatMessageEnhanced {...props} chatRefs={emptyRefs} />)
-    const before = seenOverrides[seenOverrides.length - 1] as {
-      a: React.FC<{ href: string; children?: React.ReactNode }>
-    }
-    // Unresolved: the raw card id is surfaced so the breakage is visible.
-    expect(render(<>{before.a({ href: 'card://blog:late', children: 'x' })}</>).container.textContent)
-      .toBe('late')
-
-    // Same content, same everything — only the refs map gains the entry.
-    const resolvedRefs: Record<string, ChatRef> = {
-      'blog:late': { type: 'blog', id: 'late', title: 'Late Title', url: null },
-    }
-    view.rerender(<ChatMessageEnhanced {...props} chatRefs={resolvedRefs} />)
-
-    const after = seenOverrides[seenOverrides.length - 1] as {
-      a: React.FC<{ href: string; children?: React.ReactNode }>
-    }
-    expect(after).not.toBe(before)
-    expect(render(<>{after.a({ href: 'card://blog:late', children: 'x' })}</>).container.textContent)
-      .toBe('Late Title')
-  })
-
-  /**
-   * REGRESSION (round 5): a later refs frame REPLACES the map for a send index
-   * with the SAME key set but richer values — the `title` going from the raw
-   * cardId to the resolved document title is the exact production case. A
-   * key-set-only token produced an identical string, so the override map kept
-   * its identity, the engine's completed-block memo bailed, and the pill stayed
-   * on its fallback forever. The token fingerprints VALUES now.
-   */
-  it('gives componentOverrides a NEW identity when a ref VALUE is enriched (same key set)', () => {
-    seenOverrides.length = 0
-    const content: MessageSegment[] = [{ type: 'text', text: 'See [card://blog:abc].' }]
-    const props = { role: 'assistant' as const, isTyping: false, content, NavLinkAnchor }
-
-    // First frame: the ref exists but its title is still the raw card id.
-    const stub: Record<string, ChatRef> = {
-      'blog:abc': { type: 'blog', id: 'abc', title: 'abc', url: null },
-    }
-    const view = render(<ChatMessageEnhanced {...props} chatRefs={stub} />)
-    const before = seenOverrides[seenOverrides.length - 1] as {
-      a: React.FC<{ href: string; children?: React.ReactNode }>
-    }
-    expect(render(<>{before.a({ href: 'card://blog:abc', children: 'x' })}</>).container.textContent)
-      .toBe('abc')
-
-    // Second frame: SAME key set, enriched value.
-    const enriched: Record<string, ChatRef> = {
-      'blog:abc': { type: 'blog', id: 'abc', title: 'Resolved Document Title', url: null },
-    }
-    view.rerender(<ChatMessageEnhanced {...props} chatRefs={enriched} />)
-
-    const after = seenOverrides[seenOverrides.length - 1] as {
-      a: React.FC<{ href: string; children?: React.ReactNode }>
-    }
-    expect(after).not.toBe(before)
-    expect(render(<>{after.a({ href: 'card://blog:abc', children: 'x' })}</>).container.textContent)
-      .toBe('Resolved Document Title')
-  })
-
-  /** …but a same-KEY refs object (new identity, same entries) must NOT churn
-   *  the override map — that is the streaming-stability guarantee above. */
-  it('keeps the override identity when only the refs object identity changes', () => {
-    seenOverrides.length = 0
-    const content: MessageSegment[] = [{ type: 'text', text: 'See [card://blog:abc].' }]
-    const ref: ChatRef = { type: 'blog', id: 'abc', title: 'T', url: null }
-    const props = { role: 'assistant' as const, content, NavLinkAnchor }
-
-    const view = render(<ChatMessageEnhanced {...props} chatRefs={{ 'blog:abc': ref }} />)
-    view.rerender(<ChatMessageEnhanced {...props} chatRefs={{ 'blog:abc': ref }} />)
-
-    expect(new Set(seenOverrides).size).toBe(1)
-  })
-})