` element from an out-of-sync copy-paste edit).\n */\nfunction ApprovalCardBody({ data }: { data: ApprovalRequestMessageProps['data'] }) {\n return (\n \n \n {data.command}\n {data.icon && {data.icon}}\n \n {data.fields && data.fields.length > 0 ? (\n {data.explanation}
\n )\n )}\n \n );\n}\n\nconst ApprovalRequestMessage = forwardRef(\n // `assistantType` is accepted for prop-parity with the batch card (so hosts\n // can forward it uniformly); the viewer variant is driven by `variant`.\n (\n {\n className,\n data,\n onApprove,\n onReject,\n status = 'pending',\n assistantType: _assistantType,\n variant = 'admin',\n resolvedByName,\n showFooterActions = true,\n ...props\n },\n ref,\n ) => {\n const [isProcessing, setIsProcessing] = useState(false);\n\n const handleApprove = async () => {\n setIsProcessing(true);\n try {\n await onApprove?.(data.requestId);\n } finally {\n setIsProcessing(false);\n }\n };\n\n const handleReject = async () => {\n setIsProcessing(true);\n try {\n await onReject?.(data.requestId);\n } finally {\n setIsProcessing(false);\n }\n };\n\n // CLIENT (Fae end-user) card — Figma 203-11947 \"fae-approval-block\".\n // Shows ONLY the BE-generated title (`explanation`) plus the actions row\n // or the full-text resolved pill; the raw command is never rendered.\n if (variant === 'client') {\n return (\n \n \n {data.explanation?.trim() || 'Approval required'}\n
\n {!showFooterActions ? null : status === 'pending' ? (\n \n \n Approve\n \n \n Reject\n \n \n ) : (\n \n \n \n Approve\n \n \n Reject\n \n \n ) : (\n \n {status === 'approved' ? (\n , 'children'>, VariantProps {\n label: React.ReactNode;\n labelClassName?: string;\n icon?: React.ReactNode;\n onClose?: () => void;\n disabled?: boolean;\n /**\n * Root element. Defaults to `'div'`. Pass `'span'` to render an INLINE tag\n * that is valid inside phrasing content (e.g. a markdown `` — a block\n * `
` there is invalid HTML and breaks hydration). The variant base is\n * already `inline-flex`, so the span lays out identically. Note: `onClose`\n * renders a `\n )}\n \n );\n}\n\nexport { Tag, tagVariants };\n","'use client';\n\nimport {\n useFloating,\n autoUpdate,\n offset,\n flip,\n shift,\n size,\n useDismiss,\n useRole,\n useInteractions,\n FloatingPortal,\n useHover,\n safePolygon,\n arrow,\n} from '@floating-ui/react';\nimport { type ReactNode, useMemo, useState } from 'react';\nimport { cn } from '../../utils/cn';\n\ninterface FloatingTooltipProps {\n content: ReactNode;\n children: ReactNode;\n side?: 'top' | 'right' | 'bottom' | 'left';\n className?: string;\n delayDuration?: number;\n /** Disable the tooltip without unmounting the trigger wrapper. */\n disabled?: boolean;\n /**\n * Classes for the trigger wrapper — the element this component puts around\n * `children` to anchor the tooltip. That element becomes the flex/grid item in\n * the caller's layout, so anything the child needed there (`min-w-0`, `flex-1`)\n * must move onto it. Omit it and the wrapper carries no class, exactly as before.\n */\n triggerClassName?: string;\n /**\n * Trigger wrapper element. Default `'div'`. Use `'span'` where a block element\n * is invalid HTML — inside a ``, a heading, or another ``.\n */\n as?: 'div' | 'span';\n}\n\n// Parse colored text markup like [YELLOW]text[/YELLOW] into JSX\nfunction parseColoredText(text: string): ReactNode {\n if (typeof text !== 'string') return text;\n\n const parts: ReactNode[] = [];\n let lastIndex = 0;\n\n // Regex to match [COLOR]text[/COLOR] patterns\n const colorRegex = /\\[([A-Z]+)\\](.*?)\\[\\/\\1\\]/g;\n let match;\n let keyIndex = 0;\n\n while ((match = colorRegex.exec(text)) !== null) {\n // Add text before the colored part\n if (match.index > lastIndex) {\n const beforeText = text.slice(lastIndex, match.index);\n parts.push({beforeText});\n }\n\n // Add colored text\n const color = match[1].toLowerCase();\n const coloredText = match[2];\n\n // Map colors to ODS CSS classes using correct Tailwind class names\n const colorClass =\n color === 'yellow'\n ? 'text-ods-accent'\n : color === 'green'\n ? 'text-ods-success'\n : color === 'red'\n ? 'text-ods-error'\n : color === 'blue'\n ? 'text-ods-info'\n : color === 'pink'\n ? 'text-ods-accent'\n : color === 'cyan'\n ? 'text-ods-info'\n : 'text-ods-accent'; // Default to ODS accent\n\n parts.push(\n \n {coloredText}\n ,\n );\n\n lastIndex = match.index + match[0].length;\n }\n\n // Add remaining text\n if (lastIndex < text.length) {\n const remainingText = text.slice(lastIndex);\n parts.push({remainingText});\n }\n\n return parts.length > 0 ? <>{parts} : text;\n}\n\nexport function FloatingTooltip({\n content,\n children,\n side = 'right',\n className,\n delayDuration = 0,\n disabled = false,\n triggerClassName,\n as: TriggerTag = 'div',\n}: FloatingTooltipProps) {\n const [isOpen, setIsOpen] = useState(false);\n // The arrow node is STATE, not a ref: `arrow()`'s `element` accepts either,\n // and the ref form has to be read during render to build the middleware\n // array. State also makes the middleware re-run the moment the arrow mounts\n // instead of relying on the next positioning pass to notice it.\n const [arrowEl, setArrowEl] = useState(null);\n\n const { refs, floatingStyles, context, placement, middlewareData } = useFloating({\n open: isOpen,\n onOpenChange: setIsOpen,\n placement: side,\n middleware: [\n offset(12),\n flip({\n fallbackAxisSideDirection: 'start',\n crossAxis: false,\n padding: 8,\n }),\n shift({ padding: 8 }),\n // Cap the tooltip to the space left in the viewport so tall content\n // scrolls inside it instead of overflowing off-screen. Applied straight to\n // the floating node's style (no React state → no autoUpdate re-render loop);\n // the inner scroll wrapper below turns the cap into an actual scroll area.\n size({\n padding: 8,\n apply({ availableHeight, elements }) {\n const floatingEl = elements.floating;\n floatingEl.style.maxHeight = `${Math.max(64, availableHeight)}px`;\n },\n }),\n arrow({ element: arrowEl }),\n ],\n whileElementsMounted: autoUpdate,\n });\n\n const hover = useHover(context, {\n move: false,\n enabled: !disabled,\n delay: { open: delayDuration, close: 0 },\n handleClose: safePolygon(),\n });\n const dismiss = useDismiss(context);\n const role = useRole(context, { role: 'tooltip' });\n\n const { getReferenceProps, getFloatingProps } = useInteractions([hover, dismiss, role]);\n\n // Destructured once: reaching for `refs.setFloating` inside the JSX is a\n // property read on floating-ui's ref bag on every render, which the compiler\n // reads as touching a ref in render even though these are plain callback\n // setters being handed straight to React.\n const { setReference, setFloating } = refs;\n\n // Parse content if it's a string with color markup\n const parsedContent = useMemo(() => {\n if (typeof content === 'string') {\n return parseColoredText(content);\n }\n return content;\n }, [content]);\n\n // Calculate arrow position\n const { x: arrowX, y: arrowY } = middlewareData.arrow ?? {};\n\n const staticSide = {\n top: 'bottom',\n right: 'left',\n bottom: 'top',\n left: 'right',\n }[placement.split('-')[0]];\n\n return (\n <>\n \n {children}\n \n \n {isOpen && (\n \n {/* Scroll wrapper — `min-h-0` lets it shrink below content height inside\n the max-height cap set by the `size` middleware, so tall content scrolls. */}\n \n {parsedContent}\n \n {/* Arrow element */}\n
\n )}\n \n \n );\n}\n","'use client';\n\nimport { forwardRef, useState } from 'react';\nimport type { HTMLAttributes } from 'react';\nimport { cn } from '../../utils/cn';\nimport { CheckCircleIcon, DotsLoaderIcon, XmarkCircleIcon, XmarkIcon } from '../icons-v2-generated';\nimport type { ToolType } from '../platform';\nimport { ToolIcon } from '../tool-icon';\nimport { Button } from '../ui/button';\nimport { Tag } from '../ui/tag';\nimport { ExpandChevron } from './expand-chevron';\nimport { useCollapsible } from './hooks/use-collapsible';\nimport { ArgRow, ResultBlock } from './tool-call-blocks';\nimport type {\n ApprovalBlockVariant,\n AssistantType,\n ApprovalBatchExecutionState,\n ApprovalBatchSegment,\n PendingToolCallData,\n} from './types';\nimport { COMMAND_BODY_ARG_KEYS, getCommandText } from './utils/tool-call-helpers';\n\nexport interface ApprovalBatchMessageProps extends HTMLAttributes {\n data: ApprovalBatchSegment['data'];\n status?: ApprovalBatchSegment['status'];\n onApprove?: (requestId?: string) => void | boolean | Promise;\n onReject?: (requestId?: string) => void | boolean | Promise;\n /**\n * Cap the tool-call list height so it scrolls internally while the footer\n * (explanations + Approve/Reject) stays pinned below. Omit for the default\n * chat behaviour where the whole batch grows with its content.\n */\n maxBodyHeight?: number | string;\n /** Display name of the user who resolved the request; shown as \"by {name}\" beside the status tag. */\n resolvedByName?: string | null;\n /**\n * Per-tool execution status icon (queued dots → check/cross). On in dialog messages where tool\n * execution is tracked live; turn off for notifications, which have no execution state and would\n * otherwise show the dots spinner forever after approval. Defaults to on.\n */\n showExecutionStatus?: boolean;\n /**\n * Chat identity. Kept for prop parity with the message renderers; does NOT\n * drive the styling anymore — use `variant` instead. An admin can be\n * looking at a Fae dialog (tickets dialog client tab) and must still see\n * the full admin block.\n */\n assistantType?: AssistantType;\n /**\n * Viewer variant. `'admin'` (default) = full block with command preview,\n * expandable args/result and tool icon. `'client'` = end-client (Fae\n * desktop app) card that shows ONLY the BE-generated title(s) plus the\n * Approve/Reject buttons or the full-text resolved pill (\"Approved by\n * {name}\") — commands and scripts are never rendered.\n */\n variant?: ApprovalBlockVariant;\n /**\n * Render the footer Approve/Reject buttons (or the resolved-status tag).\n * Turn off when the host owns the actions row — e.g. the approval\n * notification tile. Explanation bullets still render.\n */\n showFooterActions?: boolean;\n}\n\nconst COMMAND_BODY_KEYS = new Set(COMMAND_BODY_ARG_KEYS);\n\nexport interface ApprovalStatusTagProps {\n status: ApprovalBatchSegment['status'];\n resolvedByName?: string | null;\n inlineResolver?: boolean;\n}\n\n/**\n * Terminal-status badge for a resolved approval batch (approved / rejected /\n * cancelled); renders nothing while pending. With `inlineResolver` the\n * resolver's name is baked into the tag as a single full-text pill\n * (\"Approved by {name}\"); otherwise callers render \"by {name}\" as a separate\n * muted span. Also used by the approval notification tile, which hosts the\n * actions row itself (`showFooterActions={false}`).\n */\nexport function ApprovalStatusTag({ status, resolvedByName, inlineResolver = false }: ApprovalStatusTagProps) {\n const suffix = inlineResolver && resolvedByName ? ` by ${resolvedByName}` : '';\n if (status === 'approved') {\n return `.\nfunction ToolCallRow({ call, expanded, onToggle, batchStatus, execution, showExecutionStatus }: ToolCallRowProps) {\n const command = getCommandText(call);\n const args = getArgEntries(call);\n const toolType = (call.toolType as ToolType) || 'OPENFRAME';\n const { innerRef, containerStyle } = useCollapsible({ expanded });\n const result = execution?.status === 'done' ? execution.result : undefined;\n const hasExpandableBody = args.length > 0 || (typeof result === 'string' && result.length > 0);\n\n return (\n \n \n \n \n {command}\n \n {showExecutionStatus && (\n \n 0 ? 'mt-[var(--spacing-system-xsf)]' : undefined}\n />\n )}\n \n )}\n \n \n \n );\n}\n\nconst ApprovalBatchMessage = forwardRef(\n (\n {\n className,\n data,\n onApprove,\n onReject,\n status = 'pending',\n maxBodyHeight,\n resolvedByName,\n showExecutionStatus = true,\n assistantType: _assistantType,\n variant = 'admin',\n showFooterActions = true,\n ...props\n },\n ref,\n ) => {\n const [expandedId, setExpandedId] = useState(null);\n const [isProcessing, setIsProcessing] = useState(false);\n const isClient = variant === 'client';\n\n const explanations = data.toolCalls.map(c => c.toolExplanation?.trim()).filter((s): s is string => !!s);\n\n const handleApprove = async () => {\n setIsProcessing(true);\n try {\n await onApprove?.(data.approvalRequestId);\n } finally {\n setIsProcessing(false);\n }\n };\n\n const handleReject = async () => {\n setIsProcessing(true);\n try {\n await onReject?.(data.approvalRequestId);\n } finally {\n setIsProcessing(false);\n }\n };\n\n const actionButtons = (\n <>\n \n Approve\n \n \n Reject\n \n \n );\n\n // CLIENT (Fae end-user) card — Figma 203-11947 \"fae-approval-block\".\n // One bordered card: BE-generated title(s) + Approve/Reject buttons or the\n // full-text resolved pill (\"Approved by {name}\"). No commands, scripts,\n // expansion or execution icons — the end client must not see them.\n if (isClient) {\n const titles = data.toolCalls\n .map(c => c.toolExplanation?.trim() || c.toolTitle?.trim())\n .filter((s): s is string => !!s);\n return (\n \n {titles.length > 0 ? (\n titles.map((title, i) => (\n \n {title}\n
\n ))\n ) : (\n Approval required
\n )}\n {showFooterActions &&\n (status === 'pending' ? (\n {actionButtons}\n ) : (\n \n \n \n {data.toolCalls.map(call => (\n \n setExpandedId(prev => (prev === call.toolExecutionRequestId ? null : call.toolExecutionRequestId))\n }\n batchStatus={status}\n execution={data.executions?.[call.toolExecutionRequestId]}\n showExecutionStatus={showExecutionStatus}\n />\n ))}\n \n\n {showFooterBlock && (\n \n {explanations.length > 0 && (\n \n {explanations.map((expl, i) => (\n - {expl}
\n ))}\n
\n )}\n\n {showFooterActions &&\n (status === 'pending' ? (\n {actionButtons}\n ) : (\n \n (null);\n const [contentHeight, setContentHeight] = useState(0);\n const [collapsedPx, setCollapsedPx] = useState(0);\n\n useLayoutEffect(() => {\n if (!element) return undefined;\n const measure = () => {\n setContentHeight(element.scrollHeight);\n setCollapsedPx(collapsedHeight === '1lh' ? parseFloat(getComputedStyle(element).lineHeight) : collapsedHeight);\n };\n measure();\n const observer = new ResizeObserver(measure);\n observer.observe(element);\n return () => observer.disconnect();\n }, [element, collapsedHeight]);\n\n // When the caller asks for `\"1lh\"`, fall back to a measured pixel value\n // (inner element's line-height) as soon as it's available. Setting\n // `max-height: 1lh` via CSS resolves against the OUTER element's\n // line-height, which can differ from the inner content's line-height and\n // leak the top of the next block element past the clip line. The measured\n // pixel value matches the inner content exactly.\n const collapsedValue: number | string = collapsedHeight === '1lh' ? collapsedPx || collapsedHeight : collapsedHeight;\n\n const containerStyle: CSSProperties = {\n overflow: 'hidden',\n maxHeight: expanded ? contentHeight : collapsedValue,\n transition: disableTransition ? 'none' : `max-height ${durationMs}ms ease-in-out`,\n };\n\n return {\n innerRef: setElement,\n isOverflowing: contentHeight > collapsedPx,\n containerStyle,\n };\n}\n","import type { PendingToolCallData } from '../types';\n\n/**\n * Keys in `toolCallArguments` whose value is the actual command/query/script\n * body — anything that should be rendered as the tool's \"title\" line in the\n * approval card. Order matters: first match wins.\n */\nexport const COMMAND_BODY_ARG_KEYS = ['command', 'query', 'script', 'scriptContent', 'code'] as const;\n\n/**\n * Resolve the human-readable title/preview line for a tool call.\n * Order: command/query/script/scriptContent/code arg → title → name → fallback.\n *\n * Shape-agnostic so both the approval card (`PendingToolCallData`:\n * `toolCallArguments`/`toolName`) and the execution card (`ToolExecutionData`:\n * `parameters`/`toolFunction`) can share one source of truth.\n */\nexport function getToolCallTitle(opts: {\n args?: Record | null;\n title?: string | null;\n name?: string | null;\n}): string {\n const { args, title, name } = opts;\n if (args && typeof args === 'object') {\n for (const key of COMMAND_BODY_ARG_KEYS) {\n const candidate = args[key];\n if (typeof candidate === 'string' && candidate.trim()) return candidate;\n }\n }\n return title || name || 'Tool call';\n}\n\n/**\n * Extract a human-readable command string from a batch tool call.\n * Thin adapter over {@link getToolCallTitle}.\n */\nexport function getCommandText(call: PendingToolCallData): string {\n return getToolCallTitle({\n args: call.toolCallArguments,\n title: call.toolTitle,\n name: call.toolName,\n });\n}\n\n/**\n * The raw command/query/script body only (first {@link COMMAND_BODY_ARG_KEYS}\n * match), with no title/name fallback. Used by the CLIENT (Fae) card to show\n * the command in the expanded body once the collapsed line switches to the\n * human-readable `toolExplanation`.\n */\nexport function getCommandBody(args?: Record | null): string | undefined {\n if (args && typeof args === 'object') {\n for (const key of COMMAND_BODY_ARG_KEYS) {\n const candidate = args[key];\n if (typeof candidate === 'string' && candidate.trim()) return candidate;\n }\n }\n return undefined;\n}\n\nexport type FormattedArgValue =\n { kind: 'inline'; text: string } | { kind: 'block'; text: string; language: 'json' | 'text' };\n\nconst INLINE_STRING_MAX = 80;\n\n/**\n * Pretty-print like `JSON.stringify(value, null, 2)`, but render multi-line\n * string values across real lines instead of escaped `\\n` sequences.\n *\n * Trade-off: the output is optimised for human reading, not for being\n * re-parsed as JSON (multi-line string bodies lose their surrounding quotes\n * and escaping). Single-line strings keep normal JSON quoting/escaping.\n *\n * `indent` is the nesting level of this value's content lines / closing\n * bracket (matching the 2-space step of `JSON.stringify(_, null, 2)`).\n */\nfunction expandJson(value: unknown, indent: number): string {\n const pad = (n: number) => ' '.repeat(n);\n\n if (value === null) return 'null';\n const t = typeof value;\n if (t === 'number' || t === 'boolean' || t === 'bigint') return String(value);\n\n if (t === 'string') {\n const s = (value as string).replace(/\\r\\n/g, '\\n').replace(/\\r/g, '\\n');\n if (!s.includes('\\n')) return JSON.stringify(s);\n return s\n .replace(/^\\n+/, '')\n .replace(/\\n+$/, '')\n .split('\\n')\n .map(line => pad(indent) + line)\n .join('\\n');\n }\n\n if (Array.isArray(value)) {\n if (value.length === 0) return '[]';\n const items = value.map(v =>\n typeof v === 'string' && /[\\r\\n]/.test(v)\n ? expandJson(v, indent + 1)\n : pad(indent + 1) + expandJson(v, indent + 1),\n );\n return '[\\n' + items.join(',\\n') + '\\n' + pad(indent) + ']';\n }\n\n if (t === 'object') {\n const entries = Object.entries(value as Record);\n if (entries.length === 0) return '{}';\n const items = entries.map(([k, v]) => {\n const key = JSON.stringify(k);\n if (typeof v === 'string' && /[\\r\\n]/.test(v)) {\n return pad(indent + 1) + key + ':\\n' + expandJson(v, indent + 2);\n }\n return pad(indent + 1) + key + ': ' + expandJson(v, indent + 1);\n });\n return '{\\n' + items.join(',\\n') + '\\n' + pad(indent) + '}';\n }\n\n return JSON.stringify(value);\n}\n\n/**\n * Entry point for {@link expandJson}: readable pretty-print where multi-line\n * string fields (script bodies, command output, …) are shown with real line\n * breaks instead of literal `\\n`.\n */\nexport function expandedJsonStringify(value: unknown): string {\n try {\n return expandJson(value, 0);\n } catch {\n return String(value);\n }\n}\n\n/**\n * Decide how to render a single `toolCallArguments` value:\n * - objects/arrays → pretty-printed JSON block\n * - strings that parse as JSON → pretty-printed JSON block\n * - multi-line or long strings → preserved-whitespace text block\n * - everything else → inline single line\n */\nexport function formatToolArgValue(value: unknown): FormattedArgValue {\n if (value === null || value === undefined) return { kind: 'inline', text: '' };\n\n if (typeof value === 'object') {\n return { kind: 'block', text: safeStringify(value), language: 'json' };\n }\n\n if (typeof value === 'string') {\n const trimmed = value.trim();\n if ((trimmed.startsWith('{') && trimmed.endsWith('}')) || (trimmed.startsWith('[') && trimmed.endsWith(']'))) {\n try {\n return { kind: 'block', text: expandedJsonStringify(JSON.parse(trimmed)), language: 'json' };\n } catch {\n // not valid JSON — fall through\n }\n }\n if (value.includes('\\n') || value.length > INLINE_STRING_MAX) {\n return { kind: 'block', text: value, language: 'text' };\n }\n return { kind: 'inline', text: value };\n }\n\n return { kind: 'inline', text: String(value) };\n}\n\nfunction safeStringify(value: unknown): string {\n return expandedJsonStringify(value);\n}\n\n/**\n * Decide how to render a tool execution `result` string.\n * - Strips a single surrounding markdown code fence (``` … ```), since the\n * backend often wraps Bash/PowerShell output that way.\n * - If the body parses as JSON, returns a pretty-printed JSON block.\n * - If the body is multi-line / long, returns a preserved-whitespace block.\n * - Otherwise inline.\n */\nexport function formatToolResult(value: string | undefined | null): FormattedArgValue {\n if (typeof value !== 'string') return { kind: 'inline', text: '' };\n\n const fenced = value.match(/^\\s*```(?:[a-zA-Z0-9_-]*)\\n([\\s\\S]*?)\\n```\\s*$/);\n const body = fenced ? fenced[1] : value;\n const trimmed = body.trim();\n\n if ((trimmed.startsWith('{') && trimmed.endsWith('}')) || (trimmed.startsWith('[') && trimmed.endsWith(']'))) {\n try {\n return { kind: 'block', text: expandedJsonStringify(JSON.parse(trimmed)), language: 'json' };\n } catch {\n // fall through\n }\n }\n\n if (body.includes('\\n') || body.length > INLINE_STRING_MAX) {\n return { kind: 'block', text: body, language: 'text' };\n }\n return { kind: 'inline', text: body };\n}\n","'use client';\n\nimport { cn } from '../../utils/cn';\nimport { formatToolArgValue, formatToolResult } from './utils/tool-call-helpers';\n\n/**\n * Monospace code body shared by ArgRow / ResultBlock.\n *\n * Uses the ODS `text-code` composite token (Azeret Mono 500, h6 responsive\n * scale, no transform) — the token this file was originally flagged for.\n */\nconst CODE_PRE_CLASS =\n 'bg-ods-bg border border-ods-border rounded-md p-[var(--spacing-system-sf)] w-full max-h-64 overflow-auto overscroll-contain text-code text-ods-text-primary whitespace-pre';\n\n/**\n * Single arg row: inline `key: value` or labeled `` block.\n * Shared between ApprovalBatchMessage and ToolExecutionDisplay so both\n * surfaces render long script bodies / JSON the same way.\n */\nexport function ArgRow({ argKey, value }: { argKey: string; value: unknown }) {\n const formatted = formatToolArgValue(value);\n\n if (formatted.kind === 'inline') {\n return (\n \n {argKey}:\n {formatted.text}\n \n );\n }\n\n return (\n \n {argKey}:\n \n {formatted.text}\n
\n \n );\n}\n\n/**\n * Result block for a tool execution. Renders inline for short single-line\n * output and as a scrollable `` for code / JSON / multiline output.\n */\nexport function ResultBlock({ result, className }: { result: string | undefined | null; className?: string }) {\n const formatted = formatToolResult(result);\n if (!formatted.text) return null;\n\n if (formatted.kind === 'inline') {\n return (\n \n Result:\n {formatted.text}\n \n );\n }\n\n return (\n \n Result:\n \n {formatted.text}\n
\n \n );\n}\n\n/**\n * Raw command/script body as an unlabeled code block. Used by the CLIENT (Fae)\n * card in the expanded state, where the collapsed line shows the human-readable\n * `toolExplanation` and the actual command moves into the body (Figma 1972-6100).\n */\nexport function CommandBlock({ command, className }: { command: string; className?: string }) {\n if (!command) return null;\n return (\n \n {command}\n
\n );\n}\n","'use client';\n\nimport { forwardRef, type HTMLAttributes } from 'react';\nimport { cn } from '../../utils/cn';\nimport { ApprovalRequestMessage } from './approval-request-message';\nimport type { EscalationOfferSegment } from './types/message.types';\n\nexport interface EscalationOfferMessageProps extends HTMLAttributes {\n data: EscalationOfferSegment['data'];\n status?: EscalationOfferSegment['status'];\n resolvedByName?: string | null;\n onApprove?: EscalationOfferSegment['onApprove'];\n onReject?: EscalationOfferSegment['onReject'];\n}\n\n/**\n * Ticket-escalation offer block.\n *\n * Renders THROUGH the client approval card rather than reimplementing it:\n * per Figma (fae chat › \"escalation to admin\") the offer is that exact\n * component, down to the Approve/Reject labels and the resolved\n * \"Approved by {name}\" pill. Only the wiring differs — approve/reject call\n * the ticket-escalation mutations, never the tool-approval endpoint — which\n * is why this is a distinct segment type with its own handlers.\n *\n * The handoff receipt that follows an approval is NOT rendered here: it is its\n * own `TICKET_ESCALATED` block on the wire, which also covers the inactivity\n * auto-escalation — a path that raises no offer to infer from.\n */\nconst EscalationOfferMessage = forwardRef(\n ({ className, data, status = 'pending', resolvedByName, onApprove, onReject, ...props }, ref) => (\n \n {\n data: TicketEscalatedSegment['data'];\n /** Timestamp of the message row this block came in on. */\n timestamp?: Date;\n}\n\n/**\n * Handoff receipt — the conversation now belongs to a human technician.\n * Figma `ai-assistant-info` (type=escalation); chrome and the wrapping/\n * truncation trade-offs live in the shared `AiAssistantInfo` shell.\n *\n * The body is whatever the backend authored, so the reason it gives stays\n * server-side; the client never composes an explanation and never branches on\n * `data.reason`, which is why a reason added server-side needs no change here.\n */\nconst TicketEscalatedMessage = forwardRef(\n ({ data, timestamp, ...props }, ref) => {\n const body = data.text?.trim() || DEFAULT_BODY;\n return (\n {\n /** Rendered inside the standard 48px framed box (typically a 24px icon). */\n icon?: ReactNode;\n /** Replaces the framed icon box entirely (e.g. a round 48px avatar for the\n * `direct-chat` variant). Wins over `icon` when both are set. */\n leading?: ReactNode;\n title: string;\n /** Secondary line under the title. Omitted → the row is title-only. */\n body?: ReactNode;\n /** Timestamp of the message row this block came in on. */\n timestamp?: Date;\n}\n\n/**\n * Figma `ai-assistant-info` — the shared in-thread status card: a framed\n * icon (or avatar), a title with a right-aligned time, and a secondary line.\n * One presentational shell for every lifecycle receipt in a chat thread\n * (handoff, technician joined, ticket resolved/reopened, …); the per-event\n * components (`TicketEscalatedMessage`, `TicketEventMessage`) own the copy\n * and icon choice and delegate the chrome here.\n *\n * The body WRAPS, deliberately diverging from the mock's single-line\n * ellipsis: the mock's 72px comes from its placeholder copy fitting one\n * line, while real wire text is a full sentence, and clipping the only\n * explanation of a lifecycle change is not recoverable on touch. The title\n * still truncates — it holds one line so the timestamp is never pushed out\n * of the row at narrow widths.\n */\nconst AiAssistantInfo = forwardRef(\n ({ className, icon, leading, title, body, timestamp, ...props }, ref) => {\n return (\n \n {leading ?? (\n \n {icon}\n \n )}\n \n \n \n {title}\n
\n {timestamp && (\n {formatTime(timestamp)}\n )}\n \n {body != null && body !== '' && {body}
}\n \n \n );\n },\n);\n\nAiAssistantInfo.displayName = 'AiAssistantInfo';\n\nexport { AiAssistantInfo };\n","// Locale-aware date/time formatters — mirrors openframe-frontend\n// `src/lib/format-date.ts`. Formats follow the user's locale\n// (e.g. MM/DD/YYYY in en-US vs DD.MM.YYYY in european locales).\n\ntype DateInput = string | number | Date;\n\nconst toDate = (input: DateInput): Date => (input instanceof Date ? input : new Date(input));\n\n// Shown when the input is missing or unparseable. `Intl.DateTimeFormat.format`\n// throws `RangeError: Invalid time value` on an invalid Date, so every formatter\n// here guards first — callers can pass raw API values without a per-call check.\nconst INVALID_DATE_PLACEHOLDER = '—';\n\nconst dateFmt = new Intl.DateTimeFormat(undefined, { dateStyle: 'short' });\nconst timeFmt = new Intl.DateTimeFormat(undefined, { timeStyle: 'short' });\n\nconst format = (input: DateInput, fmt: Intl.DateTimeFormat): string => {\n const date = toDate(input);\n return Number.isNaN(date.getTime()) ? INVALID_DATE_PLACEHOLDER : fmt.format(date);\n};\n\nexport const formatDate = (input: DateInput): string => format(input, dateFmt);\n\nexport const formatTime = (input: DateInput): string => format(input, timeFmt);\n","'use client';\n\nimport { forwardRef, type HTMLAttributes } from 'react';\nimport { CheckCircleIcon, InfoCircleIcon } from '../icons-v2-generated';\nimport { AiAssistantInfo } from './ai-assistant-info';\nimport { TICKET_EVENT_KIND, type TicketEventSegment } from './types/message.types';\n\n/** Actor types the backend uses for the AI agent. Open set on the wire —\n * compared case-insensitively; anything else is treated as a human. */\nconst AI_ACTOR_TYPES = new Set(['AI', 'AGENT', 'ASSISTANT', 'BOT']);\n\nfunction isAiActor(actorType?: string): boolean {\n return !!actorType && AI_ACTOR_TYPES.has(actorType.toUpperCase());\n}\n\n/** `TICKET_ON_HOLD` → `Ticket On Hold` — neutral title for kinds this build\n * does not know, which must still render (the vocabulary is open). */\nfunction humanizeKind(kind: string): string {\n return kind\n .split(/[_\\s-]+/)\n .filter(Boolean)\n .map(word => word.charAt(0).toUpperCase() + word.slice(1).toLowerCase())\n .join(' ');\n}\n\nexport interface TicketEventMessageProps extends HTMLAttributes {\n data: TicketEventSegment['data'];\n /** Timestamp of the message row this block came in on. */\n timestamp?: Date;\n}\n\n/** Where the ticket reopened INTO → the \"who picks it up next\" line.\n * Kind-tokens per the lifecycle statuses; the vocabulary is open, so an\n * unrecognized target falls back to the actor heuristic below. */\nconst REOPEN_TARGET_COPY: Record = {\n AI_ASSISTANCE: 'The AI assistant will continue helping you in this conversation.',\n TECH_REQUIRED: 'A technician will reply when available.',\n};\n\n/**\n * Ticket lifecycle receipt — resolved / reopened / an unknown future kind.\n * Figma `ai-assistant-info` (type=resolved-fae | resolved-tech |\n * reopened-fae | reopened-tech | reopened-reason).\n *\n * Copy is composed client-side from the event's fields (unlike\n * `ticket_escalated`, whose body the backend authors):\n * RESOLVED → \"Resolved by {actorName}.\" under a green check;\n * REOPENED → the reason when the wire carries one; otherwise who picks the\n * conversation up next — `targetStatusKind` decides deterministically,\n * with the `actorType` heuristic as the fallback for older backends\n * that don't send the target;\n * unknown kind → a neutral info line: humanized kind as the title, the\n * reason or actor as the body. Never dropped — the vocabulary is open.\n */\nconst TicketEventMessage = forwardRef(({ data, timestamp, ...props }, ref) => {\n const { kind, actorName, actorType, reason, targetStatusKind } = data;\n const resolved = kind === TICKET_EVENT_KIND.RESOLVED;\n const reopened = kind === TICKET_EVENT_KIND.REOPENED;\n\n const title = resolved ? 'Ticket Resolved' : reopened ? 'Ticket Reopened' : humanizeKind(kind);\n\n let body: string | undefined;\n if (resolved) {\n body = actorName ? `Resolved by ${actorName}.` : 'The ticket has been resolved.';\n } else if (reopened) {\n body =\n (reason ? `Reason: ${reason}` : undefined) ??\n (targetStatusKind ? REOPEN_TARGET_COPY[targetStatusKind] : undefined) ??\n (isAiActor(actorType)\n ? `${actorName || 'Fae'} will continue assisting in this conversation.`\n : 'A technician will reply when available.');\n } else {\n body = reason || (actorName ? `By ${actorName}.` : undefined);\n }\n\n const icon = resolved ? (\n ;\n result?: string;\n success?: boolean;\n /**\n * Backend-issued id (matches `PendingToolCallData.toolExecutionRequestId`).\n * When present, lets the accumulator merge this execution event into the\n * matching approval batch row instead of emitting a standalone segment.\n */\n toolExecutionRequestId?: string;\n}\n\n/**\n * Snapshot of an in-flight tool kept between the `EXECUTING_TOOL` and\n * `EXECUTED_TOOL` events. The backend only sends `toolTitle` on\n * `EXECUTING_TOOL`; carrying this state lets the accumulator restore it onto\n * the merged `EXECUTED_TOOL` segment instead of falling back to the raw\n * `toolFunction`.\n */\nexport interface ExecutingToolState {\n integratedToolType: string;\n toolFunction: string;\n /** Mirrors {@link ToolExecutionData.toolTitle}; absent on `EXECUTED_TOOL`. */\n toolTitle?: string;\n /** Mirrors {@link ToolExecutionData.toolExplanation}; absent on `EXECUTED_TOOL`. */\n toolExplanation?: string;\n parameters?: Record;\n}\n\n// ========== Approval Request Types ==========\n\nexport interface ApprovalRequestField {\n /** Short label — e.g. \"Subject\", \"Priority\". Rendered in a muted\n * caps style above the value. */\n label: string;\n /** Free-text value. Wraps and line-breaks are preserved\n * (`whitespace-pre-wrap`). */\n value: string;\n}\n\nexport interface ApprovalRequestData {\n command: string;\n /** Structured field list — preferred over `explanation`. When set,\n * the approval card renders a vertical label/value stack with\n * proper spacing. Falls back to `explanation` (a single paragraph)\n * when omitted. Keep BOTH when you want hosts on older lib\n * versions to still see the prose; new hosts should send only\n * `fields`. */\n fields?: ApprovalRequestField[];\n explanation?: string;\n icon?: ReactNode;\n requestId?: string;\n approvalRequestId?: string;\n approvalType?: string;\n}\n\nexport interface ApprovalResultData {\n approvalRequestId: string;\n approved: boolean;\n approvalType?: string;\n /** Display name of the user who resolved the request; null/absent for system actions. */\n resolvedByName?: string | null;\n}\n\n// ========== Escalation Offer Types ==========\n\nexport interface EscalationOfferData {\n offerId: string;\n /** Backend-fixed card copy; the client never composes it. */\n text: string;\n /** Why the offer was raised (`TOOL`, `MANUAL`, a trigger reason). Carried\n * for telemetry — every origin renders the same card. */\n origin?: string;\n}\n\n// ========== Ticket Escalated Types ==========\n\n/** Open union: the wire currently defines only `INACTIVITY`, and the block\n * renders from `text` rather than branching on this, so a reason added\n * server-side needs no client change. */\nexport type TicketEscalationReason = 'INACTIVITY' | (string & {});\n\n/** The handoff receipt — a real block on the wire, not something the client\n * infers from an escalation offer's state. */\nexport interface TicketEscalatedData {\n ticketId: string;\n ticketNumber?: number;\n reason: TicketEscalationReason;\n /** Backend-authored explanation; the card falls back to generic copy when\n * the wire omits it (the field is nullable). */\n text?: string;\n}\n\n// ========== Ticket Event Types ==========\n\n/** Known `TicketEventData.kind` values. The vocabulary is OPEN on the wire:\n * an unknown kind still renders (as a neutral info line) rather than being\n * dropped, so the backend can add lifecycle kinds without a client release. */\nexport const TICKET_EVENT_KIND = {\n RESOLVED: 'RESOLVED',\n REOPENED: 'REOPENED',\n} as const;\n\nexport type TicketEventKind = (typeof TICKET_EVENT_KIND)[keyof typeof TICKET_EVENT_KIND] | (string & {});\n\n/** Ticket lifecycle receipt (`TICKET_EVENT`) — the ticket was resolved,\n * reopened, etc. Same field names live (NATS chunk) and persisted\n * (GraphQL `TicketEventData` inside `messageData`), so ONE mapper covers\n * both paths. All actor fields are optional: the event stays renderable\n * when the backend can't attribute it. */\nexport interface TicketEventData {\n kind: TicketEventKind;\n actorId?: string;\n actorName?: string;\n /** Who acted — e.g. an AI agent vs a human. Open string like `kind`. */\n actorType?: string;\n reason?: string;\n /** Kind-token of the status the ticket reopened INTO (AI_ASSISTANCE /\n * TECH_REQUIRED / CUSTOM / ...) — same open vocabulary the lifecycle\n * statuses use. Picks the REOPENED card's subtitle deterministically;\n * absent on RESOLVED events and older backends. */\n targetStatusKind?: string;\n}\n\n/**\n * Single tool call inside a batch approval request.\n * Mirrors backend PendingToolCallDto.\n */\nexport interface PendingToolCallData {\n toolExecutionRequestId: string;\n toolName: string;\n toolTitle?: string;\n toolExplanation?: string;\n toolType?: string;\n requiresApproval: boolean;\n approvalType?: string | null;\n toolCallArguments?: Record | null;\n}\n\n/**\n * Per-tool execution state inside an approval batch.\n * Populated by EXECUTING_TOOL / EXECUTED_TOOL chunks that carry a\n * `toolExecutionRequestId` matching one of the batch's tool calls.\n */\nexport interface ApprovalBatchExecutionState {\n status: 'executing' | 'done';\n result?: string;\n success?: boolean;\n}\n\nexport interface ApprovalBatchData {\n approvalRequestId: string;\n /** Highest approval type required across the batch (e.g. ADMIN beats CLIENT). */\n approvalType: string;\n toolCalls: PendingToolCallData[];\n /**\n * Keyed by `PendingToolCallData.toolExecutionRequestId`. Absent before\n * approval; rows without an entry render as \"queued\" (loader) once the\n * batch itself is approved.\n */\n executions?: Record;\n}\n\n/** Approve/reject handler stamped onto approval segments. MAY resolve a\n * boolean success flag — `false` means the confirm FAILED (expired\n * proposal, network error); batch approve-all loops use it to tick the\n * row's failure cross. `void` (legacy transports) is treated as\n * success. Single source of truth for this signature — component\n * props, accumulator callbacks, and adapters all reference it. */\nexport type ApprovalResolutionHandler = (requestId?: string) => void | boolean | Promise;\n\n// ========== Message Segment Types ==========\n\nexport type TextSegment = {\n type: 'text';\n text: string;\n};\n\nexport type ThinkingSegment = {\n type: 'thinking';\n text: string;\n};\n\n/** One reading the assistant offers in an `ask` card. `label` is BOTH the row's\n * headline and the exact text sent back when the row is picked — the backend's\n * guide classifier resolves the user's next message against the labels it\n * offered, so the reply must be the label verbatim. `description` is a short\n * clarifying line rendered under it. */\nexport type AskOptionData = {\n label: string;\n description?: string;\n};\n\n/** Clarification card — the assistant asking WHICH reading of an ambiguous\n * question it should answer, rendered as a heading plus a list of clickable\n * options instead of prose bullets. NATS-only (the `ASK` chunk); the intro\n * sentence riding the same chunk becomes an ordinary `text` segment in front\n * of the card, so it goes through the normal markdown body pipeline. Unlike\n * the three delta streams an ask arrives whole — it is never coalesced. */\nexport type AskSegment = {\n type: 'ask';\n question: string;\n options: AskOptionData[];\n};\n\nexport type ToolExecutionSegment = {\n type: 'tool_execution';\n data: ToolExecutionData;\n};\n\nexport type ApprovalRequestSegment = {\n type: 'approval_request';\n data: ApprovalRequestData & { approvalType?: string };\n status?: ChatApprovalStatus;\n /** Display name of the user who resolved the request; baked into the client\n * variant's full-text status pill (\"Approved by {name}\"). */\n resolvedByName?: string | null;\n onApprove?: ApprovalResolutionHandler;\n onReject?: ApprovalResolutionHandler;\n};\n\nexport type ApprovalBatchSegment = {\n type: 'approval_batch';\n data: ApprovalBatchData;\n status?: ChatApprovalStatus;\n /** Display name of the user who resolved the request; set when the batch is resolved (null/absent for system actions). */\n resolvedByName?: string | null;\n onApprove?: ApprovalResolutionHandler;\n onReject?: ApprovalResolutionHandler;\n};\n\n/**\n * Ticket-escalation offer block. Visually the client approval card (same\n * Figma component), but a SEPARATE segment type on purpose: it resolves\n * through the ticket-escalation GraphQL mutations rather than the tool\n * approval endpoint, and hosts that hide pending tool approvals from the\n * thread must still render this one inline.\n *\n * `cancelled` is the wire's SUPERSEDED — the client typed over the offer.\n */\nexport type EscalationOfferSegment = {\n type: 'escalation_offer';\n data: EscalationOfferData;\n status?: ChatApprovalStatus;\n resolvedByName?: string | null;\n onApprove?: ApprovalResolutionHandler;\n onReject?: ApprovalResolutionHandler;\n};\n\n/**\n * The conversation was handed off to a human technician. Decoded from the\n * `TICKET_ESCALATED` block, so it appears for every escalation path the\n * backend emits it for — including the inactivity auto-escalation, which\n * raises no offer and therefore has no offer state to infer from.\n */\nexport type TicketEscalatedSegment = {\n type: 'ticket_escalated';\n data: TicketEscalatedData;\n};\n\n/**\n * Ticket lifecycle receipt (resolved / reopened / an unknown future kind).\n * Arrives as a standalone `TICKET_EVENT` chunk outside MESSAGE_START/END —\n * same delivery shape as `ticket_escalated`.\n *\n * `streamSeq` is the chunk's JetStream sequence, kept ON the segment because\n * it is the event's only stable identity: the accumulator upserts on it so a\n * redelivered chunk (catch-up over hydrated history) replaces rather than\n * stacks a second card, while two genuinely distinct events of the same kind\n * (resolve → reopen → resolve) keep distinct sequences and both render.\n */\nexport type TicketEventSegment = {\n type: 'ticket_event';\n data: TicketEventData;\n streamSeq?: number;\n /** When THIS event happened (history: the persisted row's `createdAt`;\n * live: chunk arrival). Kept beside `streamSeq`, not in `data`: the\n * upsert's payload-equality fallback must keep matching a redelivered\n * chunk to its hydrated twin, and their times come from different clocks.\n * Without it the card inherits the surrounding assistant bubble's\n * timestamp — the FIRST row of the whole turn, so every lifecycle card\n * reads the same stale time. */\n occurredAt?: Date;\n};\n\nexport type ErrorSegment = {\n type: 'error';\n title: string;\n details?: string;\n};\n\nexport type ContextCompactionSegment = {\n type: 'context_compaction';\n status: 'started' | 'completed';\n summary?: string;\n};\n\nexport type MessageSegment =\n | TextSegment\n | ThinkingSegment\n | AskSegment\n | ToolExecutionSegment\n | ApprovalRequestSegment\n | ApprovalBatchSegment\n | EscalationOfferSegment\n | TicketEscalatedSegment\n | TicketEventSegment\n | ErrorSegment\n | ContextCompactionSegment;\n\nexport type MessageContent = string | MessageSegment[];\n\n// ========== Message Data Types (from GraphQL/API) ==========\n\nexport interface MessageDataBase {\n type: MessageType;\n}\n\nexport interface TextMessageData extends MessageDataBase {\n type: 'TEXT';\n text?: string;\n /** Entity references the user attached to the message. Wire shape is\n * `[{ type, id }]`; rows missing `id` are dropped by the history\n * processor, so `id` is optional here. */\n contextItems?: Array<{ type?: string; id?: string }>;\n}\n\nexport interface ThinkingMessageData extends MessageDataBase {\n type: 'THINKING';\n text?: string;\n}\n\n/**\n * A document cited by an assistant answer, rendered as a chip under it.\n *\n * Lives here, beside `Message`, because BOTH transports produce it now: the SSE\n * adapter reads it off the per-turn metadata frame, and the NATS path decodes it\n * out of a `GUIDE`/`SOURCES` chunk. It used to be declared inside\n * `use-sse-chat-adapter`, which made \"a Guide answer's citations\" structurally a\n * property of one transport — `use-sse-chat-adapter` still re-exports the name\n * so existing imports keep working.\n */\nexport interface ChatSource {\n /** 1-based citation number. `[1]` in the answer text refers to this. */\n index: number;\n name: string;\n path: string;\n documentType: string;\n externalUrl?: string;\n /** Platform that owns the destination at `externalUrl`. */\n targetPlatform?: string | null;\n /** Primary-key value for single-row chips. */\n id?: string;\n /** Per-row items for grouped chips. */\n items?: Array<{\n id: string;\n documentType: string;\n name: string;\n externalUrl?: string;\n targetPlatform?: string | null;\n /** In-app doc-tree path for markdown / data-room-doc rows so the\n * grouped chip's anchor can trigger an in-page doc-tree swap via\n * `handleChatNavClick` (parity with single-row chips + cards). */\n path?: string | null;\n }>;\n /** RagTableConfig.id for this source. */\n sourceRepo?: string;\n /** Optional display label override returned by the chat API. */\n label?: string;\n}\n\n/** Persisted source-metadata row. `payload` is the SAME object the live chunk\n * carries, so history and realtime share one decoder (`sourceMetadataEvent`)\n * and cannot drift apart. Left as an open record here rather than typed\n * structurally: it is unvalidated wire data, and the decoder is what turns it\n * into `ChatSource[]` / `ChatRef[]`. */\nexport interface SourceMetadataMessageData extends MessageDataBase {\n type: 'GUIDE' | 'SOURCES';\n payload?: unknown;\n}\n\n/** Persisted `ASK` row (GraphQL `AskData`). `text` is the intro sentence, which\n * history replays as a text segment ahead of the card — same split the live\n * `ASK` chunk carries. */\nexport interface AskMessageData extends MessageDataBase {\n type: 'ASK';\n text?: string;\n question?: string;\n /** WIRE shape — `label` is optional here because the backend can (and does)\n * ship label-less rows; `normalizeAskOptions` drops them, which is what\n * turns this into the card's `AskOptionData[]`. */\n options?: Array<{ label?: string; description?: string }>;\n}\n\nexport interface ExecutingToolMessageData extends MessageDataBase {\n type: 'EXECUTING_TOOL';\n integratedToolType?: string;\n toolFunction?: string;\n /** Backend-issued human-readable title (wire field, mirrors `ChunkData.title`). */\n title?: string;\n /** Backend-issued human-readable explanation (what/why) of the tool call. */\n toolExplanation?: string;\n parameters?: Record;\n toolExecutionRequestId?: string;\n}\n\nexport interface ExecutedToolMessageData extends MessageDataBase {\n type: 'EXECUTED_TOOL';\n integratedToolType?: string;\n toolFunction?: string;\n /** Backend-issued human-readable title (wire field, mirrors `ChunkData.title`). */\n title?: string;\n parameters?: Record;\n result?: string;\n success?: boolean;\n toolExecutionRequestId?: string;\n}\n\nexport interface ApprovalRequestMessageData extends MessageDataBase {\n type: 'APPROVAL_REQUEST';\n approvalRequestId?: string;\n approvalType?: string;\n command?: string;\n explanation?: string;\n /** Present when the approval is a batch of tool calls (new format). */\n toolCalls?: PendingToolCallData[];\n}\n\nexport interface ApprovalResultMessageData extends MessageDataBase {\n type: 'APPROVAL_RESULT';\n approvalRequestId?: string;\n approved?: boolean;\n approvalType?: string;\n /** Display name of the user who resolved the request; null/absent for system actions. */\n resolvedByName?: string | null;\n}\n\n/**\n * Persisted escalation-offer row. The PENDING row carries `text`/`origin`;\n * the resolution is a SECOND row with the same `offerId`, state\n * APPROVED/DECLINED/SUPERSEDED and no text — matched on replay by id.\n */\nexport interface EscalationOfferMessageData extends MessageDataBase {\n type: 'ESCALATION_OFFER';\n offerId?: string;\n state?: string;\n text?: string;\n origin?: string;\n resolvedByUserId?: string | null;\n resolvedByName?: string | null;\n}\n\nexport interface TicketEscalatedMessageData extends MessageDataBase {\n type: 'TICKET_ESCALATED';\n ticketId?: string;\n ticketNumber?: number;\n reason?: TicketEscalationReason;\n text?: string;\n}\n\n/** Persisted ticket lifecycle row — same field names as the live chunk\n * (see `TicketEventData`), decoded by the SAME mapper on replay. Fields are\n * wire-shaped (`| null`): every one is a nullable GraphQL scalar. */\nexport interface TicketEventMessageData extends MessageDataBase {\n type: 'TICKET_EVENT';\n kind?: string | null;\n actorId?: string | null;\n actorName?: string | null;\n actorType?: string | null;\n reason?: string | null;\n targetStatusKind?: string | null;\n}\n\nexport interface ErrorMessageData extends MessageDataBase {\n type: 'ERROR';\n error?: string;\n details?: string;\n}\n\nexport interface AIMetadataMessageData extends MessageDataBase {\n type: 'AI_METADATA';\n modelName?: string;\n providerName?: string;\n provider?: string;\n contextWindow?: number;\n}\n\nexport interface TokenUsageData {\n inputTokensSize: number;\n outputTokensSize: number;\n totalTokensSize: number;\n contextSize: number;\n}\n\nexport interface SystemMessageData extends MessageDataBase {\n type: 'SYSTEM';\n text?: string;\n}\n\n/**\n * Human-technician takeover row. A REALTIME-only concept: the history\n * processors have no branch for it, so a persisted `DIRECT_MESSAGE` row\n * contributes nothing on reload (pinned by the golden characterization test).\n * Declared here so the wire shape is nameable without `any`.\n */\nexport interface DirectMessageData extends MessageDataBase {\n type: 'DIRECT_MESSAGE';\n text?: string;\n}\n\nexport interface ContextCompactionStartMessageData extends MessageDataBase {\n type: 'CONTEXT_COMPACTION_START';\n}\n\nexport interface ContextCompactionEndMessageData extends MessageDataBase {\n type: 'CONTEXT_COMPACTION_END';\n summary?: string;\n}\n\nexport type MessageData =\n | TextMessageData\n | ThinkingMessageData\n | AskMessageData\n | SourceMetadataMessageData\n | ExecutingToolMessageData\n | ExecutedToolMessageData\n | ApprovalRequestMessageData\n | ApprovalResultMessageData\n | EscalationOfferMessageData\n | TicketEscalatedMessageData\n | TicketEventMessageData\n | ErrorMessageData\n | AIMetadataMessageData\n | SystemMessageData\n | DirectMessageData\n | ContextCompactionStartMessageData\n | ContextCompactionEndMessageData;\n\n// ========== Historical Message Types ==========\n\nexport interface HistoricalMessage {\n id: string;\n dialogId?: string;\n chatType?: string;\n createdAt: string;\n owner?: MessageOwner;\n messageData?: MessageData | MessageData[];\n /** Persisted stream sequence of this row's last chunk (the backend's\n * `lastChunkStreamSeq`). Passed through to the processed message's\n * `streamSeq` so `mergeHistoryWithRealtime` can decide coverage per-role\n * (a synthetic is covered only by a persisted row of its OWN role reaching\n * its seq). Optional — absent for rows the backend doesn't stamp (e.g. user\n * MESSAGE_REQUEST rows), which then don't participate in seq coverage. */\n lastChunkStreamSeq?: number | null;\n}\n\n// ========== Processed Message Types ==========\n\nexport interface ProcessedMessage {\n id: string;\n role: 'user' | 'assistant' | 'error'; // Limited to display roles\n content: MessageContent;\n name?: string;\n assistantType?: AssistantType;\n authorType?: AuthorType;\n timestamp: Date;\n avatar?: string;\n /** Persisted last-chunk stream sequence carried through from\n * `HistoricalMessage.lastChunkStreamSeq` (for assistant turns: the MAX\n * across the grouped rows). Hosts stamp it onto the rendered message's\n * `streamSeq` so the history/realtime merge can do per-role seq coverage.\n * Absent when the source row(s) carried no seq. */\n streamSeq?: number;\n /** Documents this answer cited — see `Message.sources`, the same field.\n * Replayed from the turn's persisted `GUIDE`/`SOURCES` row, so a reloaded\n * answer carries the citations the live one did. */\n sources?: ChatSource[];\n /** Entity references this answer's metadata described — see `Message.refs`. */\n refs?: ChatRef[];\n}\n\n// ========== Base Message Interface ==========\n\nimport type { ReactNode } from 'react';\nimport type { ChatContextItem } from './context-item.types';\n\nexport interface Message {\n id: string;\n role: 'user' | 'assistant' | 'error'; // Limited to display roles\n content: MessageContent;\n name?: string;\n assistantType?: AssistantType;\n authorType?: AuthorType;\n timestamp?: Date;\n avatar?: string | null;\n /** Highest CONTENT chunk streamSeq that composed this message. Stamped on\n * realtime synthetics so `mergeHistoryWithRealtime` can decide history\n * coverage per-message (see `MergeableChatMessage.streamSeq`). */\n streamSeq?: number;\n /** Entity-context items attached to this (user) message via the composer's\n * context picker. When present the message bubble renders the context\n * chips beneath its text (Figma node 31:28709). Optional — omitted for\n * assistant messages and turns sent without context. */\n contextItems?: ChatContextItem[];\n /** Per-message viewport-positioning hint. OPTIONAL — when omitted (the\n * default for every LLM Q&A / browse / search / find / Discuss path)\n * the chat tails as today via `use-stick-to-bottom`. Only `'top'` opts\n * in to the alternative top-anchor behaviour (display-action answers\n * whose body is a long article). The server is the sole decision-\n * maker — set on the metadata leading frame. */\n scrollAnchor?: ScrollAnchor;\n /** When true the message is part of the API conversation history (sent\n * to the LLM so it has context) but is NOT rendered in the chat UI.\n *\n * Used for \"synthetic continuation\" turns: when the user clicks Approve\n * on a tool proposal, the host auto-fires a follow-up `sendMessage`\n * with `hidden: true` carrying a directive like \"the user just\n * approved ; ask follow-up questions per protocol\". The LLM's\n * response IS rendered (as a normal assistant message); only the\n * trigger prompt is suppressed so the chat reads naturally:\n *\n * user: \"open a ticket\"\n * assistant: preamble + approval card\n * [user clicks Approve]\n * assistant: \"Now to triage faster, can you share...\" ← auto-fires\n *\n * Without this flag the trigger prompt would surface as a confusing\n * bubble like \"(continue per protocol)\" between the approval card\n * and the AI's follow-up. */\n hidden?: boolean;\n /**\n * Documents this answer cited, rendered as chips beneath it.\n *\n * Per MESSAGE, not per conversation: an answer's citations belong to the\n * answer, and a thread can hold several answers that each cited something\n * different. Ordering is a rendering concern — see `splitCitedSources`.\n */\n sources?: ChatSource[];\n /**\n * Entity references this answer's metadata described — videos and cards.\n *\n * Presence here does NOT mean \"render it\": only the `[card://type:id]`\n * markers actually written into the answer text are rendered, and these\n * supply the data those markers expand with. The metadata frame routinely\n * describes more than the model chose to cite.\n */\n refs?: ChatRef[];\n}\n","'use client';\n\nimport { forwardRef } from 'react';\n\nimport { cn } from '../../utils/cn';\nimport { CheckCircleIcon, DotsLoaderIcon } from '../icons-v2-generated';\nimport type { ContextCompactionDisplayProps } from './types';\n\nconst ContextCompactionDisplay = forwardRef(\n ({ className, status, ...props }, ref) => {\n const isStarted = status === 'started';\n const label = isStarted ? 'Context limit reached. Summarizing earlier messages.' : 'Earlier context summarized.';\n\n return (\n \n {label}\n {isStarted ? (\n (\n ({ className, text, isStreaming = false, ...props }, ref) => {\n const [expanded, setExpanded] = useState(false);\n // 26px ≈ one line of `text-sm leading-snug` (~19px) + space for the\n // bordered/padded `` badges that markdown renders inline. With\n // exact 1lh the bottom of those badges gets clipped.\n const { innerRef, isOverflowing, containerStyle } = useCollapsible({\n expanded,\n collapsedHeight: 19,\n disableTransition: isStreaming,\n });\n const label = isStreaming ? 'Thinking' : 'Thought';\n const canToggle = isOverflowing || expanded;\n\n const toggle = () => canToggle && setExpanded(!expanded);\n const handleKeyDown = (e: KeyboardEvent) => {\n if (!canToggle) return;\n if (e.key === 'Enter' || e.key === ' ') {\n e.preventDefault();\n setExpanded(!expanded);\n }\n };\n\n return (\n \n \n \n {label}:\n {isStreaming && \n \n );\n },\n);\n\nThinkingDisplay.displayName = 'ThinkingDisplay';\n\nexport { ThinkingDisplay };\n","'use client';\n\n/**\n * MarkdownEngine — THE one react-markdown pipeline for every surface\n * (chat messages, blog, docs, KB articles, legal, releases, admin previews).\n *\n * `SimpleMarkdownRenderer` and `RichMarkdownRenderer` are thin compositions\n * over this engine (see ./simple-markdown-renderer.tsx and ./rich/) — there\n * is exactly ONE parse path, ONE sanitizer stack, ONE mermaid, ONE\n * heading-id algorithm, ONE link-click model. Do not fork this pipeline;\n * extend via `componentOverrides` / `additionalRemarkPlugins` /\n * `preprocessContent` / `extraAllowedHtmlTags`.\n *\n * Pipeline order (each stage documented in ./sanitize.ts):\n * preprocessContent (composition hook, e.g. shortcodes)\n * → completeStreamingTail (streaming only — MUST precede the escape pass)\n * → escapeUnknownHtmlTags (text pre-pass, React 19 crash guard)\n * → remark: remarkGfm, remarkBreaks, ...additionalRemarkPlugins\n * → rehype: rehypeRaw → rehypeSanitize(schema) → rehypeStripUnsafe\n * → rehypeHighlight\n * → urlTransform: cardAwareUrlTransform\n * → components: buildBaseComponents(...) spread-last componentOverrides\n */\nimport type React from 'react';\nimport { memo, useMemo } from 'react';\nimport ReactMarkdown, { type Components } from 'react-markdown';\nimport rehypeHighlight from 'rehype-highlight';\nimport rehypeRaw from 'rehype-raw';\nimport rehypeSanitize from 'rehype-sanitize';\nimport remarkBreaks from 'remark-breaks';\nimport remarkGfm from 'remark-gfm';\nimport type { PluggableList } from 'unified';\nimport type { ResolveLinkResult } from '../../../types/doc-source';\nimport { buildBaseComponents } from './base-components';\nimport { HeadingIdMapContext, HeadingLineOffsetContext, useHeadingIdMap, type HeadingSection } from './heading-ids';\nimport {\n buildEffectiveTagSet,\n buildSanitizeSchema,\n cardAwareUrlTransform,\n escapeUnknownHtmlTags,\n rehypeStripUnsafe,\n} from './sanitize';\nimport { completeStreamingTail, splitStreamingBlocks } from './streaming';\nimport { resolveTextSizeConfig, type TextSizeConfig } from './text-size';\n\nexport type { ResolveLinkResult };\n\n/**\n * Module-scope empty default for `brokenLinks`.\n *\n * A `brokenLinks = []` DEFAULT PARAMETER allocates a fresh array on every\n * render, so the `components` useMemo (which lists it as a dep) recomputed\n * every render, which changed `StreamingBlockRenderer`'s `components` prop\n * identity, which made its `memo` bail EVERY time — every completed block\n * re-parsed on every streamed token, defeating the entire atomic-block\n * optimization. Any new default that is an object/array/function MUST be\n * hoisted here for the same reason.\n *\n * Exported so the compositions that apply the SAME default before handing\n * props down (rich) share this ONE identity instead of declaring a second\n * module-scope empty array with a copy of this rationale. Deliberately NOT\n * re-exported from ./index — it is an internal identity contract between the\n * engine and its compositions, not public API.\n */\nexport const NO_BROKEN_LINKS: readonly string[] = [];\n\nexport interface MarkdownEngineProps {\n content: string;\n className?: string;\n /** Backend-provided heading IDs for deep-link anchors */\n sectionIds?: HeadingSection[];\n /** When the page already has an H1, render markdown `#` as `` */\n demoteMarkdownH1ToH2?: boolean;\n /** List of broken link hrefs detected server-side (shown with [BROKEN] badge) */\n brokenLinks?: readonly string[];\n /** Callback for internal (non-http, non-anchor) link clicks */\n onInternalLinkClick?: (path: string, options?: { expandFolder?: boolean; fromInternalLink?: boolean }) => void;\n /** Current documentation path — enables internal-link mode when set */\n currentPath?: string;\n /** Resolve an internal link href to a navigation path. */\n onResolveLink?: (href: string, currentPath: string) => Promise;\n /** Pre-process the raw markdown string before rendering (e.g. shortcode expansion) */\n preprocessContent?: (content: string) => string;\n /** Merge additional or override react-markdown component renderers (spread LAST — caller wins) */\n componentOverrides?: Partial;\n /** Extra remark plugins appended after the built-in remarkGfm + remarkBreaks */\n additionalRemarkPlugins?: PluggableList;\n /** Text sizing preset / per-element overrides */\n textSize?: TextSizeConfig;\n /**\n * Extra raw-HTML tags this composition admits. Unioned into BOTH the\n * text pre-pass allowlist AND the sanitize schema together (the\n * coupled-allowlist invariant — see ./sanitize.ts).\n */\n extraAllowedHtmlTags?: string[];\n /**\n * Set true for the actively streaming message ONLY. Enables atomic-block\n * memoization + fence tail-completion + an aria-live wrapper. The caller\n * MUST flip back to false on completion — that final render is one\n * authoritative whole-document parse (block cache discarded), so\n * streaming can never permanently diverge from the settled output.\n */\n streaming?: boolean;\n}\n\n/**\n * One memoized completed block of a streaming message. Parent-level memos\n * keep every prop except `text` referentially stable, so a completed block\n * re-renders only if its own text changes (i.e. the splitter re-cut).\n * React key = position index — identical blocks at different positions\n * never alias (see ./streaming.ts).\n */\nconst StreamingBlockRenderer = memo(function StreamingBlockRendererImpl({\n text,\n remarkPlugins,\n rehypePlugins,\n components,\n}: {\n text: string;\n remarkPlugins: PluggableList;\n rehypePlugins: PluggableList;\n components: Components;\n}) {\n return (\n \n {text}\n \n );\n});\n\nconst MarkdownEngineImpl: React.FC = ({\n content,\n className = '',\n sectionIds,\n demoteMarkdownH1ToH2 = false,\n brokenLinks = NO_BROKEN_LINKS,\n onInternalLinkClick,\n currentPath,\n onResolveLink,\n preprocessContent,\n componentOverrides,\n additionalRemarkPlugins,\n textSize,\n extraAllowedHtmlTags,\n streaming = false,\n}) => {\n const textSizes = useMemo(() => resolveTextSizeConfig(textSize), [textSize]);\n\n // Stable identity key for the caller's tag array — a fresh array with the\n // same contents must not bust these memos.\n const extraTagsKey = extraAllowedHtmlTags?.join('|') ?? '';\n\n // Effective tag allowlist — shared source for pre-pass AND schema.\n // Both memos consume ONLY `extraTagsKey`, so the dep list is honest and\n // needs no eslint suppression.\n const effectiveTags = useMemo(\n () => buildEffectiveTagSet(extraTagsKey ? extraTagsKey.split('|') : undefined),\n [extraTagsKey],\n );\n\n const processedContent = useMemo(() => {\n const preprocessed = preprocessContent ? preprocessContent(content) : content;\n // ORDER IS LOAD-BEARING: complete the streaming tail FIRST, then escape.\n //\n // Escaping first failed OPEN on the most common streaming shape. During a\n // stream every partially-emitted fence is unclosed, and both of the\n // pre-pass's fence notions (`PROTECTED_SPAN_RE` for the carve AND the\n // mask) only recognize CLOSED fences — so a `` inside the\n // still-open fence satisfied \"is closed later\", the prose opener above it\n // stayed live, and parse5 swallowed the rest of the message until the\n // fence closed (an LLM explaining `` written inside that span\n * VISIBLE in the closer haystack, `hasLaterCloser` true, the prose opener LIVE,\n * and parse5 swallowing the rest of the message as the textarea's value.\n * A clean cliff, padding length the only variable: span content ≤4094 chars ⇒\n * blanked, opener escaped, 0 live textareas; ≥4099 ⇒ closer visible, 1 live\n * textarea. That is a fail-OPEN in the security boundary, and it contradicts\n * this module's own contract that every mask approximation \"rounds towards\n * blanking\".\n *\n * THE BOUND COULD NOT SIMPLY BE DROPPED. `[^\\n]` confines backtracking to one\n * LINE, but a single line is not a small input — a chat message can be one.\n * MEASURED (round 16, this repo's vitest env, one line of nothing but\n * backticks — the pathological shape; figures from plain node are within 3%):\n *\n * input capped regex uncapped regex this linear scan\n * 50K chars 295 ms (5.9 µs/c) 615 ms (12.3 µs/c) 0.69 ms (14 ns/c)\n * 200K chars 1220 ms (6.1 µs/c) 9772 ms (48.9 µs/c) 0.42 ms (2 ns/c)\n * 800K chars 5072 ms (6.3 µs/c) 158263 ms (198 µs/c) — (node)\n *\n * The capped regex is flat per char (linear, huge constant); the UNCAPPED one\n * is plainly QUADRATIC — 31x the capped cost at 800KB and still climbing. Every\n * other shape probed (lone tick + text, `` `` `` + text, one tick per 32 chars,\n * one tick per line) is ≈2-4 ns/char in BOTH regex spellings, so the blowup is\n * specific to long backtick runs — which an attacker controls. The cap was load\n * bearing; the REGEX is what had to go. A realistic 260KB backtick-dense\n * message (`Use `foo` and `bar` here.` × 10000) scans in 4.2 ms.\n *\n * `findInlineCodeRanges` is a LINEAR index scan that reproduces the old\n * regex's match semantics exactly (verified by differential fuzz against the\n * uncapped regex) with no backtracking and no cap: per line it collects the\n * backtick RUNS, then for each opener run of length `n` picks the largest\n * closer length `k ≤ n` that occurs later on the line — either inside the same\n * run (needs `n ≥ 2k`, mirroring the regex giving back backticks from a greedy\n * `` (`+) ``) or at the earliest following run of length ≥ k — and takes the\n * EARLIEST such position (the lazy quantifier). The forward walk is amortized\n * O(1) per run because the scan cursor jumps past every run it skipped.\n *\n * `PROTECTED_SPAN_RE` (the CARVE) KEEPS its cap, deliberately: the two\n * consumers round in OPPOSITE directions, see the note on\n * `escapeLeftoverTagStarts`. In the carve, \"not known to be code\" means ESCAPE,\n * so an over-cap span there costs a code sample rendered as escaped text.\n */\nconst BACKTICK_CODE = 0x60;\n\n/**\n * PARAGRAPH SEGMENTS, NOT LINES (round 18 — SECURITY). A CommonMark code span\n * CROSSES LINE BREAKS: `` `foo\\n` `` is one `inlineCode` node, so\n * that `` is a code sample and not a closer — yet this scan (and\n * `PROTECTED_SPAN_RE`, whose body class is `[^\\n]`) was strictly PER LINE, so\n * the mask never saw the span, the closer stayed visible in the haystack,\n * `hasLaterCloser` returned true, and a prose `
` — proving the closer is a code sample\n * — beside a live textarea swallowing the prose). This is the shape that is not\n * a CONTAINER at all, so no container sweep could ever have reached it.\n *\n * A code span CANNOT cross a paragraph break, so the scan unit is a maximal run\n * of non-blank lines. Blank lines still terminate a segment, which keeps the\n * fail-CLOSED direction (an unterminated opener consumes at most its own\n * paragraph, never the rest of the document) and keeps the bound linear — the\n * `suffMax` / cursor structure is unchanged, `\\n` is simply an ordinary\n * character inside a segment.\n *\n * `PROTECTED_SPAN_RE` (the CARVE) is deliberately left per-line: it rounds the\n * other way, so at worst a multi-line code sample renders as escaped text.\n */\nfunction findInlineCodeRanges(source: string): Array<[number, number]> {\n const ranges: Array<[number, number]> = [];\n const len = source.length;\n let pos = 0;\n while (pos <= len) {\n // Grow one PARAGRAPH SEGMENT: the maximal run of non-blank lines starting\n // at or after `pos`. `segStart`/`segEnd` bound it; blank lines never enter.\n let segStart = -1;\n let segEnd = -1;\n while (pos <= len) {\n let end = source.indexOf('\\n', pos);\n if (end === -1) end = len;\n const blank = isBlankLine(source.slice(pos, end));\n if (blank && segStart !== -1) break;\n if (!blank) {\n if (segStart === -1) segStart = pos;\n segEnd = end;\n }\n pos = end === len ? len + 1 : end + 1;\n }\n if (segStart === -1) break;\n const lineStart = segStart;\n const lineEnd = segEnd;\n const runStart: number[] = [];\n const runLen: number[] = [];\n for (let i = lineStart; i < lineEnd; i++) {\n if (source.charCodeAt(i) !== BACKTICK_CODE) continue;\n let j = i + 1;\n while (j < lineEnd && source.charCodeAt(j) === BACKTICK_CODE) j++;\n runStart.push(i);\n runLen.push(j - i);\n i = j - 1;\n }\n const n = runStart.length;\n if (n > 0) {\n // suffMax[t] = longest run at or after t; 0 past the end.\n const suffMax = new Array(n + 1).fill(0);\n for (let t = n - 1; t >= 0; t--) suffMax[t] = Math.max(runLen[t], suffMax[t + 1]);\n let cursor = lineStart;\n let idx = 0;\n while (idx < n) {\n const runEnd = runStart[idx] + runLen[idx];\n // The scan resumes at the END of the previous match, which can land\n // MID-RUN — exactly as the global regex's `lastIndex` did. The\n // REMAINDER of the run is then an opener in its own right (`` `a`` ``\n // matches twice), so clamp rather than skip.\n if (runEnd <= cursor) {\n idx++;\n continue;\n }\n const p = Math.max(runStart[idx], cursor);\n const openLen = runEnd - p;\n // Largest closer length reachable via a LATER run, and via THIS one.\n const kLater = Math.min(openLen, suffMax[idx + 1]);\n const kSame = openLen >> 1;\n const k = Math.max(kLater, kSame);\n // No match is possible only when this is the last run and it is a\n // single backtick — every longer run closes on itself, so advancing by\n // one character (what the regex does) cannot find one either.\n if (k < 1) {\n cursor = runEnd;\n idx++;\n continue;\n }\n let q = kSame >= k ? p + k : -1;\n if (q === -1)\n for (let t = idx + 1; t < n; t++)\n if (runLen[t] >= k) {\n q = runStart[t];\n break;\n }\n ranges.push([p, q + k]);\n cursor = q + k;\n }\n }\n }\n return ranges;\n}\n\n/** Exported for the differential fuzz against the retired regex. */\nexport const __findInlineCodeRangesForTest = findInlineCodeRanges;\n\n/**\n * ASCII-ONLY case fold. `String.prototype.toLowerCase()` is NOT\n * length-preserving: U+0130 (Turkish dotted capital `İ`) expands to `i` +\n * U+0307 (1 code unit → 2). It is the only BMP character that does so, and it\n * is ordinary Turkish prose (`İstanbul`, `İzmir`) — so a message with enough\n * of them ahead of a ``, and left the opener LIVE\n * — reopening the RAWTEXT swallow the mask exists to close.\n *\n * Tag names are ASCII by definition (`TAG_LIKE_REGEX` only matches\n * `[a-zA-Z][a-zA-Z0-9-]*`), so folding ASCII alone loses nothing.\n * `buildCloserHaystack(src).length === src.length` is asserted over the whole\n * fixture corpus in the parity test — that invariant is the actual guard.\n */\nfunction foldAsciiCase(text: string): string {\n return text.replace(/[A-Z]/g, c => String.fromCharCode(c.charCodeAt(0) + 32));\n}\n\n/**\n * ---------------------------------------------------------------------------\n * MASK-ONLY code-region blanking (never the carve)\n * ---------------------------------------------------------------------------\n * All of the blanking passes below share one contract:\n *\n * - they SCAN `source` (the folded but otherwise unmasked copy) and APPLY the\n * resulting ranges to `masked`. That split is LOAD-BEARING: the inline-code\n * pass chews a pair of backticks off an unclosed ```` ``` ```` opener (the\n * opener run gives back backticks until a single one matches the next one as\n * its closer), so a fence scan over the masked copy sees no fence at all. Both\n * strings have identical indices, so offsets transfer verbatim.\n * `blankComments` is the ONE deliberate exception (it is fed the masked\n * copy, and runs last) — see its docblock for why the reasoning inverts.\n * - they are LENGTH-PRESERVING (every non-newline char in a range becomes a\n * space), because `escapeOutsideFences` indexes the mask with offsets it\n * computed from the ORIGINAL text.\n * - they fail CLOSED. Blanking too much can only make `hasLaterCloser` return\n * false, i.e. ESCAPE a RAWTEXT opener that could have stayed live; blanking\n * too little leaves a prose `` stayed\n * in the haystack and the opener above it stayed live, in ten spellings).\n * These two tables have caught six literally-false or missing claims across\n * six rounds; they are the instrument, and the round that skipped them is the\n * round that regressed. Filling them in is not documentation, it is the audit.\n *\n * blankLinkDefinitions\n * R no `[` on the line / `LINK_DEF_OPEN_RE` fails → not a definition line.\n * R `\\[^` (GFM footnote), REFERENCED → BLOCK-parsed body, may\n * hold real HTML (r19).\n * Only when the label is\n * REFERENCED: r22 found\n * the decline fail-OPEN\n * for the unreferenced\n * case, which\n * `blankUnreferencedFootnotes`\n * now blanks whole.\n * R `findLabelClose`: `]` not followed by `:` → shortcut reference or\n * plain text; remark\n * EMITS it (the same\n * exclusion\n * `blankBracketLabels`\n * documents).\n * R `findLabelClose`: unescaped `[` in the label → CommonMark rejects the\n * label → paragraph text.\n * R `findLabelClose`: paragraph bound, no `]:` → an ordinary\n * `[`-leading prose\n * paragraph.\n * R `parseDestOnLine` -1 (angle dest unclosed) → no line ending allowed\n * in `<…>`, and a bare\n * dest may not start with\n * `<` → not a definition.\n * R `parseDefTail`/`parseTitleTail` `decline` → trailing content, or a\n * title neither\n * space-separated nor\n * delimiter-opened →\n * remark reads a\n * PARAGRAPH. On the\n * OPENER line this\n * unwinds the WHOLE\n * construct (nothing is\n * blanked). On a\n * CONTINUATION line it\n * splits in TWO, and the\n * old single sentence\n * was true of only one\n * (r22):\n * · after `needTitle`\n * the definition WAS\n * already complete\n * (a title is\n * optional), so\n * stopping is exact;\n * · after `needDest`\n * it was NOT — with\n * no parseable\n * destination remark\n * reads the whole run\n * as a PARAGRAPH —\n * and lines\n * `i..close.line`\n * are ALREADY blanked\n * by the committed\n * loop. So this exit\n * OVER-blanks the\n * label lines; safe\n * because\n * over-blanking only\n * hides closers.\n * C `openTitle` (title opens, never closes) → BLANK to the paragraph\n * bound.\n * C end of `lines` / blank line while continuing → everything up to the\n * bound is already\n * blanked.\n * (no length cap exists in this pass at all)\n *\n * blankInlineLinkPayloads / parseInlineLinkPayload\n * C `q >= limit`, input REMAINS past the cap → returns `limit`, and\n * the caller widens to\n * `paragraphEnd` (r20).\n * R `q >= limit` because the INPUT IS EXHAUSTED → returns -1. Nothing\n * closes the payload and\n * nothing will, so remark\n * reads text too. Split\n * out in r22: it used to\n * share the cap exit, so\n * the ordinary STREAMING\n * tail `see [a](/x`\n * blanked its paragraph\n * and flickered.\n * R angle dest not closed before `\\n`/end → CommonMark forbids a\n * line ending in `<…>`.\n * R bare dest with unbalanced `(` → not a link → text.\n * R no `)` where the payload must end → not a link → text.\n * - `s[q] !== close` after the title loop → UNREACHABLE: the loop\n * exits only on the\n * closer or on `q >=\n * limit`, and the latter\n * returns `overflow`\n * first.\n *\n * blankUnreferencedFootnotes (round 23 — the entry round 22 never wrote)\n * R `masked.indexOf('[^') === -1` (whole-pass skip) → the document contains\n * no footnote SPELLING at\n * all, so there is nothing\n * to blank. Exact.\n * R `FOOTNOTE_DEF_OPEN_RE` fails / no `:` after the\n * label / `footnoteLabelEnd` -1 on the OPENER → not a definition line;\n * remark reads a paragraph\n * and any closer on it is\n * REAL.\n * R label IS referenced (in the REF-MASK) → round 19's case:\n * remark keeps the\n * definition, its body is\n * BLOCK-parsed and may\n * hold real HTML.\n * C `footnoteLabelEnd === -1` mid-line → `break` → abandons the REST OF\n * THE LINE's references.\n * Fail-CLOSED (fewer\n * references ⇒ more\n * definitions blanked),\n * but note the shape it\n * gives up on: a line\n * `[^x[ … [^f]` silently\n * stops counting at the\n * voided label, so a REAL\n * `[^f]` after it can be\n * missed and its\n * definition over-blanked\n * into escaped source\n * (cosmetic).\n * C body walk `break` on a SECOND definition line → the body ended; the\n * neighbour is blanked (or\n * not) on its OWN merits.\n * C body walk `break` on a de-indented line after a\n * blank one → GFM's own body bound.\n * (both body `break`s only SHORTEN the blanked range, i.e. leave MORE\n * haystack visible — the same direction as declining the definition\n * entirely, which is round 19's shipped behaviour, never a new hole)\n * (no length cap exists in this pass at all)\n *\n * blankBracketLabels\n * R no `[` in the document → no bracket construct.\n * R `]` with an empty stack → closes nothing.\n * - no length cap and no parse that can fail: the walk is total over the\n * document and crosses newlines, so it has NO give-up path to classify.\n *\n * WHICH LINES EACH PASS CLAIMS, AND AT WHAT COLUMN:\n *\n * findInlineCodeRanges — EVERY line, at column 0 of its PARAGRAPH SEGMENT\n * (a maximal run of non-blank lines). Container-agnostic: backtick runs are\n * matched with no column or prefix anchoring, so a `> ` / indent prefix is\n * ordinary text between ticks. Spans CROSS line breaks (round 18) and stop\n * at a paragraph break, which is exactly CommonMark's bound.\n * blankFencedRegions — every line of the run it is GIVEN, at that run's\n * column (the caller cut it). Absolute-column-limited by `FENCE_RE`'s 0..3\n * indent cap, which is WHY the container passes must re-cut and re-run it.\n * blankIndentedCode — every line of the run it is given, at that run's\n * column, with a list-content-column stack for the +4 threshold.\n * blankLinkDefinitions — EVERY line, in TWO dimensions that must both be\n * stated, because round 21 found the entry true of the first and silently\n * false of the second.\n * COLUMN: at column 0 AND at the column its own prefix reaches.\n * `LINK_DEF_CONTAINER_PREFIX` absorbs a blockquote run and AT MOST ONE\n * list marker, so the top-level call covers a definition at nesting depth\n * 0 or 1 directly. DEEPER nesting (`- - [a]: …`) is NOT covered by the\n * top-level call — round 19's corrected entry — and is reached only\n * because both container passes re-run this pass on their stripped runs,\n * and `blankListItemCode` re-cuts nested markers by recursing into\n * ITSELF. That re-cut is load-bearing, not redundancy.\n * SHAPE: what the label, destination and title may CONTAIN — the\n * dimension the old wording never mentioned, so five ESCAPED-delimiter\n * spellings and five MULTI-LINE spellings were \"covered\" by an entry that\n * had not examined them. The pass is now a CHARACTER PARSER, not a line\n * regex: `\\` + one character is consumed as a unit EVERYWHERE (so a\n * title may hold `\\\"` / `\\'` / `\\)` and a label `\\]`), the LABEL may\n * span lines up to the paragraph bound, and an unterminated TITLE is\n * blanked to that same bound. There is no length cap of any kind. What it\n * does NOT claim, and why, is on the exits themselves (see below).\n * blankUnreferencedFootnotes — EVERY line, container-agnostic and at ANY\n * depth: `FOOTNOTE_DEF_OPEN_RE`'s own prefix absorbs a blockquote run plus\n * ANY NUMBER of list markers, so unlike `blankLinkDefinitions` this pass\n * needs no container re-cut — and could not use one, because its reference\n * set is document-GLOBAL and a stripped run cannot see it. Exactly ONE\n * top-level call. No length cap of any kind.\n * IT READS TWO SOURCES, and that split is the security-load-bearing part\n * (round 23):\n * DEFINITIONS from the current MASK — a definition an earlier pass hid is\n * not blanked, which leaves it in the haystack (round 19's direction).\n * REFERENCES from a SEPARATE, MORE-BLANKED copy (`footnoteReferenceMask`),\n * because every region remark consumes into an ATTRIBUTE or drops — image\n * alt, full-reference label, inline link title / angle destination, HTML\n * comment, raw HTML block, inline tag attribute, autolink — yields a\n * PHANTOM reference, and a phantom keeps a dropped definition (and its\n * ``) in the haystack: fail-OPEN, reproduced live in ten\n * spellings. Counting FEWER references only blanks MORE, so that copy may\n * over-blank freely.\n * CLAIMED BODY: the label line, its lazy paragraph continuations, and\n * further blocks indented >= 4 columns past the blockquote run.\n * blankInlineLinkPayloads — EVERY inline link/image payload in the document,\n * container-agnostic: the scan is anchored on the `](` bigram with no column\n * or prefix anchoring, so a container prefix is ordinary text ahead of it.\n * Claims ONLY the `(…)` payload — never the `[…]` text of an INLINE LINK,\n * which is inline-parsed and reaches the document as HTML. Its cap\n * (`INLINE_LINK_PAYLOAD_MAX`) BLANKS THROUGH rather than declining; only an\n * unparseable SHAPE declines (round 20).\n * blankBracketLabels — EVERY `[…]` group in the document whose text remark\n * consumes into an attribute or an identifier: an image's alt (`[` preceded\n * by `!`), the second group of a `][` adjacency (a full reference's label),\n * the first group of a `][]` adjacency (a collapsed reference's identifier),\n * and a footnote label (`[^…]`, reference AND definition). Container-\n * agnostic: one left-to-right bracket walk, no column or prefix anchoring.\n * Claims NEITHER an inline link's `[…]` NOR a bare shortcut reference's —\n * remark emits both as HTML, so a closer there is real (round 20). The\n * `][` / `][]` adjacency is compared PER NESTING DEPTH (round 23 — a single\n * `prev` let a nested group clobber the sibling it had to be compared with,\n * so `[txt][[^f]]`'s label was never claimed). Its ONE option,\n * `{ footnoteLabels: false }`, is for `footnoteReferenceMask` only.\n * blankComments — EVERY line, container-agnostic: `HTML_COMMENT_RE` is\n * `[\\s\\S]`-based and anchored nowhere, so a comment matches straight through\n * any prefix. Runs LAST, over the masked copy (see its docblock).\n * blankQuotedCode — supplies runs cut at the BLOCKQUOTE content column,\n * for every maximal run of quote-prefixed lines, INCLUDING the line that\n * opens the quote (the prefix regex matches it like any other).\n * blankListItemCode — supplies runs cut at the LIST-ITEM content column\n * for EVERY line inside a list item at ANY content column >= 1 (round 19 —\n * the gate used to be `>= 4` on the claim that \"below column 4 the top-level\n * passes already cover the line at the right column\", which is true of a\n * CONTINUATION line and FALSE of the MARKER line: at content column 2 or 3\n * the marker line is examined only at column 0, where the leading `- ` /\n * `1. ` is not whitespace and `FENCE_RE` cannot match). Includes THE MARKER\n * LINE ITSELF (round 18) and re-cuts NESTED markers by recursing into itself\n * (round 19), since `LIST_MARKER_RE` matches only the FIRST marker on a\n * line.\n *\n * The two container passes call each other AND `blankListItemCode` calls itself,\n * and all of them call the fence + indented + link-definition passes, so a line\n * nested in any order and any DEPTH of containers is eventually cut to its own\n * content column. That composition is a MEANS to the invariant above, not a\n * substitute for it. When adding a pass or a container, the question to answer\n * is \"which lines does it claim, at which column, and is any line now claimed by\n * nobody\" — not \"does the call graph look symmetric\".\n */\n\n/**\n * Length-preserving blank of MANY ranges in one pass. Ranges must be\n * non-overlapping and ascending.\n *\n * THE ONLY BLANKING PRIMITIVE (round 18 — performance). There used to be a\n * single-range `blankRange` beside it, and `blankIndentedCode` /\n * `blankFencedRegions` / `blankComments` each folded the document through it\n * ONCE PER LINE OR REGION. Every call rebuilds the entire string, so masking an\n * all-indented-code document was QUADRATIC — measured on\n * `__buildCloserHaystackForTest`: 37 KB → 6 ms, 151 KB → 178 ms, 389 KB →\n * 1127 ms, 989 KB → 3753 ms (2.5x input ⇒ ~6x time), and the two container\n * passes re-run both over every nested run, multiplying the constant. A ~400 KB\n * KB article or release-notes page — all of which go through this renderer —\n * blocked the main thread for over a second. Every pass now COLLECTS ranges and\n * applies them here exactly once, which is what the inline pass already did.\n * After, same four sizes and same harness: 2 ms / 5 ms / 12 ms / 28 ms — dead\n * linear at ~28 ns/char, a 134x improvement at 989 KB.\n *\n * Do not reintroduce a per-range helper; a pass that blanks in a loop is the\n * regression.\n */\nfunction blankRanges(masked: string, ranges: Array<[number, number]>): string {\n if (ranges.length === 0) return masked;\n const parts: string[] = [];\n let cursor = 0;\n for (const [from, to] of ranges) {\n parts.push(masked.slice(cursor, from), masked.slice(from, to).replace(/[^\\n]/g, ' '));\n cursor = to;\n }\n parts.push(masked.slice(cursor));\n return parts.join('');\n}\n\n/** One scannable line: where it starts, and (for container-nested scans) where\n * its scanned content starts once the container prefix is stripped. */\ninterface MaskLine {\n start: number;\n contentStart: number;\n content: string;\n}\n\nfunction toMaskLines(source: string): MaskLine[] {\n const out: MaskLine[] = [];\n let offset = 0;\n for (const line of source.split('\\n')) {\n out.push({ start: offset, contentStart: offset, content: line });\n offset += line.length + 1;\n }\n return out;\n}\n\n/**\n * Blank every FENCED region in a line run, using the real CommonMark fence\n * state machine (`createFenceTracker`) rather than a regex.\n *\n * This replaces the old `blankUnclosedFence` + `PROTECTED_SPAN_RE` fence\n * alternative and subsumes both:\n * - a CLOSED fence is blanked from its opener line through its closer line;\n * - an EOF-terminated fence is blanked from its opener line to the end of the\n * run (the case `blankUnclosedFence` covered);\n * - a would-be closer carrying an INFO STRING (```` ```html ````) no longer\n * ends the region, because the tracker applies CommonMark's rule that a\n * closer may not have one. `PROTECTED_SPAN_RE` did end the span there, so\n * ` ```js … ```html\\n\\n``` ` left the `` unmasked and\n * a prose opener above it stayed live.\n */\nfunction blankFencedRegions(masked: string, lines: MaskLine[]): string {\n const fences = createFenceTracker();\n const ranges: Array<[number, number]> = [];\n let openStart: number | null = null;\n let lastEnd = 0;\n for (const line of lines) {\n const role = fences.push(line.content);\n lastEnd = line.contentStart + line.content.length;\n if (role === 'open') openStart = line.start;\n else if (role === 'close' && openStart !== null) {\n ranges.push([openStart, lastEnd]);\n openStart = null;\n }\n }\n if (openStart !== null) ranges.push([openStart, lastEnd]);\n return blankRanges(masked, ranges);\n}\n\n/**\n * Blank INDENTED code blocks. A `` written as an indented code\n * sample is code, not a closer — but `FENCE_RE` deliberately caps fence indent\n * at 3 spaces, so the tracker never sees these lines.\n *\n * The threshold is LIST-AWARE, not a flat 4 columns. CommonMark measures\n * indented code from the enclosing list item's CONTENT column, so under\n * `1. ` (content column 4) a 4-space line is a paragraph continuation, not\n * code — and `\"1. Here is a form:\\n\\n \\n\"` had\n * its closer blanked, `hasLaterCloser` returned false, and a perfectly real\n * element got escaped. A numbered list containing markup is a very ordinary\n * chat answer, so \"fail closed\" is not a good enough excuse here.\n *\n * The walk mirrors `blankQuotedCode`'s line-state approach: a stack of open\n * list content columns, `code` meaning `indent >= top + 4`. Blank lines keep\n * the state (a list item survives them); a line indented below the top of the\n * stack pops it. A line indented past the code threshold is treated as code\n * BEFORE it is considered as a list marker.\n *\n * SCAN-SOURCE INVERSION (same reasoning as `blankComments`, and NOT the shared\n * contract): the caller must pass lines re-derived from the CURRENT mask, not\n * from `folded`. Fence content is already blanked by `blankFencedRegions`, but\n * that only holds for WRITING the mask — a walk over `folded` still SEES those\n * lines, so a `- x` written inside a fence pushed a content column of 2 and a\n * later top-level column-4 indented-code line then failed `indent >= top + 4`,\n * went unblanked, and its code-sample `` kept a prose opener LIVE.\n * Over the masked copy those lines are all spaces, hit the `isBlankLine`\n * continue, preserve list state and push no bogus column.\n *\n * CONTENT-COLUMN CLAMP: CommonMark clamps an item's content column to\n * `markerEnd + 1` when the first block starts MORE than 4 spaces after the\n * marker — the remainder is indented code INSIDE the item. Taking the literal\n * column instead meant `-` + six spaces raised the threshold to 11, so a\n * column-7 `` code sample was not blanked.\n *\n * KNOWN OMISSION (deliberate, fail-CLOSED): there is NO paragraph state. Under\n * CommonMark indented code cannot interrupt a paragraph, so a LAZY\n * continuation line — `'Here is a form: \\n'`\n * — is paragraph text, yet this walk blanks it as code and the (real, properly\n * closed) element is escaped to visible source. That is cosmetic, and the\n * option NOT taken here is the fail-OPEN direction: skipping the code test in\n * paragraph state means blanking LESS, i.e. more closers visible to\n * `hasLaterCloser` and more openers left live. The list-awareness above was\n * worth its risk because it is unconditional over an entire list item; this\n * one is not, so it is documented rather than implemented.\n */\nconst LIST_MARKER_RE = /^([ \\t]*)(?:[-*+]|\\d{1,9}[.)])([ \\t]+)(?=\\S)/;\n\n/** Visual column of `upTo` chars of `line`, expanding tabs to 4-col stops. */\nfunction visualColumn(line: string, upTo: number): number {\n let col = 0;\n for (let i = 0; i < upTo; i++) col = line[i] === '\\t' ? col + 4 - (col % 4) : col + 1;\n return col;\n}\n\nfunction leadingIndent(line: string): number {\n // `[ \\t]*` is anchored and nullable, so it always matches (possibly empty);\n // `?? ''` is the same zero-length match the engine would return, expressed\n // without asserting on `exec`'s nullable result.\n const ws = /^[ \\t]*/.exec(line)?.[0] ?? '';\n return visualColumn(line, ws.length);\n}\n\n/** Character index at which `line` reaches visual column `col`, or -1 when the\n * column falls INSIDE a tab (no exact character boundary) or the line is too\n * short. The mask is length-preserving, so a container prefix can only ever be\n * cut at a character boundary; -1 makes the caller decline to strip, which\n * leaves the line looking indented and therefore blanks MORE (fail-CLOSED). */\nfunction charIndexAtColumn(line: string, col: number): number {\n let c = 0;\n for (let i = 0; i < line.length; i++) {\n if (c === col) return i;\n c = line[i] === '\\t' ? c + 4 - (c % 4) : c + 1;\n if (c > col) return -1;\n }\n return c === col ? line.length : -1;\n}\n\nfunction blankIndentedCode(masked: string, lines: MaskLine[]): string {\n const listContentCols: number[] = [];\n const ranges: Array<[number, number]> = [];\n for (const line of lines) {\n // CommonMark's blank line (spaces/tabs, `\\r`-tolerant), NOT `trim()` — see\n // `isBlankLine`. An NBSP-only line is CONTENT, and skipping it here as\n // \"blank\" is the same one-character reopening documented there.\n if (isBlankLine(line.content)) continue;\n const indent = leadingIndent(line.content);\n const top = listContentCols.length ? listContentCols[listContentCols.length - 1] : 0;\n if (indent >= top + 4) {\n ranges.push([line.contentStart, line.contentStart + line.content.length]);\n continue;\n }\n while (listContentCols.length && indent < listContentCols[listContentCols.length - 1]) listContentCols.pop();\n const marker = LIST_MARKER_RE.exec(line.content);\n if (marker) {\n const markerEndCol = visualColumn(line.content, marker[0].length - marker[2].length);\n const contentCol = visualColumn(line.content, marker[0].length);\n listContentCols.push(contentCol - markerEndCol > 4 ? markerEndCol + 1 : contentCol);\n }\n }\n return blankRanges(masked, ranges);\n}\n\n/** Re-derive scannable lines from the CURRENT mask, preserving each line's\n * original `start` / `contentStart` (every pass is length-preserving, so the\n * offsets transfer verbatim). See `blankIndentedCode`'s SCAN-SOURCE\n * INVERSION. */\nfunction remapToMask(masked: string, lines: MaskLine[]): MaskLine[] {\n return lines.map(line => ({\n ...line,\n content: masked.slice(line.contentStart, line.contentStart + line.content.length),\n }));\n}\n\n/**\n * Blank HTML COMMENTS. `` is not a closer — parse5 consumes\n * it as comment data — yet it satisfied the raw substring search. The\n * unterminated form is blanked to EOF, matching what the tokenizer does with a\n * comment that never ends (and, again, failing closed).\n *\n * SCAN-SOURCE EXCEPTION: this is the ONE pass fed the already-masked copy\n * rather than the unmasked one. The shared contract exists because\n * the inline-code pass chews backticks off an unclosed fence opener and would\n * blind a fence scan — but for comments the reasoning INVERTS: a `|` is dropped entirely. LAST, as everywhere\n * else, because it scans the masked copy. (The pipeline's own comment pass\n * still runs last over the REAL mask; this is a separate string.)\n *\n * OVER-BLANKING HERE IS FREE: fewer references means more definitions look\n * unreferenced, which blanks MORE of the haystack — the fail-CLOSED direction.\n * That is why this copy may apply passes out of the pipeline's order and may\n * use a block model that only approximates remark's.\n */\n/** AUTOLINKS, both spellings, DELIBERATELY over-wide (this regex is only ever\n * applied to the reference-counting copy, where over-blanking is free): a\n * CommonMark `` autolink and a GFM LITERAL autolink both become an\n * `href`, so `` and `https://e.example/x[^f]y` are\n * phantom references — each reproduced a live iframe. It stops at whitespace,\n * so an ordinary `see https://e.example [^f]` keeps its REAL reference. Email\n * autolinks are deliberately absent: a `[` voids the email shape, so `[^f]`\n * inside one IS a real reference (verified — remark emits the footnote). */\nconst AUTOLINK_LIKE_RE = /<[a-z][a-z0-9+.-]{1,31}:[^\\s<>]*>|(?:https?:\\/\\/|www\\.)[^\\s<]*/gi;\n\nfunction footnoteReferenceMask(masked: string, folded: string): string {\n let ref = blankInlineLinkPayloads(masked, folded);\n ref = blankBracketLabels(ref, folded, { footnoteLabels: false });\n ref = blankRanges(ref, mergeRanges(computeHtmlBlockRanges(folded).map(({ start, end }) => [start, end])));\n ref = blankComments(ref, ref);\n ref = ref.replace(AUTOLINK_LIKE_RE, m => ' '.repeat(m.length));\n return blankTagAttributes(ref);\n}\n\n/** Blank the ATTRIBUTE RUN of every tag-like span, length-preserving. Blanking\n * the WHOLE tag would blank real `