claude-code / components / VirtualMessageList.tsx

import { c as _c } from "react/compiler-runtime";
import type { RefObject } from 'react';
import * as React from 'react';
import { useCallback, useContext, useEffect, useImperativeHandle, useRef, useState, useSyncExternalStore } from 'react';
import { useVirtualScroll } from '../hooks/useVirtualScroll.js';
import type { ScrollBoxHandle } from '../ink/components/ScrollBox.js';
import type { DOMElement } from '../ink/dom.js';
import type { MatchPosition } from '../ink/render-to-screen.js';
import { Box } from '../ink.js';
import type { RenderableMessage } from '../types/message.js';
import { TextHoverColorContext } from './design-system/ThemedText.js';
import { ScrollChromeContext } from './FullscreenLayout.js';

// Rows of breathing room above the target when we scrollTo.
const HEADROOM = 3;
import { logForDebugging } from '../utils/debug.js';
import { sleep } from '../utils/sleep.js';
import { renderableSearchText } from '../utils/transcriptSearch.js';
import { isNavigableMessage, type MessageActionsNav, type MessageActionsState, type NavigableMessage, stripSystemReminders, toolCallOf } from './messageActions.js';

// Fallback extractor: lower + cache here for callers without the
// Messages.tsx tool-lookup path (tests, static contexts). Messages.tsx
// provides its own lowering cache that also handles tool extractSearchText.
const fallbackLowerCache = new WeakMap<RenderableMessage, string>();
function defaultExtractSearchText(msg: RenderableMessage): string {
  const cached = fallbackLowerCache.get(msg);
  if (cached !== undefined) return cached;
  const lowered = renderableSearchText(msg);
  fallbackLowerCache.set(msg, lowered);
  return lowered;
}
export type StickyPrompt = {
  text: string;
  scrollTo: () => void;
}
// Click sets this — header HIDES but padding stays collapsed (0) so
// the content ❯ lands at screen row 0 instead of row 1. Cleared on
// the next sticky-prompt compute (user scrolls again).
| 'clicked';

/** Huge pasted prompts (cat file | claude) can be MBs. Header wraps into
 *  2 rows via overflow:hidden — this just bounds the React prop size. */
const STICKY_TEXT_CAP = 500;

/** Imperative handle for transcript navigation. Methods compute matches
 *  HERE (renderableMessages indices are only valid inside this component —
 *  Messages.tsx filters and reorders, REPL can't compute externally). */
export type JumpHandle = {
  jumpToIndex: (i: number) => void;
  setSearchQuery: (q: string) => void;
  nextMatch: () => void;
  prevMatch: () => void;
  /** Capture current scrollTop as the incsearch anchor. Typing jumps
   *  around as preview; 0-matches snaps back here. Enter/n/N never
   *  restore (they don't call setSearchQuery with empty). Next / call
   *  overwrites. */
  setAnchor: () => void;
  /** Warm the search-text cache by extracting every message's text.
   *  Returns elapsed ms, or 0 if already warm (subsequent / in same
   *  transcript session). Yields before work so the caller can paint
   *  "indexing…" first. Caller shows "indexed in Xms" on resolve. */
  warmSearchIndex: () => Promise<number>;
  /** Manual scroll (j/k/PgUp/wheel) exited the search context. Clear
   *  positions (yellow goes away, inverse highlights stay). Next n/N
   *  re-establishes via step()→jump(). Wired from ScrollKeybindingHandler's
   *  onScroll — only fires for keyboard/wheel, not programmatic scrollTo. */
  disarmSearch: () => void;
};
type Props = {
  messages: RenderableMessage[];
  scrollRef: RefObject<ScrollBoxHandle | null>;
  /** Invalidates heightCache on change — cached heights from a different
   *  width are wrong (text rewrap → black screen on scroll-up after widen). */
  columns: number;
  itemKey: (msg: RenderableMessage) => string;
  renderItem: (msg: RenderableMessage, index: number) => React.ReactNode;
  /** Fires when a message Box is clicked (toggle per-message verbose). */
  onItemClick?: (msg: RenderableMessage) => void;
  /** Per-item filter — suppress hover/click for messages where the verbose
   *  toggle does nothing (text, file edits, etc). Defaults to all-clickable. */
  isItemClickable?: (msg: RenderableMessage) => boolean;
  /** Expanded items get a persistent grey bg (not just on hover). */
  isItemExpanded?: (msg: RenderableMessage) => boolean;
  /** PRE-LOWERED search text. Messages.tsx caches the lowered result
   *  once at warm time so setSearchQuery's per-keystroke loop does
   *  only indexOf (zero toLowerCase alloc). Falls back to a lowering
   *  wrapper on renderableSearchText for callers without the cache. */
  extractSearchText?: (msg: RenderableMessage) => string;
  /** Enable the sticky-prompt tracker. StickyTracker writes via
   *  ScrollChromeContext (not a callback prop) so state lives in
   *  FullscreenLayout instead of REPL. */
  trackStickyPrompt?: boolean;
  selectedIndex?: number;
  /** Nav handle lives here because height measurement lives here. */
  cursorNavRef?: React.Ref<MessageActionsNav>;
  setCursor?: (c: MessageActionsState | null) => void;
  jumpRef?: RefObject<JumpHandle | null>;
  /** Fires when search matches change (query edit, n/N). current is
   *  1-based for "3/47" display; 0 means no matches. */
  onSearchMatchesChange?: (count: number, current: number) => void;
  /** Paint existing DOM subtree to fresh Screen, scan. Element from the
   *  main tree (all providers). Message-relative positions (row 0 = el
   *  top). Works for any height — closes the tall-message gap. */
  scanElement?: (el: DOMElement) => MatchPosition[];
  /** Position-based CURRENT highlight. Positions known upfront (from
   *  scanElement), navigation = index arithmetic + scrollTo. rowOffset
   *  = message's current screen-top; positions stay stable. */
  setPositions?: (state: {
    positions: MatchPosition[];
    rowOffset: number;
    currentIdx: number;
  } | null) => void;
};

/**
 * Returns the text of a real user prompt, or null for anything else.
 * "Real" = what the human typed: not tool results, not XML-wrapped payloads
 * (<bash-stdout>, <command-message>, <teammate-message>, etc.), not meta.
 *
 * Two shapes land here: NormalizedUserMessage (normal prompts) and
 * AttachmentMessage with type==='queued_command' (prompts sent mid-turn
 * while a tool was executing — they get drained as attachments on the
 * next turn, see query.ts:1410). Both render as ❯-prefixed UserTextMessage
 * in the UI so both should stick.
 *
 * Leading <system-reminder> blocks are stripped before checking — they get
 * prepended to the stored text for Claude's context (memory updates, auto
 * mode reminders) but aren't what the user typed. Without stripping, any
 * prompt that happened to get a reminder is rejected by the startsWith('<')
 * check. Shows up on `cc -c` resumes where memory-update reminders are dense.
 */
const promptTextCache = new WeakMap<RenderableMessage, string | null>();
function stickyPromptText(msg: RenderableMessage): string | null {
  // Cache keyed on message object — messages are append-only and don't
  // mutate, so a WeakMap hit is always valid. The walk (StickyTracker,
  // per-scroll-tick) calls this 5-50+ times with the SAME messages every
  // tick; the system-reminder strip allocates a fresh string on each
  // parse. WeakMap self-GCs on compaction/clear (messages[] replaced).
  const cached = promptTextCache.get(msg);
  if (cached !== undefined) return cached;
  const result = computeStickyPromptText(msg);
  promptTextCache.set(msg, result);
  return result;
}
function computeStickyPromptText(msg: RenderableMessage): string | null {
  let raw: string | null = null;
  if (msg.type === 'user') {
    if (msg.isMeta || msg.isVisibleInTranscriptOnly) return null;
    const block = msg.message.content[0];
    if (block?.type !== 'text') return null;
    raw = block.text;
  } else if (msg.type === 'attachment' && msg.attachment.type === 'queued_command' && msg.attachment.commandMode !== 'task-notification' && !msg.attachment.isMeta) {
    const p = msg.attachment.prompt;
    raw = typeof p === 'string' ? p : p.flatMap(b => b.type === 'text' ? [b.text] : []).join('\n');
  }
  if (raw === null) return null;
  const t = stripSystemReminders(raw);
  if (t.startsWith('<') || t === '') return null;
  return t;
}

/**
 * Virtualized message list for fullscreen mode. Split from Messages.tsx so
 * useVirtualScroll is called unconditionally (rules-of-hooks) — Messages.tsx
 * conditionally renders either this or a plain .map().
 *
 * The wrapping <Box ref> is the measurement anchor — MessageRow doesn't take
 * a ref. Single-child column Box passes Yoga height through unchanged.
 */
type VirtualItemProps = {
  itemKey: string;
  msg: RenderableMessage;
  idx: number;
  measureRef: (key: string) => (el: DOMElement | null) => void;
  expanded: boolean | undefined;
  hovered: boolean;
  clickable: boolean;
  onClickK: (msg: RenderableMessage, cellIsBlank: boolean) => void;
  onEnterK: (k: string) => void;
  onLeaveK: (k: string) => void;
  renderItem: (msg: RenderableMessage, idx: number) => React.ReactNode;
};

// Item wrapper with stable click handlers. The per-item closures were the
// `operationNewArrowFunction` leafs → `FunctionExecutable::finalizeUnconditionally`
// GC cleanup (16% of GC time during fast scroll). 3 closures × 60 mounted ×
// 10 commits/sec = 1800 closures/sec. With stable onClickK/onEnterK/onLeaveK
// threaded via itemKey, the closures here are per-item-per-render but CHEAP
// (just wrap the stable callback with k bound) and don't close over msg/idx
// which lets JIT inline them. The bigger win is inside: MessageRow.memo
// bails for unchanged msgs, skipping marked.lexer + formatToken.
//
// NOT React.memo'd — renderItem captures changing state (cursor, selectedIdx,
// verbose). Memoing with a comparator that ignores renderItem would use a
// STALE closure on bail (wrong selection highlight, stale verbose). Including
// renderItem in the comparator defeats memo since it's fresh each render.
function VirtualItem(t0) {
  const $ = _c(30);
  const {
    itemKey: k,
    msg,
    idx,
    measureRef,
    expanded,
    hovered,
    clickable,
    onClickK,
    onEnterK,
    onLeaveK,
    renderItem
  } = t0;
  let t1;
  if ($[0] !== k || $[1] !== measureRef) {
    t1 = measureRef(k);
    $[0] = k;
    $[1] = measureRef;
    $[2] = t1;
  } else {
    t1 = $[2];
  }
  const t2 = expanded ? "userMessageBackgroundHover" : undefined;
  const t3 = expanded ? 1 : undefined;
  let t4;
  if ($[3] !== clickable || $[4] !== msg || $[5] !== onClickK) {
    t4 = clickable ? e => onClickK(msg, e.cellIsBlank) : undefined;
    $[3] = clickable;
    $[4] = msg;
    $[5] = onClickK;
    $[6] = t4;
  } else {
    t4 = $[6];
  }
  let t5;
  if ($[7] !== clickable || $[8] !== k || $[9] !== onEnterK) {
    t5 = clickable ? () => onEnterK(k) : undefined;
    $[7] = clickable;
    $[8] = k;
    $[9] = onEnterK;
    $[10] = t5;
  } else {
    t5 = $[10];
  }
  let t6;
  if ($[11] !== clickable || $[12] !== k || $[13] !== onLeaveK) {
    t6 = clickable ? () => onLeaveK(k) : undefined;
    $[11] = clickable;
    $[12] = k;
    $[13] = onLeaveK;
    $[14] = t6;
  } else {
    t6 = $[14];
  }
  const t7 = hovered && !expanded ? "text" : undefined;
  let t8;
  if ($[15] !== idx || $[16] !== msg || $[17] !== renderItem) {
    t8 = renderItem(msg, idx);
    $[15] = idx;
    $[16] = msg;
    $[17] = renderItem;
    $[18] = t8;
  } else {
    t8 = $[18];
  }
  let t9;
  if ($[19] !== t7 || $[20] !== t8) {
    t9 = <TextHoverColorContext.Provider value={t7}>{t8}</TextHoverColorContext.Provider>;
    $[19] = t7;
    $[20] = t8;
    $[21] = t9;
  } else {
    t9 = $[21];
  }
  let t10;
  if ($[22] !== t1 || $[23] !== t2 || $[24] !== t3 || $[25] !== t4 || $[26] !== t5 || $[27] !== t6 || $[28] !== t9) {
    t10 = <Box ref={t1} flexDirection="column" backgroundColor={t2} paddingBottom={t3} onClick={t4} onMouseEnter={t5} onMouseLeave={t6}>{t9}</Box>;
    $[22] = t1;
    $[23] = t2;
    $[24] = t3;
    $[25] = t4;
    $[26] = t5;
    $[27] = t6;
    $[28] = t9;
    $[29] = t10;
  } else {
    t10 = $[29];
  }
  return t10;
}
export function VirtualMessageList({
  messages,
  scrollRef,
  columns,
  itemKey,
  renderItem,
  onItemClick,
  isItemClickable,
  isItemExpanded,
  extractSearchText = defaultExtractSearchText,
  trackStickyPrompt,
  selectedIndex,
  cursorNavRef,
  setCursor,
  jumpRef,
  onSearchMatchesChange,
  scanElement,
  setPositions
}: Props): React.ReactNode {
  // Incremental key array. Streaming appends one message at a time; rebuilding
  // the full string array on every commit allocates O(n) per message (~1MB
  // churn at 27k messages). Append-only delta push when the prefix matches;
  // fall back to full rebuild on compaction, /clear, or itemKey change.
  const keysRef = useRef<string[]>([]);
  const prevMessagesRef = useRef<typeof messages>(messages);
  const prevItemKeyRef = useRef(itemKey);
  if (prevItemKeyRef.current !== itemKey || messages.length < keysRef.current.length || messages[0] !== prevMessagesRef.current[0]) {
    keysRef.current = messages.map(m => itemKey(m));
  } else {
    for (let i = keysRef.current.length; i < messages.length; i++) {
      keysRef.current.push(itemKey(messages[i]!));
    }
  }
  prevMessagesRef.current = messages;
  prevItemKeyRef.current = itemKey;
  const keys = keysRef.current;
  const {
    range,
    topSpacer,
    bottomSpacer,
    measureRef,
    spacerRef,
    offsets,
    getItemTop,
    getItemElement,
    getItemHeight,
    scrollToIndex
  } = useVirtualScroll(scrollRef, keys, columns);
  const [start, end] = range;

  // Unmeasured (undefined height) falls through — assume visible.
  const isVisible = useCallback((i: number) => {
    const h = getItemHeight(i);
    if (h === 0) return false;
    return isNavigableMessage(messages[i]!);
  }, [getItemHeight, messages]);
  useImperativeHandle(cursorNavRef, (): MessageActionsNav => {
    const select = (m: NavigableMessage) => setCursor?.({
      uuid: m.uuid,
      msgType: m.type,
      expanded: false,
      toolName: toolCallOf(m)?.name
    });
    const selIdx = selectedIndex ?? -1;
    const scan = (from: number, dir: 1 | -1, pred: (i: number) => boolean = isVisible) => {
      for (let i = from; i >= 0 && i < messages.length; i += dir) {
        if (pred(i)) {
          select(messages[i]!);
          return true;
        }
      }
      return false;
    };
    const isUser = (i: number) => isVisible(i) && messages[i]!.type === 'user';
    return {
      // Entry via shift+↑ = same semantic as in-cursor shift+↑ (prevUser).
      enterCursor: () => scan(messages.length - 1, -1, isUser),
      navigatePrev: () => scan(selIdx - 1, -1),
      navigateNext: () => {
        if (scan(selIdx + 1, 1)) return;
        // Past last visible → exit + repin. Last message's TOP is at viewport
        // top (selection-scroll effect); its BOTTOM may be below the fold.
        scrollRef.current?.scrollToBottom();
        setCursor?.(null);
      },
      // type:'user' only — queued_command attachments look like prompts but have no raw UserMessage to rewind to.
      navigatePrevUser: () => scan(selIdx - 1, -1, isUser),
      navigateNextUser: () => scan(selIdx + 1, 1, isUser),
      navigateTop: () => scan(0, 1),
      navigateBottom: () => scan(messages.length - 1, -1),
      getSelected: () => selIdx >= 0 ? messages[selIdx] ?? null : null
    };
  }, [messages, selectedIndex, setCursor, isVisible]);
  // Two-phase jump + search engine. Read-through-ref so the handle stays
  // stable across renders — offsets/messages identity changes every render,
  // can't go in useImperativeHandle deps without recreating the handle.
  const jumpState = useRef({
    offsets,
    start,
    getItemElement,
    getItemTop,
    messages,
    scrollToIndex
  });
  jumpState.current = {
    offsets,
    start,
    getItemElement,
    getItemTop,
    messages,
    scrollToIndex
  };

  // Keep cursor-selected message visible. offsets rebuilds every render
  // — as a bare dep this re-pinned on every mousewheel tick. Read through
  // jumpState instead; past-overscan jumps land via scrollToIndex, next
  // nav is precise.
  useEffect(() => {
    if (selectedIndex === undefined) return;
    const s = jumpState.current;
    const el = s.getItemElement(selectedIndex);
    if (el) {
      scrollRef.current?.scrollToElement(el, 1);
    } else {
      s.scrollToIndex(selectedIndex);
    }
  }, [selectedIndex, scrollRef]);

  // Pending seek request. jump() sets this + bumps seekGen. The seek
  // effect fires post-paint (passive effect — after resetAfterCommit),
  // checks if target is mounted. Yes → scan+highlight. No → re-estimate
  // with a fresher anchor (start moved toward idx) and scrollTo again.
  const scanRequestRef = useRef<{
    idx: number;
    wantLast: boolean;
    tries: number;
  } | null>(null);
  // Message-relative positions from scanElement. Row 0 = message top.
  // Stable across scroll — highlight computes rowOffset fresh. msgIdx
  // for computing rowOffset = getItemTop(msgIdx) - scrollTop.
  const elementPositions = useRef<{
    msgIdx: number;
    positions: MatchPosition[];
  }>({
    msgIdx: -1,
    positions: []
  });
  // Wraparound guard. Auto-advance stops if ptr wraps back to here.
  const startPtrRef = useRef(-1);
  // Phantom-burst cap. Resets on scan success.
  const phantomBurstRef = useRef(0);
  // One-deep queue: n/N arriving mid-seek gets stored (not dropped) and
  // fires after the seek completes. Holding n stays smooth without
  // queueing 30 jumps. Latest press overwrites — we want the direction
  // the user is going NOW, not where they were 10 keypresses ago.
  const pendingStepRef = useRef<1 | -1 | 0>(0);
  // step + highlight via ref so the seek effect reads latest without
  // closure-capture or deps churn.
  const stepRef = useRef<(d: 1 | -1) => void>(() => {});
  const highlightRef = useRef<(ord: number) => void>(() => {});
  const searchState = useRef({
    matches: [] as number[],
    // deduplicated msg indices
    ptr: 0,
    screenOrd: 0,
    // Cumulative engine-occurrence count before each matches[k]. Lets us
    // compute a global current index: prefixSum[ptr] + screenOrd + 1.
    // Engine-counted (indexOf on extractSearchText), not render-counted —
    // close enough for the badge; exact counts would need scanElement on
    // every matched message (~1-3ms × N). total = prefixSum[matches.length].
    prefixSum: [] as number[]
  });
  // scrollTop at the moment / was pressed. Incsearch preview-jumps snap
  // back here when matches drop to 0. -1 = no anchor (before first /).
  const searchAnchor = useRef(-1);
  const indexWarmed = useRef(false);

  // Scroll target for message i: land at MESSAGE TOP. est = top - HEADROOM
  // so lo = top - est = HEADROOM ≥ 0 (or lo = top if est clamped to 0).
  // Post-clamp read-back in jump() handles the scrollHeight boundary.
  // No frac (render transform didn't respect it), no monotone clamp
  // (was a safety net for frac garbage — without frac, est IS the next
  // message's top, spam-n/N converges because message tops are ordered).
  function targetFor(i: number): number {
    const top = jumpState.current.getItemTop(i);
    return Math.max(0, top - HEADROOM);
  }

  // Highlight positions[ord]. Positions are MESSAGE-RELATIVE (row 0 =
  // element top, from scanElement). Compute rowOffset = getItemTop -
  // scrollTop fresh. If ord's position is off-viewport, scroll to bring
  // it in, recompute rowOffset. setPositions triggers overlay write.
  function highlight(ord: number): void {
    const s = scrollRef.current;
    const {
      msgIdx,
      positions
    } = elementPositions.current;
    if (!s || positions.length === 0 || msgIdx < 0) {
      setPositions?.(null);
      return;
    }
    const idx = Math.max(0, Math.min(ord, positions.length - 1));
    const p = positions[idx]!;
    const top = jumpState.current.getItemTop(msgIdx);
    // lo = item's position within scroll content (wrapper-relative).
    // viewportTop = where the scroll content starts on SCREEN (after
    // ScrollBox padding/border + any chrome above). Highlight writes to
    // screen-absolute, so rowOffset = viewportTop + lo. Observed: off-by-
    // 1+ without viewportTop (FullscreenLayout has paddingTop=1 on the
    // ScrollBox, plus any header above).
    const vpTop = s.getViewportTop();
    let lo = top - s.getScrollTop();
    const vp = s.getViewportHeight();
    let screenRow = vpTop + lo + p.row;
    // Off viewport → scroll to bring it in (HEADROOM from top).
    // scrollTo commits sync; read-back after gives fresh lo.
    if (screenRow < vpTop || screenRow >= vpTop + vp) {
      s.scrollTo(Math.max(0, top + p.row - HEADROOM));
      lo = top - s.getScrollTop();
      screenRow = vpTop + lo + p.row;
    }
    setPositions?.({
      positions,
      rowOffset: vpTop + lo,
      currentIdx: idx
    });
    // Badge: global current = sum of occurrences before this msg + ord+1.
    // prefixSum[ptr] is engine-counted (indexOf on extractSearchText);
    // may drift from render-count for ghost messages but close enough —
    // badge is a rough location hint, not a proof.
    const st = searchState.current;
    const total = st.prefixSum.at(-1) ?? 0;
    const current = (st.prefixSum[st.ptr] ?? 0) + idx + 1;
    onSearchMatchesChange?.(total, current);
    logForDebugging(`highlight(i=${msgIdx}, ord=${idx}/${positions.length}): ` + `pos={row:${p.row},col:${p.col}} lo=${lo} screenRow=${screenRow} ` + `badge=${current}/${total}`);
  }
  highlightRef.current = highlight;

  // Seek effect. jump() sets scanRequestRef + scrollToIndex + bump.
  // bump → re-render → useVirtualScroll mounts the target (scrollToIndex
  // guarantees this — scrollTop and topSpacer agree via the same
  // offsets value) → resetAfterCommit paints → this passive effect
  // fires POST-PAINT with the element mounted. Precise scrollTo + scan.
  //
  // Dep is ONLY seekGen — effect doesn't re-run on random renders
  // (onSearchMatchesChange churn during incsearch).
  const [seekGen, setSeekGen] = useState(0);
  const bumpSeek = useCallback(() => setSeekGen(g => g + 1), []);
  useEffect(() => {
    const req = scanRequestRef.current;
    if (!req) return;
    const {
      idx,
      wantLast,
      tries
    } = req;
    const s = scrollRef.current;
    if (!s) return;
    const {
      getItemElement,
      getItemTop,
      scrollToIndex
    } = jumpState.current;
    const el = getItemElement(idx);
    const h = el?.yogaNode?.getComputedHeight() ?? 0;
    if (!el || h === 0) {
      // Not mounted after scrollToIndex. Shouldn't happen — scrollToIndex
      // guarantees mount by construction (scrollTop and topSpacer agree
      // via the same offsets value). Sanity: retry once, then skip.
      if (tries > 1) {
        scanRequestRef.current = null;
        logForDebugging(`seek(i=${idx}): no mount after scrollToIndex, skip`);
        stepRef.current(wantLast ? -1 : 1);
        return;
      }
      scanRequestRef.current = {
        idx,
        wantLast,
        tries: tries + 1
      };
      scrollToIndex(idx);
      bumpSeek();
      return;
    }
    scanRequestRef.current = null;
    // Precise scrollTo — scrollToIndex got us in the neighborhood
    // (item is mounted, maybe a few-dozen rows off due to overscan
    // estimate drift). Now land it at top-HEADROOM.
    s.scrollTo(Math.max(0, getItemTop(idx) - HEADROOM));
    const positions = scanElement?.(el) ?? [];
    elementPositions.current = {
      msgIdx: idx,
      positions
    };
    logForDebugging(`seek(i=${idx} t=${tries}): ${positions.length} positions`);
    if (positions.length === 0) {
      // Phantom — engine matched, render didn't. Auto-advance.
      if (++phantomBurstRef.current > 20) {
        phantomBurstRef.current = 0;
        return;
      }
      stepRef.current(wantLast ? -1 : 1);
      return;
    }
    phantomBurstRef.current = 0;
    const ord = wantLast ? positions.length - 1 : 0;
    searchState.current.screenOrd = ord;
    startPtrRef.current = -1;
    highlightRef.current(ord);
    const pending = pendingStepRef.current;
    if (pending) {
      pendingStepRef.current = 0;
      stepRef.current(pending);
    }
    // eslint-disable-next-line react-hooks/exhaustive-deps
  }, [seekGen]);

  // Scroll to message i's top, arm scanPending. scan-effect reads fresh
  // screen next tick. wantLast: N-into-message — screenOrd = length-1.
  function jump(i: number, wantLast: boolean): void {
    const s = scrollRef.current;
    if (!s) return;
    const js = jumpState.current;
    const {
      getItemElement,
      scrollToIndex
    } = js;
    // offsets is a Float64Array whose .length is the allocated buffer (only
    // grows) — messages.length is the logical item count.
    if (i < 0 || i >= js.messages.length) return;
    // Clear stale highlight before scroll. Between now and the seek
    // effect's highlight, inverse-only from scan-highlight shows.
    setPositions?.(null);
    elementPositions.current = {
      msgIdx: -1,
      positions: []
    };
    scanRequestRef.current = {
      idx: i,
      wantLast,
      tries: 0
    };
    const el = getItemElement(i);
    const h = el?.yogaNode?.getComputedHeight() ?? 0;
    // Mounted → precise scrollTo. Unmounted → scrollToIndex mounts it
    // (scrollTop and topSpacer agree via the same offsets value — exact
    // by construction, no estimation). Seek effect does the precise
    // scrollTo after paint either way.
    if (el && h > 0) {
      s.scrollTo(targetFor(i));
    } else {
      scrollToIndex(i);
    }
    bumpSeek();
  }

  // Advance screenOrd within elementPositions. Exhausted → ptr advances,
  // jump to next matches[ptr], re-scan. Phantom (scan found 0 after
  // jump) triggers auto-advance from scan-effect. Wraparound guard stops
  // if every message is a phantom.
  function step(delta: 1 | -1): void {
    const st = searchState.current;
    const {
      matches,
      prefixSum
    } = st;
    const total = prefixSum.at(-1) ?? 0;
    if (matches.length === 0) return;

    // Seek in-flight — queue this press (one-deep, latest overwrites).
    // The seek effect fires it after highlight.
    if (scanRequestRef.current) {
      pendingStepRef.current = delta;
      return;
    }
    if (startPtrRef.current < 0) startPtrRef.current = st.ptr;
    const {
      positions
    } = elementPositions.current;
    const newOrd = st.screenOrd + delta;
    if (newOrd >= 0 && newOrd < positions.length) {
      st.screenOrd = newOrd;
      highlight(newOrd); // updates badge internally
      startPtrRef.current = -1;
      return;
    }

    // Exhausted visible. Advance ptr → jump → re-scan.
    const ptr = (st.ptr + delta + matches.length) % matches.length;
    if (ptr === startPtrRef.current) {
      setPositions?.(null);
      startPtrRef.current = -1;
      logForDebugging(`step: wraparound at ptr=${ptr}, all ${matches.length} msgs phantoms`);
      return;
    }
    st.ptr = ptr;
    st.screenOrd = 0; // resolved after scan (wantLast → length-1)
    jump(matches[ptr]!, delta < 0);
    // screenOrd will resolve after scan. Best-effort: prefixSum[ptr] + 0
    // for n (first pos), prefixSum[ptr+1] for N (last pos = count-1).
    // The scan-effect's highlight will be the real value; this is a
    // pre-scan placeholder so the badge updates immediately.
    const placeholder = delta < 0 ? prefixSum[ptr + 1] ?? total : prefixSum[ptr]! + 1;
    onSearchMatchesChange?.(total, placeholder);
  }
  stepRef.current = step;
  useImperativeHandle(jumpRef, () => ({
    // Non-search jump (sticky header click, etc). No scan, no positions.
    jumpToIndex: (i: number) => {
      const s = scrollRef.current;
      if (s) s.scrollTo(targetFor(i));
    },
    setSearchQuery: (q: string) => {
      // New search invalidates everything.
      scanRequestRef.current = null;
      elementPositions.current = {
        msgIdx: -1,
        positions: []
      };
      startPtrRef.current = -1;
      setPositions?.(null);
      const lq = q.toLowerCase();
      // One entry per MESSAGE (deduplicated). Boolean "does this msg
      // contain the query". ~10ms for 9k messages with cached lowered.
      const matches: number[] = [];
      // Per-message occurrence count → prefixSum for global current
      // index. Engine-counted (cheap indexOf loop); may differ from
      // render-count (scanElement) for ghost/phantom messages but close
      // enough for the badge. The badge is a rough location hint.
      const prefixSum: number[] = [0];
      if (lq) {
        const msgs = jumpState.current.messages;
        for (let i = 0; i < msgs.length; i++) {
          const text = extractSearchText(msgs[i]!);
          let pos = text.indexOf(lq);
          let cnt = 0;
          while (pos >= 0) {
            cnt++;
            pos = text.indexOf(lq, pos + lq.length);
          }
          if (cnt > 0) {
            matches.push(i);
            prefixSum.push(prefixSum.at(-1)! + cnt);
          }
        }
      }
      const total = prefixSum.at(-1)!;
      // Nearest MESSAGE to the anchor. <= so ties go to later.
      let ptr = 0;
      const s = scrollRef.current;
      const {
        offsets,
        start,
        getItemTop
      } = jumpState.current;
      const firstTop = getItemTop(start);
      const origin = firstTop >= 0 ? firstTop - offsets[start]! : 0;
      if (matches.length > 0 && s) {
        const curTop = searchAnchor.current >= 0 ? searchAnchor.current : s.getScrollTop();
        let best = Infinity;
        for (let k = 0; k < matches.length; k++) {
          const d = Math.abs(origin + offsets[matches[k]!]! - curTop);
          if (d <= best) {
            best = d;
            ptr = k;
          }
        }
        logForDebugging(`setSearchQuery('${q}'): ${matches.length} msgs · ptr=${ptr} ` + `msgIdx=${matches[ptr]} curTop=${curTop} origin=${origin}`);
      }
      searchState.current = {
        matches,
        ptr,
        screenOrd: 0,
        prefixSum
      };
      if (matches.length > 0) {
        // wantLast=true: preview the LAST occurrence in the nearest
        // message. At sticky-bottom (common / entry), nearest is the
        // last msg; its last occurrence is closest to where the user
        // was — minimal view movement. n advances forward from there.
        jump(matches[ptr]!, true);
      } else if (searchAnchor.current >= 0 && s) {
        // /foob → 0 matches → snap back to anchor. less/vim incsearch.
        s.scrollTo(searchAnchor.current);
      }
      // Global occurrence count + 1-based current. wantLast=true so the
      // scan will land on the last occurrence in matches[ptr]. Placeholder
      // = prefixSum[ptr+1] (count through this msg). highlight() updates
      // to the exact value after scan completes.
      onSearchMatchesChange?.(total, matches.length > 0 ? prefixSum[ptr + 1] ?? total : 0);
    },
    nextMatch: () => step(1),
    prevMatch: () => step(-1),
    setAnchor: () => {
      const s = scrollRef.current;
      if (s) searchAnchor.current = s.getScrollTop();
    },
    disarmSearch: () => {
      // Manual scroll invalidates screen-absolute positions.
      setPositions?.(null);
      scanRequestRef.current = null;
      elementPositions.current = {
        msgIdx: -1,
        positions: []
      };
      startPtrRef.current = -1;
    },
    warmSearchIndex: async () => {
      if (indexWarmed.current) return 0;
      const msgs = jumpState.current.messages;
      const CHUNK = 500;
      let workMs = 0;
      const wallStart = performance.now();
      for (let i = 0; i < msgs.length; i += CHUNK) {
        await sleep(0);
        const t0 = performance.now();
        const end = Math.min(i + CHUNK, msgs.length);
        for (let j = i; j < end; j++) {
          extractSearchText(msgs[j]!);
        }
        workMs += performance.now() - t0;
      }
      const wallMs = Math.round(performance.now() - wallStart);
      logForDebugging(`warmSearchIndex: ${msgs.length} msgs · work=${Math.round(workMs)}ms wall=${wallMs}ms chunks=${Math.ceil(msgs.length / CHUNK)}`);
      indexWarmed.current = true;
      return Math.round(workMs);
    }
  }),
  // Closures over refs + callbacks. scrollRef stable; others are
  // useCallback([]) or prop-drilled from REPL (stable).
  // eslint-disable-next-line react-hooks/exhaustive-deps
  [scrollRef]);

  // StickyTracker goes AFTER the list content. It returns null (no DOM node)
  // so order shouldn't matter for layout — but putting it first means every
  // fine-grained commit from its own scroll subscription reconciles THROUGH
  // the sibling items (React walks children in order). After the items, it's
  // a leaf reconcile. Defensive: also avoids any Yoga child-index quirks if
  // the Ink reconciler ever materializes a placeholder for null returns.
  const [hoveredKey, setHoveredKey] = useState<string | null>(null);
  // Stable click/hover handlers — called with k, dispatch from a ref so
  // closure identity doesn't change per render. The per-item handler
  // closures (`e => ...`, `() => setHoveredKey(k)`) were the
  // `operationNewArrowFunction` leafs in the scroll CPU profile; their
  // cleanup was 16% of GC time (`FunctionExecutable::finalizeUnconditionally`).
  // Allocating 3 closures × 60 mounted items × 10 commits/sec during fast
  // scroll = 1800 short-lived closures/sec. With stable refs the item
  // wrapper props don't change → VirtualItem.memo bails for the ~35
  // unchanged items, only ~25 fresh items pay createElement cost.
  const handlersRef = useRef({
    onItemClick,
    setHoveredKey
  });
  handlersRef.current = {
    onItemClick,
    setHoveredKey
  };
  const onClickK = useCallback((msg: RenderableMessage, cellIsBlank: boolean) => {
    const h = handlersRef.current;
    if (!cellIsBlank && h.onItemClick) h.onItemClick(msg);
  }, []);
  const onEnterK = useCallback((k: string) => {
    handlersRef.current.setHoveredKey(k);
  }, []);
  const onLeaveK = useCallback((k: string) => {
    handlersRef.current.setHoveredKey(prev => prev === k ? null : prev);
  }, []);
  return <>
      <Box ref={spacerRef} height={topSpacer} flexShrink={0} />
      {messages.slice(start, end).map((msg, i) => {
      const idx = start + i;
      const k = keys[idx]!;
      const clickable = !!onItemClick && (isItemClickable?.(msg) ?? true);
      const hovered = clickable && hoveredKey === k;
      const expanded = isItemExpanded?.(msg);
      return <VirtualItem key={k} itemKey={k} msg={msg} idx={idx} measureRef={measureRef} expanded={expanded} hovered={hovered} clickable={clickable} onClickK={onClickK} onEnterK={onEnterK} onLeaveK={onLeaveK} renderItem={renderItem} />;
    })}
      {bottomSpacer > 0 && <Box height={bottomSpacer} flexShrink={0} />}
      {trackStickyPrompt && <StickyTracker messages={messages} start={start} end={end} offsets={offsets} getItemTop={getItemTop} getItemElement={getItemElement} scrollRef={scrollRef} />}
    </>;
}
const NOOP_UNSUB = () => {};

/**
 * Effect-only child that tracks the last user-prompt scrolled above the
 * viewport top and fires onChange when it changes.
 *
 * Rendered as a separate component (not a hook in VirtualMessageList) so it
 * can subscribe to scroll at FINER granularity than SCROLL_QUANTUM=40. The
 * list needs the coarse quantum to avoid per-wheel-tick Yoga relayouts; this
 * tracker is just a walk + comparison and can afford to run every tick. When
 * it re-renders alone, the list's reconciled output is unchanged (same props
 * from the parent's last commit) — no Yoga work. Without this split, the
 * header lags by ~one conversation turn (40 rows ≈ one prompt + response).
 *
 * firstVisible derivation: item Boxes are direct Yoga children of the
 * ScrollBox content wrapper (fragments collapse in the Ink DOM), so
 * yoga.getComputedTop is content-wrapper-relative — same coordinate space as
 * scrollTop. Compare against scrollTop + pendingDelta (the scroll TARGET —
 * scrollBy only sets pendingDelta, committed scrollTop lags). Walk backward
 * from the mount-range end; break when an item's top is above target.
 */
function StickyTracker({
  messages,
  start,
  end,
  offsets,
  getItemTop,
  getItemElement,
  scrollRef
}: {
  messages: RenderableMessage[];
  start: number;
  end: number;
  offsets: ArrayLike<number>;
  getItemTop: (index: number) => number;
  getItemElement: (index: number) => DOMElement | null;
  scrollRef: RefObject<ScrollBoxHandle | null>;
}): null {
  const {
    setStickyPrompt
  } = useContext(ScrollChromeContext);
  // Fine-grained subscription — snapshot is unquantized scrollTop+delta so
  // every scroll action (wheel tick, PgUp, drag) triggers a re-render of
  // THIS component only. Sticky bit folded into the sign so sticky→broken
  // also triggers (scrollToBottom sets sticky without moving scrollTop).
  const subscribe = useCallback((listener: () => void) => scrollRef.current?.subscribe(listener) ?? NOOP_UNSUB, [scrollRef]);
  useSyncExternalStore(subscribe, () => {
    const s = scrollRef.current;
    if (!s) return NaN;
    const t = s.getScrollTop() + s.getPendingDelta();
    return s.isSticky() ? -1 - t : t;
  });

  // Read live scroll state on every render.
  const isSticky = scrollRef.current?.isSticky() ?? true;
  const target = Math.max(0, (scrollRef.current?.getScrollTop() ?? 0) + (scrollRef.current?.getPendingDelta() ?? 0));

  // Walk the mounted range to find the first item at-or-below the viewport
  // top. `range` is from the parent's coarse-quantum render (may be slightly
  // stale) but overscan guarantees it spans well past the viewport in both
  // directions. Items without a Yoga layout yet (newly mounted this frame)
  // are treated as at-or-below — they're somewhere in view, and assuming
  // otherwise would show a sticky for a prompt that's actually on screen.
  let firstVisible = start;
  let firstVisibleTop = -1;
  for (let i = end - 1; i >= start; i--) {
    const top = getItemTop(i);
    if (top >= 0) {
      if (top < target) break;
      firstVisibleTop = top;
    }
    firstVisible = i;
  }
  let idx = -1;
  let text: string | null = null;
  if (firstVisible > 0 && !isSticky) {
    for (let i = firstVisible - 1; i >= 0; i--) {
      const t = stickyPromptText(messages[i]!);
      if (t === null) continue;
      // The prompt's wrapping Box top is above target (that's why it's in
      // the [0, firstVisible) range), but its ❯ is at top+1 (marginTop=1).
      // If the ❯ is at-or-below target, it's VISIBLE at viewport top —
      // showing the same text in the header would duplicate it. Happens
      // in the 1-row gap between Box top scrolling past and ❯ scrolling
      // past. Skip to the next-older prompt (its ❯ is definitely above).
      const top = getItemTop(i);
      if (top >= 0 && top + 1 >= target) continue;
      idx = i;
      text = t;
      break;
    }
  }
  const baseOffset = firstVisibleTop >= 0 ? firstVisibleTop - offsets[firstVisible]! : 0;
  const estimate = idx >= 0 ? Math.max(0, baseOffset + offsets[idx]!) : -1;

  // For click-jumps to items not yet mounted (user scrolled far past,
  // prompt is in the topSpacer). Click handler scrolls to the estimate
  // to mount it; this anchors by element once it appears. scrollToElement
  // defers the Yoga-position read to render time (render-node-to-output
  // reads el.yogaNode.getComputedTop() in the SAME calculateLayout pass
  // that produces scrollHeight) — no throttle race. Cap retries: a /clear
  // race could unmount the item mid-sequence.
  const pending = useRef({
    idx: -1,
    tries: 0
  });
  // Suppression state machine. The click handler arms; the onChange effect
  // consumes (armed→force) then fires-and-clears on the render AFTER that
  // (force→none). The force step poisons the dedup: after click, idx often
  // recomputes to the SAME prompt (its top is still above target), so
  // without force the last.idx===idx guard would hold 'clicked' until the
  // user crossed a prompt boundary. Previously encoded in last.idx as
  // -1/-2/-3 which overlapped with real indices — too clever.
  type Suppress = 'none' | 'armed' | 'force';
  const suppress = useRef<Suppress>('none');
  // Dedup on idx only — estimate derives from firstVisibleTop which shifts
  // every scroll tick, so including it in the key made the guard dead
  // (setStickyPrompt fired a fresh {text,scrollTo} per-frame). The scrollTo
  // closure still captures the current estimate; it just doesn't need to
  // re-fire when only estimate moved.
  const lastIdx = useRef(-1);

  // setStickyPrompt effect FIRST — must see pending.idx before the
  // correction effect below clears it. On the estimate-fallback path, the
  // render that mounts the item is ALSO the render where correction clears
  // pending; if this ran second, the pending gate would be dead and
  // setStickyPrompt(prevPrompt) would fire mid-jump, re-mounting the
  // header over 'clicked'.
  useEffect(() => {
    // Hold while two-phase correction is in flight.
    if (pending.current.idx >= 0) return;
    if (suppress.current === 'armed') {
      suppress.current = 'force';
      return;
    }
    const force = suppress.current === 'force';
    suppress.current = 'none';
    if (!force && lastIdx.current === idx) return;
    lastIdx.current = idx;
    if (text === null) {
      setStickyPrompt(null);
      return;
    }
    // First paragraph only (split on blank line) — a prompt like
    // "still seeing bugs:\n\n1. foo\n2. bar" previews as just the
    // lead-in. trimStart so a leading blank line (queued_command mid-
    // turn messages sometimes have one) doesn't find paraEnd at 0.
    const trimmed = text.trimStart();
    const paraEnd = trimmed.search(/\n\s*\n/);
    const collapsed = (paraEnd >= 0 ? trimmed.slice(0, paraEnd) : trimmed).slice(0, STICKY_TEXT_CAP).replace(/\s+/g, ' ').trim();
    if (collapsed === '') {
      setStickyPrompt(null);
      return;
    }
    const capturedIdx = idx;
    const capturedEstimate = estimate;
    setStickyPrompt({
      text: collapsed,
      scrollTo: () => {
        // Hide header, keep padding collapsed — FullscreenLayout's
        // 'clicked' sentinel → scrollBox_y=0 + pad=0 → viewportTop=0.
        setStickyPrompt('clicked');
        suppress.current = 'armed';
        // scrollToElement anchors by DOMElement ref, not a number:
        // render-node-to-output reads el.yogaNode.getComputedTop() at
        // paint time (same Yoga pass as scrollHeight). No staleness from
        // the throttled render — the ref is stable, the position read is
        // deferred. offset=1 = UserPromptMessage marginTop.
        const el = getItemElement(capturedIdx);
        if (el) {
          scrollRef.current?.scrollToElement(el, 1);
        } else {
          // Not mounted (scrolled far past — in topSpacer). Jump to
          // estimate to mount it; correction effect re-anchors once it
          // appears. Estimate is DEFAULT_ESTIMATE-based — lands short.
          scrollRef.current?.scrollTo(capturedEstimate);
          pending.current = {
            idx: capturedIdx,
            tries: 0
          };
        }
      }
    });
    // No deps — must run every render. Suppression state lives in a ref
    // (not idx/estimate), so a deps-gated effect would never see it tick.
    // Body's own guards short-circuit when nothing changed.
    // eslint-disable-next-line react-hooks/exhaustive-deps
  });

  // Correction: for click-jumps to unmounted items. Click handler scrolled
  // to the estimate; this re-anchors by element once the item appears.
  // scrollToElement defers the Yoga read to paint time — deterministic.
  // SECOND so it clears pending AFTER the onChange gate above has seen it.
  useEffect(() => {
    if (pending.current.idx < 0) return;
    const el = getItemElement(pending.current.idx);
    if (el) {
      scrollRef.current?.scrollToElement(el, 1);
      pending.current = {
        idx: -1,
        tries: 0
      };
    } else if (++pending.current.tries > 5) {
      pending.current = {
        idx: -1,
        tries: 0
      };
    }
  });
  return null;
}
//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["RefObject","React","useCallback","useContext","useEffect","useImperativeHandle","useRef","useState","useSyncExternalStore","useVirtualScroll","ScrollBoxHandle","DOMElement","MatchPosition","Box","RenderableMessage","TextHoverColorContext","ScrollChromeContext","HEADROOM","logForDebugging","sleep","renderableSearchText","isNavigableMessage","MessageActionsNav","MessageActionsState","NavigableMessage","stripSystemReminders","toolCallOf","fallbackLowerCache","WeakMap","defaultExtractSearchText","msg","cached","get","undefined","lowered","set","StickyPrompt","text","scrollTo","STICKY_TEXT_CAP","JumpHandle","jumpToIndex","i","setSearchQuery","q","nextMatch","prevMatch","setAnchor","warmSearchIndex","Promise","disarmSearch","Props","messages","scrollRef","columns","itemKey","renderItem","index","ReactNode","onItemClick","isItemClickable","isItemExpanded","extractSearchText","trackStickyPrompt","selectedIndex","cursorNavRef","Ref","setCursor","c","jumpRef","onSearchMatchesChange","count","current","scanElement","el","setPositions","state","positions","rowOffset","currentIdx","promptTextCache","stickyPromptText","result","computeStickyPromptText","raw","type","isMeta","isVisibleInTranscriptOnly","block","message","content","attachment","commandMode","p","prompt","flatMap","b","join","t","startsWith","VirtualItemProps","idx","measureRef","key","expanded","hovered","clickable","onClickK","cellIsBlank","onEnterK","k","onLeaveK","VirtualItem","t0","$","_c","t1","t2","t3","t4","e","t5","t6","t7","t8","t9","t10","VirtualMessageList","keysRef","prevMessagesRef","prevItemKeyRef","length","map","m","push","keys","range","topSpacer","bottomSpacer","spacerRef","offsets","getItemTop","getItemElement","getItemHeight","scrollToIndex","start","end","isVisible","h","select","uuid","msgType","toolName","name","selIdx","scan","from","dir","pred","isUser","enterCursor","navigatePrev","navigateNext","scrollToBottom","navigatePrevUser","navigateNextUser","navigateTop","navigateBottom","getSelected","jumpState","s","scrollToElement","scanRequestRef","wantLast","tries","elementPositions","msgIdx","startPtrRef","phantomBurstRef","pendingStepRef","stepRef","d","highlightRef","ord","searchState","matches","ptr","screenOrd","prefixSum","searchAnchor","indexWarmed","targetFor","top","Math","max","highlight","min","vpTop","getViewportTop","lo","getScrollTop","vp","getViewportHeight","screenRow","row","st","total","at","col","seekGen","setSeekGen","bumpSeek","g","req","yogaNode","getComputedHeight","pending","jump","js","step","delta","newOrd","placeholder","lq","toLowerCase","msgs","pos","indexOf","cnt","firstTop","origin","curTop","best","Infinity","abs","CHUNK","workMs","wallStart","performance","now","j","wallMs","round","ceil","hoveredKey","setHoveredKey","handlersRef","prev","slice","NOOP_UNSUB","StickyTracker","ArrayLike","setStickyPrompt","subscribe","listener","NaN","getPendingDelta","isSticky","target","firstVisible","firstVisibleTop","baseOffset","estimate","Suppress","suppress","lastIdx","force","trimmed","trimStart","paraEnd","search","collapsed","replace","trim","capturedIdx","capturedEstimate"],"sources":["VirtualMessageList.tsx"],"sourcesContent":["import type { RefObject } from 'react'\nimport * as React from 'react'\nimport {\n  useCallback,\n  useContext,\n  useEffect,\n  useImperativeHandle,\n  useRef,\n  useState,\n  useSyncExternalStore,\n} from 'react'\nimport { useVirtualScroll } from '../hooks/useVirtualScroll.js'\nimport type { ScrollBoxHandle } from '../ink/components/ScrollBox.js'\nimport type { DOMElement } from '../ink/dom.js'\nimport type { MatchPosition } from '../ink/render-to-screen.js'\nimport { Box } from '../ink.js'\nimport type { RenderableMessage } from '../types/message.js'\nimport { TextHoverColorContext } from './design-system/ThemedText.js'\nimport { ScrollChromeContext } from './FullscreenLayout.js'\n\n// Rows of breathing room above the target when we scrollTo.\nconst HEADROOM = 3\n\nimport { logForDebugging } from '../utils/debug.js'\nimport { sleep } from '../utils/sleep.js'\nimport { renderableSearchText } from '../utils/transcriptSearch.js'\nimport {\n  isNavigableMessage,\n  type MessageActionsNav,\n  type MessageActionsState,\n  type NavigableMessage,\n  stripSystemReminders,\n  toolCallOf,\n} from './messageActions.js'\n\n// Fallback extractor: lower + cache here for callers without the\n// Messages.tsx tool-lookup path (tests, static contexts). Messages.tsx\n// provides its own lowering cache that also handles tool extractSearchText.\nconst fallbackLowerCache = new WeakMap<RenderableMessage, string>()\nfunction defaultExtractSearchText(msg: RenderableMessage): string {\n  const cached = fallbackLowerCache.get(msg)\n  if (cached !== undefined) return cached\n  const lowered = renderableSearchText(msg)\n  fallbackLowerCache.set(msg, lowered)\n  return lowered\n}\n\nexport type StickyPrompt =\n  | { text: string; scrollTo: () => void }\n  // Click sets this — header HIDES but padding stays collapsed (0) so\n  // the content ❯ lands at screen row 0 instead of row 1. Cleared on\n  // the next sticky-prompt compute (user scrolls again).\n  | 'clicked'\n\n/** Huge pasted prompts (cat file | claude) can be MBs. Header wraps into\n *  2 rows via overflow:hidden — this just bounds the React prop size. */\nconst STICKY_TEXT_CAP = 500\n\n/** Imperative handle for transcript navigation. Methods compute matches\n *  HERE (renderableMessages indices are only valid inside this component —\n *  Messages.tsx filters and reorders, REPL can't compute externally). */\nexport type JumpHandle = {\n  jumpToIndex: (i: number) => void\n  setSearchQuery: (q: string) => void\n  nextMatch: () => void\n  prevMatch: () => void\n  /** Capture current scrollTop as the incsearch anchor. Typing jumps\n   *  around as preview; 0-matches snaps back here. Enter/n/N never\n   *  restore (they don't call setSearchQuery with empty). Next / call\n   *  overwrites. */\n  setAnchor: () => void\n  /** Warm the search-text cache by extracting every message's text.\n   *  Returns elapsed ms, or 0 if already warm (subsequent / in same\n   *  transcript session). Yields before work so the caller can paint\n   *  \"indexing…\" first. Caller shows \"indexed in Xms\" on resolve. */\n  warmSearchIndex: () => Promise<number>\n  /** Manual scroll (j/k/PgUp/wheel) exited the search context. Clear\n   *  positions (yellow goes away, inverse highlights stay). Next n/N\n   *  re-establishes via step()→jump(). Wired from ScrollKeybindingHandler's\n   *  onScroll — only fires for keyboard/wheel, not programmatic scrollTo. */\n  disarmSearch: () => void\n}\n\ntype Props = {\n  messages: RenderableMessage[]\n  scrollRef: RefObject<ScrollBoxHandle | null>\n  /** Invalidates heightCache on change — cached heights from a different\n   *  width are wrong (text rewrap → black screen on scroll-up after widen). */\n  columns: number\n  itemKey: (msg: RenderableMessage) => string\n  renderItem: (msg: RenderableMessage, index: number) => React.ReactNode\n  /** Fires when a message Box is clicked (toggle per-message verbose). */\n  onItemClick?: (msg: RenderableMessage) => void\n  /** Per-item filter — suppress hover/click for messages where the verbose\n   *  toggle does nothing (text, file edits, etc). Defaults to all-clickable. */\n  isItemClickable?: (msg: RenderableMessage) => boolean\n  /** Expanded items get a persistent grey bg (not just on hover). */\n  isItemExpanded?: (msg: RenderableMessage) => boolean\n  /** PRE-LOWERED search text. Messages.tsx caches the lowered result\n   *  once at warm time so setSearchQuery's per-keystroke loop does\n   *  only indexOf (zero toLowerCase alloc). Falls back to a lowering\n   *  wrapper on renderableSearchText for callers without the cache. */\n  extractSearchText?: (msg: RenderableMessage) => string\n  /** Enable the sticky-prompt tracker. StickyTracker writes via\n   *  ScrollChromeContext (not a callback prop) so state lives in\n   *  FullscreenLayout instead of REPL. */\n  trackStickyPrompt?: boolean\n  selectedIndex?: number\n  /** Nav handle lives here because height measurement lives here. */\n  cursorNavRef?: React.Ref<MessageActionsNav>\n  setCursor?: (c: MessageActionsState | null) => void\n  jumpRef?: RefObject<JumpHandle | null>\n  /** Fires when search matches change (query edit, n/N). current is\n   *  1-based for \"3/47\" display; 0 means no matches. */\n  onSearchMatchesChange?: (count: number, current: number) => void\n  /** Paint existing DOM subtree to fresh Screen, scan. Element from the\n   *  main tree (all providers). Message-relative positions (row 0 = el\n   *  top). Works for any height — closes the tall-message gap. */\n  scanElement?: (el: DOMElement) => MatchPosition[]\n  /** Position-based CURRENT highlight. Positions known upfront (from\n   *  scanElement), navigation = index arithmetic + scrollTo. rowOffset\n   *  = message's current screen-top; positions stay stable. */\n  setPositions?: (\n    state: {\n      positions: MatchPosition[]\n      rowOffset: number\n      currentIdx: number\n    } | null,\n  ) => void\n}\n\n/**\n * Returns the text of a real user prompt, or null for anything else.\n * \"Real\" = what the human typed: not tool results, not XML-wrapped payloads\n * (<bash-stdout>, <command-message>, <teammate-message>, etc.), not meta.\n *\n * Two shapes land here: NormalizedUserMessage (normal prompts) and\n * AttachmentMessage with type==='queued_command' (prompts sent mid-turn\n * while a tool was executing — they get drained as attachments on the\n * next turn, see query.ts:1410). Both render as ❯-prefixed UserTextMessage\n * in the UI so both should stick.\n *\n * Leading <system-reminder> blocks are stripped before checking — they get\n * prepended to the stored text for Claude's context (memory updates, auto\n * mode reminders) but aren't what the user typed. Without stripping, any\n * prompt that happened to get a reminder is rejected by the startsWith('<')\n * check. Shows up on `cc -c` resumes where memory-update reminders are dense.\n */\nconst promptTextCache = new WeakMap<RenderableMessage, string | null>()\n\nfunction stickyPromptText(msg: RenderableMessage): string | null {\n  // Cache keyed on message object — messages are append-only and don't\n  // mutate, so a WeakMap hit is always valid. The walk (StickyTracker,\n  // per-scroll-tick) calls this 5-50+ times with the SAME messages every\n  // tick; the system-reminder strip allocates a fresh string on each\n  // parse. WeakMap self-GCs on compaction/clear (messages[] replaced).\n  const cached = promptTextCache.get(msg)\n  if (cached !== undefined) return cached\n  const result = computeStickyPromptText(msg)\n  promptTextCache.set(msg, result)\n  return result\n}\n\nfunction computeStickyPromptText(msg: RenderableMessage): string | null {\n  let raw: string | null = null\n  if (msg.type === 'user') {\n    if (msg.isMeta || msg.isVisibleInTranscriptOnly) return null\n    const block = msg.message.content[0]\n    if (block?.type !== 'text') return null\n    raw = block.text\n  } else if (\n    msg.type === 'attachment' &&\n    msg.attachment.type === 'queued_command' &&\n    msg.attachment.commandMode !== 'task-notification' &&\n    !msg.attachment.isMeta\n  ) {\n    const p = msg.attachment.prompt\n    raw =\n      typeof p === 'string'\n        ? p\n        : p.flatMap(b => (b.type === 'text' ? [b.text] : [])).join('\\n')\n  }\n  if (raw === null) return null\n\n  const t = stripSystemReminders(raw)\n  if (t.startsWith('<') || t === '') return null\n  return t\n}\n\n/**\n * Virtualized message list for fullscreen mode. Split from Messages.tsx so\n * useVirtualScroll is called unconditionally (rules-of-hooks) — Messages.tsx\n * conditionally renders either this or a plain .map().\n *\n * The wrapping <Box ref> is the measurement anchor — MessageRow doesn't take\n * a ref. Single-child column Box passes Yoga height through unchanged.\n */\ntype VirtualItemProps = {\n  itemKey: string\n  msg: RenderableMessage\n  idx: number\n  measureRef: (key: string) => (el: DOMElement | null) => void\n  expanded: boolean | undefined\n  hovered: boolean\n  clickable: boolean\n  onClickK: (msg: RenderableMessage, cellIsBlank: boolean) => void\n  onEnterK: (k: string) => void\n  onLeaveK: (k: string) => void\n  renderItem: (msg: RenderableMessage, idx: number) => React.ReactNode\n}\n\n// Item wrapper with stable click handlers. The per-item closures were the\n// `operationNewArrowFunction` leafs → `FunctionExecutable::finalizeUnconditionally`\n// GC cleanup (16% of GC time during fast scroll). 3 closures × 60 mounted ×\n// 10 commits/sec = 1800 closures/sec. With stable onClickK/onEnterK/onLeaveK\n// threaded via itemKey, the closures here are per-item-per-render but CHEAP\n// (just wrap the stable callback with k bound) and don't close over msg/idx\n// which lets JIT inline them. The bigger win is inside: MessageRow.memo\n// bails for unchanged msgs, skipping marked.lexer + formatToken.\n//\n// NOT React.memo'd — renderItem captures changing state (cursor, selectedIdx,\n// verbose). Memoing with a comparator that ignores renderItem would use a\n// STALE closure on bail (wrong selection highlight, stale verbose). Including\n// renderItem in the comparator defeats memo since it's fresh each render.\nfunction VirtualItem({\n  itemKey: k,\n  msg,\n  idx,\n  measureRef,\n  expanded,\n  hovered,\n  clickable,\n  onClickK,\n  onEnterK,\n  onLeaveK,\n  renderItem,\n}: VirtualItemProps): React.ReactNode {\n  return (\n    <Box\n      ref={measureRef(k)}\n      flexDirection=\"column\"\n      backgroundColor={expanded ? 'userMessageBackgroundHover' : undefined}\n      // bg here masks useVirtualScroll's one-frame offset lag on expand —\n      // don't move to the margined Box inside. paddingBottom mirrors the\n      // tinted marginTop.\n      paddingBottom={expanded ? 1 : undefined}\n      onClick={clickable ? e => onClickK(msg, e.cellIsBlank) : undefined}\n      onMouseEnter={clickable ? () => onEnterK(k) : undefined}\n      onMouseLeave={clickable ? () => onLeaveK(k) : undefined}\n    >\n      <TextHoverColorContext.Provider\n        value={hovered && !expanded ? 'text' : undefined}\n      >\n        {renderItem(msg, idx)}\n      </TextHoverColorContext.Provider>\n    </Box>\n  )\n}\n\nexport function VirtualMessageList({\n  messages,\n  scrollRef,\n  columns,\n  itemKey,\n  renderItem,\n  onItemClick,\n  isItemClickable,\n  isItemExpanded,\n  extractSearchText = defaultExtractSearchText,\n  trackStickyPrompt,\n  selectedIndex,\n  cursorNavRef,\n  setCursor,\n  jumpRef,\n  onSearchMatchesChange,\n  scanElement,\n  setPositions,\n}: Props): React.ReactNode {\n  // Incremental key array. Streaming appends one message at a time; rebuilding\n  // the full string array on every commit allocates O(n) per message (~1MB\n  // churn at 27k messages). Append-only delta push when the prefix matches;\n  // fall back to full rebuild on compaction, /clear, or itemKey change.\n  const keysRef = useRef<string[]>([])\n  const prevMessagesRef = useRef<typeof messages>(messages)\n  const prevItemKeyRef = useRef(itemKey)\n  if (\n    prevItemKeyRef.current !== itemKey ||\n    messages.length < keysRef.current.length ||\n    messages[0] !== prevMessagesRef.current[0]\n  ) {\n    keysRef.current = messages.map(m => itemKey(m))\n  } else {\n    for (let i = keysRef.current.length; i < messages.length; i++) {\n      keysRef.current.push(itemKey(messages[i]!))\n    }\n  }\n  prevMessagesRef.current = messages\n  prevItemKeyRef.current = itemKey\n  const keys = keysRef.current\n  const {\n    range,\n    topSpacer,\n    bottomSpacer,\n    measureRef,\n    spacerRef,\n    offsets,\n    getItemTop,\n    getItemElement,\n    getItemHeight,\n    scrollToIndex,\n  } = useVirtualScroll(scrollRef, keys, columns)\n  const [start, end] = range\n\n  // Unmeasured (undefined height) falls through — assume visible.\n  const isVisible = useCallback(\n    (i: number) => {\n      const h = getItemHeight(i)\n      if (h === 0) return false\n      return isNavigableMessage(messages[i]!)\n    },\n    [getItemHeight, messages],\n  )\n  useImperativeHandle(cursorNavRef, (): MessageActionsNav => {\n    const select = (m: NavigableMessage) =>\n      setCursor?.({\n        uuid: m.uuid,\n        msgType: m.type,\n        expanded: false,\n        toolName: toolCallOf(m)?.name,\n      })\n    const selIdx = selectedIndex ?? -1\n    const scan = (\n      from: number,\n      dir: 1 | -1,\n      pred: (i: number) => boolean = isVisible,\n    ) => {\n      for (let i = from; i >= 0 && i < messages.length; i += dir) {\n        if (pred(i)) {\n          select(messages[i]!)\n          return true\n        }\n      }\n      return false\n    }\n    const isUser = (i: number) => isVisible(i) && messages[i]!.type === 'user'\n    return {\n      // Entry via shift+↑ = same semantic as in-cursor shift+↑ (prevUser).\n      enterCursor: () => scan(messages.length - 1, -1, isUser),\n      navigatePrev: () => scan(selIdx - 1, -1),\n      navigateNext: () => {\n        if (scan(selIdx + 1, 1)) return\n        // Past last visible → exit + repin. Last message's TOP is at viewport\n        // top (selection-scroll effect); its BOTTOM may be below the fold.\n        scrollRef.current?.scrollToBottom()\n        setCursor?.(null)\n      },\n      // type:'user' only — queued_command attachments look like prompts but have no raw UserMessage to rewind to.\n      navigatePrevUser: () => scan(selIdx - 1, -1, isUser),\n      navigateNextUser: () => scan(selIdx + 1, 1, isUser),\n      navigateTop: () => scan(0, 1),\n      navigateBottom: () => scan(messages.length - 1, -1),\n      getSelected: () => (selIdx >= 0 ? (messages[selIdx] ?? null) : null),\n    }\n  }, [messages, selectedIndex, setCursor, isVisible])\n  // Two-phase jump + search engine. Read-through-ref so the handle stays\n  // stable across renders — offsets/messages identity changes every render,\n  // can't go in useImperativeHandle deps without recreating the handle.\n  const jumpState = useRef({\n    offsets,\n    start,\n    getItemElement,\n    getItemTop,\n    messages,\n    scrollToIndex,\n  })\n  jumpState.current = {\n    offsets,\n    start,\n    getItemElement,\n    getItemTop,\n    messages,\n    scrollToIndex,\n  }\n\n  // Keep cursor-selected message visible. offsets rebuilds every render\n  // — as a bare dep this re-pinned on every mousewheel tick. Read through\n  // jumpState instead; past-overscan jumps land via scrollToIndex, next\n  // nav is precise.\n  useEffect(() => {\n    if (selectedIndex === undefined) return\n    const s = jumpState.current\n    const el = s.getItemElement(selectedIndex)\n    if (el) {\n      scrollRef.current?.scrollToElement(el, 1)\n    } else {\n      s.scrollToIndex(selectedIndex)\n    }\n  }, [selectedIndex, scrollRef])\n\n  // Pending seek request. jump() sets this + bumps seekGen. The seek\n  // effect fires post-paint (passive effect — after resetAfterCommit),\n  // checks if target is mounted. Yes → scan+highlight. No → re-estimate\n  // with a fresher anchor (start moved toward idx) and scrollTo again.\n  const scanRequestRef = useRef<{\n    idx: number\n    wantLast: boolean\n    tries: number\n  } | null>(null)\n  // Message-relative positions from scanElement. Row 0 = message top.\n  // Stable across scroll — highlight computes rowOffset fresh. msgIdx\n  // for computing rowOffset = getItemTop(msgIdx) - scrollTop.\n  const elementPositions = useRef<{\n    msgIdx: number\n    positions: MatchPosition[]\n  }>({ msgIdx: -1, positions: [] })\n  // Wraparound guard. Auto-advance stops if ptr wraps back to here.\n  const startPtrRef = useRef(-1)\n  // Phantom-burst cap. Resets on scan success.\n  const phantomBurstRef = useRef(0)\n  // One-deep queue: n/N arriving mid-seek gets stored (not dropped) and\n  // fires after the seek completes. Holding n stays smooth without\n  // queueing 30 jumps. Latest press overwrites — we want the direction\n  // the user is going NOW, not where they were 10 keypresses ago.\n  const pendingStepRef = useRef<1 | -1 | 0>(0)\n  // step + highlight via ref so the seek effect reads latest without\n  // closure-capture or deps churn.\n  const stepRef = useRef<(d: 1 | -1) => void>(() => {})\n  const highlightRef = useRef<(ord: number) => void>(() => {})\n  const searchState = useRef({\n    matches: [] as number[], // deduplicated msg indices\n    ptr: 0,\n    screenOrd: 0,\n    // Cumulative engine-occurrence count before each matches[k]. Lets us\n    // compute a global current index: prefixSum[ptr] + screenOrd + 1.\n    // Engine-counted (indexOf on extractSearchText), not render-counted —\n    // close enough for the badge; exact counts would need scanElement on\n    // every matched message (~1-3ms × N). total = prefixSum[matches.length].\n    prefixSum: [] as number[],\n  })\n  // scrollTop at the moment / was pressed. Incsearch preview-jumps snap\n  // back here when matches drop to 0. -1 = no anchor (before first /).\n  const searchAnchor = useRef(-1)\n  const indexWarmed = useRef(false)\n\n  // Scroll target for message i: land at MESSAGE TOP. est = top - HEADROOM\n  // so lo = top - est = HEADROOM ≥ 0 (or lo = top if est clamped to 0).\n  // Post-clamp read-back in jump() handles the scrollHeight boundary.\n  // No frac (render transform didn't respect it), no monotone clamp\n  // (was a safety net for frac garbage — without frac, est IS the next\n  // message's top, spam-n/N converges because message tops are ordered).\n  function targetFor(i: number): number {\n    const top = jumpState.current.getItemTop(i)\n    return Math.max(0, top - HEADROOM)\n  }\n\n  // Highlight positions[ord]. Positions are MESSAGE-RELATIVE (row 0 =\n  // element top, from scanElement). Compute rowOffset = getItemTop -\n  // scrollTop fresh. If ord's position is off-viewport, scroll to bring\n  // it in, recompute rowOffset. setPositions triggers overlay write.\n  function highlight(ord: number): void {\n    const s = scrollRef.current\n    const { msgIdx, positions } = elementPositions.current\n    if (!s || positions.length === 0 || msgIdx < 0) {\n      setPositions?.(null)\n      return\n    }\n    const idx = Math.max(0, Math.min(ord, positions.length - 1))\n    const p = positions[idx]!\n    const top = jumpState.current.getItemTop(msgIdx)\n    // lo = item's position within scroll content (wrapper-relative).\n    // viewportTop = where the scroll content starts on SCREEN (after\n    // ScrollBox padding/border + any chrome above). Highlight writes to\n    // screen-absolute, so rowOffset = viewportTop + lo. Observed: off-by-\n    // 1+ without viewportTop (FullscreenLayout has paddingTop=1 on the\n    // ScrollBox, plus any header above).\n    const vpTop = s.getViewportTop()\n    let lo = top - s.getScrollTop()\n    const vp = s.getViewportHeight()\n    let screenRow = vpTop + lo + p.row\n    // Off viewport → scroll to bring it in (HEADROOM from top).\n    // scrollTo commits sync; read-back after gives fresh lo.\n    if (screenRow < vpTop || screenRow >= vpTop + vp) {\n      s.scrollTo(Math.max(0, top + p.row - HEADROOM))\n      lo = top - s.getScrollTop()\n      screenRow = vpTop + lo + p.row\n    }\n    setPositions?.({ positions, rowOffset: vpTop + lo, currentIdx: idx })\n    // Badge: global current = sum of occurrences before this msg + ord+1.\n    // prefixSum[ptr] is engine-counted (indexOf on extractSearchText);\n    // may drift from render-count for ghost messages but close enough —\n    // badge is a rough location hint, not a proof.\n    const st = searchState.current\n    const total = st.prefixSum.at(-1) ?? 0\n    const current = (st.prefixSum[st.ptr] ?? 0) + idx + 1\n    onSearchMatchesChange?.(total, current)\n    logForDebugging(\n      `highlight(i=${msgIdx}, ord=${idx}/${positions.length}): ` +\n        `pos={row:${p.row},col:${p.col}} lo=${lo} screenRow=${screenRow} ` +\n        `badge=${current}/${total}`,\n    )\n  }\n  highlightRef.current = highlight\n\n  // Seek effect. jump() sets scanRequestRef + scrollToIndex + bump.\n  // bump → re-render → useVirtualScroll mounts the target (scrollToIndex\n  // guarantees this — scrollTop and topSpacer agree via the same\n  // offsets value) → resetAfterCommit paints → this passive effect\n  // fires POST-PAINT with the element mounted. Precise scrollTo + scan.\n  //\n  // Dep is ONLY seekGen — effect doesn't re-run on random renders\n  // (onSearchMatchesChange churn during incsearch).\n  const [seekGen, setSeekGen] = useState(0)\n  const bumpSeek = useCallback(() => setSeekGen(g => g + 1), [])\n\n  useEffect(() => {\n    const req = scanRequestRef.current\n    if (!req) return\n    const { idx, wantLast, tries } = req\n    const s = scrollRef.current\n    if (!s) return\n    const { getItemElement, getItemTop, scrollToIndex } = jumpState.current\n    const el = getItemElement(idx)\n    const h = el?.yogaNode?.getComputedHeight() ?? 0\n\n    if (!el || h === 0) {\n      // Not mounted after scrollToIndex. Shouldn't happen — scrollToIndex\n      // guarantees mount by construction (scrollTop and topSpacer agree\n      // via the same offsets value). Sanity: retry once, then skip.\n      if (tries > 1) {\n        scanRequestRef.current = null\n        logForDebugging(`seek(i=${idx}): no mount after scrollToIndex, skip`)\n        stepRef.current(wantLast ? -1 : 1)\n        return\n      }\n      scanRequestRef.current = { idx, wantLast, tries: tries + 1 }\n      scrollToIndex(idx)\n      bumpSeek()\n      return\n    }\n\n    scanRequestRef.current = null\n    // Precise scrollTo — scrollToIndex got us in the neighborhood\n    // (item is mounted, maybe a few-dozen rows off due to overscan\n    // estimate drift). Now land it at top-HEADROOM.\n    s.scrollTo(Math.max(0, getItemTop(idx) - HEADROOM))\n    const positions = scanElement?.(el) ?? []\n    elementPositions.current = { msgIdx: idx, positions }\n    logForDebugging(`seek(i=${idx} t=${tries}): ${positions.length} positions`)\n    if (positions.length === 0) {\n      // Phantom — engine matched, render didn't. Auto-advance.\n      if (++phantomBurstRef.current > 20) {\n        phantomBurstRef.current = 0\n        return\n      }\n      stepRef.current(wantLast ? -1 : 1)\n      return\n    }\n    phantomBurstRef.current = 0\n    const ord = wantLast ? positions.length - 1 : 0\n    searchState.current.screenOrd = ord\n    startPtrRef.current = -1\n    highlightRef.current(ord)\n    const pending = pendingStepRef.current\n    if (pending) {\n      pendingStepRef.current = 0\n      stepRef.current(pending)\n    }\n    // eslint-disable-next-line react-hooks/exhaustive-deps\n  }, [seekGen])\n\n  // Scroll to message i's top, arm scanPending. scan-effect reads fresh\n  // screen next tick. wantLast: N-into-message — screenOrd = length-1.\n  function jump(i: number, wantLast: boolean): void {\n    const s = scrollRef.current\n    if (!s) return\n    const js = jumpState.current\n    const { getItemElement, scrollToIndex } = js\n    // offsets is a Float64Array whose .length is the allocated buffer (only\n    // grows) — messages.length is the logical item count.\n    if (i < 0 || i >= js.messages.length) return\n    // Clear stale highlight before scroll. Between now and the seek\n    // effect's highlight, inverse-only from scan-highlight shows.\n    setPositions?.(null)\n    elementPositions.current = { msgIdx: -1, positions: [] }\n    scanRequestRef.current = { idx: i, wantLast, tries: 0 }\n    const el = getItemElement(i)\n    const h = el?.yogaNode?.getComputedHeight() ?? 0\n    // Mounted → precise scrollTo. Unmounted → scrollToIndex mounts it\n    // (scrollTop and topSpacer agree via the same offsets value — exact\n    // by construction, no estimation). Seek effect does the precise\n    // scrollTo after paint either way.\n    if (el && h > 0) {\n      s.scrollTo(targetFor(i))\n    } else {\n      scrollToIndex(i)\n    }\n    bumpSeek()\n  }\n\n  // Advance screenOrd within elementPositions. Exhausted → ptr advances,\n  // jump to next matches[ptr], re-scan. Phantom (scan found 0 after\n  // jump) triggers auto-advance from scan-effect. Wraparound guard stops\n  // if every message is a phantom.\n  function step(delta: 1 | -1): void {\n    const st = searchState.current\n    const { matches, prefixSum } = st\n    const total = prefixSum.at(-1) ?? 0\n    if (matches.length === 0) return\n\n    // Seek in-flight — queue this press (one-deep, latest overwrites).\n    // The seek effect fires it after highlight.\n    if (scanRequestRef.current) {\n      pendingStepRef.current = delta\n      return\n    }\n\n    if (startPtrRef.current < 0) startPtrRef.current = st.ptr\n\n    const { positions } = elementPositions.current\n    const newOrd = st.screenOrd + delta\n    if (newOrd >= 0 && newOrd < positions.length) {\n      st.screenOrd = newOrd\n      highlight(newOrd) // updates badge internally\n      startPtrRef.current = -1\n      return\n    }\n\n    // Exhausted visible. Advance ptr → jump → re-scan.\n    const ptr = (st.ptr + delta + matches.length) % matches.length\n    if (ptr === startPtrRef.current) {\n      setPositions?.(null)\n      startPtrRef.current = -1\n      logForDebugging(\n        `step: wraparound at ptr=${ptr}, all ${matches.length} msgs phantoms`,\n      )\n      return\n    }\n    st.ptr = ptr\n    st.screenOrd = 0 // resolved after scan (wantLast → length-1)\n    jump(matches[ptr]!, delta < 0)\n    // screenOrd will resolve after scan. Best-effort: prefixSum[ptr] + 0\n    // for n (first pos), prefixSum[ptr+1] for N (last pos = count-1).\n    // The scan-effect's highlight will be the real value; this is a\n    // pre-scan placeholder so the badge updates immediately.\n    const placeholder =\n      delta < 0 ? (prefixSum[ptr + 1] ?? total) : prefixSum[ptr]! + 1\n    onSearchMatchesChange?.(total, placeholder)\n  }\n  stepRef.current = step\n\n  useImperativeHandle(\n    jumpRef,\n    () => ({\n      // Non-search jump (sticky header click, etc). No scan, no positions.\n      jumpToIndex: (i: number) => {\n        const s = scrollRef.current\n        if (s) s.scrollTo(targetFor(i))\n      },\n      setSearchQuery: (q: string) => {\n        // New search invalidates everything.\n        scanRequestRef.current = null\n        elementPositions.current = { msgIdx: -1, positions: [] }\n        startPtrRef.current = -1\n        setPositions?.(null)\n        const lq = q.toLowerCase()\n        // One entry per MESSAGE (deduplicated). Boolean \"does this msg\n        // contain the query\". ~10ms for 9k messages with cached lowered.\n        const matches: number[] = []\n        // Per-message occurrence count → prefixSum for global current\n        // index. Engine-counted (cheap indexOf loop); may differ from\n        // render-count (scanElement) for ghost/phantom messages but close\n        // enough for the badge. The badge is a rough location hint.\n        const prefixSum: number[] = [0]\n        if (lq) {\n          const msgs = jumpState.current.messages\n          for (let i = 0; i < msgs.length; i++) {\n            const text = extractSearchText(msgs[i]!)\n            let pos = text.indexOf(lq)\n            let cnt = 0\n            while (pos >= 0) {\n              cnt++\n              pos = text.indexOf(lq, pos + lq.length)\n            }\n            if (cnt > 0) {\n              matches.push(i)\n              prefixSum.push(prefixSum.at(-1)! + cnt)\n            }\n          }\n        }\n        const total = prefixSum.at(-1)!\n        // Nearest MESSAGE to the anchor. <= so ties go to later.\n        let ptr = 0\n        const s = scrollRef.current\n        const { offsets, start, getItemTop } = jumpState.current\n        const firstTop = getItemTop(start)\n        const origin = firstTop >= 0 ? firstTop - offsets[start]! : 0\n        if (matches.length > 0 && s) {\n          const curTop =\n            searchAnchor.current >= 0 ? searchAnchor.current : s.getScrollTop()\n          let best = Infinity\n          for (let k = 0; k < matches.length; k++) {\n            const d = Math.abs(origin + offsets[matches[k]!]! - curTop)\n            if (d <= best) {\n              best = d\n              ptr = k\n            }\n          }\n          logForDebugging(\n            `setSearchQuery('${q}'): ${matches.length} msgs · ptr=${ptr} ` +\n              `msgIdx=${matches[ptr]} curTop=${curTop} origin=${origin}`,\n          )\n        }\n        searchState.current = { matches, ptr, screenOrd: 0, prefixSum }\n        if (matches.length > 0) {\n          // wantLast=true: preview the LAST occurrence in the nearest\n          // message. At sticky-bottom (common / entry), nearest is the\n          // last msg; its last occurrence is closest to where the user\n          // was — minimal view movement. n advances forward from there.\n          jump(matches[ptr]!, true)\n        } else if (searchAnchor.current >= 0 && s) {\n          // /foob → 0 matches → snap back to anchor. less/vim incsearch.\n          s.scrollTo(searchAnchor.current)\n        }\n        // Global occurrence count + 1-based current. wantLast=true so the\n        // scan will land on the last occurrence in matches[ptr]. Placeholder\n        // = prefixSum[ptr+1] (count through this msg). highlight() updates\n        // to the exact value after scan completes.\n        onSearchMatchesChange?.(\n          total,\n          matches.length > 0 ? (prefixSum[ptr + 1] ?? total) : 0,\n        )\n      },\n      nextMatch: () => step(1),\n      prevMatch: () => step(-1),\n      setAnchor: () => {\n        const s = scrollRef.current\n        if (s) searchAnchor.current = s.getScrollTop()\n      },\n      disarmSearch: () => {\n        // Manual scroll invalidates screen-absolute positions.\n        setPositions?.(null)\n        scanRequestRef.current = null\n        elementPositions.current = { msgIdx: -1, positions: [] }\n        startPtrRef.current = -1\n      },\n      warmSearchIndex: async () => {\n        if (indexWarmed.current) return 0\n        const msgs = jumpState.current.messages\n        const CHUNK = 500\n        let workMs = 0\n        const wallStart = performance.now()\n        for (let i = 0; i < msgs.length; i += CHUNK) {\n          await sleep(0)\n          const t0 = performance.now()\n          const end = Math.min(i + CHUNK, msgs.length)\n          for (let j = i; j < end; j++) {\n            extractSearchText(msgs[j]!)\n          }\n          workMs += performance.now() - t0\n        }\n        const wallMs = Math.round(performance.now() - wallStart)\n        logForDebugging(\n          `warmSearchIndex: ${msgs.length} msgs · work=${Math.round(workMs)}ms wall=${wallMs}ms chunks=${Math.ceil(msgs.length / CHUNK)}`,\n        )\n        indexWarmed.current = true\n        return Math.round(workMs)\n      },\n    }),\n    // Closures over refs + callbacks. scrollRef stable; others are\n    // useCallback([]) or prop-drilled from REPL (stable).\n    // eslint-disable-next-line react-hooks/exhaustive-deps\n    [scrollRef],\n  )\n\n  // StickyTracker goes AFTER the list content. It returns null (no DOM node)\n  // so order shouldn't matter for layout — but putting it first means every\n  // fine-grained commit from its own scroll subscription reconciles THROUGH\n  // the sibling items (React walks children in order). After the items, it's\n  // a leaf reconcile. Defensive: also avoids any Yoga child-index quirks if\n  // the Ink reconciler ever materializes a placeholder for null returns.\n  const [hoveredKey, setHoveredKey] = useState<string | null>(null)\n  // Stable click/hover handlers — called with k, dispatch from a ref so\n  // closure identity doesn't change per render. The per-item handler\n  // closures (`e => ...`, `() => setHoveredKey(k)`) were the\n  // `operationNewArrowFunction` leafs in the scroll CPU profile; their\n  // cleanup was 16% of GC time (`FunctionExecutable::finalizeUnconditionally`).\n  // Allocating 3 closures × 60 mounted items × 10 commits/sec during fast\n  // scroll = 1800 short-lived closures/sec. With stable refs the item\n  // wrapper props don't change → VirtualItem.memo bails for the ~35\n  // unchanged items, only ~25 fresh items pay createElement cost.\n  const handlersRef = useRef({ onItemClick, setHoveredKey })\n  handlersRef.current = { onItemClick, setHoveredKey }\n  const onClickK = useCallback(\n    (msg: RenderableMessage, cellIsBlank: boolean) => {\n      const h = handlersRef.current\n      if (!cellIsBlank && h.onItemClick) h.onItemClick(msg)\n    },\n    [],\n  )\n  const onEnterK = useCallback((k: string) => {\n    handlersRef.current.setHoveredKey(k)\n  }, [])\n  const onLeaveK = useCallback((k: string) => {\n    handlersRef.current.setHoveredKey(prev => (prev === k ? null : prev))\n  }, [])\n\n  return (\n    <>\n      <Box ref={spacerRef} height={topSpacer} flexShrink={0} />\n      {messages.slice(start, end).map((msg, i) => {\n        const idx = start + i\n        const k = keys[idx]!\n        const clickable = !!onItemClick && (isItemClickable?.(msg) ?? true)\n        const hovered = clickable && hoveredKey === k\n        const expanded = isItemExpanded?.(msg)\n        return (\n          <VirtualItem\n            key={k}\n            itemKey={k}\n            msg={msg}\n            idx={idx}\n            measureRef={measureRef}\n            expanded={expanded}\n            hovered={hovered}\n            clickable={clickable}\n            onClickK={onClickK}\n            onEnterK={onEnterK}\n            onLeaveK={onLeaveK}\n            renderItem={renderItem}\n          />\n        )\n      })}\n      {bottomSpacer > 0 && <Box height={bottomSpacer} flexShrink={0} />}\n      {trackStickyPrompt && (\n        <StickyTracker\n          messages={messages}\n          start={start}\n          end={end}\n          offsets={offsets}\n          getItemTop={getItemTop}\n          getItemElement={getItemElement}\n          scrollRef={scrollRef}\n        />\n      )}\n    </>\n  )\n}\n\nconst NOOP_UNSUB = () => {}\n\n/**\n * Effect-only child that tracks the last user-prompt scrolled above the\n * viewport top and fires onChange when it changes.\n *\n * Rendered as a separate component (not a hook in VirtualMessageList) so it\n * can subscribe to scroll at FINER granularity than SCROLL_QUANTUM=40. The\n * list needs the coarse quantum to avoid per-wheel-tick Yoga relayouts; this\n * tracker is just a walk + comparison and can afford to run every tick. When\n * it re-renders alone, the list's reconciled output is unchanged (same props\n * from the parent's last commit) — no Yoga work. Without this split, the\n * header lags by ~one conversation turn (40 rows ≈ one prompt + response).\n *\n * firstVisible derivation: item Boxes are direct Yoga children of the\n * ScrollBox content wrapper (fragments collapse in the Ink DOM), so\n * yoga.getComputedTop is content-wrapper-relative — same coordinate space as\n * scrollTop. Compare against scrollTop + pendingDelta (the scroll TARGET —\n * scrollBy only sets pendingDelta, committed scrollTop lags). Walk backward\n * from the mount-range end; break when an item's top is above target.\n */\nfunction StickyTracker({\n  messages,\n  start,\n  end,\n  offsets,\n  getItemTop,\n  getItemElement,\n  scrollRef,\n}: {\n  messages: RenderableMessage[]\n  start: number\n  end: number\n  offsets: ArrayLike<number>\n  getItemTop: (index: number) => number\n  getItemElement: (index: number) => DOMElement | null\n  scrollRef: RefObject<ScrollBoxHandle | null>\n}): null {\n  const { setStickyPrompt } = useContext(ScrollChromeContext)\n  // Fine-grained subscription — snapshot is unquantized scrollTop+delta so\n  // every scroll action (wheel tick, PgUp, drag) triggers a re-render of\n  // THIS component only. Sticky bit folded into the sign so sticky→broken\n  // also triggers (scrollToBottom sets sticky without moving scrollTop).\n  const subscribe = useCallback(\n    (listener: () => void) =>\n      scrollRef.current?.subscribe(listener) ?? NOOP_UNSUB,\n    [scrollRef],\n  )\n  useSyncExternalStore(subscribe, () => {\n    const s = scrollRef.current\n    if (!s) return NaN\n    const t = s.getScrollTop() + s.getPendingDelta()\n    return s.isSticky() ? -1 - t : t\n  })\n\n  // Read live scroll state on every render.\n  const isSticky = scrollRef.current?.isSticky() ?? true\n  const target = Math.max(\n    0,\n    (scrollRef.current?.getScrollTop() ?? 0) +\n      (scrollRef.current?.getPendingDelta() ?? 0),\n  )\n\n  // Walk the mounted range to find the first item at-or-below the viewport\n  // top. `range` is from the parent's coarse-quantum render (may be slightly\n  // stale) but overscan guarantees it spans well past the viewport in both\n  // directions. Items without a Yoga layout yet (newly mounted this frame)\n  // are treated as at-or-below — they're somewhere in view, and assuming\n  // otherwise would show a sticky for a prompt that's actually on screen.\n  let firstVisible = start\n  let firstVisibleTop = -1\n  for (let i = end - 1; i >= start; i--) {\n    const top = getItemTop(i)\n    if (top >= 0) {\n      if (top < target) break\n      firstVisibleTop = top\n    }\n    firstVisible = i\n  }\n\n  let idx = -1\n  let text: string | null = null\n  if (firstVisible > 0 && !isSticky) {\n    for (let i = firstVisible - 1; i >= 0; i--) {\n      const t = stickyPromptText(messages[i]!)\n      if (t === null) continue\n      // The prompt's wrapping Box top is above target (that's why it's in\n      // the [0, firstVisible) range), but its ❯ is at top+1 (marginTop=1).\n      // If the ❯ is at-or-below target, it's VISIBLE at viewport top —\n      // showing the same text in the header would duplicate it. Happens\n      // in the 1-row gap between Box top scrolling past and ❯ scrolling\n      // past. Skip to the next-older prompt (its ❯ is definitely above).\n      const top = getItemTop(i)\n      if (top >= 0 && top + 1 >= target) continue\n      idx = i\n      text = t\n      break\n    }\n  }\n\n  const baseOffset =\n    firstVisibleTop >= 0 ? firstVisibleTop - offsets[firstVisible]! : 0\n  const estimate = idx >= 0 ? Math.max(0, baseOffset + offsets[idx]!) : -1\n\n  // For click-jumps to items not yet mounted (user scrolled far past,\n  // prompt is in the topSpacer). Click handler scrolls to the estimate\n  // to mount it; this anchors by element once it appears. scrollToElement\n  // defers the Yoga-position read to render time (render-node-to-output\n  // reads el.yogaNode.getComputedTop() in the SAME calculateLayout pass\n  // that produces scrollHeight) — no throttle race. Cap retries: a /clear\n  // race could unmount the item mid-sequence.\n  const pending = useRef({ idx: -1, tries: 0 })\n  // Suppression state machine. The click handler arms; the onChange effect\n  // consumes (armed→force) then fires-and-clears on the render AFTER that\n  // (force→none). The force step poisons the dedup: after click, idx often\n  // recomputes to the SAME prompt (its top is still above target), so\n  // without force the last.idx===idx guard would hold 'clicked' until the\n  // user crossed a prompt boundary. Previously encoded in last.idx as\n  // -1/-2/-3 which overlapped with real indices — too clever.\n  type Suppress = 'none' | 'armed' | 'force'\n  const suppress = useRef<Suppress>('none')\n  // Dedup on idx only — estimate derives from firstVisibleTop which shifts\n  // every scroll tick, so including it in the key made the guard dead\n  // (setStickyPrompt fired a fresh {text,scrollTo} per-frame). The scrollTo\n  // closure still captures the current estimate; it just doesn't need to\n  // re-fire when only estimate moved.\n  const lastIdx = useRef(-1)\n\n  // setStickyPrompt effect FIRST — must see pending.idx before the\n  // correction effect below clears it. On the estimate-fallback path, the\n  // render that mounts the item is ALSO the render where correction clears\n  // pending; if this ran second, the pending gate would be dead and\n  // setStickyPrompt(prevPrompt) would fire mid-jump, re-mounting the\n  // header over 'clicked'.\n  useEffect(() => {\n    // Hold while two-phase correction is in flight.\n    if (pending.current.idx >= 0) return\n    if (suppress.current === 'armed') {\n      suppress.current = 'force'\n      return\n    }\n    const force = suppress.current === 'force'\n    suppress.current = 'none'\n    if (!force && lastIdx.current === idx) return\n    lastIdx.current = idx\n    if (text === null) {\n      setStickyPrompt(null)\n      return\n    }\n    // First paragraph only (split on blank line) — a prompt like\n    // \"still seeing bugs:\\n\\n1. foo\\n2. bar\" previews as just the\n    // lead-in. trimStart so a leading blank line (queued_command mid-\n    // turn messages sometimes have one) doesn't find paraEnd at 0.\n    const trimmed = text.trimStart()\n    const paraEnd = trimmed.search(/\\n\\s*\\n/)\n    const collapsed = (paraEnd >= 0 ? trimmed.slice(0, paraEnd) : trimmed)\n      .slice(0, STICKY_TEXT_CAP)\n      .replace(/\\s+/g, ' ')\n      .trim()\n    if (collapsed === '') {\n      setStickyPrompt(null)\n      return\n    }\n    const capturedIdx = idx\n    const capturedEstimate = estimate\n    setStickyPrompt({\n      text: collapsed,\n      scrollTo: () => {\n        // Hide header, keep padding collapsed — FullscreenLayout's\n        // 'clicked' sentinel → scrollBox_y=0 + pad=0 → viewportTop=0.\n        setStickyPrompt('clicked')\n        suppress.current = 'armed'\n        // scrollToElement anchors by DOMElement ref, not a number:\n        // render-node-to-output reads el.yogaNode.getComputedTop() at\n        // paint time (same Yoga pass as scrollHeight). No staleness from\n        // the throttled render — the ref is stable, the position read is\n        // deferred. offset=1 = UserPromptMessage marginTop.\n        const el = getItemElement(capturedIdx)\n        if (el) {\n          scrollRef.current?.scrollToElement(el, 1)\n        } else {\n          // Not mounted (scrolled far past — in topSpacer). Jump to\n          // estimate to mount it; correction effect re-anchors once it\n          // appears. Estimate is DEFAULT_ESTIMATE-based — lands short.\n          scrollRef.current?.scrollTo(capturedEstimate)\n          pending.current = { idx: capturedIdx, tries: 0 }\n        }\n      },\n    })\n    // No deps — must run every render. Suppression state lives in a ref\n    // (not idx/estimate), so a deps-gated effect would never see it tick.\n    // Body's own guards short-circuit when nothing changed.\n    // eslint-disable-next-line react-hooks/exhaustive-deps\n  })\n\n  // Correction: for click-jumps to unmounted items. Click handler scrolled\n  // to the estimate; this re-anchors by element once the item appears.\n  // scrollToElement defers the Yoga read to paint time — deterministic.\n  // SECOND so it clears pending AFTER the onChange gate above has seen it.\n  useEffect(() => {\n    if (pending.current.idx < 0) return\n    const el = getItemElement(pending.current.idx)\n    if (el) {\n      scrollRef.current?.scrollToElement(el, 1)\n      pending.current = { idx: -1, tries: 0 }\n    } else if (++pending.current.tries > 5) {\n      pending.current = { idx: -1, tries: 0 }\n    }\n  })\n\n  return null\n}\n"],"mappings":"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","ignoreList":[]}