@iaforged/context-code 1.0.63 → 1.0.67

package/dist/src/components/VirtualMessageList.js

@@ -1,892 +0,0 @@
-import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-runtime";
-import { c as _c } from "react/compiler-runtime";
-import { useCallback, useContext, useEffect, useImperativeHandle, useRef, useState, useSyncExternalStore } from 'react';
-import { useVirtualScroll } from '../hooks/useVirtualScroll.js';
-import { Box } from '../ink.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, 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();
-function defaultExtractSearchText(msg) {
-    const cached = fallbackLowerCache.get(msg);
-    if (cached !== undefined)
-        return cached;
-    const lowered = renderableSearchText(msg);
-    fallbackLowerCache.set(msg, lowered);
-    return lowered;
-}
-/** 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;
-/**
- * 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();
-function stickyPromptText(msg) {
-    // 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) {
-    let raw = 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;
-}
-// 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 = _jsx(TextHoverColorContext.Provider, { value: t7, children: t8 });
-        $[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 = _jsx(Box, { ref: t1, flexDirection: "column", backgroundColor: t2, paddingBottom: t3, onClick: t4, onMouseEnter: t5, onMouseLeave: t6, children: t9 });
-        $[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 }) {
-    // 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([]);
-    const prevMessagesRef = useRef(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) => {
-        const h = getItemHeight(i);
-        if (h === 0)
-            return false;
-        return isNavigableMessage(messages[i]);
-    }, [getItemHeight, messages]);
-    useImperativeHandle(cursorNavRef, () => {
-        const select = (m) => setCursor?.({
-            uuid: m.uuid,
-            msgType: m.type,
-            expanded: false,
-            toolName: toolCallOf(m)?.name
-        });
-        const selIdx = selectedIndex ?? -1;
-        const scan = (from, dir, pred = 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) => 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(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: -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(0);
-    // step + highlight via ref so the seek effect reads latest without
-    // closure-capture or deps churn.
-    const stepRef = useRef(() => { });
-    const highlightRef = useRef(() => { });
-    const searchState = useRef({
-        matches: [],
-        // 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: []
-    });
-    // 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) {
-        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) {
-        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, wantLast) {
-        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) {
-        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) => {
-            const s = scrollRef.current;
-            if (s)
-                s.scrollTo(targetFor(i));
-        },
-        setSearchQuery: (q) => {
-            // 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 = [];
-            // 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 = [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(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, cellIsBlank) => {
-        const h = handlersRef.current;
-        if (!cellIsBlank && h.onItemClick)
-            h.onItemClick(msg);
-    }, []);
-    const onEnterK = useCallback((k) => {
-        handlersRef.current.setHoveredKey(k);
-    }, []);
-    const onLeaveK = useCallback((k) => {
-        handlersRef.current.setHoveredKey(prev => prev === k ? null : prev);
-    }, []);
-    return _jsxs(_Fragment, { children: [_jsx(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 _jsx(VirtualItem, { itemKey: k, msg: msg, idx: idx, measureRef: measureRef, expanded: expanded, hovered: hovered, clickable: clickable, onClickK: onClickK, onEnterK: onEnterK, onLeaveK: onLeaveK, renderItem: renderItem }, k);
-            }), bottomSpacer > 0 && _jsx(Box, { height: bottomSpacer, flexShrink: 0 }), trackStickyPrompt && _jsx(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 }) {
-    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) => 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 = 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
-    });
-    const suppress = useRef('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;
-}