Something went wrong. Try again.
source dump of claude code forked from oppi.li/claude-code
Something went wrong. Try again.
147 kB · 834 lines
TSX
at main
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834import { c as _c } from "react/compiler-runtime";import { feature } from 'bun:bundle';import chalk from 'chalk';import type { UUID } from 'crypto';import type { RefObject } from 'react';import * as React from 'react';import { useCallback, useEffect, useMemo, useRef, useState } from 'react';import { every } from 'src/utils/set.js';import { getIsRemoteMode } from '../bootstrap/state.js';import type { Command } from '../commands.js';import { BLACK_CIRCLE } from '../constants/figures.js';import { useTerminalSize } from '../hooks/useTerminalSize.js';import type { ScrollBoxHandle } from '../ink/components/ScrollBox.js';import { useTerminalNotification } from '../ink/useTerminalNotification.js';import { Box, Text } from '../ink.js';import { useShortcutDisplay } from '../keybindings/useShortcutDisplay.js';import type { Screen } from '../screens/REPL.js';import type { Tools } from '../Tool.js';import { findToolByName } from '../Tool.js';import type { AgentDefinitionsResult } from '../tools/AgentTool/loadAgentsDir.js';import type { Message as MessageType, NormalizedMessage, ProgressMessage as ProgressMessageType, RenderableMessage } from '../types/message.js';import { type AdvisorBlock, isAdvisorBlock } from '../utils/advisor.js';import { collapseBackgroundBashNotifications } from '../utils/collapseBackgroundBashNotifications.js';import { collapseHookSummaries } from '../utils/collapseHookSummaries.js';import { collapseReadSearchGroups } from '../utils/collapseReadSearch.js';import { collapseTeammateShutdowns } from '../utils/collapseTeammateShutdowns.js';import { getGlobalConfig } from '../utils/config.js';import { isEnvTruthy } from '../utils/envUtils.js';import { isFullscreenEnvEnabled } from '../utils/fullscreen.js';import { applyGrouping } from '../utils/groupToolUses.js';import { buildMessageLookups, createAssistantMessage, deriveUUID, getMessagesAfterCompactBoundary, getToolUseID, getToolUseIDs, hasUnresolvedHooksFromLookup, isNotEmptyMessage, normalizeMessages, reorderMessagesInUI, type StreamingThinking, type StreamingToolUse, shouldShowUserMessage } from '../utils/messages.js';import { plural } from '../utils/stringUtils.js';import { renderableSearchText } from '../utils/transcriptSearch.js';import { Divider } from './design-system/Divider.js';import type { UnseenDivider } from './FullscreenLayout.js';import { LogoV2 } from './LogoV2/LogoV2.js';import { StreamingMarkdown } from './Markdown.js';import { hasContentAfterIndex, MessageRow } from './MessageRow.js';import { InVirtualListContext, type MessageActionsNav, MessageActionsSelectedContext, type MessageActionsState } from './messageActions.js';import { AssistantThinkingMessage } from './messages/AssistantThinkingMessage.js';import { isNullRenderingAttachment } from './messages/nullRenderingAttachments.js';import { OffscreenFreeze } from './OffscreenFreeze.js';import type { ToolUseConfirm } from './permissions/PermissionRequest.js';import { StatusNotices } from './StatusNotices.js';import type { JumpHandle } from './VirtualMessageList.js';
// Memoed logo header: this box is the FIRST sibling before all MessageRows// in main-screen mode. If it becomes dirty on every Messages re-render,// renderChildren's seenDirtyChild cascade disables prevScreen (blit) for// ALL subsequent siblings — every MessageRow re-writes from scratch instead// of blitting. In long sessions (~2800 messages) this is 150K+ writes/frame// and pegs CPU at 100%. Memo on agentDefinitions so a new messages array// doesn't invalidate the logo subtree. LogoV2/StatusNotices internally// subscribe to useAppState/useSettings for their own updates.const LogoHeader = React.memo(function LogoHeader(t0) { const $ = _c(3); const { agentDefinitions } = t0; let t1; if ($[0] === Symbol.for("react.memo_cache_sentinel")) { t1 = <LogoV2 />; $[0] = t1; } else { t1 = $[0]; } let t2; if ($[1] !== agentDefinitions) { t2 = <OffscreenFreeze><Box flexDirection="column" gap={1}>{t1}<React.Suspense fallback={null}><StatusNotices agentDefinitions={agentDefinitions} /></React.Suspense></Box></OffscreenFreeze>; $[1] = agentDefinitions; $[2] = t2; } else { t2 = $[2]; } return t2;});
// Dead code elimination: conditional import for proactive mode/* eslint-disable @typescript-eslint/no-require-imports */const proactiveModule = feature('PROACTIVE') || feature('KAIROS') ? require('../proactive/index.js') : null;const BRIEF_TOOL_NAME: string | null = feature('KAIROS') || feature('KAIROS_BRIEF') ? (require('../tools/BriefTool/prompt.js') as typeof import('../tools/BriefTool/prompt.js')).BRIEF_TOOL_NAME : null;const SEND_USER_FILE_TOOL_NAME: string | null = feature('KAIROS') ? (require('../tools/SendUserFileTool/prompt.js') as typeof import('../tools/SendUserFileTool/prompt.js')).SEND_USER_FILE_TOOL_NAME : null;
/* eslint-enable @typescript-eslint/no-require-imports */import { VirtualMessageList } from './VirtualMessageList.js';
/** * In brief-only mode, filter messages to show ONLY Brief tool_use blocks, * their tool_results, and real user input. All assistant text is dropped — * if the model forgets to call Brief, the user sees nothing for that turn. * That's on the model to get right; the filter does not second-guess it. */export function filterForBriefTool<T extends { type: string; subtype?: string; isMeta?: boolean; isApiErrorMessage?: boolean; message?: { content: Array<{ type: string; name?: string; tool_use_id?: string; }>; }; attachment?: { type: string; isMeta?: boolean; origin?: unknown; commandMode?: string; };}>(messages: T[], briefToolNames: string[]): T[] { const nameSet = new Set(briefToolNames); // tool_use always precedes its tool_result in the array, so we can collect // IDs and match against them in a single pass. const briefToolUseIDs = new Set<string>(); return messages.filter(msg => { // System messages (attach confirmation, remote errors, compact boundaries) // must stay visible — dropping them leaves the viewer with no feedback. // Exception: api_metrics is per-turn debug noise (TTFT, config writes, // hook timing) that defeats the point of brief mode. Still visible in // transcript mode (ctrl+o) which bypasses this filter. if (msg.type === 'system') return msg.subtype !== 'api_metrics'; const block = msg.message?.content[0]; if (msg.type === 'assistant') { // API error messages (auth failures, rate limits, etc.) must stay visible if (msg.isApiErrorMessage) return true; // Keep Brief tool_use blocks (renders with standard tool call chrome, // and must be in the list so buildMessageLookups can resolve tool results) if (block?.type === 'tool_use' && block.name && nameSet.has(block.name)) { if ('id' in block) { briefToolUseIDs.add((block as { id: string; }).id); } return true; } return false; } if (msg.type === 'user') { if (block?.type === 'tool_result') { return block.tool_use_id !== undefined && briefToolUseIDs.has(block.tool_use_id); } // Real user input only — drop meta/tick messages. return !msg.isMeta; } if (msg.type === 'attachment') { // Human input drained mid-turn arrives as a queued_command attachment // (query.ts mid-chain drain → getQueuedCommandAttachments). Keep it — // it's what the user typed. commandMode === 'prompt' positively // identifies human-typed input; task-notification callers set // mode: 'task-notification' but not origin/isMeta, so the positive // commandMode check is required to exclude them. const att = msg.attachment; return att?.type === 'queued_command' && att.commandMode === 'prompt' && !att.isMeta && att.origin === undefined; } return false; });}
/** * Full-transcript companion to filterForBriefTool. When the Brief tool is * in use, the model's text output is redundant with the SendUserMessage * content it wrote right after — drop the text so only the SendUserMessage * block shows. Tool calls and their results stay visible. * * Per-turn: only drops text in turns that actually called Brief. If the * model forgets, text still shows — otherwise the user would see nothing. */export function dropTextInBriefTurns<T extends { type: string; isMeta?: boolean; message?: { content: Array<{ type: string; name?: string; }>; };}>(messages: T[], briefToolNames: string[]): T[] { const nameSet = new Set(briefToolNames); // First pass: find which turns (bounded by non-meta user messages) contain // a Brief tool_use. Tag each assistant text block with its turn index. const turnsWithBrief = new Set<number>(); const textIndexToTurn: number[] = []; let turn = 0; for (let i = 0; i < messages.length; i++) { const msg = messages[i]!; const block = msg.message?.content[0]; if (msg.type === 'user' && block?.type !== 'tool_result' && !msg.isMeta) { turn++; continue; } if (msg.type === 'assistant') { if (block?.type === 'text') { textIndexToTurn[i] = turn; } else if (block?.type === 'tool_use' && block.name && nameSet.has(block.name)) { turnsWithBrief.add(turn); } } } if (turnsWithBrief.size === 0) return messages; // Second pass: drop text blocks whose turn called Brief. return messages.filter((_, i) => { const t = textIndexToTurn[i]; return t === undefined || !turnsWithBrief.has(t); });}type Props = { messages: MessageType[]; tools: Tools; commands: Command[]; verbose: boolean; toolJSX: { jsx: React.ReactNode | null; shouldHidePromptInput: boolean; shouldContinueAnimation?: true; } | null; toolUseConfirmQueue: ToolUseConfirm[]; inProgressToolUseIDs: Set<string>; isMessageSelectorVisible: boolean; conversationId: string; screen: Screen; streamingToolUses: StreamingToolUse[]; showAllInTranscript?: boolean; agentDefinitions?: AgentDefinitionsResult; onOpenRateLimitOptions?: () => void; /** Hide the logo/header - used for subagent zoom view */ hideLogo?: boolean; isLoading: boolean; /** In transcript mode, hide all thinking blocks except the last one */ hidePastThinking?: boolean; /** Streaming thinking content (live updates, not frozen) */ streamingThinking?: StreamingThinking | null; /** Streaming text preview (rendered as last item so transition to final message is positionally seamless) */ streamingText?: string | null; /** When true, only show Brief tool output (hide everything else) */ isBriefOnly?: boolean; /** Fullscreen-mode "─── N new ───" divider. Renders before the first * renderableMessage derived from firstUnseenUuid (matched by the 24-char * prefix that deriveUUID preserves). */ unseenDivider?: UnseenDivider; /** Fullscreen-mode ScrollBox handle. Enables React-level virtualization when present. */ scrollRef?: RefObject<ScrollBoxHandle | null>; /** Fullscreen-mode: enable sticky-prompt tracking (writes via ScrollChromeContext). */ trackStickyPrompt?: boolean; /** Transcript search: jump-to-index + setSearchQuery/nextMatch/prevMatch. */ jumpRef?: RefObject<JumpHandle | null>; /** Transcript search: fires when match count/position changes. */ onSearchMatchesChange?: (count: number, current: number) => void; /** Paint an existing DOM subtree to fresh Screen, scan. Element comes * from the main tree (all real providers). Message-relative positions. */ scanElement?: (el: import('../ink/dom.js').DOMElement) => import('../ink/render-to-screen.js').MatchPosition[]; /** Position-based CURRENT highlight. positions stable (msg-relative), * rowOffset tracks scroll. null clears. */ setPositions?: (state: { positions: import('../ink/render-to-screen.js').MatchPosition[]; rowOffset: number; currentIdx: number; } | null) => void; /** Bypass MAX_MESSAGES_WITHOUT_VIRTUALIZATION. For one-shot headless renders * (e.g. /export via renderToString) where the memory concern doesn't apply * and the "already in scrollback" justification doesn't hold. */ disableRenderCap?: boolean; /** In-transcript cursor; expanded overrides verbose for selected message. */ cursor?: MessageActionsState | null; setCursor?: (cursor: MessageActionsState | null) => void; /** Passed through to VirtualMessageList (heightCache owns visibility). */ cursorNavRef?: React.Ref<MessageActionsNav>; /** Render only collapsed.slice(start, end). For chunked headless export * (streamRenderedMessages in exportRenderer.tsx): prep runs on the FULL * messages array so grouping/lookups are correct, but only this slice * chunk instead of the full session. The logo renders only for chunk 0 * (start === 0); later chunks are mid-stream continuations. * Measured Mar 2026: 538-msg session, 20 slices → −55% plateau RSS. */ renderRange?: readonly [start: number, end: number];};const MAX_MESSAGES_TO_SHOW_IN_TRANSCRIPT_MODE = 30;
// Safety cap for the non-virtualized render path (fullscreen off or// explicitly disabled). Ink mounts a full fiber tree per message (~250 KB// RSS each); yoga layout height grows unbounded; the screen buffer is sized// to fit every line. At ~2000 messages this is ~3000-line screens, ~500 MB// of fibers, and per-frame write costs that push the process into a GC// death spiral (observed: 59 GB RSS, 14k mmap/munmap/sec). Content dropped// from this slice has already been printed to terminal scrollback — users// can still scroll up natively. VirtualMessageList (the default ant path)// bypasses this cap entirely. Headless one-shot renders (e.g. /export)// pass disableRenderCap to opt out — they have no scrollback and the// memory concern doesn't apply to renderToString.//// The slice boundary is tracked as a UUID anchor, not a count-derived// index. Count-based slicing (slice(-200)) drops one message from the// front on every append, shifting scrollback content and forcing a full// terminal reset per turn (CC-941). Quantizing to 50-message steps// (CC-1154) helped but still shifted on compaction and collapse regrouping// since those change collapsed.length without adding messages. The UUID// anchor only advances when rendered count genuinely exceeds CAP+STEP —// immune to length churn from grouping/compaction (CC-1174).//// The anchor stores BOTH uuid and index. Some uuids are unstable between// renders: collapseHookSummaries derives the merged uuid from the first// summary in a group, but reorderMessagesInUI reshuffles hook adjacency// as tool results stream in, changing which summary is first. When the// uuid vanishes, falling back to the stored index (clamped) keeps the// slice roughly where it was instead of resetting to 0 — which would// jump from ~200 rendered messages to the full history, orphaning// in-progress badge snapshots in scrollback.const MAX_MESSAGES_WITHOUT_VIRTUALIZATION = 200;const MESSAGE_CAP_STEP = 50;export type SliceAnchor = { uuid: string; idx: number;} | null;
/** Exported for testing. Mutates anchorRef when the window needs to advance. */export function computeSliceStart(collapsed: ReadonlyArray<{ uuid: string;}>, anchorRef: { current: SliceAnchor;}, cap = MAX_MESSAGES_WITHOUT_VIRTUALIZATION, step = MESSAGE_CAP_STEP): number { const anchor = anchorRef.current; const anchorIdx = anchor ? collapsed.findIndex(m => m.uuid === anchor.uuid) : -1; // Anchor found → use it. Anchor lost → fall back to stored index // (clamped) so collapse-regrouping uuid churn doesn't reset to 0. let start = anchorIdx >= 0 ? anchorIdx : anchor ? Math.min(anchor.idx, Math.max(0, collapsed.length - cap)) : 0; if (collapsed.length - start > cap + step) { start = collapsed.length - cap; } // Refresh anchor from whatever lives at the current start — heals a // stale uuid after fallback and captures a new one after advancement. const msgAtStart = collapsed[start]; if (msgAtStart && (anchor?.uuid !== msgAtStart.uuid || anchor.idx !== start)) { anchorRef.current = { uuid: msgAtStart.uuid, idx: start }; } else if (!msgAtStart && anchor) { anchorRef.current = null; } return start;}const MessagesImpl = ({ messages, tools, commands, verbose, toolJSX, toolUseConfirmQueue, inProgressToolUseIDs, isMessageSelectorVisible, conversationId, screen, streamingToolUses, showAllInTranscript = false, agentDefinitions, onOpenRateLimitOptions, hideLogo = false, isLoading, hidePastThinking = false, streamingThinking, streamingText, isBriefOnly = false, unseenDivider, scrollRef, trackStickyPrompt, jumpRef, onSearchMatchesChange, scanElement, setPositions, disableRenderCap = false, cursor = null, setCursor, cursorNavRef, renderRange}: Props): React.ReactNode => { const { columns } = useTerminalSize(); const toggleShowAllShortcut = useShortcutDisplay('transcript:toggleShowAll', 'Transcript', 'Ctrl+E'); const normalizedMessages = useMemo(() => normalizeMessages(messages).filter(isNotEmptyMessage), [messages]);
// Check if streaming thinking should be visible (streaming or within 30s timeout) const isStreamingThinkingVisible = useMemo(() => { if (!streamingThinking) return false; if (streamingThinking.isStreaming) return true; if (streamingThinking.streamingEndedAt) { return Date.now() - streamingThinking.streamingEndedAt < 30000; } return false; }, [streamingThinking]);
// Find the last thinking block (message UUID + content index) for hiding past thinking in transcript mode // When streaming thinking is visible, use a special ID that won't match any completed thinking block // With adaptive thinking, only consider thinking blocks from the current turn and stop searching once we // hit the last user message. const lastThinkingBlockId = useMemo(() => { if (!hidePastThinking) return null; // If streaming thinking is visible, hide all completed thinking blocks by using a non-matching ID if (isStreamingThinkingVisible) return 'streaming'; // Iterate backwards to find the last message with a thinking block for (let i = normalizedMessages.length - 1; i >= 0; i--) { const msg = normalizedMessages[i]; if (msg?.type === 'assistant') { const content = msg.message.content; // Find the last thinking block in this message for (let j = content.length - 1; j >= 0; j--) { if (content[j]?.type === 'thinking') { return `${msg.uuid}:${j}`; } } } else if (msg?.type === 'user') { const hasToolResult = msg.message.content.some(block => block.type === 'tool_result'); if (!hasToolResult) { // Reached a previous user turn so don't show stale thinking from before return 'no-thinking'; } } } return null; }, [normalizedMessages, hidePastThinking, isStreamingThinkingVisible]);
// Find the latest user bash output message (from ! commands) // This allows us to show full output for the most recent bash command const latestBashOutputUUID = useMemo(() => { // Iterate backwards to find the last user message with bash output for (let i_0 = normalizedMessages.length - 1; i_0 >= 0; i_0--) { const msg_0 = normalizedMessages[i_0]; if (msg_0?.type === 'user') { const content_0 = msg_0.message.content; // Check if any text content is bash output for (const block_0 of content_0) { if (block_0.type === 'text') { const text = block_0.text; if (text.startsWith('<bash-stdout') || text.startsWith('<bash-stderr')) { return msg_0.uuid; } } } } } return null; }, [normalizedMessages]);
// streamingToolUses updates on every input_json_delta while normalizedMessages // stays stable — precompute the Set so the filter is O(k) not O(n×k) per chunk. const normalizedToolUseIDs = useMemo(() => getToolUseIDs(normalizedMessages), [normalizedMessages]); const streamingToolUsesWithoutInProgress = useMemo(() => streamingToolUses.filter(stu => !inProgressToolUseIDs.has(stu.contentBlock.id) && !normalizedToolUseIDs.has(stu.contentBlock.id)), [streamingToolUses, inProgressToolUseIDs, normalizedToolUseIDs]); const syntheticStreamingToolUseMessages = useMemo(() => streamingToolUsesWithoutInProgress.flatMap(streamingToolUse => { const msg_1 = createAssistantMessage({ content: [streamingToolUse.contentBlock] }); // Override randomUUID with deterministic value derived from content // block ID to prevent React key changes on every memo recomputation. // Same class of bug fixed in normalizeMessages (commit 383326e613): // fresh randomUUID → unstable React keys → component remounts → // Ink rendering corruption (overlapping text from stale DOM nodes). msg_1.uuid = deriveUUID(streamingToolUse.contentBlock.id as UUID, 0); return normalizeMessages([msg_1]); }), [streamingToolUsesWithoutInProgress]); const isTranscriptMode = screen === 'transcript'; // Hoisted to mount-time — this component re-renders on every scroll. const disableVirtualScroll = useMemo(() => isEnvTruthy(process.env.CLAUDE_CODE_DISABLE_VIRTUAL_SCROLL), []); // Virtual scroll replaces the transcript cap: everything is scrollable and // memory is bounded by the mounted-item count, not the total. scrollRef is // only passed when isFullscreenEnvEnabled() is true (REPL.tsx gates it), // so scrollRef's presence is the signal. const virtualScrollRuntimeGate = scrollRef != null && !disableVirtualScroll; const shouldTruncate = isTranscriptMode && !showAllInTranscript && !virtualScrollRuntimeGate;
// Anchor for the first rendered message in the non-virtualized cap slice. // Monotonic advance only — mutation during render is idempotent (safe // under StrictMode double-render). See MAX_MESSAGES_WITHOUT_VIRTUALIZATION // comment above for why this replaced count-based slicing. const sliceAnchorRef = useRef<SliceAnchor>(null);
// Expensive message transforms — filter, reorder, group, collapse, lookups. // All O(n) over 27k messages. Split from the renderRange slice so scrolling // (which only changes renderRange) doesn't re-run these. Previously this // useMemo included renderRange → every scroll rebuilt 6 Maps over 27k // messages + 4 filter/map passes = ~50ms alloc per scroll → GC pressure → // 100-173ms stop-the-world pauses on the 1GB heap. const { collapsed: collapsed_0, lookups: lookups_0, hasTruncatedMessages: hasTruncatedMessages_0, hiddenMessageCount: hiddenMessageCount_0 } = useMemo(() => { // In fullscreen mode the alt buffer has no native scrollback, so the // compact-boundary filter just hides history the ScrollBox could // otherwise scroll to. Main-screen mode keeps the filter — pre-compact // rows live above the viewport in native scrollback there, and // re-rendering them triggers full resets. // includeSnipped: UI rendering keeps snipped messages for scrollback // (this PR's core goal — full history in UI, filter only for the model). // Also avoids a UUID mismatch: normalizeMessages derives new UUIDs, so // projectSnippedView's check against original removedUuids would fail. const compactAwareMessages = verbose || isFullscreenEnvEnabled() ? normalizedMessages : getMessagesAfterCompactBoundary(normalizedMessages, { includeSnipped: true }); const messagesToShowNotTruncated = reorderMessagesInUI(compactAwareMessages.filter((msg_2): msg_2 is Exclude<NormalizedMessage, ProgressMessageType> => msg_2.type !== 'progress') // CC-724: drop attachment messages that AttachmentMessage renders as // null (hook_success, hook_additional_context, hook_cancelled, etc.) // BEFORE counting/slicing so they don't inflate the "N messages" // count in ctrl-o or consume slots in the 200-message render cap. .filter(msg_3 => !isNullRenderingAttachment(msg_3)).filter(_ => shouldShowUserMessage(_, isTranscriptMode)), syntheticStreamingToolUseMessages); // Three-tier filtering. Transcript mode (ctrl+o screen) is truly unfiltered. // Brief-only: SendUserMessage + user input only. Default: drop redundant // assistant text in turns where SendUserMessage was called (the model's // text is working-notes that duplicate the SendUserMessage content). const briefToolNames = [BRIEF_TOOL_NAME, SEND_USER_FILE_TOOL_NAME].filter((n): n is string => n !== null); // dropTextInBriefTurns should only trigger on SendUserMessage turns — // SendUserFile delivers a file without replacement text, so dropping // assistant text for file-only turns would leave the user with no context. const dropTextToolNames = [BRIEF_TOOL_NAME].filter((n_0): n_0 is string => n_0 !== null); const briefFiltered = briefToolNames.length > 0 && !isTranscriptMode ? isBriefOnly ? filterForBriefTool(messagesToShowNotTruncated, briefToolNames) : dropTextToolNames.length > 0 ? dropTextInBriefTurns(messagesToShowNotTruncated, dropTextToolNames) : messagesToShowNotTruncated : messagesToShowNotTruncated; const messagesToShow = shouldTruncate ? briefFiltered.slice(-MAX_MESSAGES_TO_SHOW_IN_TRANSCRIPT_MODE) : briefFiltered; const hasTruncatedMessages = shouldTruncate && briefFiltered.length > MAX_MESSAGES_TO_SHOW_IN_TRANSCRIPT_MODE; const { messages: groupedMessages } = applyGrouping(messagesToShow, tools, verbose); const collapsed = collapseBackgroundBashNotifications(collapseHookSummaries(collapseTeammateShutdowns(collapseReadSearchGroups(groupedMessages, tools))), verbose); const lookups = buildMessageLookups(normalizedMessages, messagesToShow); const hiddenMessageCount = messagesToShowNotTruncated.length - MAX_MESSAGES_TO_SHOW_IN_TRANSCRIPT_MODE; return { collapsed, lookups, hasTruncatedMessages, hiddenMessageCount }; }, [verbose, normalizedMessages, isTranscriptMode, syntheticStreamingToolUseMessages, shouldTruncate, tools, isBriefOnly]);
// Cheap slice — only runs when scroll range or slice config changes. const renderableMessages = useMemo(() => { // Safety cap for the non-virtualized render path. Applied here (not at // the JSX site) so renderMessageRow's index-based lookups and // dividerBeforeIndex compute on the same array. VirtualMessageList // never sees this slice — virtualScrollRuntimeGate is constant for the // component's lifetime (scrollRef is either always passed or never). // renderRange is first: the chunked export path slices the // post-grouping array so each chunk gets correct tool-call grouping. const capApplies = !virtualScrollRuntimeGate && !disableRenderCap; const sliceStart = capApplies ? computeSliceStart(collapsed_0, sliceAnchorRef) : 0; return renderRange ? collapsed_0.slice(renderRange[0], renderRange[1]) : sliceStart > 0 ? collapsed_0.slice(sliceStart) : collapsed_0; }, [collapsed_0, renderRange, virtualScrollRuntimeGate, disableRenderCap]); const streamingToolUseIDs = useMemo(() => new Set(streamingToolUses.map(__0 => __0.contentBlock.id)), [streamingToolUses]);
// Divider insertion point: first renderableMessage whose uuid shares the // 24-char prefix with firstUnseenUuid (deriveUUID keeps the first 24 // chars of the source message uuid, so this matches any block from it). const dividerBeforeIndex = useMemo(() => { if (!unseenDivider) return -1; const prefix = unseenDivider.firstUnseenUuid.slice(0, 24); return renderableMessages.findIndex(m => m.uuid.slice(0, 24) === prefix); }, [unseenDivider, renderableMessages]); const selectedIdx = useMemo(() => { if (!cursor) return -1; return renderableMessages.findIndex(m_0 => m_0.uuid === cursor.uuid); }, [cursor, renderableMessages]);
// Fullscreen: click a message to toggle verbose rendering for it. Keyed by // tool_use_id where available so a tool_use and its tool_result (separate // rows) expand together; falls back to uuid for groups/thinking. Stale keys // are harmless — they never match anything in renderableMessages. const [expandedKeys, setExpandedKeys] = useState<ReadonlySet<string>>(() => new Set()); const onItemClick = useCallback((msg_4: RenderableMessage) => { const k = expandKey(msg_4); setExpandedKeys(prev => { const next = new Set(prev); if (next.has(k)) next.delete(k);else next.add(k); return next; }); }, []); const isItemExpanded = useCallback((msg_5: RenderableMessage) => expandedKeys.size > 0 && expandedKeys.has(expandKey(msg_5)), [expandedKeys]); // Only hover/click messages where the verbose toggle reveals more: // collapsed read/search groups, or tool results that self-report truncation // via isResultTruncated. Callback must be stable across message updates: if // its identity (or return value) flips during streaming, onMouseEnter // attaches after the mouse is already inside → hover never fires. tools is // session-stable; lookups is read via ref so the callback doesn't churn on // every new message. const lookupsRef = useRef(lookups_0); lookupsRef.current = lookups_0; const isItemClickable = useCallback((msg_6: RenderableMessage): boolean => { if (msg_6.type === 'collapsed_read_search') return true; if (msg_6.type === 'assistant') { const b = msg_6.message.content[0] as unknown as AdvisorBlock | undefined; return b != null && isAdvisorBlock(b) && b.type === 'advisor_tool_result' && b.content.type === 'advisor_result'; } if (msg_6.type !== 'user') return false; const b_0 = msg_6.message.content[0]; if (b_0?.type !== 'tool_result' || b_0.is_error || !msg_6.toolUseResult) return false; const name = lookupsRef.current.toolUseByToolUseID.get(b_0.tool_use_id)?.name; const tool = name ? findToolByName(tools, name) : undefined; return tool?.isResultTruncated?.(msg_6.toolUseResult as never) ?? false; }, [tools]); const canAnimate = (!toolJSX || !!toolJSX.shouldContinueAnimation) && !toolUseConfirmQueue.length && !isMessageSelectorVisible; const hasToolsInProgress = inProgressToolUseIDs.size > 0;
// Report progress to terminal (for terminals that support OSC 9;4) const { progress } = useTerminalNotification(); const prevProgressState = useRef<string | null>(null); const progressEnabled = getGlobalConfig().terminalProgressBarEnabled && !getIsRemoteMode() && !(proactiveModule?.isProactiveActive() ?? false); useEffect(() => { const state = progressEnabled ? hasToolsInProgress ? 'indeterminate' : 'completed' : null; if (prevProgressState.current === state) return; prevProgressState.current = state; progress(state); }, [progress, progressEnabled, hasToolsInProgress]); useEffect(() => { return () => progress(null); }, [progress]); const messageKey = useCallback((msg_7: RenderableMessage) => `${msg_7.uuid}-${conversationId}`, [conversationId]); const renderMessageRow = (msg_8: RenderableMessage, index: number) => { const prevType = index > 0 ? renderableMessages[index - 1]?.type : undefined; const isUserContinuation = msg_8.type === 'user' && prevType === 'user'; // hasContentAfter is only consumed for collapsed_read_search groups; // skip the scan for everything else. streamingText is rendered as a // sibling after this map, so it's never in renderableMessages — OR it // in explicitly so the group flips to past tense as soon as text starts // streaming instead of waiting for the block to finalize. const hasContentAfter = msg_8.type === 'collapsed_read_search' && (!!streamingText || hasContentAfterIndex(renderableMessages, index, tools, streamingToolUseIDs)); const k_0 = messageKey(msg_8); const row = <MessageRow key={k_0} message={msg_8} isUserContinuation={isUserContinuation} hasContentAfter={hasContentAfter} tools={tools} commands={commands} verbose={verbose || isItemExpanded(msg_8) || cursor?.expanded === true && index === selectedIdx} inProgressToolUseIDs={inProgressToolUseIDs} streamingToolUseIDs={streamingToolUseIDs} screen={screen} canAnimate={canAnimate} onOpenRateLimitOptions={onOpenRateLimitOptions} lastThinkingBlockId={lastThinkingBlockId} latestBashOutputUUID={latestBashOutputUUID} columns={columns} isLoading={isLoading} lookups={lookups_0} />;
// Per-row Provider — only 2 rows re-render on selection change. // Wrapped BEFORE divider branch so both return paths get it. const wrapped = <MessageActionsSelectedContext.Provider key={k_0} value={index === selectedIdx}> {row} </MessageActionsSelectedContext.Provider>; if (unseenDivider && index === dividerBeforeIndex) { return [<Box key="unseen-divider" marginTop={1}> <Divider title={`${unseenDivider.count} new ${plural(unseenDivider.count, 'message')}`} width={columns} color="inactive" /> </Box>, wrapped]; } return wrapped; };
// Search indexing: for tool_result messages, look up the Tool and use // its extractSearchText — tool-owned, precise, matches what // renderToolResultMessage shows. Falls back to renderableSearchText // (duck-types toolUseResult) for tools that haven't implemented it, // and for all non-tool-result message types. The drift-catcher test // (toolSearchText.test.tsx) renders + compares to keep these in sync. // // A second-React-root reconcile approach was tried and ruled out // (measured 3.1ms/msg, growing — flushSyncWork processes all roots; // component hooks mutate shared state → main root accumulates updates). const searchTextCache = useRef(new WeakMap<RenderableMessage, string>()); const extractSearchText = useCallback((msg_9: RenderableMessage): string => { const cached = searchTextCache.current.get(msg_9); if (cached !== undefined) return cached; let text_0 = renderableSearchText(msg_9); // If this is a tool_result message and the tool implements // extractSearchText, prefer that — it's precise (tool-owned) // vs renderableSearchText's field-name heuristic. if (msg_9.type === 'user' && msg_9.toolUseResult && Array.isArray(msg_9.message.content)) { const tr = msg_9.message.content.find(b_1 => b_1.type === 'tool_result'); if (tr && 'tool_use_id' in tr) { const tu = lookups_0.toolUseByToolUseID.get(tr.tool_use_id); const tool_0 = tu && findToolByName(tools, tu.name); const extracted = tool_0?.extractSearchText?.(msg_9.toolUseResult as never); // undefined = tool didn't implement → keep heuristic. Empty // string = tool says "nothing to index" → respect that. if (extracted !== undefined) text_0 = extracted; } } // Cache LOWERED: setSearchQuery's hot loop indexOfs per keystroke. // Lowering here (once, at warm) vs there (every keystroke) trades // ~same steady-state memory for zero per-keystroke alloc. Cache // GC's with messages on transcript exit. Tool methods return raw; // renderableSearchText already lowercases (redundant but cheap). const lowered = text_0.toLowerCase(); searchTextCache.current.set(msg_9, lowered); return lowered; }, [tools, lookups_0]); return <> {/* Logo */} {!hideLogo && !(renderRange && renderRange[0] > 0) && <LogoHeader agentDefinitions={agentDefinitions} />}
{/* Truncation indicator */} {hasTruncatedMessages_0 && <Divider title={`${toggleShowAllShortcut} to show ${chalk.bold(hiddenMessageCount_0)} previous messages`} width={columns} />}
{/* Show all indicator */} {isTranscriptMode && showAllInTranscript && hiddenMessageCount_0 > 0 && // disableRenderCap (e.g. [ dump-to-scrollback) means we're uncapped // as a one-shot escape hatch, not a toggle — ctrl+e is dead and // nothing is actually "hidden" to restore. !disableRenderCap && <Divider title={`${toggleShowAllShortcut} to hide ${chalk.bold(hiddenMessageCount_0)} previous messages`} width={columns} />}
{/* Messages - rendered as memoized MessageRow components. flatMap inserts the unseen-divider as a separate keyed sibling so (a) non-fullscreen renders pay no per-message Fragment wrap, and (b) divider toggle in fullscreen preserves all MessageRows by key. Pre-compute derived values instead of passing renderableMessages to each row - React Compiler pins props in the fiber's memoCache, so passing the array would accumulate every historical version (~1-2MB over a 7-turn session). */} {virtualScrollRuntimeGate ? <InVirtualListContext.Provider value={true}> <VirtualMessageList messages={renderableMessages} scrollRef={scrollRef} columns={columns} itemKey={messageKey} renderItem={renderMessageRow} onItemClick={onItemClick} isItemClickable={isItemClickable} isItemExpanded={isItemExpanded} trackStickyPrompt={trackStickyPrompt} selectedIndex={selectedIdx >= 0 ? selectedIdx : undefined} cursorNavRef={cursorNavRef} setCursor={setCursor} jumpRef={jumpRef} onSearchMatchesChange={onSearchMatchesChange} scanElement={scanElement} setPositions={setPositions} extractSearchText={extractSearchText} /> </InVirtualListContext.Provider> : renderableMessages.flatMap(renderMessageRow)}
{streamingText && !isBriefOnly && <Box alignItems="flex-start" flexDirection="row" marginTop={1} width="100%"> <Box flexDirection="row"> <Box minWidth={2}> <Text color="text">{BLACK_CIRCLE}</Text> </Box> <Box flexDirection="column"> <StreamingMarkdown>{streamingText}</StreamingMarkdown> </Box> </Box> </Box>}
{isStreamingThinkingVisible && streamingThinking && !isBriefOnly && <Box marginTop={1}> <AssistantThinkingMessage param={{ type: 'thinking', thinking: streamingThinking.thinking }} addMargin={false} isTranscriptMode={true} verbose={verbose} hideInTranscript={false} /> </Box>} </>;};
/** Key for click-to-expand: tool_use_id where available (so tool_use + its * tool_result expand together), else uuid for groups/thinking. */function expandKey(msg: RenderableMessage): string { return (msg.type === 'assistant' || msg.type === 'user' ? getToolUseID(msg) : null) ?? msg.uuid;}
// Custom comparator to prevent unnecessary re-renders during streaming.// Default React.memo does shallow comparison which fails when:// 1. onOpenRateLimitOptions callback is recreated (doesn't affect render output)// 2. streamingToolUses array is recreated on every delta, but only contentBlock matters for rendering// 3. streamingThinking changes on every delta - we DO want to re-render for thisfunction setsEqual<T>(a: Set<T>, b: Set<T>): boolean { if (a.size !== b.size) return false; for (const item of a) { if (!b.has(item)) return false; } return true;}export const Messages = React.memo(MessagesImpl, (prev, next) => { const keys = Object.keys(prev) as (keyof typeof prev)[]; for (const key of keys) { if (key === 'onOpenRateLimitOptions' || key === 'scrollRef' || key === 'trackStickyPrompt' || key === 'setCursor' || key === 'cursorNavRef' || key === 'jumpRef' || key === 'onSearchMatchesChange' || key === 'scanElement' || key === 'setPositions') continue; if (prev[key] !== next[key]) { if (key === 'streamingToolUses') { const p = prev.streamingToolUses; const n = next.streamingToolUses; if (p.length === n.length && p.every((item, i) => item.contentBlock === n[i]?.contentBlock)) { continue; } } if (key === 'inProgressToolUseIDs') { if (setsEqual(prev.inProgressToolUseIDs, next.inProgressToolUseIDs)) { continue; } } if (key === 'unseenDivider') { const p = prev.unseenDivider; const n = next.unseenDivider; if (p?.firstUnseenUuid === n?.firstUnseenUuid && p?.count === n?.count) { continue; } } if (key === 'tools') { const p = prev.tools; const n = next.tools; if (p.length === n.length && p.every((tool, i) => tool.name === n[i]?.name)) { continue; } } // streamingThinking changes frequently - always re-render when it changes // (no special handling needed, default behavior is correct) return false; } } return true;});export function shouldRenderStatically(message: RenderableMessage, streamingToolUseIDs: Set<string>, inProgressToolUseIDs: Set<string>, siblingToolUseIDs: ReadonlySet<string>, screen: Screen, lookups: ReturnType<typeof buildMessageLookups>): boolean { if (screen === 'transcript') { return true; } switch (message.type) { case 'attachment': case 'user': case 'assistant': { if (message.type === 'assistant') { const block = message.message.content[0]; if (block?.type === 'server_tool_use') { return lookups.resolvedToolUseIDs.has(block.id); } } const toolUseID = getToolUseID(message); if (!toolUseID) { return true; } if (streamingToolUseIDs.has(toolUseID)) { return false; } if (inProgressToolUseIDs.has(toolUseID)) { return false; }
// Check if there are any unresolved PostToolUse hooks for this tool use // If so, keep the message transient so the HookProgressMessage can update if (hasUnresolvedHooksFromLookup(toolUseID, 'PostToolUse', lookups)) { return false; } return every(siblingToolUseIDs, lookups.resolvedToolUseIDs); } case 'system': { // api errors always render dynamically, since we hide // them as soon as we see another non-error message. return message.subtype !== 'api_error'; } case 'grouped_tool_use': { const allResolved = message.messages.every(msg => { const content = msg.message.content[0]; return content?.type === 'tool_use' && lookups.resolvedToolUseIDs.has(content.id); }); return allResolved; } case 'collapsed_read_search': { // In prompt mode, never mark as static to prevent flicker between API turns // (In transcript mode, we already returned true at the top of this function) return false; } }}//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["feature","chalk","UUID","RefObject","React","useCallback","useEffect","useMemo","useRef","useState","every","getIsRemoteMode","Command","BLACK_CIRCLE","useTerminalSize","ScrollBoxHandle","useTerminalNotification","Box","Text","useShortcutDisplay","Screen","Tools","findToolByName","AgentDefinitionsResult","Message","MessageType","NormalizedMessage","ProgressMessage","ProgressMessageType","RenderableMessage","AdvisorBlock","isAdvisorBlock","collapseBackgroundBashNotifications","collapseHookSummaries","collapseReadSearchGroups","collapseTeammateShutdowns","getGlobalConfig","isEnvTruthy","isFullscreenEnvEnabled","applyGrouping","buildMessageLookups","createAssistantMessage","deriveUUID","getMessagesAfterCompactBoundary","getToolUseID","getToolUseIDs","hasUnresolvedHooksFromLookup","isNotEmptyMessage","normalizeMessages","reorderMessagesInUI","StreamingThinking","StreamingToolUse","shouldShowUserMessage","plural","renderableSearchText","Divider","UnseenDivider","LogoV2","StreamingMarkdown","hasContentAfterIndex","MessageRow","InVirtualListContext","MessageActionsNav","MessageActionsSelectedContext","MessageActionsState","AssistantThinkingMessage","isNullRenderingAttachment","OffscreenFreeze","ToolUseConfirm","StatusNotices","JumpHandle","LogoHeader","memo","t0","$","_c","agentDefinitions","t1","Symbol","for","t2","proactiveModule","require","BRIEF_TOOL_NAME","SEND_USER_FILE_TOOL_NAME","VirtualMessageList","filterForBriefTool","type","subtype","isMeta","isApiErrorMessage","message","content","Array","name","tool_use_id","attachment","origin","commandMode","messages","T","briefToolNames","nameSet","Set","briefToolUseIDs","filter","msg","block","has","add","id","undefined","att","dropTextInBriefTurns","turnsWithBrief","textIndexToTurn","turn","i","length","size","_","t","Props","tools","commands","verbose","toolJSX","jsx","ReactNode","shouldHidePromptInput","shouldContinueAnimation","toolUseConfirmQueue","inProgressToolUseIDs","isMessageSelectorVisible","conversationId","screen","streamingToolUses","showAllInTranscript","onOpenRateLimitOptions","hideLogo","isLoading","hidePastThinking","streamingThinking","streamingText","isBriefOnly","unseenDivider","scrollRef","trackStickyPrompt","jumpRef","onSearchMatchesChange","count","current","scanElement","el","DOMElement","MatchPosition","setPositions","state","positions","rowOffset","currentIdx","disableRenderCap","cursor","setCursor","cursorNavRef","Ref","renderRange","start","end","MAX_MESSAGES_TO_SHOW_IN_TRANSCRIPT_MODE","MAX_MESSAGES_WITHOUT_VIRTUALIZATION","MESSAGE_CAP_STEP","SliceAnchor","uuid","idx","computeSliceStart","collapsed","ReadonlyArray","anchorRef","cap","step","anchor","anchorIdx","findIndex","m","Math","min","max","msgAtStart","MessagesImpl","columns","toggleShowAllShortcut","normalizedMessages","isStreamingThinkingVisible","isStreaming","streamingEndedAt","Date","now","lastThinkingBlockId","j","hasToolResult","some","latestBashOutputUUID","text","startsWith","normalizedToolUseIDs","streamingToolUsesWithoutInProgress","stu","contentBlock","syntheticStreamingToolUseMessages","flatMap","streamingToolUse","isTranscriptMode","disableVirtualScroll","process","env","CLAUDE_CODE_DISABLE_VIRTUAL_SCROLL","virtualScrollRuntimeGate","shouldTruncate","sliceAnchorRef","lookups","hasTruncatedMessages","hiddenMessageCount","compactAwareMessages","includeSnipped","messagesToShowNotTruncated","Exclude","n","dropTextToolNames","briefFiltered","messagesToShow","slice","groupedMessages","renderableMessages","capApplies","sliceStart","streamingToolUseIDs","map","dividerBeforeIndex","prefix","firstUnseenUuid","selectedIdx","expandedKeys","setExpandedKeys","ReadonlySet","onItemClick","k","expandKey","prev","next","delete","isItemExpanded","lookupsRef","isItemClickable","b","is_error","toolUseResult","toolUseByToolUseID","get","tool","isResultTruncated","canAnimate","hasToolsInProgress","progress","prevProgressState","progressEnabled","terminalProgressBarEnabled","isProactiveActive","messageKey","renderMessageRow","index","prevType","isUserContinuation","hasContentAfter","row","expanded","wrapped","searchTextCache","WeakMap","extractSearchText","cached","isArray","tr","find","tu","extracted","lowered","toLowerCase","set","bold","thinking","setsEqual","a","item","Messages","keys","Object","key","p","shouldRenderStatically","siblingToolUseIDs","ReturnType","resolvedToolUseIDs","toolUseID","allResolved"],"sources":["Messages.tsx"],"sourcesContent":["import { feature } from 'bun:bundle'\nimport chalk from 'chalk'\nimport type { UUID } from 'crypto'\nimport type { RefObject } from 'react'\nimport * as React from 'react'\nimport { useCallback, useEffect, useMemo, useRef, useState } from 'react'\nimport { every } from 'src/utils/set.js'\nimport { getIsRemoteMode } from '../bootstrap/state.js'\nimport type { Command } from '../commands.js'\nimport { BLACK_CIRCLE } from '../constants/figures.js'\nimport { useTerminalSize } from '../hooks/useTerminalSize.js'\nimport type { ScrollBoxHandle } from '../ink/components/ScrollBox.js'\nimport { useTerminalNotification } from '../ink/useTerminalNotification.js'\nimport { Box, Text } from '../ink.js'\nimport { useShortcutDisplay } from '../keybindings/useShortcutDisplay.js'\nimport type { Screen } from '../screens/REPL.js'\nimport type { Tools } from '../Tool.js'\nimport { findToolByName } from '../Tool.js'\nimport type { AgentDefinitionsResult } from '../tools/AgentTool/loadAgentsDir.js'\nimport type {\n  Message as MessageType,\n  NormalizedMessage,\n  ProgressMessage as ProgressMessageType,\n  RenderableMessage,\n} from '../types/message.js'\nimport { type AdvisorBlock, isAdvisorBlock } from '../utils/advisor.js'\nimport { collapseBackgroundBashNotifications } from '../utils/collapseBackgroundBashNotifications.js'\nimport { collapseHookSummaries } from '../utils/collapseHookSummaries.js'\nimport { collapseReadSearchGroups } from '../utils/collapseReadSearch.js'\nimport { collapseTeammateShutdowns } from '../utils/collapseTeammateShutdowns.js'\nimport { getGlobalConfig } from '../utils/config.js'\nimport { isEnvTruthy } from '../utils/envUtils.js'\nimport { isFullscreenEnvEnabled } from '../utils/fullscreen.js'\nimport { applyGrouping } from '../utils/groupToolUses.js'\nimport {\n  buildMessageLookups,\n  createAssistantMessage,\n  deriveUUID,\n  getMessagesAfterCompactBoundary,\n  getToolUseID,\n  getToolUseIDs,\n  hasUnresolvedHooksFromLookup,\n  isNotEmptyMessage,\n  normalizeMessages,\n  reorderMessagesInUI,\n  type StreamingThinking,\n  type StreamingToolUse,\n  shouldShowUserMessage,\n} from '../utils/messages.js'\nimport { plural } from '../utils/stringUtils.js'\nimport { renderableSearchText } from '../utils/transcriptSearch.js'\nimport { Divider } from './design-system/Divider.js'\nimport type { UnseenDivider } from './FullscreenLayout.js'\nimport { LogoV2 } from './LogoV2/LogoV2.js'\nimport { StreamingMarkdown } from './Markdown.js'\nimport { hasContentAfterIndex, MessageRow } from './MessageRow.js'\nimport {\n  InVirtualListContext,\n  type MessageActionsNav,\n  MessageActionsSelectedContext,\n  type MessageActionsState,\n} from './messageActions.js'\nimport { AssistantThinkingMessage } from './messages/AssistantThinkingMessage.js'\nimport { isNullRenderingAttachment } from './messages/nullRenderingAttachments.js'\nimport { OffscreenFreeze } from './OffscreenFreeze.js'\nimport type { ToolUseConfirm } from './permissions/PermissionRequest.js'\nimport { StatusNotices } from './StatusNotices.js'\nimport type { JumpHandle } from './VirtualMessageList.js'\n\n// Memoed logo header: this box is the FIRST sibling before all MessageRows\n// in main-screen mode. If it becomes dirty on every Messages re-render,\n// renderChildren's seenDirtyChild cascade disables prevScreen (blit) for\n// ALL subsequent siblings — every MessageRow re-writes from scratch instead\n// of blitting. In long sessions (~2800 messages) this is 150K+ writes/frame\n// and pegs CPU at 100%. Memo on agentDefinitions so a new messages array\n// doesn't invalidate the logo subtree. LogoV2/StatusNotices internally\n// subscribe to useAppState/useSettings for their own updates.\nconst LogoHeader = React.memo(function LogoHeader({\n  agentDefinitions,\n}: {\n  agentDefinitions: AgentDefinitionsResult | undefined\n}): React.ReactNode {\n  // LogoV2 has its own internal OffscreenFreeze (catches its useAppState\n  // re-renders). This outer freeze catches agentDefinitions changes and any\n  // future StatusNotices subscriptions while the header is in scrollback.\n  return (\n    <OffscreenFreeze>\n      <Box flexDirection=\"column\" gap={1}>\n        <LogoV2 />\n        <React.Suspense fallback={null}>\n          <StatusNotices agentDefinitions={agentDefinitions} />\n        </React.Suspense>\n      </Box>\n    </OffscreenFreeze>\n  )\n})\n\n// Dead code elimination: conditional import for proactive mode\n/* eslint-disable @typescript-eslint/no-require-imports */\nconst proactiveModule =\n  feature('PROACTIVE') || feature('KAIROS')\n    ? require('../proactive/index.js')\n    : null\nconst BRIEF_TOOL_NAME: string | null =\n  feature('KAIROS') || feature('KAIROS_BRIEF')\n    ? (\n        require('../tools/BriefTool/prompt.js') as typeof import('../tools/BriefTool/prompt.js')\n      ).BRIEF_TOOL_NAME\n    : null\nconst SEND_USER_FILE_TOOL_NAME: string | null = feature('KAIROS')\n  ? (\n      require('../tools/SendUserFileTool/prompt.js') as typeof import('../tools/SendUserFileTool/prompt.js')\n    ).SEND_USER_FILE_TOOL_NAME\n  : null\n\n/* eslint-enable @typescript-eslint/no-require-imports */\nimport { VirtualMessageList } from './VirtualMessageList.js'\n\n/**\n * In brief-only mode, filter messages to show ONLY Brief tool_use blocks,\n * their tool_results, and real user input. All assistant text is dropped —\n * if the model forgets to call Brief, the user sees nothing for that turn.\n * That's on the model to get right; the filter does not second-guess it.\n */\nexport function filterForBriefTool<\n  T extends {\n    type: string\n    subtype?: string\n    isMeta?: boolean\n    isApiErrorMessage?: boolean\n    message?: {\n      content: Array<{\n        type: string\n        name?: string\n        tool_use_id?: string\n      }>\n    }\n    attachment?: {\n      type: string\n      isMeta?: boolean\n      origin?: unknown\n      commandMode?: string\n    }\n  },\n>(messages: T[], briefToolNames: string[]): T[] {\n  const nameSet = new Set(briefToolNames)\n  // tool_use always precedes its tool_result in the array, so we can collect\n  // IDs and match against them in a single pass.\n  const briefToolUseIDs = new Set<string>()\n  return messages.filter(msg => {\n    // System messages (attach confirmation, remote errors, compact boundaries)\n    // must stay visible — dropping them leaves the viewer with no feedback.\n    // Exception: api_metrics is per-turn debug noise (TTFT, config writes,\n    // hook timing) that defeats the point of brief mode. Still visible in\n    // transcript mode (ctrl+o) which bypasses this filter.\n    if (msg.type === 'system') return msg.subtype !== 'api_metrics'\n    const block = msg.message?.content[0]\n    if (msg.type === 'assistant') {\n      // API error messages (auth failures, rate limits, etc.) must stay visible\n      if (msg.isApiErrorMessage) return true\n      // Keep Brief tool_use blocks (renders with standard tool call chrome,\n      // and must be in the list so buildMessageLookups can resolve tool results)\n      if (block?.type === 'tool_use' && block.name && nameSet.has(block.name)) {\n        if ('id' in block) {\n          briefToolUseIDs.add((block as { id: string }).id)\n        }\n        return true\n      }\n      return false\n    }\n    if (msg.type === 'user') {\n      if (block?.type === 'tool_result') {\n        return (\n          block.tool_use_id !== undefined &&\n          briefToolUseIDs.has(block.tool_use_id)\n        )\n      }\n      // Real user input only — drop meta/tick messages.\n      return !msg.isMeta\n    }\n    if (msg.type === 'attachment') {\n      // Human input drained mid-turn arrives as a queued_command attachment\n      // (query.ts mid-chain drain → getQueuedCommandAttachments). Keep it —\n      // it's what the user typed. commandMode === 'prompt' positively\n      // identifies human-typed input; task-notification callers set\n      // mode: 'task-notification' but not origin/isMeta, so the positive\n      // commandMode check is required to exclude them.\n      const att = msg.attachment\n      return (\n        att?.type === 'queued_command' &&\n        att.commandMode === 'prompt' &&\n        !att.isMeta &&\n        att.origin === undefined\n      )\n    }\n    return false\n  })\n}\n\n/**\n * Full-transcript companion to filterForBriefTool. When the Brief tool is\n * in use, the model's text output is redundant with the SendUserMessage\n * content it wrote right after — drop the text so only the SendUserMessage\n * block shows. Tool calls and their results stay visible.\n *\n * Per-turn: only drops text in turns that actually called Brief. If the\n * model forgets, text still shows — otherwise the user would see nothing.\n */\nexport function dropTextInBriefTurns<\n  T extends {\n    type: string\n    isMeta?: boolean\n    message?: { content: Array<{ type: string; name?: string }> }\n  },\n>(messages: T[], briefToolNames: string[]): T[] {\n  const nameSet = new Set(briefToolNames)\n  // First pass: find which turns (bounded by non-meta user messages) contain\n  // a Brief tool_use. Tag each assistant text block with its turn index.\n  const turnsWithBrief = new Set<number>()\n  const textIndexToTurn: number[] = []\n  let turn = 0\n  for (let i = 0; i < messages.length; i++) {\n    const msg = messages[i]!\n    const block = msg.message?.content[0]\n    if (msg.type === 'user' && block?.type !== 'tool_result' && !msg.isMeta) {\n      turn++\n      continue\n    }\n    if (msg.type === 'assistant') {\n      if (block?.type === 'text') {\n        textIndexToTurn[i] = turn\n      } else if (\n        block?.type === 'tool_use' &&\n        block.name &&\n        nameSet.has(block.name)\n      ) {\n        turnsWithBrief.add(turn)\n      }\n    }\n  }\n  if (turnsWithBrief.size === 0) return messages\n  // Second pass: drop text blocks whose turn called Brief.\n  return messages.filter((_, i) => {\n    const t = textIndexToTurn[i]\n    return t === undefined || !turnsWithBrief.has(t)\n  })\n}\n\ntype Props = {\n  messages: MessageType[]\n  tools: Tools\n  commands: Command[]\n  verbose: boolean\n  toolJSX: {\n    jsx: React.ReactNode | null\n    shouldHidePromptInput: boolean\n    shouldContinueAnimation?: true\n  } | null\n  toolUseConfirmQueue: ToolUseConfirm[]\n  inProgressToolUseIDs: Set<string>\n  isMessageSelectorVisible: boolean\n  conversationId: string\n  screen: Screen\n  streamingToolUses: StreamingToolUse[]\n  showAllInTranscript?: boolean\n  agentDefinitions?: AgentDefinitionsResult\n  onOpenRateLimitOptions?: () => void\n  /** Hide the logo/header - used for subagent zoom view */\n  hideLogo?: boolean\n  isLoading: boolean\n  /** In transcript mode, hide all thinking blocks except the last one */\n  hidePastThinking?: boolean\n  /** Streaming thinking content (live updates, not frozen) */\n  streamingThinking?: StreamingThinking | null\n  /** Streaming text preview (rendered as last item so transition to final message is positionally seamless) */\n  streamingText?: string | null\n  /** When true, only show Brief tool output (hide everything else) */\n  isBriefOnly?: boolean\n  /** Fullscreen-mode \"─── N new ───\" divider. Renders before the first\n   *  renderableMessage derived from firstUnseenUuid (matched by the 24-char\n   *  prefix that deriveUUID preserves). */\n  unseenDivider?: UnseenDivider\n  /** Fullscreen-mode ScrollBox handle. Enables React-level virtualization when present. */\n  scrollRef?: RefObject<ScrollBoxHandle | null>\n  /** Fullscreen-mode: enable sticky-prompt tracking (writes via ScrollChromeContext). */\n  trackStickyPrompt?: boolean\n  /** Transcript search: jump-to-index + setSearchQuery/nextMatch/prevMatch. */\n  jumpRef?: RefObject<JumpHandle | null>\n  /** Transcript search: fires when match count/position changes. */\n  onSearchMatchesChange?: (count: number, current: number) => void\n  /** Paint an existing DOM subtree to fresh Screen, scan. Element comes\n   *  from the main tree (all real providers). Message-relative positions. */\n  scanElement?: (\n    el: import('../ink/dom.js').DOMElement,\n  ) => import('../ink/render-to-screen.js').MatchPosition[]\n  /** Position-based CURRENT highlight. positions stable (msg-relative),\n   *  rowOffset tracks scroll. null clears. */\n  setPositions?: (\n    state: {\n      positions: import('../ink/render-to-screen.js').MatchPosition[]\n      rowOffset: number\n      currentIdx: number\n    } | null,\n  ) => void\n  /** Bypass MAX_MESSAGES_WITHOUT_VIRTUALIZATION. For one-shot headless renders\n   *  (e.g. /export via renderToString) where the memory concern doesn't apply\n   *  and the \"already in scrollback\" justification doesn't hold. */\n  disableRenderCap?: boolean\n  /** In-transcript cursor; expanded overrides verbose for selected message. */\n  cursor?: MessageActionsState | null\n  setCursor?: (cursor: MessageActionsState | null) => void\n  /** Passed through to VirtualMessageList (heightCache owns visibility). */\n  cursorNavRef?: React.Ref<MessageActionsNav>\n  /** Render only collapsed.slice(start, end). For chunked headless export\n   *  (streamRenderedMessages in exportRenderer.tsx): prep runs on the FULL\n   *  messages array so grouping/lookups are correct, but only this slice\n   *  chunk instead of the full session. The logo renders only for chunk 0\n   *  (start === 0); later chunks are mid-stream continuations.\n   *  Measured Mar 2026: 538-msg session, 20 slices → −55% plateau RSS. */\n  renderRange?: readonly [start: number, end: number]\n}\n\nconst MAX_MESSAGES_TO_SHOW_IN_TRANSCRIPT_MODE = 30\n\n// Safety cap for the non-virtualized render path (fullscreen off or\n// explicitly disabled). Ink mounts a full fiber tree per message (~250 KB\n// RSS each); yoga layout height grows unbounded; the screen buffer is sized\n// to fit every line. At ~2000 messages this is ~3000-line screens, ~500 MB\n// of fibers, and per-frame write costs that push the process into a GC\n// death spiral (observed: 59 GB RSS, 14k mmap/munmap/sec). Content dropped\n// from this slice has already been printed to terminal scrollback — users\n// can still scroll up natively. VirtualMessageList (the default ant path)\n// bypasses this cap entirely. Headless one-shot renders (e.g. /export)\n// pass disableRenderCap to opt out — they have no scrollback and the\n// memory concern doesn't apply to renderToString.\n//\n// The slice boundary is tracked as a UUID anchor, not a count-derived\n// index. Count-based slicing (slice(-200)) drops one message from the\n// front on every append, shifting scrollback content and forcing a full\n// terminal reset per turn (CC-941). Quantizing to 50-message steps\n// (CC-1154) helped but still shifted on compaction and collapse regrouping\n// since those change collapsed.length without adding messages. The UUID\n// anchor only advances when rendered count genuinely exceeds CAP+STEP —\n// immune to length churn from grouping/compaction (CC-1174).\n//\n// The anchor stores BOTH uuid and index. Some uuids are unstable between\n// renders: collapseHookSummaries derives the merged uuid from the first\n// summary in a group, but reorderMessagesInUI reshuffles hook adjacency\n// as tool results stream in, changing which summary is first. When the\n// uuid vanishes, falling back to the stored index (clamped) keeps the\n// slice roughly where it was instead of resetting to 0 — which would\n// jump from ~200 rendered messages to the full history, orphaning\n// in-progress badge snapshots in scrollback.\nconst MAX_MESSAGES_WITHOUT_VIRTUALIZATION = 200\nconst MESSAGE_CAP_STEP = 50\n\nexport type SliceAnchor = { uuid: string; idx: number } | null\n\n/** Exported for testing. Mutates anchorRef when the window needs to advance. */\nexport function computeSliceStart(\n  collapsed: ReadonlyArray<{ uuid: string }>,\n  anchorRef: { current: SliceAnchor },\n  cap = MAX_MESSAGES_WITHOUT_VIRTUALIZATION,\n  step = MESSAGE_CAP_STEP,\n): number {\n  const anchor = anchorRef.current\n  const anchorIdx = anchor\n    ? collapsed.findIndex(m => m.uuid === anchor.uuid)\n    : -1\n  // Anchor found → use it. Anchor lost → fall back to stored index\n  // (clamped) so collapse-regrouping uuid churn doesn't reset to 0.\n  let start =\n    anchorIdx >= 0\n      ? anchorIdx\n      : anchor\n        ? Math.min(anchor.idx, Math.max(0, collapsed.length - cap))\n        : 0\n  if (collapsed.length - start > cap + step) {\n    start = collapsed.length - cap\n  }\n  // Refresh anchor from whatever lives at the current start — heals a\n  // stale uuid after fallback and captures a new one after advancement.\n  const msgAtStart = collapsed[start]\n  if (\n    msgAtStart &&\n    (anchor?.uuid !== msgAtStart.uuid || anchor.idx !== start)\n  ) {\n    anchorRef.current = { uuid: msgAtStart.uuid, idx: start }\n  } else if (!msgAtStart && anchor) {\n    anchorRef.current = null\n  }\n  return start\n}\n\nconst MessagesImpl = ({\n  messages,\n  tools,\n  commands,\n  verbose,\n  toolJSX,\n  toolUseConfirmQueue,\n  inProgressToolUseIDs,\n  isMessageSelectorVisible,\n  conversationId,\n  screen,\n  streamingToolUses,\n  showAllInTranscript = false,\n  agentDefinitions,\n  onOpenRateLimitOptions,\n  hideLogo = false,\n  isLoading,\n  hidePastThinking = false,\n  streamingThinking,\n  streamingText,\n  isBriefOnly = false,\n  unseenDivider,\n  scrollRef,\n  trackStickyPrompt,\n  jumpRef,\n  onSearchMatchesChange,\n  scanElement,\n  setPositions,\n  disableRenderCap = false,\n  cursor = null,\n  setCursor,\n  cursorNavRef,\n  renderRange,\n}: Props): React.ReactNode => {\n  const { columns } = useTerminalSize()\n  const toggleShowAllShortcut = useShortcutDisplay(\n    'transcript:toggleShowAll',\n    'Transcript',\n    'Ctrl+E',\n  )\n\n  const normalizedMessages = useMemo(\n    () => normalizeMessages(messages).filter(isNotEmptyMessage),\n    [messages],\n  )\n\n  // Check if streaming thinking should be visible (streaming or within 30s timeout)\n  const isStreamingThinkingVisible = useMemo(() => {\n    if (!streamingThinking) return false\n    if (streamingThinking.isStreaming) return true\n    if (streamingThinking.streamingEndedAt) {\n      return Date.now() - streamingThinking.streamingEndedAt < 30000\n    }\n    return false\n  }, [streamingThinking])\n\n  // Find the last thinking block (message UUID + content index) for hiding past thinking in transcript mode\n  // When streaming thinking is visible, use a special ID that won't match any completed thinking block\n  // With adaptive thinking, only consider thinking blocks from the current turn and stop searching once we\n  // hit the last user message.\n  const lastThinkingBlockId = useMemo(() => {\n    if (!hidePastThinking) return null\n    // If streaming thinking is visible, hide all completed thinking blocks by using a non-matching ID\n    if (isStreamingThinkingVisible) return 'streaming'\n    // Iterate backwards to find the last message with a thinking block\n    for (let i = normalizedMessages.length - 1; i >= 0; i--) {\n      const msg = normalizedMessages[i]\n      if (msg?.type === 'assistant') {\n        const content = msg.message.content\n        // Find the last thinking block in this message\n        for (let j = content.length - 1; j >= 0; j--) {\n          if (content[j]?.type === 'thinking') {\n            return `${msg.uuid}:${j}`\n          }\n        }\n      } else if (msg?.type === 'user') {\n        const hasToolResult = msg.message.content.some(\n          block => block.type === 'tool_result',\n        )\n        if (!hasToolResult) {\n          // Reached a previous user turn so don't show stale thinking from before\n          return 'no-thinking'\n        }\n      }\n    }\n    return null\n  }, [normalizedMessages, hidePastThinking, isStreamingThinkingVisible])\n\n  // Find the latest user bash output message (from ! commands)\n  // This allows us to show full output for the most recent bash command\n  const latestBashOutputUUID = useMemo(() => {\n    // Iterate backwards to find the last user message with bash output\n    for (let i = normalizedMessages.length - 1; i >= 0; i--) {\n      const msg = normalizedMessages[i]\n      if (msg?.type === 'user') {\n        const content = msg.message.content\n        // Check if any text content is bash output\n        for (const block of content) {\n          if (block.type === 'text') {\n            const text = block.text\n            if (\n              text.startsWith('<bash-stdout') ||\n              text.startsWith('<bash-stderr')\n            ) {\n              return msg.uuid\n            }\n          }\n        }\n      }\n    }\n    return null\n  }, [normalizedMessages])\n\n  // streamingToolUses updates on every input_json_delta while normalizedMessages\n  // stays stable — precompute the Set so the filter is O(k) not O(n×k) per chunk.\n  const normalizedToolUseIDs = useMemo(\n    () => getToolUseIDs(normalizedMessages),\n    [normalizedMessages],\n  )\n\n  const streamingToolUsesWithoutInProgress = useMemo(\n    () =>\n      streamingToolUses.filter(\n        stu =>\n          !inProgressToolUseIDs.has(stu.contentBlock.id) &&\n          !normalizedToolUseIDs.has(stu.contentBlock.id),\n      ),\n    [streamingToolUses, inProgressToolUseIDs, normalizedToolUseIDs],\n  )\n\n  const syntheticStreamingToolUseMessages = useMemo(\n    () =>\n      streamingToolUsesWithoutInProgress.flatMap(streamingToolUse => {\n        const msg = createAssistantMessage({\n          content: [streamingToolUse.contentBlock],\n        })\n        // Override randomUUID with deterministic value derived from content\n        // block ID to prevent React key changes on every memo recomputation.\n        // Same class of bug fixed in normalizeMessages (commit 383326e613):\n        // fresh randomUUID → unstable React keys → component remounts →\n        // Ink rendering corruption (overlapping text from stale DOM nodes).\n        msg.uuid = deriveUUID(streamingToolUse.contentBlock.id as UUID, 0)\n        return normalizeMessages([msg])\n      }),\n    [streamingToolUsesWithoutInProgress],\n  )\n\n  const isTranscriptMode = screen === 'transcript'\n  // Hoisted to mount-time — this component re-renders on every scroll.\n  const disableVirtualScroll = useMemo(\n    () => isEnvTruthy(process.env.CLAUDE_CODE_DISABLE_VIRTUAL_SCROLL),\n    [],\n  )\n  // Virtual scroll replaces the transcript cap: everything is scrollable and\n  // memory is bounded by the mounted-item count, not the total. scrollRef is\n  // only passed when isFullscreenEnvEnabled() is true (REPL.tsx gates it),\n  // so scrollRef's presence is the signal.\n  const virtualScrollRuntimeGate = scrollRef != null && !disableVirtualScroll\n  const shouldTruncate =\n    isTranscriptMode && !showAllInTranscript && !virtualScrollRuntimeGate\n\n  // Anchor for the first rendered message in the non-virtualized cap slice.\n  // Monotonic advance only — mutation during render is idempotent (safe\n  // under StrictMode double-render). See MAX_MESSAGES_WITHOUT_VIRTUALIZATION\n  // comment above for why this replaced count-based slicing.\n  const sliceAnchorRef = useRef<SliceAnchor>(null)\n\n  // Expensive message transforms — filter, reorder, group, collapse, lookups.\n  // All O(n) over 27k messages. Split from the renderRange slice so scrolling\n  // (which only changes renderRange) doesn't re-run these. Previously this\n  // useMemo included renderRange → every scroll rebuilt 6 Maps over 27k\n  // messages + 4 filter/map passes = ~50ms alloc per scroll → GC pressure →\n  // 100-173ms stop-the-world pauses on the 1GB heap.\n  const { collapsed, lookups, hasTruncatedMessages, hiddenMessageCount } =\n    useMemo(() => {\n      // In fullscreen mode the alt buffer has no native scrollback, so the\n      // compact-boundary filter just hides history the ScrollBox could\n      // otherwise scroll to. Main-screen mode keeps the filter — pre-compact\n      // rows live above the viewport in native scrollback there, and\n      // re-rendering them triggers full resets.\n      // includeSnipped: UI rendering keeps snipped messages for scrollback\n      // (this PR's core goal — full history in UI, filter only for the model).\n      // Also avoids a UUID mismatch: normalizeMessages derives new UUIDs, so\n      // projectSnippedView's check against original removedUuids would fail.\n      const compactAwareMessages =\n        verbose || isFullscreenEnvEnabled()\n          ? normalizedMessages\n          : getMessagesAfterCompactBoundary(normalizedMessages, {\n              includeSnipped: true,\n            })\n\n      const messagesToShowNotTruncated = reorderMessagesInUI(\n        compactAwareMessages\n          .filter(\n            (msg): msg is Exclude<NormalizedMessage, ProgressMessageType> =>\n              msg.type !== 'progress',\n          )\n          // CC-724: drop attachment messages that AttachmentMessage renders as\n          // null (hook_success, hook_additional_context, hook_cancelled, etc.)\n          // BEFORE counting/slicing so they don't inflate the \"N messages\"\n          // count in ctrl-o or consume slots in the 200-message render cap.\n          .filter(msg => !isNullRenderingAttachment(msg))\n          .filter(_ => shouldShowUserMessage(_, isTranscriptMode)),\n        syntheticStreamingToolUseMessages,\n      )\n      // Three-tier filtering. Transcript mode (ctrl+o screen) is truly unfiltered.\n      // Brief-only: SendUserMessage + user input only. Default: drop redundant\n      // assistant text in turns where SendUserMessage was called (the model's\n      // text is working-notes that duplicate the SendUserMessage content).\n      const briefToolNames = [BRIEF_TOOL_NAME, SEND_USER_FILE_TOOL_NAME].filter(\n        (n): n is string => n !== null,\n      )\n      // dropTextInBriefTurns should only trigger on SendUserMessage turns —\n      // SendUserFile delivers a file without replacement text, so dropping\n      // assistant text for file-only turns would leave the user with no context.\n      const dropTextToolNames = [BRIEF_TOOL_NAME].filter(\n        (n): n is string => n !== null,\n      )\n      const briefFiltered =\n        briefToolNames.length > 0 && !isTranscriptMode\n          ? isBriefOnly\n            ? filterForBriefTool(messagesToShowNotTruncated, briefToolNames)\n            : dropTextToolNames.length > 0\n              ? dropTextInBriefTurns(\n                  messagesToShowNotTruncated,\n                  dropTextToolNames,\n                )\n              : messagesToShowNotTruncated\n          : messagesToShowNotTruncated\n\n      const messagesToShow = shouldTruncate\n        ? briefFiltered.slice(-MAX_MESSAGES_TO_SHOW_IN_TRANSCRIPT_MODE)\n        : briefFiltered\n\n      const hasTruncatedMessages =\n        shouldTruncate &&\n        briefFiltered.length > MAX_MESSAGES_TO_SHOW_IN_TRANSCRIPT_MODE\n\n      const { messages: groupedMessages } = applyGrouping(\n        messagesToShow,\n        tools,\n        verbose,\n      )\n\n      const collapsed = collapseBackgroundBashNotifications(\n        collapseHookSummaries(\n          collapseTeammateShutdowns(\n            collapseReadSearchGroups(groupedMessages, tools),\n          ),\n        ),\n        verbose,\n      )\n\n      const lookups = buildMessageLookups(normalizedMessages, messagesToShow)\n\n      const hiddenMessageCount =\n        messagesToShowNotTruncated.length -\n        MAX_MESSAGES_TO_SHOW_IN_TRANSCRIPT_MODE\n\n      return {\n        collapsed,\n        lookups,\n        hasTruncatedMessages,\n        hiddenMessageCount,\n      }\n    }, [\n      verbose,\n      normalizedMessages,\n      isTranscriptMode,\n      syntheticStreamingToolUseMessages,\n      shouldTruncate,\n      tools,\n      isBriefOnly,\n    ])\n\n  // Cheap slice — only runs when scroll range or slice config changes.\n  const renderableMessages = useMemo(() => {\n    // Safety cap for the non-virtualized render path. Applied here (not at\n    // the JSX site) so renderMessageRow's index-based lookups and\n    // dividerBeforeIndex compute on the same array. VirtualMessageList\n    // never sees this slice — virtualScrollRuntimeGate is constant for the\n    // component's lifetime (scrollRef is either always passed or never).\n    // renderRange is first: the chunked export path slices the\n    // post-grouping array so each chunk gets correct tool-call grouping.\n    const capApplies = !virtualScrollRuntimeGate && !disableRenderCap\n    const sliceStart = capApplies\n      ? computeSliceStart(collapsed, sliceAnchorRef)\n      : 0\n    return renderRange\n      ? collapsed.slice(renderRange[0], renderRange[1])\n      : sliceStart > 0\n        ? collapsed.slice(sliceStart)\n        : collapsed\n  }, [collapsed, renderRange, virtualScrollRuntimeGate, disableRenderCap])\n\n  const streamingToolUseIDs = useMemo(\n    () => new Set(streamingToolUses.map(_ => _.contentBlock.id)),\n    [streamingToolUses],\n  )\n\n  // Divider insertion point: first renderableMessage whose uuid shares the\n  // 24-char prefix with firstUnseenUuid (deriveUUID keeps the first 24\n  // chars of the source message uuid, so this matches any block from it).\n  const dividerBeforeIndex = useMemo(() => {\n    if (!unseenDivider) return -1\n    const prefix = unseenDivider.firstUnseenUuid.slice(0, 24)\n    return renderableMessages.findIndex(m => m.uuid.slice(0, 24) === prefix)\n  }, [unseenDivider, renderableMessages])\n\n  const selectedIdx = useMemo(() => {\n    if (!cursor) return -1\n    return renderableMessages.findIndex(m => m.uuid === cursor.uuid)\n  }, [cursor, renderableMessages])\n\n  // Fullscreen: click a message to toggle verbose rendering for it. Keyed by\n  // tool_use_id where available so a tool_use and its tool_result (separate\n  // rows) expand together; falls back to uuid for groups/thinking. Stale keys\n  // are harmless — they never match anything in renderableMessages.\n  const [expandedKeys, setExpandedKeys] = useState<ReadonlySet<string>>(\n    () => new Set(),\n  )\n  const onItemClick = useCallback((msg: RenderableMessage) => {\n    const k = expandKey(msg)\n    setExpandedKeys(prev => {\n      const next = new Set(prev)\n      if (next.has(k)) next.delete(k)\n      else next.add(k)\n      return next\n    })\n  }, [])\n  const isItemExpanded = useCallback(\n    (msg: RenderableMessage) =>\n      expandedKeys.size > 0 && expandedKeys.has(expandKey(msg)),\n    [expandedKeys],\n  )\n  // Only hover/click messages where the verbose toggle reveals more:\n  // collapsed read/search groups, or tool results that self-report truncation\n  // via isResultTruncated. Callback must be stable across message updates: if\n  // its identity (or return value) flips during streaming, onMouseEnter\n  // attaches after the mouse is already inside → hover never fires. tools is\n  // session-stable; lookups is read via ref so the callback doesn't churn on\n  // every new message.\n  const lookupsRef = useRef(lookups)\n  lookupsRef.current = lookups\n  const isItemClickable = useCallback(\n    (msg: RenderableMessage): boolean => {\n      if (msg.type === 'collapsed_read_search') return true\n      if (msg.type === 'assistant') {\n        const b = msg.message.content[0] as unknown as AdvisorBlock | undefined\n        return (\n          b != null &&\n          isAdvisorBlock(b) &&\n          b.type === 'advisor_tool_result' &&\n          b.content.type === 'advisor_result'\n        )\n      }\n      if (msg.type !== 'user') return false\n      const b = msg.message.content[0]\n      if (b?.type !== 'tool_result' || b.is_error || !msg.toolUseResult)\n        return false\n      const name = lookupsRef.current.toolUseByToolUseID.get(\n        b.tool_use_id,\n      )?.name\n      const tool = name ? findToolByName(tools, name) : undefined\n      return tool?.isResultTruncated?.(msg.toolUseResult as never) ?? false\n    },\n    [tools],\n  )\n\n  const canAnimate =\n    (!toolJSX || !!toolJSX.shouldContinueAnimation) &&\n    !toolUseConfirmQueue.length &&\n    !isMessageSelectorVisible\n\n  const hasToolsInProgress = inProgressToolUseIDs.size > 0\n\n  // Report progress to terminal (for terminals that support OSC 9;4)\n  const { progress } = useTerminalNotification()\n  const prevProgressState = useRef<string | null>(null)\n  const progressEnabled =\n    getGlobalConfig().terminalProgressBarEnabled &&\n    !getIsRemoteMode() &&\n    !(proactiveModule?.isProactiveActive() ?? false)\n  useEffect(() => {\n    const state = progressEnabled\n      ? hasToolsInProgress\n        ? 'indeterminate'\n        : 'completed'\n      : null\n    if (prevProgressState.current === state) return\n    prevProgressState.current = state\n    progress(state)\n  }, [progress, progressEnabled, hasToolsInProgress])\n  useEffect(() => {\n    return () => progress(null)\n  }, [progress])\n\n  const messageKey = useCallback(\n    (msg: RenderableMessage) => `${msg.uuid}-${conversationId}`,\n    [conversationId],\n  )\n\n  const renderMessageRow = (msg: RenderableMessage, index: number) => {\n    const prevType = index > 0 ? renderableMessages[index - 1]?.type : undefined\n    const isUserContinuation = msg.type === 'user' && prevType === 'user'\n    // hasContentAfter is only consumed for collapsed_read_search groups;\n    // skip the scan for everything else. streamingText is rendered as a\n    // sibling after this map, so it's never in renderableMessages — OR it\n    // in explicitly so the group flips to past tense as soon as text starts\n    // streaming instead of waiting for the block to finalize.\n    const hasContentAfter =\n      msg.type === 'collapsed_read_search' &&\n      (!!streamingText ||\n        hasContentAfterIndex(\n          renderableMessages,\n          index,\n          tools,\n          streamingToolUseIDs,\n        ))\n\n    const k = messageKey(msg)\n    const row = (\n      <MessageRow\n        key={k}\n        message={msg}\n        isUserContinuation={isUserContinuation}\n        hasContentAfter={hasContentAfter}\n        tools={tools}\n        commands={commands}\n        verbose={\n          verbose ||\n          isItemExpanded(msg) ||\n          (cursor?.expanded === true && index === selectedIdx)\n        }\n        inProgressToolUseIDs={inProgressToolUseIDs}\n        streamingToolUseIDs={streamingToolUseIDs}\n        screen={screen}\n        canAnimate={canAnimate}\n        onOpenRateLimitOptions={onOpenRateLimitOptions}\n        lastThinkingBlockId={lastThinkingBlockId}\n        latestBashOutputUUID={latestBashOutputUUID}\n        columns={columns}\n        isLoading={isLoading}\n        lookups={lookups}\n      />\n    )\n\n    // Per-row Provider — only 2 rows re-render on selection change.\n    // Wrapped BEFORE divider branch so both return paths get it.\n    const wrapped = (\n      <MessageActionsSelectedContext.Provider\n        key={k}\n        value={index === selectedIdx}\n      >\n        {row}\n      </MessageActionsSelectedContext.Provider>\n    )\n\n    if (unseenDivider && index === dividerBeforeIndex) {\n      return [\n        <Box key=\"unseen-divider\" marginTop={1}>\n          <Divider\n            title={`${unseenDivider.count} new ${plural(unseenDivider.count, 'message')}`}\n            width={columns}\n            color=\"inactive\"\n          />\n        </Box>,\n        wrapped,\n      ]\n    }\n    return wrapped\n  }\n\n  // Search indexing: for tool_result messages, look up the Tool and use\n  // its extractSearchText — tool-owned, precise, matches what\n  // renderToolResultMessage shows. Falls back to renderableSearchText\n  // (duck-types toolUseResult) for tools that haven't implemented it,\n  // and for all non-tool-result message types. The drift-catcher test\n  // (toolSearchText.test.tsx) renders + compares to keep these in sync.\n  //\n  // A second-React-root reconcile approach was tried and ruled out\n  // (measured 3.1ms/msg, growing — flushSyncWork processes all roots;\n  // component hooks mutate shared state → main root accumulates updates).\n  const searchTextCache = useRef(new WeakMap<RenderableMessage, string>())\n  const extractSearchText = useCallback(\n    (msg: RenderableMessage): string => {\n      const cached = searchTextCache.current.get(msg)\n      if (cached !== undefined) return cached\n      let text = renderableSearchText(msg)\n      // If this is a tool_result message and the tool implements\n      // extractSearchText, prefer that — it's precise (tool-owned)\n      // vs renderableSearchText's field-name heuristic.\n      if (\n        msg.type === 'user' &&\n        msg.toolUseResult &&\n        Array.isArray(msg.message.content)\n      ) {\n        const tr = msg.message.content.find(b => b.type === 'tool_result')\n        if (tr && 'tool_use_id' in tr) {\n          const tu = lookups.toolUseByToolUseID.get(tr.tool_use_id)\n          const tool = tu && findToolByName(tools, tu.name)\n          const extracted = tool?.extractSearchText?.(\n            msg.toolUseResult as never,\n          )\n          // undefined = tool didn't implement → keep heuristic. Empty\n          // string = tool says \"nothing to index\" → respect that.\n          if (extracted !== undefined) text = extracted\n        }\n      }\n      // Cache LOWERED: setSearchQuery's hot loop indexOfs per keystroke.\n      // Lowering here (once, at warm) vs there (every keystroke) trades\n      // ~same steady-state memory for zero per-keystroke alloc. Cache\n      // GC's with messages on transcript exit. Tool methods return raw;\n      // renderableSearchText already lowercases (redundant but cheap).\n      const lowered = text.toLowerCase()\n      searchTextCache.current.set(msg, lowered)\n      return lowered\n    },\n    [tools, lookups],\n  )\n\n  return (\n    <>\n      {/* Logo */}\n      {!hideLogo && !(renderRange && renderRange[0] > 0) && (\n        <LogoHeader agentDefinitions={agentDefinitions} />\n      )}\n\n      {/* Truncation indicator */}\n      {hasTruncatedMessages && (\n        <Divider\n          title={`${toggleShowAllShortcut} to show ${chalk.bold(hiddenMessageCount)} previous messages`}\n          width={columns}\n        />\n      )}\n\n      {/* Show all indicator */}\n      {isTranscriptMode &&\n        showAllInTranscript &&\n        hiddenMessageCount > 0 &&\n        // disableRenderCap (e.g. [ dump-to-scrollback) means we're uncapped\n        // as a one-shot escape hatch, not a toggle — ctrl+e is dead and\n        // nothing is actually \"hidden\" to restore.\n        !disableRenderCap && (\n          <Divider\n            title={`${toggleShowAllShortcut} to hide ${chalk.bold(hiddenMessageCount)} previous messages`}\n            width={columns}\n          />\n        )}\n\n      {/* Messages - rendered as memoized MessageRow components.\n          flatMap inserts the unseen-divider as a separate keyed sibling so\n          (a) non-fullscreen renders pay no per-message Fragment wrap, and\n          (b) divider toggle in fullscreen preserves all MessageRows by key.\n          Pre-compute derived values instead of passing renderableMessages to\n          each row - React Compiler pins props in the fiber's memoCache, so\n          passing the array would accumulate every historical version\n          (~1-2MB over a 7-turn session). */}\n      {virtualScrollRuntimeGate ? (\n        <InVirtualListContext.Provider value={true}>\n          <VirtualMessageList\n            messages={renderableMessages}\n            scrollRef={scrollRef}\n            columns={columns}\n            itemKey={messageKey}\n            renderItem={renderMessageRow}\n            onItemClick={onItemClick}\n            isItemClickable={isItemClickable}\n            isItemExpanded={isItemExpanded}\n            trackStickyPrompt={trackStickyPrompt}\n            selectedIndex={selectedIdx >= 0 ? selectedIdx : undefined}\n            cursorNavRef={cursorNavRef}\n            setCursor={setCursor}\n            jumpRef={jumpRef}\n            onSearchMatchesChange={onSearchMatchesChange}\n            scanElement={scanElement}\n            setPositions={setPositions}\n            extractSearchText={extractSearchText}\n          />\n        </InVirtualListContext.Provider>\n      ) : (\n        renderableMessages.flatMap(renderMessageRow)\n      )}\n\n      {streamingText && !isBriefOnly && (\n        <Box\n          alignItems=\"flex-start\"\n          flexDirection=\"row\"\n          marginTop={1}\n          width=\"100%\"\n        >\n          <Box flexDirection=\"row\">\n            <Box minWidth={2}>\n              <Text color=\"text\">{BLACK_CIRCLE}</Text>\n            </Box>\n            <Box flexDirection=\"column\">\n              <StreamingMarkdown>{streamingText}</StreamingMarkdown>\n            </Box>\n          </Box>\n        </Box>\n      )}\n\n      {isStreamingThinkingVisible && streamingThinking && !isBriefOnly && (\n        <Box marginTop={1}>\n          <AssistantThinkingMessage\n            param={{\n              type: 'thinking',\n              thinking: streamingThinking.thinking,\n            }}\n            addMargin={false}\n            isTranscriptMode={true}\n            verbose={verbose}\n            hideInTranscript={false}\n          />\n        </Box>\n      )}\n    </>\n  )\n}\n\n/** Key for click-to-expand: tool_use_id where available (so tool_use + its\n *  tool_result expand together), else uuid for groups/thinking. */\nfunction expandKey(msg: RenderableMessage): string {\n  return (\n    (msg.type === 'assistant' || msg.type === 'user'\n      ? getToolUseID(msg)\n      : null) ?? msg.uuid\n  )\n}\n\n// Custom comparator to prevent unnecessary re-renders during streaming.\n// Default React.memo does shallow comparison which fails when:\n// 1. onOpenRateLimitOptions callback is recreated (doesn't affect render output)\n// 2. streamingToolUses array is recreated on every delta, but only contentBlock matters for rendering\n// 3. streamingThinking changes on every delta - we DO want to re-render for this\nfunction setsEqual<T>(a: Set<T>, b: Set<T>): boolean {\n  if (a.size !== b.size) return false\n  for (const item of a) {\n    if (!b.has(item)) return false\n  }\n  return true\n}\n\nexport const Messages = React.memo(MessagesImpl, (prev, next) => {\n  const keys = Object.keys(prev) as (keyof typeof prev)[]\n  for (const key of keys) {\n    if (\n      key === 'onOpenRateLimitOptions' ||\n      key === 'scrollRef' ||\n      key === 'trackStickyPrompt' ||\n      key === 'setCursor' ||\n      key === 'cursorNavRef' ||\n      key === 'jumpRef' ||\n      key === 'onSearchMatchesChange' ||\n      key === 'scanElement' ||\n      key === 'setPositions'\n    )\n      continue\n    if (prev[key] !== next[key]) {\n      if (key === 'streamingToolUses') {\n        const p = prev.streamingToolUses\n        const n = next.streamingToolUses\n        if (\n          p.length === n.length &&\n          p.every((item, i) => item.contentBlock === n[i]?.contentBlock)\n        ) {\n          continue\n        }\n      }\n      if (key === 'inProgressToolUseIDs') {\n        if (setsEqual(prev.inProgressToolUseIDs, next.inProgressToolUseIDs)) {\n          continue\n        }\n      }\n      if (key === 'unseenDivider') {\n        const p = prev.unseenDivider\n        const n = next.unseenDivider\n        if (\n          p?.firstUnseenUuid === n?.firstUnseenUuid &&\n          p?.count === n?.count\n        ) {\n          continue\n        }\n      }\n      if (key === 'tools') {\n        const p = prev.tools\n        const n = next.tools\n        if (\n          p.length === n.length &&\n          p.every((tool, i) => tool.name === n[i]?.name)\n        ) {\n          continue\n        }\n      }\n      // streamingThinking changes frequently - always re-render when it changes\n      // (no special handling needed, default behavior is correct)\n      return false\n    }\n  }\n  return true\n})\n\nexport function shouldRenderStatically(\n  message: RenderableMessage,\n  streamingToolUseIDs: Set<string>,\n  inProgressToolUseIDs: Set<string>,\n  siblingToolUseIDs: ReadonlySet<string>,\n  screen: Screen,\n  lookups: ReturnType<typeof buildMessageLookups>,\n): boolean {\n  if (screen === 'transcript') {\n    return true\n  }\n  switch (message.type) {\n    case 'attachment':\n    case 'user':\n    case 'assistant': {\n      if (message.type === 'assistant') {\n        const block = message.message.content[0]\n        if (block?.type === 'server_tool_use') {\n          return lookups.resolvedToolUseIDs.has(block.id)\n        }\n      }\n      const toolUseID = getToolUseID(message)\n      if (!toolUseID) {\n        return true\n      }\n      if (streamingToolUseIDs.has(toolUseID)) {\n        return false\n      }\n      if (inProgressToolUseIDs.has(toolUseID)) {\n        return false\n      }\n\n      // Check if there are any unresolved PostToolUse hooks for this tool use\n      // If so, keep the message transient so the HookProgressMessage can update\n      if (hasUnresolvedHooksFromLookup(toolUseID, 'PostToolUse', lookups)) {\n        return false\n      }\n\n      return every(siblingToolUseIDs, lookups.resolvedToolUseIDs)\n    }\n    case 'system': {\n      // api errors always render dynamically, since we hide\n      // them as soon as we see another non-error message.\n      return message.subtype !== 'api_error'\n    }\n    case 'grouped_tool_use': {\n      const allResolved = message.messages.every(msg => {\n        const content = msg.message.content[0]\n        return (\n          content?.type === 'tool_use' &&\n          lookups.resolvedToolUseIDs.has(content.id)\n        )\n      })\n      return allResolved\n    }\n    case 'collapsed_read_search': {\n      // In prompt mode, never mark as static to prevent flicker between API turns\n      // (In transcript mode, we already returned true at the top of this function)\n      return false\n    }\n  }\n}\n"],"mappings":";AAAA,SAASA,OAAO,QAAQ,YAAY;AACpC,OAAOC,KAAK,MAAM,OAAO;AACzB,cAAcC,IAAI,QAAQ,QAAQ;AAClC,cAAcC,SAAS,QAAQ,OAAO;AACtC,OAAO,KAAKC,KAAK,MAAM,OAAO;AAC9B,SAASC,WAAW,EAAEC,SAAS,EAAEC,OAAO,EAAEC,MAAM,EAAEC,QAAQ,QAAQ,OAAO;AACzE,SAASC,KAAK,QAAQ,kBAAkB;AACxC,SAASC,eAAe,QAAQ,uBAAuB;AACvD,cAAcC,OAAO,QAAQ,gBAAgB;AAC7C,SAASC,YAAY,QAAQ,yBAAyB;AACtD,SAASC,eAAe,QAAQ,6BAA6B;AAC7D,cAAcC,eAAe,QAAQ,gCAAgC;AACrE,SAASC,uBAAuB,QAAQ,mCAAmC;AAC3E,SAASC,GAAG,EAAEC,IAAI,QAAQ,WAAW;AACrC,SAASC,kBAAkB,QAAQ,sCAAsC;AACzE,cAAcC,MAAM,QAAQ,oBAAoB;AAChD,cAAcC,KAAK,QAAQ,YAAY;AACvC,SAASC,cAAc,QAAQ,YAAY;AAC3C,cAAcC,sBAAsB,QAAQ,qCAAqC;AACjF,cACEC,OAAO,IAAIC,WAAW,EACtBC,iBAAiB,EACjBC,eAAe,IAAIC,mBAAmB,EACtCC,iBAAiB,QACZ,qBAAqB;AAC5B,SAAS,KAAKC,YAAY,EAAEC,cAAc,QAAQ,qBAAqB;AACvE,SAASC,mCAAmC,QAAQ,iDAAiD;AACrG,SAASC,qBAAqB,QAAQ,mCAAmC;AACzE,SAASC,wBAAwB,QAAQ,gCAAgC;AACzE,SAASC,yBAAyB,QAAQ,uCAAuC;AACjF,SAASC,eAAe,QAAQ,oBAAoB;AACpD,SAASC,WAAW,QAAQ,sBAAsB;AAClD,SAASC,sBAAsB,QAAQ,wBAAwB;AAC/D,SAASC,aAAa,QAAQ,2BAA2B;AACzD,SACEC,mBAAmB,EACnBC,sBAAsB,EACtBC,UAAU,EACVC,+BAA+B,EAC/BC,YAAY,EACZC,aAAa,EACbC,4BAA4B,EAC5BC,iBAAiB,EACjBC,iBAAiB,EACjBC,mBAAmB,EACnB,KAAKC,iBAAiB,EACtB,KAAKC,gBAAgB,EACrBC,qBAAqB,QAChB,sBAAsB;AAC7B,SAASC,MAAM,QAAQ,yBAAyB;AAChD,SAASC,oBAAoB,QAAQ,8BAA8B;AACnE,SAASC,OAAO,QAAQ,4BAA4B;AACpD,cAAcC,aAAa,QAAQ,uBAAuB;AAC1D,SAASC,MAAM,QAAQ,oBAAoB;AAC3C,SAASC,iBAAiB,QAAQ,eAAe;AACjD,SAASC,oBAAoB,EAAEC,UAAU,QAAQ,iBAAiB;AAClE,SACEC,oBAAoB,EACpB,KAAKC,iBAAiB,EACtBC,6BAA6B,EAC7B,KAAKC,mBAAmB,QACnB,qBAAqB;AAC5B,SAASC,wBAAwB,QAAQ,wCAAwC;AACjF,SAASC,yBAAyB,QAAQ,wCAAwC;AAClF,SAASC,eAAe,QAAQ,sBAAsB;AACtD,cAAcC,cAAc,QAAQ,oCAAoC;AACxE,SAASC,aAAa,QAAQ,oBAAoB;AAClD,cAAcC,UAAU,QAAQ,yBAAyB;;AAEzD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,MAAMC,UAAU,GAAGnE,KAAK,CAACoE,IAAI,CAAC,SAAAD,WAAAE,EAAA;EAAA,MAAAC,CAAA,GAAAC,EAAA;EAAoB;IAAAC;EAAA,IAAAH,EAIjD;EAAA,IAAAI,EAAA;EAAA,IAAAH,CAAA,QAAAI,MAAA,CAAAC,GAAA;IAOOF,EAAA,IAAC,MAAM,GAAG;IAAAH,CAAA,MAAAG,EAAA;EAAA;IAAAA,EAAA,GAAAH,CAAA;EAAA;EAAA,IAAAM,EAAA;EAAA,IAAAN,CAAA,QAAAE,gBAAA;IAFdI,EAAA,IAAC,eAAe,CACd,CAAC,GAAG,CAAe,aAAQ,CAAR,QAAQ,CAAM,GAAC,CAAD,GAAC,CAChC,CAAAH,EAAS,CACT,gBAA0B,QAAI,CAAJ,KAAG,CAAC,CAC5B,CAAC,aAAa,CAAmBD,gBAAgB,CAAhBA,iBAAe,CAAC,GACnD,iBACF,EALC,GAAG,CAMN,EAPC,eAAe,CAOE;IAAAF,CAAA,MAAAE,gBAAA;IAAAF,CAAA,MAAAM,EAAA;EAAA;IAAAA,EAAA,GAAAN,CAAA;EAAA;EAAA,OAPlBM,EAOkB;AAAA,CAErB,CAAC;;AAEF;AACA;AACA,MAAMC,eAAe,GACnBjF,OAAO,CAAC,WAAW,CAAC,IAAIA,OAAO,CAAC,QAAQ,CAAC,GACrCkF,OAAO,CAAC,uBAAuB,CAAC,GAChC,IAAI;AACV,MAAMC,eAAe,EAAE,MAAM,GAAG,IAAI,GAClCnF,OAAO,CAAC,QAAQ,CAAC,IAAIA,OAAO,CAAC,cAAc,CAAC,GACxC,CACEkF,OAAO,CAAC,8BAA8B,CAAC,IAAI,OAAO,OAAO,8BAA8B,CAAC,EACxFC,eAAe,GACjB,IAAI;AACV,MAAMC,wBAAwB,EAAE,MAAM,GAAG,IAAI,GAAGpF,OAAO,CAAC,QAAQ,CAAC,GAC7D,CACEkF,OAAO,CAAC,qCAAqC,CAAC,IAAI,OAAO,OAAO,qCAAqC,CAAC,EACtGE,wBAAwB,GAC1B,IAAI;;AAER;AACA,SAASC,kBAAkB,QAAQ,yBAAyB;;AAE5D;AACA;AACA;AACA;AACA;AACA;AACA,OAAO,SAASC,kBAAkB,CAChC,UAAU;EACRC,IAAI,EAAE,MAAM;EACZC,OAAO,CAAC,EAAE,MAAM;EAChBC,MAAM,CAAC,EAAE,OAAO;EAChBC,iBAAiB,CAAC,EAAE,OAAO;EAC3BC,OAAO,CAAC,EAAE;IACRC,OAAO,EAAEC,KAAK,CAAC;MACbN,IAAI,EAAE,MAAM;MACZO,IAAI,CAAC,EAAE,MAAM;MACbC,WAAW,CAAC,EAAE,MAAM;IACtB,CAAC,CAAC;EACJ,CAAC;EACDC,UAAU,CAAC,EAAE;IACXT,IAAI,EAAE,MAAM;IACZE,MAAM,CAAC,EAAE,OAAO;IAChBQ,MAAM,CAAC,EAAE,OAAO;IAChBC,WAAW,CAAC,EAAE,MAAM;EACtB,CAAC;AACH,CAAC,CACFZ,CAACa,QAAQ,EAAEC,CAAC,EAAE,EAAEC,cAAc,EAAE,MAAM,EAAE,CAAC,EAAED,CAAC,EAAE,CAAC;EAC9C,MAAME,OAAO,GAAG,IAAIC,GAAG,CAACF,cAAc,CAAC;EACvC;EACA;EACA,MAAMG,eAAe,GAAG,IAAID,GAAG,CAAC,MAAM,CAAC,CAAC,CAAC;EACzC,OAAOJ,QAAQ,CAACM,MAAM,CAACC,GAAG,IAAI;IAC5B;IACA;IACA;IACA;IACA;IACA,IAAIA,GAAG,CAACnB,IAAI,KAAK,QAAQ,EAAE,OAAOmB,GAAG,CAAClB,OAAO,KAAK,aAAa;IAC/D,MAAMmB,KAAK,GAAGD,GAAG,CAACf,OAAO,EAAEC,OAAO,CAAC,CAAC,CAAC;IACrC,IAAIc,GAAG,CAACnB,IAAI,KAAK,WAAW,EAAE;MAC5B;MACA,IAAImB,GAAG,CAAChB,iBAAiB,EAAE,OAAO,IAAI;MACtC;MACA;MACA,IAAIiB,KAAK,EAAEpB,IAAI,KAAK,UAAU,IAAIoB,KAAK,CAACb,IAAI,IAAIQ,OAAO,CAACM,GAAG,CAACD,KAAK,CAACb,IAAI,CAAC,EAAE;QACvE,IAAI,IAAI,IAAIa,KAAK,EAAE;UACjBH,eAAe,CAACK,GAAG,CAAC,CAACF,KAAK,IAAI;YAAEG,EAAE,EAAE,MAAM;UAAC,CAAC,EAAEA,EAAE,CAAC;QACnD;QACA,OAAO,IAAI;MACb;MACA,OAAO,KAAK;IACd;IACA,IAAIJ,GAAG,CAACnB,IAAI,KAAK,MAAM,EAAE;MACvB,IAAIoB,KAAK,EAAEpB,IAAI,KAAK,aAAa,EAAE;QACjC,OACEoB,KAAK,CAACZ,WAAW,KAAKgB,SAAS,IAC/BP,eAAe,CAACI,GAAG,CAACD,KAAK,CAACZ,WAAW,CAAC;MAE1C;MACA;MACA,OAAO,CAACW,GAAG,CAACjB,MAAM;IACpB;IACA,IAAIiB,GAAG,CAACnB,IAAI,KAAK,YAAY,EAAE;MAC7B;MACA;MACA;MACA;MACA;MACA;MACA,MAAMyB,GAAG,GAAGN,GAAG,CAACV,UAAU;MAC1B,OACEgB,GAAG,EAAEzB,IAAI,KAAK,gBAAgB,IAC9ByB,GAAG,CAACd,WAAW,KAAK,QAAQ,IAC5B,CAACc,GAAG,CAACvB,MAAM,IACXuB,GAAG,CAACf,MAAM,KAAKc,SAAS;IAE5B;IACA,OAAO,KAAK;EACd,CAAC,CAAC;AACJ;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,OAAO,SAASE,oBAAoB,CAClC,UAAU;EACR1B,IAAI,EAAE,MAAM;EACZE,MAAM,CAAC,EAAE,OAAO;EAChBE,OAAO,CAAC,EAAE;IAAEC,OAAO,EAAEC,KAAK,CAAC;MAAEN,IAAI,EAAE,MAAM;MAAEO,IAAI,CAAC,EAAE,MAAM;IAAC,CAAC,CAAC;EAAC,CAAC;AAC/D,CAAC,CACFmB,CAACd,QAAQ,EAAEC,CAAC,EAAE,EAAEC,cAAc,EAAE,MAAM,EAAE,CAAC,EAAED,CAAC,EAAE,CAAC;EAC9C,MAAME,OAAO,GAAG,IAAIC,GAAG,CAACF,cAAc,CAAC;EACvC;EACA;EACA,MAAMa,cAAc,GAAG,IAAIX,GAAG,CAAC,MAAM,CAAC,CAAC,CAAC;EACxC,MAAMY,eAAe,EAAE,MAAM,EAAE,GAAG,EAAE;EACpC,IAAIC,IAAI,GAAG,CAAC;EACZ,KAAK,IAAIC,CAAC,GAAG,CAAC,EAAEA,CAAC,GAAGlB,QAAQ,CAACmB,MAAM,EAAED,CAAC,EAAE,EAAE;IACxC,MAAMX,GAAG,GAAGP,QAAQ,CAACkB,CAAC,CAAC,CAAC;IACxB,MAAMV,KAAK,GAAGD,GAAG,CAACf,OAAO,EAAEC,OAAO,CAAC,CAAC,CAAC;IACrC,IAAIc,GAAG,CAACnB,IAAI,KAAK,MAAM,IAAIoB,KAAK,EAAEpB,IAAI,KAAK,aAAa,IAAI,CAACmB,GAAG,CAACjB,MAAM,EAAE;MACvE2B,IAAI,EAAE;MACN;IACF;IACA,IAAIV,GAAG,CAACnB,IAAI,KAAK,WAAW,EAAE;MAC5B,IAAIoB,KAAK,EAAEpB,IAAI,KAAK,MAAM,EAAE;QAC1B4B,eAAe,CAACE,CAAC,CAAC,GAAGD,IAAI;MAC3B,CAAC,MAAM,IACLT,KAAK,EAAEpB,IAAI,KAAK,UAAU,IAC1BoB,KAAK,CAACb,IAAI,IACVQ,OAAO,CAACM,GAAG,CAACD,KAAK,CAACb,IAAI,CAAC,EACvB;QACAoB,cAAc,CAACL,GAAG,CAACO,IAAI,CAAC;MAC1B;IACF;EACF;EACA,IAAIF,cAAc,CAACK,IAAI,KAAK,CAAC,EAAE,OAAOpB,QAAQ;EAC9C;EACA,OAAOA,QAAQ,CAACM,MAAM,CAAC,CAACe,CAAC,EAAEH,CAAC,KAAK;IAC/B,MAAMI,CAAC,GAAGN,eAAe,CAACE,CAAC,CAAC;IAC5B,OAAOI,CAAC,KAAKV,SAAS,IAAI,CAACG,cAAc,CAACN,GAAG,CAACa,CAAC,CAAC;EAClD,CAAC,CAAC;AACJ;AAEA,KAAKC,KAAK,GAAG;EACXvB,QAAQ,EAAE1E,WAAW,EAAE;EACvBkG,KAAK,EAAEtG,KAAK;EACZuG,QAAQ,EAAEhH,OAAO,EAAE;EACnBiH,OAAO,EAAE,OAAO;EAChBC,OAAO,EAAE;IACPC,GAAG,EAAE3H,KAAK,CAAC4H,SAAS,GAAG,IAAI;IAC3BC,qBAAqB,EAAE,OAAO;IAC9BC,uBAAuB,CAAC,EAAE,IAAI;EAChC,CAAC,GAAG,IAAI;EACRC,mBAAmB,EAAE/D,cAAc,EAAE;EACrCgE,oBAAoB,EAAE7B,GAAG,CAAC,MAAM,CAAC;EACjC8B,wBAAwB,EAAE,OAAO;EACjCC,cAAc,EAAE,MAAM;EACtBC,MAAM,EAAEnH,MAAM;EACdoH,iBAAiB,EAAErF,gBAAgB,EAAE;EACrCsF,mBAAmB,CAAC,EAAE,OAAO;EAC7B7D,gBAAgB,CAAC,EAAErD,sBAAsB;EACzCmH,sBAAsB,CAAC,EAAE,GAAG,GAAG,IAAI;EACnC;EACAC,QAAQ,CAAC,EAAE,OAAO;EAClBC,SAAS,EAAE,OAAO;EAClB;EACAC,gBAAgB,CAAC,EAAE,OAAO;EAC1B;EACAC,iBAAiB,CAAC,EAAE5F,iBAAiB,GAAG,IAAI;EAC5C;EACA6F,aAAa,CAAC,EAAE,MAAM,GAAG,IAAI;EAC7B;EACAC,WAAW,CAAC,EAAE,OAAO;EACrB;AACF;AACA;EACEC,aAAa,CAAC,EAAEzF,aAAa;EAC7B;EACA0F,SAAS,CAAC,EAAE/I,SAAS,CAACY,eAAe,GAAG,IAAI,CAAC;EAC7C;EACAoI,iBAAiB,CAAC,EAAE,OAAO;EAC3B;EACAC,OAAO,CAAC,EAAEjJ,SAAS,CAACmE,UAAU,GAAG,IAAI,CAAC;EACtC;EACA+E,qBAAqB,CAAC,EAAE,CAACC,KAAK,EAAE,MAAM,EAAEC,OAAO,EAAE,MAAM,EAAE,GAAG,IAAI;EAChE;AACF;EACEC,WAAW,CAAC,EAAE,CACZC,EAAE,EAAE,OAAO,eAAe,EAAEC,UAAU,EACtC,GAAG,OAAO,4BAA4B,EAAEC,aAAa,EAAE;EACzD;AACF;EACEC,YAAY,CAAC,EAAE,CACbC,KAAK,EAAE;IACLC,SAAS,EAAE,OAAO,4BAA4B,EAAEH,aAAa,EAAE;IAC/DI,SAAS,EAAE,MAAM;IACjBC,UAAU,EAAE,MAAM;EACpB,CAAC,GAAG,IAAI,EACR,GAAG,IAAI;EACT;AACF;AACA;EACEC,gBAAgB,CAAC,EAAE,OAAO;EAC1B;EACAC,MAAM,CAAC,EAAElG,mBAAmB,GAAG,IAAI;EACnCmG,SAAS,CAAC,EAAE,CAACD,MAAM,EAAElG,mBAAmB,GAAG,IAAI,EAAE,GAAG,IAAI;EACxD;EACAoG,YAAY,CAAC,EAAEhK,KAAK,CAACiK,GAAG,CAACvG,iBAAiB,CAAC;EAC3C;AACF;AACA;AACA;AACA;AACA;EACEwG,WAAW,CAAC,EAAE,SAAS,CAACC,KAAK,EAAE,MAAM,EAAEC,GAAG,EAAE,MAAM,CAAC;AACrD,CAAC;AAED,MAAMC,uCAAuC,GAAG,EAAE;;AAElD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,MAAMC,mCAAmC,GAAG,GAAG;AAC/C,MAAMC,gBAAgB,GAAG,EAAE;AAE3B,OAAO,KAAKC,WAAW,GAAG;EAAEC,IAAI,EAAE,MAAM;EAAEC,GAAG,EAAE,MAAM;AAAC,CAAC,GAAG,IAAI;;AAE9D;AACA,OAAO,SAASC,iBAAiBA,CAC/BC,SAAS,EAAEC,aAAa,CAAC;EAAEJ,IAAI,EAAE,MAAM;AAAC,CAAC,CAAC,EAC1CK,SAAS,EAAE;EAAE3B,OAAO,EAAEqB,WAAW;AAAC,CAAC,EACnCO,GAAG,GAAGT,mCAAmC,EACzCU,IAAI,GAAGT,gBAAgB,CACxB,EAAE,MAAM,CAAC;EACR,MAAMU,MAAM,GAAGH,SAAS,CAAC3B,OAAO;EAChC,MAAM+B,SAAS,GAAGD,MAAM,GACpBL,SAAS,CAACO,SAAS,CAACC,CAAC,IAAIA,CAAC,CAACX,IAAI,KAAKQ,MAAM,CAACR,IAAI,CAAC,GAChD,CAAC,CAAC;EACN;EACA;EACA,IAAIN,KAAK,GACPe,SAAS,IAAI,CAAC,GACVA,SAAS,GACTD,MAAM,GACJI,IAAI,CAACC,GAAG,CAACL,MAAM,CAACP,GAAG,EAAEW,IAAI,CAACE,GAAG,CAAC,CAAC,EAAEX,SAAS,CAAC1D,MAAM,GAAG6D,GAAG,CAAC,CAAC,GACzD,CAAC;EACT,IAAIH,SAAS,CAAC1D,MAAM,GAAGiD,KAAK,GAAGY,GAAG,GAAGC,IAAI,EAAE;IACzCb,KAAK,GAAGS,SAAS,CAAC1D,MAAM,GAAG6D,GAAG;EAChC;EACA;EACA;EACA,MAAMS,UAAU,GAAGZ,SAAS,CAACT,KAAK,CAAC;EACnC,IACEqB,UAAU,KACTP,MAAM,EAAER,IAAI,KAAKe,UAAU,CAACf,IAAI,IAAIQ,MAAM,CAACP,GAAG,KAAKP,KAAK,CAAC,EAC1D;IACAW,SAAS,CAAC3B,OAAO,GAAG;MAAEsB,IAAI,EAAEe,UAAU,CAACf,IAAI;MAAEC,GAAG,EAAEP;IAAM,CAAC;EAC3D,CAAC,MAAM,IAAI,CAACqB,UAAU,IAAIP,MAAM,EAAE;IAChCH,SAAS,CAAC3B,OAAO,GAAG,IAAI;EAC1B;EACA,OAAOgB,KAAK;AACd;AAEA,MAAMsB,YAAY,GAAGA,CAAC;EACpB1F,QAAQ;EACRwB,KAAK;EACLC,QAAQ;EACRC,OAAO;EACPC,OAAO;EACPK,mBAAmB;EACnBC,oBAAoB;EACpBC,wBAAwB;EACxBC,cAAc;EACdC,MAAM;EACNC,iBAAiB;EACjBC,mBAAmB,GAAG,KAAK;EAC3B7D,gBAAgB;EAChB8D,sBAAsB;EACtBC,QAAQ,GAAG,KAAK;EAChBC,SAAS;EACTC,gBAAgB,GAAG,KAAK;EACxBC,iBAAiB;EACjBC,aAAa;EACbC,WAAW,GAAG,KAAK;EACnBC,aAAa;EACbC,SAAS;EACTC,iBAAiB;EACjBC,OAAO;EACPC,qBAAqB;EACrBG,WAAW;EACXI,YAAY;EACZK,gBAAgB,GAAG,KAAK;EACxBC,MAAM,GAAG,IAAI;EACbC,SAAS;EACTC,YAAY;EACZE;AACK,CAAN,EAAE5C,KAAK,CAAC,EAAEtH,KAAK,CAAC4H,SAAS,IAAI;EAC5B,MAAM;IAAE8D;EAAQ,CAAC,GAAGhL,eAAe,CAAC,CAAC;EACrC,MAAMiL,qBAAqB,GAAG5K,kBAAkB,CAC9C,0BAA0B,EAC1B,YAAY,EACZ,QACF,CAAC;EAED,MAAM6K,kBAAkB,GAAGzL,OAAO,CAChC,MAAMyC,iBAAiB,CAACmD,QAAQ,CAAC,CAACM,MAAM,CAAC1D,iBAAiB,CAAC,EAC3D,CAACoD,QAAQ,CACX,CAAC;;EAED;EACA,MAAM8F,0BAA0B,GAAG1L,OAAO,CAAC,MAAM;IAC/C,IAAI,CAACuI,iBAAiB,EAAE,OAAO,KAAK;IACpC,IAAIA,iBAAiB,CAACoD,WAAW,EAAE,OAAO,IAAI;IAC9C,IAAIpD,iBAAiB,CAACqD,gBAAgB,EAAE;MACtC,OAAOC,IAAI,CAACC,GAAG,CAAC,CAAC,GAAGvD,iBAAiB,CAACqD,gBAAgB,GAAG,KAAK;IAChE;IACA,OAAO,KAAK;EACd,CAAC,EAAE,CAACrD,iBAAiB,CAAC,CAAC;;EAEvB;EACA;EACA;EACA;EACA,MAAMwD,mBAAmB,GAAG/L,OAAO,CAAC,MAAM;IACxC,IAAI,CAACsI,gBAAgB,EAAE,OAAO,IAAI;IAClC;IACA,IAAIoD,0BAA0B,EAAE,OAAO,WAAW;IAClD;IACA,KAAK,IAAI5E,CAAC,GAAG2E,kBAAkB,CAAC1E,MAAM,GAAG,CAAC,EAAED,CAAC,IAAI,CAAC,EAAEA,CAAC,EAAE,EAAE;MACvD,MAAMX,GAAG,GAAGsF,kBAAkB,CAAC3E,CAAC,CAAC;MACjC,IAAIX,GAAG,EAAEnB,IAAI,KAAK,WAAW,EAAE;QAC7B,MAAMK,OAAO,GAAGc,GAAG,CAACf,OAAO,CAACC,OAAO;QACnC;QACA,KAAK,IAAI2G,CAAC,GAAG3G,OAAO,CAAC0B,MAAM,GAAG,CAAC,EAAEiF,CAAC,IAAI,CAAC,EAAEA,CAAC,EAAE,EAAE;UAC5C,IAAI3G,OAAO,CAAC2G,CAAC,CAAC,EAAEhH,IAAI,KAAK,UAAU,EAAE;YACnC,OAAO,GAAGmB,GAAG,CAACmE,IAAI,IAAI0B,CAAC,EAAE;UAC3B;QACF;MACF,CAAC,MAAM,IAAI7F,GAAG,EAAEnB,IAAI,KAAK,MAAM,EAAE;QAC/B,MAAMiH,aAAa,GAAG9F,GAAG,CAACf,OAAO,CAACC,OAAO,CAAC6G,IAAI,CAC5C9F,KAAK,IAAIA,KAAK,CAACpB,IAAI,KAAK,aAC1B,CAAC;QACD,IAAI,CAACiH,aAAa,EAAE;UAClB;UACA,OAAO,aAAa;QACtB;MACF;IACF;IACA,OAAO,IAAI;EACb,CAAC,EAAE,CAACR,kBAAkB,EAAEnD,gBAAgB,EAAEoD,0BAA0B,CAAC,CAAC;;EAEtE;EACA;EACA,MAAMS,oBAAoB,GAAGnM,OAAO,CAAC,MAAM;IACzC;IACA,KAAK,IAAI8G,GAAC,GAAG2E,kBAAkB,CAAC1E,MAAM,GAAG,CAAC,EAAED,GAAC,IAAI,CAAC,EAAEA,GAAC,EAAE,EAAE;MACvD,MAAMX,KAAG,GAAGsF,kBAAkB,CAAC3E,GAAC,CAAC;MACjC,IAAIX,KAAG,EAAEnB,IAAI,KAAK,MAAM,EAAE;QACxB,MAAMK,SAAO,GAAGc,KAAG,CAACf,OAAO,CAACC,OAAO;QACnC;QACA,KAAK,MAAMe,OAAK,IAAIf,SAAO,EAAE;UAC3B,IAAIe,OAAK,CAACpB,IAAI,KAAK,MAAM,EAAE;YACzB,MAAMoH,IAAI,GAAGhG,OAAK,CAACgG,IAAI;YACvB,IACEA,IAAI,CAACC,UAAU,CAAC,cAAc,CAAC,IAC/BD,IAAI,CAACC,UAAU,CAAC,cAAc,CAAC,EAC/B;cACA,OAAOlG,KAAG,CAACmE,IAAI;YACjB;UACF;QACF;MACF;IACF;IACA,OAAO,IAAI;EACb,CAAC,EAAE,CAACmB,kBAAkB,CAAC,CAAC;;EAExB;EACA;EACA,MAAMa,oBAAoB,GAAGtM,OAAO,CAClC,MAAMsC,aAAa,CAACmJ,kBAAkB,CAAC,EACvC,CAACA,kBAAkB,CACrB,CAAC;EAED,MAAMc,kCAAkC,GAAGvM,OAAO,CAChD,MACEiI,iBAAiB,CAAC/B,MAAM,CACtBsG,GAAG,IACD,CAAC3E,oBAAoB,CAACxB,GAAG,CAACmG,GAAG,CAACC,YAAY,CAAClG,EAAE,CAAC,IAC9C,CAAC+F,oBAAoB,CAACjG,GAAG,CAACmG,GAAG,CAACC,YAAY,CAAClG,EAAE,CACjD,CAAC,EACH,CAAC0B,iBAAiB,EAAEJ,oBAAoB,EAAEyE,oBAAoB,CAChE,CAAC;EAED,MAAMI,iCAAiC,GAAG1M,OAAO,CAC/C,MACEuM,kCAAkC,CAACI,OAAO,CAACC,gBAAgB,IAAI;IAC7D,MAAMzG,KAAG,GAAGjE,sBAAsB,CAAC;MACjCmD,OAAO,EAAE,CAACuH,gBAAgB,CAACH,YAAY;IACzC,CAAC,CAAC;IACF;IACA;IACA;IACA;IACA;IACAtG,KAAG,CAACmE,IAAI,GAAGnI,UAAU,CAACyK,gBAAgB,CAACH,YAAY,CAAClG,EAAE,IAAI5G,IAAI,EAAE,CAAC,CAAC;IAClE,OAAO8C,iBAAiB,CAAC,CAAC0D,KAAG,CAAC,CAAC;EACjC,CAAC,CAAC,EACJ,CAACoG,kCAAkC,CACrC,CAAC;EAED,MAAMM,gBAAgB,GAAG7E,MAAM,KAAK,YAAY;EAChD;EACA,MAAM8E,oBAAoB,GAAG9M,OAAO,CAClC,MAAM8B,WAAW,CAACiL,OAAO,CAACC,GAAG,CAACC,kCAAkC,CAAC,EACjE,EACF,CAAC;EACD;EACA;EACA;EACA;EACA,MAAMC,wBAAwB,GAAGvE,SAAS,IAAI,IAAI,IAAI,CAACmE,oBAAoB;EAC3E,MAAMK,cAAc,GAClBN,gBAAgB,IAAI,CAAC3E,mBAAmB,IAAI,CAACgF,wBAAwB;;EAEvE;EACA;EACA;EACA;EACA,MAAME,cAAc,GAAGnN,MAAM,CAACoK,WAAW,CAAC,CAAC,IAAI,CAAC;;EAEhD;EACA;EACA;EACA;EACA;EACA;EACA,MAAM;IAAEI,SAAS,EAATA,WAAS;IAAE4C,OAAO,EAAPA,SAAO;IAAEC,oBAAoB,EAApBA,sBAAoB;IAAEC,kBAAkB,EAAlBA;EAAmB,CAAC,GACpEvN,OAAO,CAAC,MAAM;IACZ;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA,MAAMwN,oBAAoB,GACxBlG,OAAO,IAAIvF,sBAAsB,CAAC,CAAC,GAC/B0J,kBAAkB,GAClBrJ,+BAA+B,CAACqJ,kBAAkB,EAAE;MAClDgC,cAAc,EAAE;IAClB,CAAC,CAAC;IAER,MAAMC,0BAA0B,GAAGhL,mBAAmB,CACpD8K,oBAAoB,CACjBtH,MAAM,CACL,CAACC,KAAG,CAAC,EAAEA,KAAG,IAAIwH,OAAO,CAACxM,iBAAiB,EAAEE,mBAAmB,CAAC,IAC3D8E,KAAG,CAACnB,IAAI,KAAK,UACjB;IACA;IACA;IACA;IACA;IAAA,CACCkB,MAAM,CAACC,KAAG,IAAI,CAACxC,yBAAyB,CAACwC,KAAG,CAAC,CAAC,CAC9CD,MAAM,CAACe,CAAC,IAAIpE,qBAAqB,CAACoE,CAAC,EAAE4F,gBAAgB,CAAC,CAAC,EAC1DH,iCACF,CAAC;IACD;IACA;IACA;IACA;IACA,MAAM5G,cAAc,GAAG,CAAClB,eAAe,EAAEC,wBAAwB,CAAC,CAACqB,MAAM,CACvE,CAAC0H,CAAC,CAAC,EAAEA,CAAC,IAAI,MAAM,IAAIA,CAAC,KAAK,IAC5B,CAAC;IACD;IACA;IACA;IACA,MAAMC,iBAAiB,GAAG,CAACjJ,eAAe,CAAC,CAACsB,MAAM,CAChD,CAAC0H,GAAC,CAAC,EAAEA,GAAC,IAAI,MAAM,IAAIA,GAAC,KAAK,IAC5B,CAAC;IACD,MAAME,aAAa,GACjBhI,cAAc,CAACiB,MAAM,GAAG,CAAC,IAAI,CAAC8F,gBAAgB,GAC1CpE,WAAW,GACT1D,kBAAkB,CAAC2I,0BAA0B,EAAE5H,cAAc,CAAC,GAC9D+H,iBAAiB,CAAC9G,MAAM,GAAG,CAAC,GAC1BL,oBAAoB,CAClBgH,0BAA0B,EAC1BG,iBACF,CAAC,GACDH,0BAA0B,GAC9BA,0BAA0B;IAEhC,MAAMK,cAAc,GAAGZ,cAAc,GACjCW,aAAa,CAACE,KAAK,CAAC,CAAC9D,uCAAuC,CAAC,GAC7D4D,aAAa;IAEjB,MAAMR,oBAAoB,GACxBH,cAAc,IACdW,aAAa,CAAC/G,MAAM,GAAGmD,uCAAuC;IAEhE,MAAM;MAAEtE,QAAQ,EAAEqI;IAAgB,CAAC,GAAGjM,aAAa,CACjD+L,cAAc,EACd3G,KAAK,EACLE,OACF,CAAC;IAED,MAAMmD,SAAS,GAAGhJ,mCAAmC,CACnDC,qBAAqB,CACnBE,yBAAyB,CACvBD,wBAAwB,CAACsM,eAAe,EAAE7G,KAAK,CACjD,CACF,CAAC,EACDE,OACF,CAAC;IAED,MAAM+F,OAAO,GAAGpL,mBAAmB,CAACwJ,kBAAkB,EAAEsC,cAAc,CAAC;IAEvE,MAAMR,kBAAkB,GACtBG,0BAA0B,CAAC3G,MAAM,GACjCmD,uCAAuC;IAEzC,OAAO;MACLO,SAAS;MACT4C,OAAO;MACPC,oBAAoB;MACpBC;IACF,CAAC;EACH,CAAC,EAAE,CACDjG,OAAO,EACPmE,kBAAkB,EAClBoB,gBAAgB,EAChBH,iCAAiC,EACjCS,cAAc,EACd/F,KAAK,EACLqB,WAAW,CACZ,CAAC;;EAEJ;EACA,MAAMyF,kBAAkB,GAAGlO,OAAO,CAAC,MAAM;IACvC;IACA;IACA;IACA;IACA;IACA;IACA;IACA,MAAMmO,UAAU,GAAG,CAACjB,wBAAwB,IAAI,CAACxD,gBAAgB;IACjE,MAAM0E,UAAU,GAAGD,UAAU,GACzB3D,iBAAiB,CAACC,WAAS,EAAE2C,cAAc,CAAC,GAC5C,CAAC;IACL,OAAOrD,WAAW,GACdU,WAAS,CAACuD,KAAK,CAACjE,WAAW,CAAC,CAAC,CAAC,EAAEA,WAAW,CAAC,CAAC,CAAC,CAAC,GAC/CqE,UAAU,GAAG,CAAC,GACZ3D,WAAS,CAACuD,KAAK,CAACI,UAAU,CAAC,GAC3B3D,WAAS;EACjB,CAAC,EAAE,CAACA,WAAS,EAAEV,WAAW,EAAEmD,wBAAwB,EAAExD,gBAAgB,CAAC,CAAC;EAExE,MAAM2E,mBAAmB,GAAGrO,OAAO,CACjC,MAAM,IAAIgG,GAAG,CAACiC,iBAAiB,CAACqG,GAAG,CAACrH,GAAC,IAAIA,GAAC,CAACwF,YAAY,CAAClG,EAAE,CAAC,CAAC,EAC5D,CAAC0B,iBAAiB,CACpB,CAAC;;EAED;EACA;EACA;EACA,MAAMsG,kBAAkB,GAAGvO,OAAO,CAAC,MAAM;IACvC,IAAI,CAAC0I,aAAa,EAAE,OAAO,CAAC,CAAC;IAC7B,MAAM8F,MAAM,GAAG9F,aAAa,CAAC+F,eAAe,CAACT,KAAK,CAAC,CAAC,EAAE,EAAE,CAAC;IACzD,OAAOE,kBAAkB,CAAClD,SAAS,CAACC,CAAC,IAAIA,CAAC,CAACX,IAAI,CAAC0D,KAAK,CAAC,CAAC,EAAE,EAAE,CAAC,KAAKQ,MAAM,CAAC;EAC1E,CAAC,EAAE,CAAC9F,aAAa,EAAEwF,kBAAkB,CAAC,CAAC;EAEvC,MAAMQ,WAAW,GAAG1O,OAAO,CAAC,MAAM;IAChC,IAAI,CAAC2J,MAAM,EAAE,OAAO,CAAC,CAAC;IACtB,OAAOuE,kBAAkB,CAAClD,SAAS,CAACC,GAAC,IAAIA,GAAC,CAACX,IAAI,KAAKX,MAAM,CAACW,IAAI,CAAC;EAClE,CAAC,EAAE,CAACX,MAAM,EAAEuE,kBAAkB,CAAC,CAAC;;EAEhC;EACA;EACA;EACA;EACA,MAAM,CAACS,YAAY,EAAEC,eAAe,CAAC,GAAG1O,QAAQ,CAAC2O,WAAW,CAAC,MAAM,CAAC,CAAC,CACnE,MAAM,IAAI7I,GAAG,CAAC,CAChB,CAAC;EACD,MAAM8I,WAAW,GAAGhP,WAAW,CAAC,CAACqG,KAAG,EAAE7E,iBAAiB,KAAK;IAC1D,MAAMyN,CAAC,GAAGC,SAAS,CAAC7I,KAAG,CAAC;IACxByI,eAAe,CAACK,IAAI,IAAI;MACtB,MAAMC,IAAI,GAAG,IAAIlJ,GAAG,CAACiJ,IAAI,CAAC;MAC1B,IAAIC,IAAI,CAAC7I,GAAG,CAAC0I,CAAC,CAAC,EAAEG,IAAI,CAACC,MAAM,CAACJ,CAAC,CAAC,MAC1BG,IAAI,CAAC5I,GAAG,CAACyI,CAAC,CAAC;MAChB,OAAOG,IAAI;IACb,CAAC,CAAC;EACJ,CAAC,EAAE,EAAE,CAAC;EACN,MAAME,cAAc,GAAGtP,WAAW,CAChC,CAACqG,KAAG,EAAE7E,iBAAiB,KACrBqN,YAAY,CAAC3H,IAAI,GAAG,CAAC,IAAI2H,YAAY,CAACtI,GAAG,CAAC2I,SAAS,CAAC7I,KAAG,CAAC,CAAC,EAC3D,CAACwI,YAAY,CACf,CAAC;EACD;EACA;EACA;EACA;EACA;EACA;EACA;EACA,MAAMU,UAAU,GAAGpP,MAAM,CAACoN,SAAO,CAAC;EAClCgC,UAAU,CAACrG,OAAO,GAAGqE,SAAO;EAC5B,MAAMiC,eAAe,GAAGxP,WAAW,CACjC,CAACqG,KAAG,EAAE7E,iBAAiB,CAAC,EAAE,OAAO,IAAI;IACnC,IAAI6E,KAAG,CAACnB,IAAI,KAAK,uBAAuB,EAAE,OAAO,IAAI;IACrD,IAAImB,KAAG,CAACnB,IAAI,KAAK,WAAW,EAAE;MAC5B,MAAMuK,CAAC,GAAGpJ,KAAG,CAACf,OAAO,CAACC,OAAO,CAAC,CAAC,CAAC,IAAI,OAAO,IAAI9D,YAAY,GAAG,SAAS;MACvE,OACEgO,CAAC,IAAI,IAAI,IACT/N,cAAc,CAAC+N,CAAC,CAAC,IACjBA,CAAC,CAACvK,IAAI,KAAK,qBAAqB,IAChCuK,CAAC,CAAClK,OAAO,CAACL,IAAI,KAAK,gBAAgB;IAEvC;IACA,IAAImB,KAAG,CAACnB,IAAI,KAAK,MAAM,EAAE,OAAO,KAAK;IACrC,MAAMuK,GAAC,GAAGpJ,KAAG,CAACf,OAAO,CAACC,OAAO,CAAC,CAAC,CAAC;IAChC,IAAIkK,GAAC,EAAEvK,IAAI,KAAK,aAAa,IAAIuK,GAAC,CAACC,QAAQ,IAAI,CAACrJ,KAAG,CAACsJ,aAAa,EAC/D,OAAO,KAAK;IACd,MAAMlK,IAAI,GAAG8J,UAAU,CAACrG,OAAO,CAAC0G,kBAAkB,CAACC,GAAG,CACpDJ,GAAC,CAAC/J,WACJ,CAAC,EAAED,IAAI;IACP,MAAMqK,IAAI,GAAGrK,IAAI,GAAGxE,cAAc,CAACqG,KAAK,EAAE7B,IAAI,CAAC,GAAGiB,SAAS;IAC3D,OAAOoJ,IAAI,EAAEC,iBAAiB,GAAG1J,KAAG,CAACsJ,aAAa,IAAI,KAAK,CAAC,IAAI,KAAK;EACvE,CAAC,EACD,CAACrI,KAAK,CACR,CAAC;EAED,MAAM0I,UAAU,GACd,CAAC,CAACvI,OAAO,IAAI,CAAC,CAACA,OAAO,CAACI,uBAAuB,KAC9C,CAACC,mBAAmB,CAACb,MAAM,IAC3B,CAACe,wBAAwB;EAE3B,MAAMiI,kBAAkB,GAAGlI,oBAAoB,CAACb,IAAI,GAAG,CAAC;;EAExD;EACA,MAAM;IAAEgJ;EAAS,CAAC,GAAGvP,uBAAuB,CAAC,CAAC;EAC9C,MAAMwP,iBAAiB,GAAGhQ,MAAM,CAAC,MAAM,GAAG,IAAI,CAAC,CAAC,IAAI,CAAC;EACrD,MAAMiQ,eAAe,GACnBrO,eAAe,CAAC,CAAC,CAACsO,0BAA0B,IAC5C,CAAC/P,eAAe,CAAC,CAAC,IAClB,EAAEsE,eAAe,EAAE0L,iBAAiB,CAAC,CAAC,IAAI,KAAK,CAAC;EAClDrQ,SAAS,CAAC,MAAM;IACd,MAAMuJ,KAAK,GAAG4G,eAAe,GACzBH,kBAAkB,GAChB,eAAe,GACf,WAAW,GACb,IAAI;IACR,IAAIE,iBAAiB,CAACjH,OAAO,KAAKM,KAAK,EAAE;IACzC2G,iBAAiB,CAACjH,OAAO,GAAGM,KAAK;IACjC0G,QAAQ,CAAC1G,KAAK,CAAC;EACjB,CAAC,EAAE,CAAC0G,QAAQ,EAAEE,eAAe,EAAEH,kBAAkB,CAAC,CAAC;EACnDhQ,SAAS,CAAC,MAAM;IACd,OAAO,MAAMiQ,QAAQ,CAAC,IAAI,CAAC;EAC7B,CAAC,EAAE,CAACA,QAAQ,CAAC,CAAC;EAEd,MAAMK,UAAU,GAAGvQ,WAAW,CAC5B,CAACqG,KAAG,EAAE7E,iBAAiB,KAAK,GAAG6E,KAAG,CAACmE,IAAI,IAAIvC,cAAc,EAAE,EAC3D,CAACA,cAAc,CACjB,CAAC;EAED,MAAMuI,gBAAgB,GAAGA,CAACnK,KAAG,EAAE7E,iBAAiB,EAAEiP,KAAK,EAAE,MAAM,KAAK;IAClE,MAAMC,QAAQ,GAAGD,KAAK,GAAG,CAAC,GAAGrC,kBAAkB,CAACqC,KAAK,GAAG,CAAC,CAAC,EAAEvL,IAAI,GAAGwB,SAAS;IAC5E,MAAMiK,kBAAkB,GAAGtK,KAAG,CAACnB,IAAI,KAAK,MAAM,IAAIwL,QAAQ,KAAK,MAAM;IACrE;IACA;IACA;IACA;IACA;IACA,MAAME,eAAe,GACnBvK,KAAG,CAACnB,IAAI,KAAK,uBAAuB,KACnC,CAAC,CAACwD,aAAa,IACdpF,oBAAoB,CAClB8K,kBAAkB,EAClBqC,KAAK,EACLnJ,KAAK,EACLiH,mBACF,CAAC,CAAC;IAEN,MAAMU,GAAC,GAAGsB,UAAU,CAAClK,KAAG,CAAC;IACzB,MAAMwK,GAAG,GACP,CAAC,UAAU,CACT,GAAG,CAAC,CAAC5B,GAAC,CAAC,CACP,OAAO,CAAC,CAAC5I,KAAG,CAAC,CACb,kBAAkB,CAAC,CAACsK,kBAAkB,CAAC,CACvC,eAAe,CAAC,CAACC,eAAe,CAAC,CACjC,KAAK,CAAC,CAACtJ,KAAK,CAAC,CACb,QAAQ,CAAC,CAACC,QAAQ,CAAC,CACnB,OAAO,CAAC,CACNC,OAAO,IACP8H,cAAc,CAACjJ,KAAG,CAAC,IAClBwD,MAAM,EAAEiH,QAAQ,KAAK,IAAI,IAAIL,KAAK,KAAK7B,WAC1C,CAAC,CACD,oBAAoB,CAAC,CAAC7G,oBAAoB,CAAC,CAC3C,mBAAmB,CAAC,CAACwG,mBAAmB,CAAC,CACzC,MAAM,CAAC,CAACrG,MAAM,CAAC,CACf,UAAU,CAAC,CAAC8H,UAAU,CAAC,CACvB,sBAAsB,CAAC,CAAC3H,sBAAsB,CAAC,CAC/C,mBAAmB,CAAC,CAAC4D,mBAAmB,CAAC,CACzC,oBAAoB,CAAC,CAACI,oBAAoB,CAAC,CAC3C,OAAO,CAAC,CAACZ,OAAO,CAAC,CACjB,SAAS,CAAC,CAAClD,SAAS,CAAC,CACrB,OAAO,CAAC,CAACgF,SAAO,CAAC,GAEpB;;IAED;IACA;IACA,MAAMwD,OAAO,GACX,CAAC,6BAA6B,CAAC,QAAQ,CACrC,GAAG,CAAC,CAAC9B,GAAC,CAAC,CACP,KAAK,CAAC,CAACwB,KAAK,KAAK7B,WAAW,CAAC;AAErC,QAAQ,CAACiC,GAAG;AACZ,MAAM,EAAE,6BAA6B,CAAC,QAAQ,CACzC;IAED,IAAIjI,aAAa,IAAI6H,KAAK,KAAKhC,kBAAkB,EAAE;MACjD,OAAO,CACL,CAAC,GAAG,CAAC,GAAG,CAAC,gBAAgB,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC;AAC/C,UAAU,CAAC,OAAO,CACN,KAAK,CAAC,CAAC,GAAG7F,aAAa,CAACK,KAAK,QAAQjG,MAAM,CAAC4F,aAAa,CAACK,KAAK,EAAE,SAAS,CAAC,EAAE,CAAC,CAC9E,KAAK,CAAC,CAACwC,OAAO,CAAC,CACf,KAAK,CAAC,UAAU;AAE5B,QAAQ,EAAE,GAAG,CAAC,EACNsF,OAAO,CACR;IACH;IACA,OAAOA,OAAO;EAChB,CAAC;;EAED;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA,MAAMC,eAAe,GAAG7Q,MAAM,CAAC,IAAI8Q,OAAO,CAACzP,iBAAiB,EAAE,MAAM,CAAC,CAAC,CAAC,CAAC;EACxE,MAAM0P,iBAAiB,GAAGlR,WAAW,CACnC,CAACqG,KAAG,EAAE7E,iBAAiB,CAAC,EAAE,MAAM,IAAI;IAClC,MAAM2P,MAAM,GAAGH,eAAe,CAAC9H,OAAO,CAAC2G,GAAG,CAACxJ,KAAG,CAAC;IAC/C,IAAI8K,MAAM,KAAKzK,SAAS,EAAE,OAAOyK,MAAM;IACvC,IAAI7E,MAAI,GAAGrJ,oBAAoB,CAACoD,KAAG,CAAC;IACpC;IACA;IACA;IACA,IACEA,KAAG,CAACnB,IAAI,KAAK,MAAM,IACnBmB,KAAG,CAACsJ,aAAa,IACjBnK,KAAK,CAAC4L,OAAO,CAAC/K,KAAG,CAACf,OAAO,CAACC,OAAO,CAAC,EAClC;MACA,MAAM8L,EAAE,GAAGhL,KAAG,CAACf,OAAO,CAACC,OAAO,CAAC+L,IAAI,CAAC7B,GAAC,IAAIA,GAAC,CAACvK,IAAI,KAAK,aAAa,CAAC;MAClE,IAAImM,EAAE,IAAI,aAAa,IAAIA,EAAE,EAAE;QAC7B,MAAME,EAAE,GAAGhE,SAAO,CAACqC,kBAAkB,CAACC,GAAG,CAACwB,EAAE,CAAC3L,WAAW,CAAC;QACzD,MAAMoK,MAAI,GAAGyB,EAAE,IAAItQ,cAAc,CAACqG,KAAK,EAAEiK,EAAE,CAAC9L,IAAI,CAAC;QACjD,MAAM+L,SAAS,GAAG1B,MAAI,EAAEoB,iBAAiB,GACvC7K,KAAG,CAACsJ,aAAa,IAAI,KACvB,CAAC;QACD;QACA;QACA,IAAI6B,SAAS,KAAK9K,SAAS,EAAE4F,MAAI,GAAGkF,SAAS;MAC/C;IACF;IACA;IACA;IACA;IACA;IACA;IACA,MAAMC,OAAO,GAAGnF,MAAI,CAACoF,WAAW,CAAC,CAAC;IAClCV,eAAe,CAAC9H,OAAO,CAACyI,GAAG,CAACtL,KAAG,EAAEoL,OAAO,CAAC;IACzC,OAAOA,OAAO;EAChB,CAAC,EACD,CAACnK,KAAK,EAAEiG,SAAO,CACjB,CAAC;EAED,OACE;AACJ,MAAM,CAAC,UAAU;AACjB,MAAM,CAAC,CAACjF,QAAQ,IAAI,EAAE2B,WAAW,IAAIA,WAAW,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,IAChD,CAAC,UAAU,CAAC,gBAAgB,CAAC,CAAC1F,gBAAgB,CAAC,GAChD;AACP;AACA,MAAM,CAAC,0BAA0B;AACjC,MAAM,CAACiJ,sBAAoB,IACnB,CAAC,OAAO,CACN,KAAK,CAAC,CAAC,GAAG9B,qBAAqB,YAAY9L,KAAK,CAACgS,IAAI,CAACnE,oBAAkB,CAAC,oBAAoB,CAAC,CAC9F,KAAK,CAAC,CAAChC,OAAO,CAAC,GAElB;AACP;AACA,MAAM,CAAC,wBAAwB;AAC/B,MAAM,CAACsB,gBAAgB,IACf3E,mBAAmB,IACnBqF,oBAAkB,GAAG,CAAC;IACtB;IACA;IACA;IACA,CAAC7D,gBAAgB,IACf,CAAC,OAAO,CACN,KAAK,CAAC,CAAC,GAAG8B,qBAAqB,YAAY9L,KAAK,CAACgS,IAAI,CAACnE,oBAAkB,CAAC,oBAAoB,CAAC,CAC9F,KAAK,CAAC,CAAChC,OAAO,CAAC,GAElB;AACT;AACA,MAAM,CAAC;AACP;AACA;AACA;AACA;AACA;AACA;AACA,4CAA4C;AAC5C,MAAM,CAAC2B,wBAAwB,GACvB,CAAC,oBAAoB,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC,IAAI,CAAC;AACnD,UAAU,CAAC,kBAAkB,CACjB,QAAQ,CAAC,CAACgB,kBAAkB,CAAC,CAC7B,SAAS,CAAC,CAACvF,SAAS,CAAC,CACrB,OAAO,CAAC,CAAC4C,OAAO,CAAC,CACjB,OAAO,CAAC,CAAC8E,UAAU,CAAC,CACpB,UAAU,CAAC,CAACC,gBAAgB,CAAC,CAC7B,WAAW,CAAC,CAACxB,WAAW,CAAC,CACzB,eAAe,CAAC,CAACQ,eAAe,CAAC,CACjC,cAAc,CAAC,CAACF,cAAc,CAAC,CAC/B,iBAAiB,CAAC,CAACxG,iBAAiB,CAAC,CACrC,aAAa,CAAC,CAAC8F,WAAW,IAAI,CAAC,GAAGA,WAAW,GAAGlI,SAAS,CAAC,CAC1D,YAAY,CAAC,CAACqD,YAAY,CAAC,CAC3B,SAAS,CAAC,CAACD,SAAS,CAAC,CACrB,OAAO,CAAC,CAACf,OAAO,CAAC,CACjB,qBAAqB,CAAC,CAACC,qBAAqB,CAAC,CAC7C,WAAW,CAAC,CAACG,WAAW,CAAC,CACzB,YAAY,CAAC,CAACI,YAAY,CAAC,CAC3B,iBAAiB,CAAC,CAAC2H,iBAAiB,CAAC;AAEjD,QAAQ,EAAE,oBAAoB,CAAC,QAAQ,CAAC,GAEhC9C,kBAAkB,CAACvB,OAAO,CAAC2D,gBAAgB,CAC5C;AACP;AACA,MAAM,CAAC9H,aAAa,IAAI,CAACC,WAAW,IAC5B,CAAC,GAAG,CACF,UAAU,CAAC,YAAY,CACvB,aAAa,CAAC,KAAK,CACnB,SAAS,CAAC,CAAC,CAAC,CAAC,CACb,KAAK,CAAC,MAAM;AAEtB,UAAU,CAAC,GAAG,CAAC,aAAa,CAAC,KAAK;AAClC,YAAY,CAAC,GAAG,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC;AAC7B,cAAc,CAAC,IAAI,CAAC,KAAK,CAAC,MAAM,CAAC,CAACnI,YAAY,CAAC,EAAE,IAAI;AACrD,YAAY,EAAE,GAAG;AACjB,YAAY,CAAC,GAAG,CAAC,aAAa,CAAC,QAAQ;AACvC,cAAc,CAAC,iBAAiB,CAAC,CAACkI,aAAa,CAAC,EAAE,iBAAiB;AACnE,YAAY,EAAE,GAAG;AACjB,UAAU,EAAE,GAAG;AACf,QAAQ,EAAE,GAAG,CACN;AACP;AACA,MAAM,CAACkD,0BAA0B,IAAInD,iBAAiB,IAAI,CAACE,WAAW,IAC9D,CAAC,GAAG,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC;AAC1B,UAAU,CAAC,wBAAwB,CACvB,KAAK,CAAC,CAAC;QACLzD,IAAI,EAAE,UAAU;QAChB2M,QAAQ,EAAEpJ,iBAAiB,CAACoJ;MAC9B,CAAC,CAAC,CACF,SAAS,CAAC,CAAC,KAAK,CAAC,CACjB,gBAAgB,CAAC,CAAC,IAAI,CAAC,CACvB,OAAO,CAAC,CAACrK,OAAO,CAAC,CACjB,gBAAgB,CAAC,CAAC,KAAK,CAAC;AAEpC,QAAQ,EAAE,GAAG,CACN;AACP,IAAI,GAAG;AAEP,CAAC;;AAED;AACA;AACA,SAAS0H,SAASA,CAAC7I,GAAG,EAAE7E,iBAAiB,CAAC,EAAE,MAAM,CAAC;EACjD,OACE,CAAC6E,GAAG,CAACnB,IAAI,KAAK,WAAW,IAAImB,GAAG,CAACnB,IAAI,KAAK,MAAM,GAC5C3C,YAAY,CAAC8D,GAAG,CAAC,GACjB,IAAI,KAAKA,GAAG,CAACmE,IAAI;AAEzB;;AAEA;AACA;AACA;AACA;AACA;AACA,SAASsH,SAAS,CAAC,CAAC,CAACA,CAACC,CAAC,EAAE7L,GAAG,CAACH,CAAC,CAAC,EAAE0J,CAAC,EAAEvJ,GAAG,CAACH,CAAC,CAAC,CAAC,EAAE,OAAO,CAAC;EACnD,IAAIgM,CAAC,CAAC7K,IAAI,KAAKuI,CAAC,CAACvI,IAAI,EAAE,OAAO,KAAK;EACnC,KAAK,MAAM8K,IAAI,IAAID,CAAC,EAAE;IACpB,IAAI,CAACtC,CAAC,CAAClJ,GAAG,CAACyL,IAAI,CAAC,EAAE,OAAO,KAAK;EAChC;EACA,OAAO,IAAI;AACb;AAEA,OAAO,MAAMC,QAAQ,GAAGlS,KAAK,CAACoE,IAAI,CAACqH,YAAY,EAAE,CAAC2D,IAAI,EAAEC,IAAI,KAAK;EAC/D,MAAM8C,IAAI,GAAGC,MAAM,CAACD,IAAI,CAAC/C,IAAI,CAAC,IAAI,CAAC,MAAM,OAAOA,IAAI,CAAC,EAAE;EACvD,KAAK,MAAMiD,GAAG,IAAIF,IAAI,EAAE;IACtB,IACEE,GAAG,KAAK,wBAAwB,IAChCA,GAAG,KAAK,WAAW,IACnBA,GAAG,KAAK,mBAAmB,IAC3BA,GAAG,KAAK,WAAW,IACnBA,GAAG,KAAK,cAAc,IACtBA,GAAG,KAAK,SAAS,IACjBA,GAAG,KAAK,uBAAuB,IAC/BA,GAAG,KAAK,aAAa,IACrBA,GAAG,KAAK,cAAc,EAEtB;IACF,IAAIjD,IAAI,CAACiD,GAAG,CAAC,KAAKhD,IAAI,CAACgD,GAAG,CAAC,EAAE;MAC3B,IAAIA,GAAG,KAAK,mBAAmB,EAAE;QAC/B,MAAMC,CAAC,GAAGlD,IAAI,CAAChH,iBAAiB;QAChC,MAAM2F,CAAC,GAAGsB,IAAI,CAACjH,iBAAiB;QAChC,IACEkK,CAAC,CAACpL,MAAM,KAAK6G,CAAC,CAAC7G,MAAM,IACrBoL,CAAC,CAAChS,KAAK,CAAC,CAAC2R,IAAI,EAAEhL,CAAC,KAAKgL,IAAI,CAACrF,YAAY,KAAKmB,CAAC,CAAC9G,CAAC,CAAC,EAAE2F,YAAY,CAAC,EAC9D;UACA;QACF;MACF;MACA,IAAIyF,GAAG,KAAK,sBAAsB,EAAE;QAClC,IAAIN,SAAS,CAAC3C,IAAI,CAACpH,oBAAoB,EAAEqH,IAAI,CAACrH,oBAAoB,CAAC,EAAE;UACnE;QACF;MACF;MACA,IAAIqK,GAAG,KAAK,eAAe,EAAE;QAC3B,MAAMC,CAAC,GAAGlD,IAAI,CAACvG,aAAa;QAC5B,MAAMkF,CAAC,GAAGsB,IAAI,CAACxG,aAAa;QAC5B,IACEyJ,CAAC,EAAE1D,eAAe,KAAKb,CAAC,EAAEa,eAAe,IACzC0D,CAAC,EAAEpJ,KAAK,KAAK6E,CAAC,EAAE7E,KAAK,EACrB;UACA;QACF;MACF;MACA,IAAImJ,GAAG,KAAK,OAAO,EAAE;QACnB,MAAMC,CAAC,GAAGlD,IAAI,CAAC7H,KAAK;QACpB,MAAMwG,CAAC,GAAGsB,IAAI,CAAC9H,KAAK;QACpB,IACE+K,CAAC,CAACpL,MAAM,KAAK6G,CAAC,CAAC7G,MAAM,IACrBoL,CAAC,CAAChS,KAAK,CAAC,CAACyP,IAAI,EAAE9I,CAAC,KAAK8I,IAAI,CAACrK,IAAI,KAAKqI,CAAC,CAAC9G,CAAC,CAAC,EAAEvB,IAAI,CAAC,EAC9C;UACA;QACF;MACF;MACA;MACA;MACA,OAAO,KAAK;IACd;EACF;EACA,OAAO,IAAI;AACb,CAAC,CAAC;AAEF,OAAO,SAAS6M,sBAAsBA,CACpChN,OAAO,EAAE9D,iBAAiB,EAC1B+M,mBAAmB,EAAErI,GAAG,CAAC,MAAM,CAAC,EAChC6B,oBAAoB,EAAE7B,GAAG,CAAC,MAAM,CAAC,EACjCqM,iBAAiB,EAAExD,WAAW,CAAC,MAAM,CAAC,EACtC7G,MAAM,EAAEnH,MAAM,EACdwM,OAAO,EAAEiF,UAAU,CAAC,OAAOrQ,mBAAmB,CAAC,CAChD,EAAE,OAAO,CAAC;EACT,IAAI+F,MAAM,KAAK,YAAY,EAAE;IAC3B,OAAO,IAAI;EACb;EACA,QAAQ5C,OAAO,CAACJ,IAAI;IAClB,KAAK,YAAY;IACjB,KAAK,MAAM;IACX,KAAK,WAAW;MAAE;QAChB,IAAII,OAAO,CAACJ,IAAI,KAAK,WAAW,EAAE;UAChC,MAAMoB,KAAK,GAAGhB,OAAO,CAACA,OAAO,CAACC,OAAO,CAAC,CAAC,CAAC;UACxC,IAAIe,KAAK,EAAEpB,IAAI,KAAK,iBAAiB,EAAE;YACrC,OAAOqI,OAAO,CAACkF,kBAAkB,CAAClM,GAAG,CAACD,KAAK,CAACG,EAAE,CAAC;UACjD;QACF;QACA,MAAMiM,SAAS,GAAGnQ,YAAY,CAAC+C,OAAO,CAAC;QACvC,IAAI,CAACoN,SAAS,EAAE;UACd,OAAO,IAAI;QACb;QACA,IAAInE,mBAAmB,CAAChI,GAAG,CAACmM,SAAS,CAAC,EAAE;UACtC,OAAO,KAAK;QACd;QACA,IAAI3K,oBAAoB,CAACxB,GAAG,CAACmM,SAAS,CAAC,EAAE;UACvC,OAAO,KAAK;QACd;;QAEA;QACA;QACA,IAAIjQ,4BAA4B,CAACiQ,SAAS,EAAE,aAAa,EAAEnF,OAAO,CAAC,EAAE;UACnE,OAAO,KAAK;QACd;QAEA,OAAOlN,KAAK,CAACkS,iBAAiB,EAAEhF,OAAO,CAACkF,kBAAkB,CAAC;MAC7D;IACA,KAAK,QAAQ;MAAE;QACb;QACA;QACA,OAAOnN,OAAO,CAACH,OAAO,KAAK,WAAW;MACxC;IACA,KAAK,kBAAkB;MAAE;QACvB,MAAMwN,WAAW,GAAGrN,OAAO,CAACQ,QAAQ,CAACzF,KAAK,CAACgG,GAAG,IAAI;UAChD,MAAMd,OAAO,GAAGc,GAAG,CAACf,OAAO,CAACC,OAAO,CAAC,CAAC,CAAC;UACtC,OACEA,OAAO,EAAEL,IAAI,KAAK,UAAU,IAC5BqI,OAAO,CAACkF,kBAAkB,CAAClM,GAAG,CAAChB,OAAO,CAACkB,EAAE,CAAC;QAE9C,CAAC,CAAC;QACF,OAAOkM,WAAW;MACpB;IACA,KAAK,uBAAuB;MAAE;QAC5B;QACA;QACA,OAAO,KAAK;MACd;EACF;AACF","ignoreList":[]}