Messages.tsx

Full source

import { 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 this
function 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":[]}