@xelauvas/xela-cli 0.1.0

package/src/components/FullscreenLayout.tsx

@@ -0,0 +1,637 @@
+import { c as _c } from "react/compiler-runtime";
+import figures from 'figures';
+import React, { createContext, type ReactNode, type RefObject, useCallback, useEffect, useLayoutEffect, useMemo, useRef, useState, useSyncExternalStore } from 'react';
+import { fileURLToPath } from 'url';
+import { ModalContext } from '../context/modalContext.js';
+import { PromptOverlayProvider, usePromptOverlay, usePromptOverlayDialog } from '../context/promptOverlayContext.js';
+import { useTerminalSize } from '../hooks/useTerminalSize.js';
+import ScrollBox, { type ScrollBoxHandle } from '../ink/components/ScrollBox.js';
+import instances from '../ink/instances.js';
+import { Box, Text } from '../ink.js';
+import type { Message } from '../types/message.js';
+import { openBrowser, openPath } from '../utils/browser.js';
+import { isFullscreenEnvEnabled } from '../utils/fullscreen.js';
+import { plural } from '../utils/stringUtils.js';
+import { isNullRenderingAttachment } from './messages/nullRenderingAttachments.js';
+import PromptInputFooterSuggestions from './PromptInput/PromptInputFooterSuggestions.js';
+import type { StickyPrompt } from './VirtualMessageList.js';
+
+/** Rows of transcript context kept visible above the modal pane's ▔ divider. */
+const MODAL_TRANSCRIPT_PEEK = 2;
+
+/** Context for scroll-derived chrome (sticky header, pill). StickyTracker
+ *  in VirtualMessageList writes via this instead of threading a callback
+ *  up through Messages → REPL → FullscreenLayout. The setter is stable so
+ *  consuming this context never causes re-renders. */
+export const ScrollChromeContext = createContext<{
+  setStickyPrompt: (p: StickyPrompt | null) => void;
+}>({
+  setStickyPrompt: () => {}
+});
+type Props = {
+  /** Content that scrolls (messages, tool output) */
+  scrollable: ReactNode;
+  /** Content pinned to the bottom (spinner, prompt, permissions) */
+  bottom: ReactNode;
+  /** Content rendered inside the ScrollBox after messages — user can scroll
+   *  up to see context while it's showing (used by PermissionRequest). */
+  overlay?: ReactNode;
+  /** Absolute-positioned content anchored at the bottom-right of the
+   *  ScrollBox area, floating over scrollback. Rendered inside the flexGrow
+   *  region (not the bottom slot) so the overflowY:hidden cap doesn't clip
+   *  it. Fullscreen only — used for the companion speech bubble. */
+  bottomFloat?: ReactNode;
+  /** Slash-command dialog content. Rendered in an absolute-positioned
+   *  bottom-anchored pane (▔ divider, paddingX=2) that paints over the
+   *  ScrollBox AND bottom slot. Provides ModalContext so Pane/Dialog inside
+   *  skip their own frame. Fullscreen only; inline after overlay otherwise. */
+  modal?: ReactNode;
+  /** Ref passed via ModalContext so Tabs (or any scroll-owning descendant)
+   *  can attach it to their own ScrollBox for tall content. */
+  modalScrollRef?: React.RefObject<ScrollBoxHandle | null>;
+  /** Ref to the scroll box for keyboard scrolling. RefObject (not Ref) so
+   *  pillVisible's useSyncExternalStore can subscribe to scroll changes. */
+  scrollRef?: RefObject<ScrollBoxHandle | null>;
+  /** Y-position (scrollHeight at snapshot) of the unseen-divider. Pill
+   *  shows while viewport bottom hasn't reached this. Ref so REPL doesn't
+   *  re-render on the one-shot snapshot write. */
+  dividerYRef?: RefObject<number | null>;
+  /** Force-hide the pill (e.g. viewing a sub-agent task). */
+  hidePill?: boolean;
+  /** Force-hide the sticky prompt header (e.g. viewing a teammate task). */
+  hideSticky?: boolean;
+  /** Count for the pill text. 0 → "Jump to bottom", >0 → "N new messages". */
+  newMessageCount?: number;
+  /** Called when the user clicks the "N new" pill. */
+  onPillClick?: () => void;
+};
+
+/**
+ * Tracks the in-transcript "N new messages" divider position while the
+ * user is scrolled up. Snapshots message count AND scrollHeight the first
+ * time sticky breaks. scrollHeight ≈ the y-position of the divider in the
+ * scroll content (it renders right after the last message that existed at
+ * snapshot time).
+ *
+ * `pillVisible` lives in FullscreenLayout (not here) — it subscribes
+ * directly to ScrollBox via useSyncExternalStore with a boolean snapshot
+ * against `dividerYRef`, so per-frame scroll never re-renders REPL.
+ * `dividerIndex` stays here because REPL needs it for computeUnseenDivider
+ * → Messages' divider line; it changes only ~twice/scroll-session
+ * (first scroll-away + repin), acceptable REPL re-render cost.
+ *
+ * `onScrollAway` must be called by every scroll-away action with the
+ * handle; `onRepin` by submit/scroll-to-bottom.
+ */
+export function useUnseenDivider(messageCount: number): {
+  /** Index into messages[] where the divider line renders. Cleared on
+   *  sticky-resume (scroll back to bottom) so the "N new" line doesn't
+   *  linger once everything is visible. */
+  dividerIndex: number | null;
+  /** scrollHeight snapshot at first scroll-away — the divider's y-position.
+   *  FullscreenLayout subscribes to ScrollBox and compares viewport bottom
+   *  against this for pillVisible. Ref so writes don't re-render REPL. */
+  dividerYRef: RefObject<number | null>;
+  onScrollAway: (handle: ScrollBoxHandle) => void;
+  onRepin: () => void;
+  /** Scroll the handle so the divider line is at the top of the viewport. */
+  jumpToNew: (handle: ScrollBoxHandle | null) => void;
+  /** Shift dividerIndex and dividerYRef when messages are prepended
+   *  (infinite scroll-back). indexDelta = number of messages prepended;
+   *  heightDelta = content height growth in rows. */
+  shiftDivider: (indexDelta: number, heightDelta: number) => void;
+} {
+  const [dividerIndex, setDividerIndex] = useState<number | null>(null);
+  // Ref holds the current count for onScrollAway to snapshot. Written in
+  // the render body (not useEffect) so wheel events arriving between a
+  // message-append render and its effect flush don't capture a stale
+  // count (off-by-one in the baseline). React Compiler bails out here —
+  // acceptable for a hook instantiated once in REPL.
+  const countRef = useRef(messageCount);
+  countRef.current = messageCount;
+  // scrollHeight snapshot — the divider's y in content coords. Ref-only:
+  // read synchronously in onScrollAway (setState is batched, can't
+  // read-then-write in the same callback) AND by FullscreenLayout's
+  // pillVisible subscription. null = pinned to bottom.
+  const dividerYRef = useRef<number | null>(null);
+  const onRepin = useCallback(() => {
+    // Don't clear dividerYRef here — a trackpad momentum wheel event
+    // racing in the same stdin batch would see null and re-snapshot,
+    // overriding the setDividerIndex(null) below. The useEffect below
+    // clears the ref after React commits the null dividerIndex, so the
+    // ref stays non-null until the state settles.
+    setDividerIndex(null);
+  }, []);
+  const onScrollAway = useCallback((handle: ScrollBoxHandle) => {
+    // Nothing below the viewport → nothing to jump to. Covers both:
+    // • empty/short session: scrollUp calls scrollTo(0) which breaks sticky
+    //   even at scrollTop=0 (wheel-up on fresh session showed the pill)
+    // • click-to-select at bottom: useDragToScroll.check() calls
+    //   scrollTo(current) to break sticky so streaming content doesn't shift
+    //   under the selection, then onScroll(false, …) — but scrollTop is still
+    //   at max (Sarah Deaton, #claude-code-feedback 2026-03-15)
+    // pendingDelta: scrollBy accumulates without updating scrollTop. Without
+    // it, wheeling up from max would see scrollTop==max and suppress the pill.
+    const max = Math.max(0, handle.getScrollHeight() - handle.getViewportHeight());
+    if (handle.getScrollTop() + handle.getPendingDelta() >= max) return;
+    // Snapshot only on the FIRST scroll-away. onScrollAway fires on EVERY
+    // scroll action (not just the initial break from sticky) — this guard
+    // preserves the original baseline so the count doesn't reset on the
+    // second PageUp. Subsequent calls are ref-only no-ops (no REPL re-render).
+    if (dividerYRef.current === null) {
+      dividerYRef.current = handle.getScrollHeight();
+      // New scroll-away session → move the divider here (replaces old one)
+      setDividerIndex(countRef.current);
+    }
+  }, []);
+  const jumpToNew = useCallback((handle_0: ScrollBoxHandle | null) => {
+    if (!handle_0) return;
+    // scrollToBottom (not scrollTo(dividerY)): sets stickyScroll=true so
+    // useVirtualScroll mounts the tail and render-node-to-output pins
+    // scrollTop=maxScroll. scrollTo sets stickyScroll=false → the clamp
+    // (still at top-range bounds before React re-renders) pins scrollTop
+    // back, stopping short. The divider stays rendered (dividerIndex
+    // unchanged) so users see where new messages started; the clear on
+    // next submit/explicit scroll-to-bottom handles cleanup.
+    handle_0.scrollToBottom();
+  }, []);
+
+  // Sync dividerYRef with dividerIndex. When onRepin fires (submit,
+  // scroll-to-bottom), it sets dividerIndex=null but leaves the ref
+  // non-null — a wheel event racing in the same stdin batch would
+  // otherwise see null and re-snapshot. Deferring the ref clear to
+  // useEffect guarantees the ref stays non-null until React has committed
+  // the null dividerIndex, blocking the if-null guard in onScrollAway.
+  //
+  // Also handles /clear, rewind, teammate-view swap — if the count drops
+  // below the divider index, the divider would point at nothing.
+  useEffect(() => {
+    if (dividerIndex === null) {
+      dividerYRef.current = null;
+    } else if (messageCount < dividerIndex) {
+      dividerYRef.current = null;
+      setDividerIndex(null);
+    }
+  }, [messageCount, dividerIndex]);
+  const shiftDivider = useCallback((indexDelta: number, heightDelta: number) => {
+    setDividerIndex(idx => idx === null ? null : idx + indexDelta);
+    if (dividerYRef.current !== null) {
+      dividerYRef.current += heightDelta;
+    }
+  }, []);
+  return {
+    dividerIndex,
+    dividerYRef,
+    onScrollAway,
+    onRepin,
+    jumpToNew,
+    shiftDivider
+  };
+}
+
+/**
+ * Counts assistant turns in messages[dividerIndex..end). A "turn" is what
+ * users think of as "a new message from Claude" — not raw assistant entries
+ * (one turn yields multiple entries: tool_use blocks + text blocks). We count
+ * non-assistant→assistant transitions, but only for entries that actually
+ * carry text — tool-use-only entries are skipped (like progress messages)
+ * so "⏺ Searched for 13 patterns, read 6 files" doesn't tick the pill.
+ */
+export function countUnseenAssistantTurns(messages: readonly Message[], dividerIndex: number): number {
+  let count = 0;
+  let prevWasAssistant = false;
+  for (let i = dividerIndex; i < messages.length; i++) {
+    const m = messages[i]!;
+    if (m.type === 'progress') continue;
+    // Tool-use-only assistant entries aren't "new messages" to the user —
+    // skip them the same way we skip progress. prevWasAssistant is NOT
+    // updated, so a text block immediately following still counts as the
+    // same turn (tool_use + text from one API response = 1).
+    if (m.type === 'assistant' && !assistantHasVisibleText(m)) continue;
+    const isAssistant = m.type === 'assistant';
+    if (isAssistant && !prevWasAssistant) count++;
+    prevWasAssistant = isAssistant;
+  }
+  return count;
+}
+function assistantHasVisibleText(m: Message): boolean {
+  if (m.type !== 'assistant') return false;
+  for (const b of m.message.content) {
+    if (b.type === 'text' && b.text.trim() !== '') return true;
+  }
+  return false;
+}
+export type UnseenDivider = {
+  firstUnseenUuid: Message['uuid'];
+  count: number;
+};
+
+/**
+ * Builds the unseenDivider object REPL passes to Messages + the pill.
+ * Returns undefined only when no content has arrived past the divider
+ * yet (messages[dividerIndex] doesn't exist). Once ANY message arrives
+ * — including tool_use-only assistant entries and tool_result user entries
+ * that countUnseenAssistantTurns skips — count floors at 1 so the pill
+ * flips from "Jump to bottom" to "1 new message". Without the floor,
+ * the pill stays "Jump to bottom" through an entire tool-call sequence
+ * until Claude's text response lands.
+ */
+export function computeUnseenDivider(messages: readonly Message[], dividerIndex: number | null): UnseenDivider | undefined {
+  if (dividerIndex === null) return undefined;
+  // Skip progress and null-rendering attachments when picking the divider
+  // anchor — Messages.tsx filters these out of renderableMessages before the
+  // dividerBeforeIndex search, so their UUID wouldn't be found (CC-724).
+  // Hook attachments use randomUUID() so nothing shares their 24-char prefix.
+  let anchorIdx = dividerIndex;
+  while (anchorIdx < messages.length && (messages[anchorIdx]?.type === 'progress' || isNullRenderingAttachment(messages[anchorIdx]!))) {
+    anchorIdx++;
+  }
+  const uuid = messages[anchorIdx]?.uuid;
+  if (!uuid) return undefined;
+  const count = countUnseenAssistantTurns(messages, dividerIndex);
+  return {
+    firstUnseenUuid: uuid,
+    count: Math.max(1, count)
+  };
+}
+
+/**
+ * Layout wrapper for the REPL. In fullscreen mode, puts scrollable
+ * content in a sticky-scroll box and pins bottom content via flexbox.
+ * Outside fullscreen mode, renders content sequentially so the existing
+ * main-screen scrollback rendering works unchanged.
+ *
+ * Fullscreen mode defaults on for ants (CLAUDE_CODE_NO_FLICKER=0 to opt out)
+ * and off for external users (CLAUDE_CODE_NO_FLICKER=1 to opt in).
+ * The <AlternateScreen> wrapper
+ * (alt buffer + mouse tracking + height constraint) lives at REPL's root
+ * so nothing can accidentally render outside it.
+ */
+export function FullscreenLayout(t0) {
+  const $ = _c(47);
+  const {
+    scrollable,
+    bottom,
+    overlay,
+    bottomFloat,
+    modal,
+    modalScrollRef,
+    scrollRef,
+    dividerYRef,
+    hidePill: t1,
+    hideSticky: t2,
+    newMessageCount: t3,
+    onPillClick
+  } = t0;
+  const hidePill = t1 === undefined ? false : t1;
+  const hideSticky = t2 === undefined ? false : t2;
+  const newMessageCount = t3 === undefined ? 0 : t3;
+  const {
+    rows: terminalRows,
+    columns
+  } = useTerminalSize();
+  const [stickyPrompt, setStickyPrompt] = useState(null);
+  let t4;
+  if ($[0] === Symbol.for("react.memo_cache_sentinel")) {
+    t4 = {
+      setStickyPrompt
+    };
+    $[0] = t4;
+  } else {
+    t4 = $[0];
+  }
+  const chromeCtx = t4;
+  let t5;
+  if ($[1] !== scrollRef) {
+    t5 = listener => scrollRef?.current?.subscribe(listener) ?? _temp;
+    $[1] = scrollRef;
+    $[2] = t5;
+  } else {
+    t5 = $[2];
+  }
+  const subscribe = t5;
+  let t6;
+  if ($[3] !== dividerYRef || $[4] !== scrollRef) {
+    t6 = () => {
+      const s = scrollRef?.current;
+      const dividerY = dividerYRef?.current;
+      if (!s || dividerY == null) {
+        return false;
+      }
+      return s.getScrollTop() + s.getPendingDelta() + s.getViewportHeight() < dividerY;
+    };
+    $[3] = dividerYRef;
+    $[4] = scrollRef;
+    $[5] = t6;
+  } else {
+    t6 = $[5];
+  }
+  const pillVisible = useSyncExternalStore(subscribe, t6);
+  let t7;
+  if ($[6] === Symbol.for("react.memo_cache_sentinel")) {
+    t7 = [];
+    $[6] = t7;
+  } else {
+    t7 = $[6];
+  }
+  useLayoutEffect(_temp3, t7);
+  if (isFullscreenEnvEnabled()) {
+    const sticky = hideSticky ? null : stickyPrompt;
+    const headerPrompt = sticky != null && sticky !== "clicked" && overlay == null ? sticky : null;
+    const padCollapsed = sticky != null && overlay == null;
+    let t8;
+    if ($[7] !== headerPrompt) {
+      t8 = headerPrompt && <StickyPromptHeader text={headerPrompt.text} onClick={headerPrompt.scrollTo} />;
+      $[7] = headerPrompt;
+      $[8] = t8;
+    } else {
+      t8 = $[8];
+    }
+    const t9 = padCollapsed ? 0 : 1;
+    let t10;
+    if ($[9] !== scrollable) {
+      t10 = <ScrollChromeContext value={chromeCtx}>{scrollable}</ScrollChromeContext>;
+      $[9] = scrollable;
+      $[10] = t10;
+    } else {
+      t10 = $[10];
+    }
+    let t11;
+    if ($[11] !== overlay || $[12] !== scrollRef || $[13] !== t10 || $[14] !== t9) {
+      t11 = <ScrollBox ref={scrollRef} flexGrow={1} flexDirection="column" paddingTop={t9} stickyScroll={true}>{t10}{overlay}</ScrollBox>;
+      $[11] = overlay;
+      $[12] = scrollRef;
+      $[13] = t10;
+      $[14] = t9;
+      $[15] = t11;
+    } else {
+      t11 = $[15];
+    }
+    let t12;
+    if ($[16] !== hidePill || $[17] !== newMessageCount || $[18] !== onPillClick || $[19] !== overlay || $[20] !== pillVisible) {
+      t12 = !hidePill && pillVisible && overlay == null && <NewMessagesPill count={newMessageCount} onClick={onPillClick} />;
+      $[16] = hidePill;
+      $[17] = newMessageCount;
+      $[18] = onPillClick;
+      $[19] = overlay;
+      $[20] = pillVisible;
+      $[21] = t12;
+    } else {
+      t12 = $[21];
+    }
+    let t13;
+    if ($[22] !== bottomFloat) {
+      t13 = bottomFloat != null && <Box position="absolute" bottom={0} right={0} opaque={true}>{bottomFloat}</Box>;
+      $[22] = bottomFloat;
+      $[23] = t13;
+    } else {
+      t13 = $[23];
+    }
+    let t14;
+    if ($[24] !== t11 || $[25] !== t12 || $[26] !== t13 || $[27] !== t8) {
+      t14 = <Box flexGrow={1} flexDirection="column" overflow="hidden">{t8}{t11}{t12}{t13}</Box>;
+      $[24] = t11;
+      $[25] = t12;
+      $[26] = t13;
+      $[27] = t8;
+      $[28] = t14;
+    } else {
+      t14 = $[28];
+    }
+    let t15;
+    let t16;
+    if ($[29] === Symbol.for("react.memo_cache_sentinel")) {
+      t15 = <SuggestionsOverlay />;
+      t16 = <DialogOverlay />;
+      $[29] = t15;
+      $[30] = t16;
+    } else {
+      t15 = $[29];
+      t16 = $[30];
+    }
+    let t17;
+    if ($[31] !== bottom) {
+      t17 = <Box flexDirection="column" flexShrink={0} width="100%" maxHeight="50%">{t15}{t16}<Box flexDirection="column" width="100%" flexGrow={1} overflowY="hidden">{bottom}</Box></Box>;
+      $[31] = bottom;
+      $[32] = t17;
+    } else {
+      t17 = $[32];
+    }
+    let t18;
+    if ($[33] !== columns || $[34] !== modal || $[35] !== modalScrollRef || $[36] !== terminalRows) {
+      t18 = modal != null && <ModalContext value={{
+        rows: terminalRows - MODAL_TRANSCRIPT_PEEK - 1,
+        columns: columns - 4,
+        scrollRef: modalScrollRef ?? null
+      }}><Box position="absolute" bottom={0} left={0} right={0} maxHeight={terminalRows - MODAL_TRANSCRIPT_PEEK} flexDirection="column" overflow="hidden" opaque={true}><Box flexShrink={0}><Text color="permission">{"\u2594".repeat(columns)}</Text></Box><Box flexDirection="column" paddingX={2} flexShrink={0} overflow="hidden">{modal}</Box></Box></ModalContext>;
+      $[33] = columns;
+      $[34] = modal;
+      $[35] = modalScrollRef;
+      $[36] = terminalRows;
+      $[37] = t18;
+    } else {
+      t18 = $[37];
+    }
+    let t19;
+    if ($[38] !== t14 || $[39] !== t17 || $[40] !== t18) {
+      t19 = <PromptOverlayProvider>{t14}{t17}{t18}</PromptOverlayProvider>;
+      $[38] = t14;
+      $[39] = t17;
+      $[40] = t18;
+      $[41] = t19;
+    } else {
+      t19 = $[41];
+    }
+    return t19;
+  }
+  let t8;
+  if ($[42] !== bottom || $[43] !== modal || $[44] !== overlay || $[45] !== scrollable) {
+    t8 = <>{scrollable}{bottom}{overlay}{modal}</>;
+    $[42] = bottom;
+    $[43] = modal;
+    $[44] = overlay;
+    $[45] = scrollable;
+    $[46] = t8;
+  } else {
+    t8 = $[46];
+  }
+  return t8;
+}
+
+// Slack-style pill. Absolute overlay at bottom={0} of the scrollwrap — floats
+// over the ScrollBox's last content row, only obscuring the centered pill
+// text (the rest of the row shows ScrollBox content). Scroll-smear from
+// DECSTBM shifting the pill's pixels is repaired at the Ink layer
+// (absoluteRectsPrev third-pass in render-node-to-output.ts, #23939). Shows
+// "Jump to bottom" when count is 0 (scrolled away but no new messages yet —
+// the dead zone where users previously thought chat stalled).
+function _temp3() {
+  if (!isFullscreenEnvEnabled()) {
+    return;
+  }
+  const ink = instances.get(process.stdout);
+  if (!ink) {
+    return;
+  }
+  ink.onHyperlinkClick = _temp2;
+  return () => {
+    ink.onHyperlinkClick = undefined;
+  };
+}
+function _temp2(url) {
+  if (url.startsWith("file:")) {
+    try {
+      openPath(fileURLToPath(url));
+    } catch {}
+  } else {
+    openBrowser(url);
+  }
+}
+function _temp() {}
+function NewMessagesPill(t0) {
+  const $ = _c(10);
+  const {
+    count,
+    onClick
+  } = t0;
+  const [hover, setHover] = useState(false);
+  let t1;
+  let t2;
+  if ($[0] === Symbol.for("react.memo_cache_sentinel")) {
+    t1 = () => setHover(true);
+    t2 = () => setHover(false);
+    $[0] = t1;
+    $[1] = t2;
+  } else {
+    t1 = $[0];
+    t2 = $[1];
+  }
+  const t3 = hover ? "userMessageBackgroundHover" : "userMessageBackground";
+  let t4;
+  if ($[2] !== count) {
+    t4 = count > 0 ? `${count} new ${plural(count, "message")}` : "Jump to bottom";
+    $[2] = count;
+    $[3] = t4;
+  } else {
+    t4 = $[3];
+  }
+  let t5;
+  if ($[4] !== t3 || $[5] !== t4) {
+    t5 = <Text backgroundColor={t3} dimColor={true}>{" "}{t4}{" "}{figures.arrowDown}{" "}</Text>;
+    $[4] = t3;
+    $[5] = t4;
+    $[6] = t5;
+  } else {
+    t5 = $[6];
+  }
+  let t6;
+  if ($[7] !== onClick || $[8] !== t5) {
+    t6 = <Box position="absolute" bottom={0} left={0} right={0} justifyContent="center"><Box onClick={onClick} onMouseEnter={t1} onMouseLeave={t2}>{t5}</Box></Box>;
+    $[7] = onClick;
+    $[8] = t5;
+    $[9] = t6;
+  } else {
+    t6 = $[9];
+  }
+  return t6;
+}
+
+// Context breadcrumb: when scrolled up into history, pin the current
+// conversation turn's prompt above the viewport so you know what Claude was
+// responding to. Normal-flow sibling BEFORE the ScrollBox (mirrors the pill
+// below it) — shrinks the ScrollBox by exactly 1 row via flex, stays outside
+// the DECSTBM scroll region. Click jumps back to the prompt.
+//
+// Height is FIXED at 1 row (truncate-end for long prompts). A variable-height
+// header (1 when short, 2 when wrapped) shifts the ScrollBox by 1 row every
+// time the sticky prompt switches during scroll — content jumps on screen
+// even with scrollTop unchanged (the DECSTBM region top shifts with the
+// ScrollBox, and the diff engine sees "everything moved"). Fixed height
+// keeps the ScrollBox anchored; only the header TEXT changes, not its box.
+function StickyPromptHeader(t0) {
+  const $ = _c(8);
+  const {
+    text,
+    onClick
+  } = t0;
+  const [hover, setHover] = useState(false);
+  const t1 = hover ? "userMessageBackgroundHover" : "userMessageBackground";
+  let t2;
+  let t3;
+  if ($[0] === Symbol.for("react.memo_cache_sentinel")) {
+    t2 = () => setHover(true);
+    t3 = () => setHover(false);
+    $[0] = t2;
+    $[1] = t3;
+  } else {
+    t2 = $[0];
+    t3 = $[1];
+  }
+  let t4;
+  if ($[2] !== text) {
+    t4 = <Text color="subtle" wrap="truncate-end">{figures.pointer} {text}</Text>;
+    $[2] = text;
+    $[3] = t4;
+  } else {
+    t4 = $[3];
+  }
+  let t5;
+  if ($[4] !== onClick || $[5] !== t1 || $[6] !== t4) {
+    t5 = <Box flexShrink={0} width="100%" height={1} paddingRight={1} backgroundColor={t1} onClick={onClick} onMouseEnter={t2} onMouseLeave={t3}>{t4}</Box>;
+    $[4] = onClick;
+    $[5] = t1;
+    $[6] = t4;
+    $[7] = t5;
+  } else {
+    t5 = $[7];
+  }
+  return t5;
+}
+
+// Slash-command suggestion overlay — see promptOverlayContext.tsx for why
+// it's portaled. Scroll-smear from floating over the DECSTBM region is
+// repaired at the Ink layer (absoluteRectsPrev in render-node-to-output.ts).
+// The renderer clamps negative y to 0 for absolute elements (see
+// render-node-to-output.ts), so the top rows (best matches) stay visible
+// even when the overlay extends above the viewport. We omit minHeight and
+// flex-end here: they would create empty padding rows that shift visible
+// items down into the prompt area when the list has fewer items than max.
+function SuggestionsOverlay() {
+  const $ = _c(4);
+  const data = usePromptOverlay();
+  if (!data || data.suggestions.length === 0) {
+    return null;
+  }
+  let t0;
+  if ($[0] !== data.maxColumnWidth || $[1] !== data.selectedSuggestion || $[2] !== data.suggestions) {
+    t0 = <Box position="absolute" bottom="100%" left={0} right={0} paddingX={2} paddingTop={1} flexDirection="column" opaque={true}><PromptInputFooterSuggestions suggestions={data.suggestions} selectedSuggestion={data.selectedSuggestion} maxColumnWidth={data.maxColumnWidth} overlay={true} /></Box>;
+    $[0] = data.maxColumnWidth;
+    $[1] = data.selectedSuggestion;
+    $[2] = data.suggestions;
+    $[3] = t0;
+  } else {
+    t0 = $[3];
+  }
+  return t0;
+}
+
+// Dialog portaled from PromptInput (AutoModeOptInDialog) — same clip-escape
+// pattern as SuggestionsOverlay. Renders later in tree order so it paints
+// over suggestions if both are ever up (they shouldn't be).
+function DialogOverlay() {
+  const $ = _c(2);
+  const node = usePromptOverlayDialog();
+  if (!node) {
+    return null;
+  }
+  let t0;
+  if ($[0] !== node) {
+    t0 = <Box position="absolute" bottom="100%" left={0} right={0} opaque={true}>{node}</Box>;
+    $[0] = node;
+    $[1] = t0;
+  } else {
+    t0 = $[1];
+  }
+  return t0;
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["figures","React","createContext","ReactNode","RefObject","useCallback","useEffect","useLayoutEffect","useMemo","useRef","useState","useSyncExternalStore","fileURLToPath","ModalContext","PromptOverlayProvider","usePromptOverlay","usePromptOverlayDialog","useTerminalSize","ScrollBox","ScrollBoxHandle","instances","Box","Text","Message","openBrowser","openPath","isFullscreenEnvEnabled","plural","isNullRenderingAttachment","PromptInputFooterSuggestions","StickyPrompt","MODAL_TRANSCRIPT_PEEK","ScrollChromeContext","setStickyPrompt","p","Props","scrollable","bottom","overlay","bottomFloat","modal","modalScrollRef","scrollRef","dividerYRef","hidePill","hideSticky","newMessageCount","onPillClick","useUnseenDivider","messageCount","dividerIndex","onScrollAway","handle","onRepin","jumpToNew","shiftDivider","indexDelta","heightDelta","setDividerIndex","countRef","current","max","Math","getScrollHeight","getViewportHeight","getScrollTop","getPendingDelta","scrollToBottom","idx","countUnseenAssistantTurns","messages","count","prevWasAssistant","i","length","m","type","assistantHasVisibleText","isAssistant","b","message","content","text","trim","UnseenDivider","firstUnseenUuid","computeUnseenDivider","undefined","anchorIdx","uuid","FullscreenLayout","t0","$","_c","t1","t2","t3","rows","terminalRows","columns","stickyPrompt","t4","Symbol","for","chromeCtx","t5","listener","subscribe","_temp","t6","s","dividerY","pillVisible","t7","_temp3","sticky","headerPrompt","padCollapsed","t8","scrollTo","t9","t10","t11","t12","t13","t14","t15","t16","t17","t18","repeat","t19","ink","get","process","stdout","onHyperlinkClick","_temp2","url","startsWith","NewMessagesPill","onClick","hover","setHover","arrowDown","StickyPromptHeader","pointer","SuggestionsOverlay","data","suggestions","maxColumnWidth","selectedSuggestion","DialogOverlay","node"],"sources":["FullscreenLayout.tsx"],"sourcesContent":["import figures from 'figures'\nimport React, {\n  createContext,\n  type ReactNode,\n  type RefObject,\n  useCallback,\n  useEffect,\n  useLayoutEffect,\n  useMemo,\n  useRef,\n  useState,\n  useSyncExternalStore,\n} from 'react'\nimport { fileURLToPath } from 'url'\nimport { ModalContext } from '../context/modalContext.js'\nimport {\n  PromptOverlayProvider,\n  usePromptOverlay,\n  usePromptOverlayDialog,\n} from '../context/promptOverlayContext.js'\nimport { useTerminalSize } from '../hooks/useTerminalSize.js'\nimport ScrollBox, { type ScrollBoxHandle } from '../ink/components/ScrollBox.js'\nimport instances from '../ink/instances.js'\nimport { Box, Text } from '../ink.js'\nimport type { Message } from '../types/message.js'\nimport { openBrowser, openPath } from '../utils/browser.js'\nimport { isFullscreenEnvEnabled } from '../utils/fullscreen.js'\nimport { plural } from '../utils/stringUtils.js'\nimport { isNullRenderingAttachment } from './messages/nullRenderingAttachments.js'\nimport PromptInputFooterSuggestions from './PromptInput/PromptInputFooterSuggestions.js'\nimport type { StickyPrompt } from './VirtualMessageList.js'\n\n/** Rows of transcript context kept visible above the modal pane's ▔ divider. */\nconst MODAL_TRANSCRIPT_PEEK = 2\n\n/** Context for scroll-derived chrome (sticky header, pill). StickyTracker\n *  in VirtualMessageList writes via this instead of threading a callback\n *  up through Messages → REPL → FullscreenLayout. The setter is stable so\n *  consuming this context never causes re-renders. */\nexport const ScrollChromeContext = createContext<{\n  setStickyPrompt: (p: StickyPrompt | null) => void\n}>({ setStickyPrompt: () => {} })\n\ntype Props = {\n  /** Content that scrolls (messages, tool output) */\n  scrollable: ReactNode\n  /** Content pinned to the bottom (spinner, prompt, permissions) */\n  bottom: ReactNode\n  /** Content rendered inside the ScrollBox after messages — user can scroll\n   *  up to see context while it's showing (used by PermissionRequest). */\n  overlay?: ReactNode\n  /** Absolute-positioned content anchored at the bottom-right of the\n   *  ScrollBox area, floating over scrollback. Rendered inside the flexGrow\n   *  region (not the bottom slot) so the overflowY:hidden cap doesn't clip\n   *  it. Fullscreen only — used for the companion speech bubble. */\n  bottomFloat?: ReactNode\n  /** Slash-command dialog content. Rendered in an absolute-positioned\n   *  bottom-anchored pane (▔ divider, paddingX=2) that paints over the\n   *  ScrollBox AND bottom slot. Provides ModalContext so Pane/Dialog inside\n   *  skip their own frame. Fullscreen only; inline after overlay otherwise. */\n  modal?: ReactNode\n  /** Ref passed via ModalContext so Tabs (or any scroll-owning descendant)\n   *  can attach it to their own ScrollBox for tall content. */\n  modalScrollRef?: React.RefObject<ScrollBoxHandle | null>\n  /** Ref to the scroll box for keyboard scrolling. RefObject (not Ref) so\n   *  pillVisible's useSyncExternalStore can subscribe to scroll changes. */\n  scrollRef?: RefObject<ScrollBoxHandle | null>\n  /** Y-position (scrollHeight at snapshot) of the unseen-divider. Pill\n   *  shows while viewport bottom hasn't reached this. Ref so REPL doesn't\n   *  re-render on the one-shot snapshot write. */\n  dividerYRef?: RefObject<number | null>\n  /** Force-hide the pill (e.g. viewing a sub-agent task). */\n  hidePill?: boolean\n  /** Force-hide the sticky prompt header (e.g. viewing a teammate task). */\n  hideSticky?: boolean\n  /** Count for the pill text. 0 → \"Jump to bottom\", >0 → \"N new messages\". */\n  newMessageCount?: number\n  /** Called when the user clicks the \"N new\" pill. */\n  onPillClick?: () => void\n}\n\n/**\n * Tracks the in-transcript \"N new messages\" divider position while the\n * user is scrolled up. Snapshots message count AND scrollHeight the first\n * time sticky breaks. scrollHeight ≈ the y-position of the divider in the\n * scroll content (it renders right after the last message that existed at\n * snapshot time).\n *\n * `pillVisible` lives in FullscreenLayout (not here) — it subscribes\n * directly to ScrollBox via useSyncExternalStore with a boolean snapshot\n * against `dividerYRef`, so per-frame scroll never re-renders REPL.\n * `dividerIndex` stays here because REPL needs it for computeUnseenDivider\n * → Messages' divider line; it changes only ~twice/scroll-session\n * (first scroll-away + repin), acceptable REPL re-render cost.\n *\n * `onScrollAway` must be called by every scroll-away action with the\n * handle; `onRepin` by submit/scroll-to-bottom.\n */\nexport function useUnseenDivider(messageCount: number): {\n  /** Index into messages[] where the divider line renders. Cleared on\n   *  sticky-resume (scroll back to bottom) so the \"N new\" line doesn't\n   *  linger once everything is visible. */\n  dividerIndex: number | null\n  /** scrollHeight snapshot at first scroll-away — the divider's y-position.\n   *  FullscreenLayout subscribes to ScrollBox and compares viewport bottom\n   *  against this for pillVisible. Ref so writes don't re-render REPL. */\n  dividerYRef: RefObject<number | null>\n  onScrollAway: (handle: ScrollBoxHandle) => void\n  onRepin: () => void\n  /** Scroll the handle so the divider line is at the top of the viewport. */\n  jumpToNew: (handle: ScrollBoxHandle | null) => void\n  /** Shift dividerIndex and dividerYRef when messages are prepended\n   *  (infinite scroll-back). indexDelta = number of messages prepended;\n   *  heightDelta = content height growth in rows. */\n  shiftDivider: (indexDelta: number, heightDelta: number) => void\n} {\n  const [dividerIndex, setDividerIndex] = useState<number | null>(null)\n  // Ref holds the current count for onScrollAway to snapshot. Written in\n  // the render body (not useEffect) so wheel events arriving between a\n  // message-append render and its effect flush don't capture a stale\n  // count (off-by-one in the baseline). React Compiler bails out here —\n  // acceptable for a hook instantiated once in REPL.\n  const countRef = useRef(messageCount)\n  countRef.current = messageCount\n  // scrollHeight snapshot — the divider's y in content coords. Ref-only:\n  // read synchronously in onScrollAway (setState is batched, can't\n  // read-then-write in the same callback) AND by FullscreenLayout's\n  // pillVisible subscription. null = pinned to bottom.\n  const dividerYRef = useRef<number | null>(null)\n\n  const onRepin = useCallback(() => {\n    // Don't clear dividerYRef here — a trackpad momentum wheel event\n    // racing in the same stdin batch would see null and re-snapshot,\n    // overriding the setDividerIndex(null) below. The useEffect below\n    // clears the ref after React commits the null dividerIndex, so the\n    // ref stays non-null until the state settles.\n    setDividerIndex(null)\n  }, [])\n\n  const onScrollAway = useCallback((handle: ScrollBoxHandle) => {\n    // Nothing below the viewport → nothing to jump to. Covers both:\n    // • empty/short session: scrollUp calls scrollTo(0) which breaks sticky\n    //   even at scrollTop=0 (wheel-up on fresh session showed the pill)\n    // • click-to-select at bottom: useDragToScroll.check() calls\n    //   scrollTo(current) to break sticky so streaming content doesn't shift\n    //   under the selection, then onScroll(false, …) — but scrollTop is still\n    //   at max (Sarah Deaton, #claude-code-feedback 2026-03-15)\n    // pendingDelta: scrollBy accumulates without updating scrollTop. Without\n    // it, wheeling up from max would see scrollTop==max and suppress the pill.\n    const max = Math.max(\n      0,\n      handle.getScrollHeight() - handle.getViewportHeight(),\n    )\n    if (handle.getScrollTop() + handle.getPendingDelta() >= max) return\n    // Snapshot only on the FIRST scroll-away. onScrollAway fires on EVERY\n    // scroll action (not just the initial break from sticky) — this guard\n    // preserves the original baseline so the count doesn't reset on the\n    // second PageUp. Subsequent calls are ref-only no-ops (no REPL re-render).\n    if (dividerYRef.current === null) {\n      dividerYRef.current = handle.getScrollHeight()\n      // New scroll-away session → move the divider here (replaces old one)\n      setDividerIndex(countRef.current)\n    }\n  }, [])\n\n  const jumpToNew = useCallback((handle: ScrollBoxHandle | null) => {\n    if (!handle) return\n    // scrollToBottom (not scrollTo(dividerY)): sets stickyScroll=true so\n    // useVirtualScroll mounts the tail and render-node-to-output pins\n    // scrollTop=maxScroll. scrollTo sets stickyScroll=false → the clamp\n    // (still at top-range bounds before React re-renders) pins scrollTop\n    // back, stopping short. The divider stays rendered (dividerIndex\n    // unchanged) so users see where new messages started; the clear on\n    // next submit/explicit scroll-to-bottom handles cleanup.\n    handle.scrollToBottom()\n  }, [])\n\n  // Sync dividerYRef with dividerIndex. When onRepin fires (submit,\n  // scroll-to-bottom), it sets dividerIndex=null but leaves the ref\n  // non-null — a wheel event racing in the same stdin batch would\n  // otherwise see null and re-snapshot. Deferring the ref clear to\n  // useEffect guarantees the ref stays non-null until React has committed\n  // the null dividerIndex, blocking the if-null guard in onScrollAway.\n  //\n  // Also handles /clear, rewind, teammate-view swap — if the count drops\n  // below the divider index, the divider would point at nothing.\n  useEffect(() => {\n    if (dividerIndex === null) {\n      dividerYRef.current = null\n    } else if (messageCount < dividerIndex) {\n      dividerYRef.current = null\n      setDividerIndex(null)\n    }\n  }, [messageCount, dividerIndex])\n\n  const shiftDivider = useCallback(\n    (indexDelta: number, heightDelta: number) => {\n      setDividerIndex(idx => (idx === null ? null : idx + indexDelta))\n      if (dividerYRef.current !== null) {\n        dividerYRef.current += heightDelta\n      }\n    },\n    [],\n  )\n\n  return {\n    dividerIndex,\n    dividerYRef,\n    onScrollAway,\n    onRepin,\n    jumpToNew,\n    shiftDivider,\n  }\n}\n\n/**\n * Counts assistant turns in messages[dividerIndex..end). A \"turn\" is what\n * users think of as \"a new message from Claude\" — not raw assistant entries\n * (one turn yields multiple entries: tool_use blocks + text blocks). We count\n * non-assistant→assistant transitions, but only for entries that actually\n * carry text — tool-use-only entries are skipped (like progress messages)\n * so \"⏺ Searched for 13 patterns, read 6 files\" doesn't tick the pill.\n */\nexport function countUnseenAssistantTurns(\n  messages: readonly Message[],\n  dividerIndex: number,\n): number {\n  let count = 0\n  let prevWasAssistant = false\n  for (let i = dividerIndex; i < messages.length; i++) {\n    const m = messages[i]!\n    if (m.type === 'progress') continue\n    // Tool-use-only assistant entries aren't \"new messages\" to the user —\n    // skip them the same way we skip progress. prevWasAssistant is NOT\n    // updated, so a text block immediately following still counts as the\n    // same turn (tool_use + text from one API response = 1).\n    if (m.type === 'assistant' && !assistantHasVisibleText(m)) continue\n    const isAssistant = m.type === 'assistant'\n    if (isAssistant && !prevWasAssistant) count++\n    prevWasAssistant = isAssistant\n  }\n  return count\n}\n\nfunction assistantHasVisibleText(m: Message): boolean {\n  if (m.type !== 'assistant') return false\n  for (const b of m.message.content) {\n    if (b.type === 'text' && b.text.trim() !== '') return true\n  }\n  return false\n}\n\nexport type UnseenDivider = { firstUnseenUuid: Message['uuid']; count: number }\n\n/**\n * Builds the unseenDivider object REPL passes to Messages + the pill.\n * Returns undefined only when no content has arrived past the divider\n * yet (messages[dividerIndex] doesn't exist). Once ANY message arrives\n * — including tool_use-only assistant entries and tool_result user entries\n * that countUnseenAssistantTurns skips — count floors at 1 so the pill\n * flips from \"Jump to bottom\" to \"1 new message\". Without the floor,\n * the pill stays \"Jump to bottom\" through an entire tool-call sequence\n * until Claude's text response lands.\n */\nexport function computeUnseenDivider(\n  messages: readonly Message[],\n  dividerIndex: number | null,\n): UnseenDivider | undefined {\n  if (dividerIndex === null) return undefined\n  // Skip progress and null-rendering attachments when picking the divider\n  // anchor — Messages.tsx filters these out of renderableMessages before the\n  // dividerBeforeIndex search, so their UUID wouldn't be found (CC-724).\n  // Hook attachments use randomUUID() so nothing shares their 24-char prefix.\n  let anchorIdx = dividerIndex\n  while (\n    anchorIdx < messages.length &&\n    (messages[anchorIdx]?.type === 'progress' ||\n      isNullRenderingAttachment(messages[anchorIdx]!))\n  ) {\n    anchorIdx++\n  }\n  const uuid = messages[anchorIdx]?.uuid\n  if (!uuid) return undefined\n  const count = countUnseenAssistantTurns(messages, dividerIndex)\n  return { firstUnseenUuid: uuid, count: Math.max(1, count) }\n}\n\n/**\n * Layout wrapper for the REPL. In fullscreen mode, puts scrollable\n * content in a sticky-scroll box and pins bottom content via flexbox.\n * Outside fullscreen mode, renders content sequentially so the existing\n * main-screen scrollback rendering works unchanged.\n *\n * Fullscreen mode defaults on for ants (CLAUDE_CODE_NO_FLICKER=0 to opt out)\n * and off for external users (CLAUDE_CODE_NO_FLICKER=1 to opt in).\n * The <AlternateScreen> wrapper\n * (alt buffer + mouse tracking + height constraint) lives at REPL's root\n * so nothing can accidentally render outside it.\n */\nexport function FullscreenLayout({\n  scrollable,\n  bottom,\n  overlay,\n  bottomFloat,\n  modal,\n  modalScrollRef,\n  scrollRef,\n  dividerYRef,\n  hidePill = false,\n  hideSticky = false,\n  newMessageCount = 0,\n  onPillClick,\n}: Props): React.ReactNode {\n  const { rows: terminalRows, columns } = useTerminalSize()\n  // Scroll-derived chrome state lives HERE, not in REPL. StickyTracker\n  // writes via ScrollChromeContext; pillVisible subscribes directly to\n  // ScrollBox. Both change rarely (pill flips once per threshold crossing,\n  // sticky changes ~5-20×/transcript) — re-rendering FullscreenLayout on\n  // those is fine; re-rendering the 6966-line REPL + its 22+ useAppState\n  // selectors per-scroll-frame was not.\n  const [stickyPrompt, setStickyPrompt] = useState<StickyPrompt | null>(null)\n  const chromeCtx = useMemo(() => ({ setStickyPrompt }), [])\n  // Boolean-quantized scroll subscription. Snapshot is \"is viewport bottom\n  // above the divider y?\" — Object.is on a boolean → FullscreenLayout only\n  // re-renders when the pill should actually flip, not per-frame.\n  const subscribe = useCallback(\n    (listener: () => void) =>\n      scrollRef?.current?.subscribe(listener) ?? (() => {}),\n    [scrollRef],\n  )\n  const pillVisible = useSyncExternalStore(subscribe, () => {\n    const s = scrollRef?.current\n    const dividerY = dividerYRef?.current\n    if (!s || dividerY == null) return false\n    return (\n      s.getScrollTop() + s.getPendingDelta() + s.getViewportHeight() < dividerY\n    )\n  })\n  // Wire up hyperlink click handling — in fullscreen mode, mouse tracking\n  // intercepts clicks before the terminal can open OSC 8 links natively.\n  useLayoutEffect(() => {\n    if (!isFullscreenEnvEnabled()) return\n    const ink = instances.get(process.stdout)\n    if (!ink) return\n    ink.onHyperlinkClick = url => {\n      // Most OSC 8 links emitted by Claude Code are file:// URLs from\n      // FilePathLink (FileEdit/FileWrite/FileRead tool output). openBrowser\n      // rejects non-http(s) protocols — route file: to openPath instead.\n      if (url.startsWith('file:')) {\n        try {\n          void openPath(fileURLToPath(url))\n        } catch {\n          // Malformed file: URLs (e.g. file://host/path from plain-text\n          // detection) cause fileURLToPath to throw — ignore silently.\n        }\n      } else {\n        void openBrowser(url)\n      }\n    }\n    return () => {\n      ink.onHyperlinkClick = undefined\n    }\n  }, [])\n\n  if (isFullscreenEnvEnabled()) {\n    // Overlay renders BELOW messages inside the same ScrollBox — user can\n    // scroll up to see prior context while a permission dialog is showing.\n    // The ScrollBox never unmounts across overlay transitions, so scroll\n    // position is preserved without save/restore. stickyScroll auto-scrolls\n    // to the appended overlay when it mounts (if user was already at\n    // bottom); REPL re-pins on the overlay appear/dismiss transition for\n    // the case where sticky was broken. Tall dialogs (FileEdit diffs) still\n    // get PgUp/PgDn/wheel — same scrollRef drives the same ScrollBox.\n    // Three sticky states: null (at bottom), {text,scrollTo} (scrolled up,\n    // header shows), 'clicked' (just clicked header — hide it so the\n    // content ❯ takes row 0). padCollapsed covers the latter two: once\n    // scrolled away from bottom, padding drops to 0 and stays there until\n    // repin. headerVisible is only the middle state. After click:\n    // scrollBox_y=0 (header gone) + padding=0 → viewportTop=0 → ❯ at\n    // row 0. On next scroll the onChange fires with a fresh {text} and\n    // header comes back (viewportTop 0→1, a single 1-row shift —\n    // acceptable since user explicitly scrolled).\n    const sticky = hideSticky ? null : stickyPrompt\n    const headerPrompt =\n      sticky != null && sticky !== 'clicked' && overlay == null ? sticky : null\n    const padCollapsed = sticky != null && overlay == null\n    return (\n      <PromptOverlayProvider>\n        <Box flexGrow={1} flexDirection=\"column\" overflow=\"hidden\">\n          {headerPrompt && (\n            <StickyPromptHeader\n              text={headerPrompt.text}\n              onClick={headerPrompt.scrollTo}\n            />\n          )}\n          <ScrollBox\n            ref={scrollRef}\n            flexGrow={1}\n            flexDirection=\"column\"\n            paddingTop={padCollapsed ? 0 : 1}\n            stickyScroll\n          >\n            <ScrollChromeContext value={chromeCtx}>\n              {scrollable}\n            </ScrollChromeContext>\n            {overlay}\n          </ScrollBox>\n          {!hidePill && pillVisible && overlay == null && (\n            <NewMessagesPill count={newMessageCount} onClick={onPillClick} />\n          )}\n          {bottomFloat != null && (\n            <Box position=\"absolute\" bottom={0} right={0} opaque>\n              {bottomFloat}\n            </Box>\n          )}\n        </Box>\n        <Box flexDirection=\"column\" flexShrink={0} width=\"100%\" maxHeight=\"50%\">\n          <SuggestionsOverlay />\n          <DialogOverlay />\n          <Box\n            flexDirection=\"column\"\n            width=\"100%\"\n            flexGrow={1}\n            overflowY=\"hidden\"\n          >\n            {bottom}\n          </Box>\n        </Box>\n        {modal != null && (\n          <ModalContext\n            value={{\n              rows: terminalRows - MODAL_TRANSCRIPT_PEEK - 1,\n              columns: columns - 4,\n              scrollRef: modalScrollRef ?? null,\n            }}\n          >\n            {/* Bottom-anchored, grows upward to fit content. maxHeight keeps a\n                few rows of transcript peek above the ▔ divider. Short modals\n                (/model) sit small at the bottom with lots of transcript above;\n                tall modals (/buddy Card) grow as needed, clipped by overflow.\n                Previously fixed-height (top+bottom anchored) — any fixed cap\n                either clipped tall content or left short content floating in\n                a mostly-empty pane.\n\n                flexShrink=0 on the inner Box is load-bearing: with Shrink=1,\n                yoga squeezes deep children to h=0 when content > maxHeight,\n                and sibling Texts land on the same row → ghost overlap\n                (\"5 serversP servers\"). Clipping at the outer Box's maxHeight\n                keeps children at natural size.\n\n                Divider wrapped in flexShrink=0: when the inner box overflows\n                (tall /config option list), yoga shrinks the divider Text to\n                h=0 to absorb the deficit — it's the only shrinkable sibling.\n                The wrapper keeps it at 1 row; overflow past maxHeight is\n                clipped at the bottom by overflow=hidden instead. */}\n            <Box\n              position=\"absolute\"\n              bottom={0}\n              left={0}\n              right={0}\n              maxHeight={terminalRows - MODAL_TRANSCRIPT_PEEK}\n              flexDirection=\"column\"\n              overflow=\"hidden\"\n              opaque\n            >\n              <Box flexShrink={0}>\n                <Text color=\"permission\">{'▔'.repeat(columns)}</Text>\n              </Box>\n              <Box\n                flexDirection=\"column\"\n                paddingX={2}\n                flexShrink={0}\n                overflow=\"hidden\"\n              >\n                {modal}\n              </Box>\n            </Box>\n          </ModalContext>\n        )}\n      </PromptOverlayProvider>\n    )\n  }\n\n  return (\n    <>\n      {scrollable}\n      {bottom}\n      {overlay}\n      {modal}\n    </>\n  )\n}\n\n// Slack-style pill. Absolute overlay at bottom={0} of the scrollwrap — floats\n// over the ScrollBox's last content row, only obscuring the centered pill\n// text (the rest of the row shows ScrollBox content). Scroll-smear from\n// DECSTBM shifting the pill's pixels is repaired at the Ink layer\n// (absoluteRectsPrev third-pass in render-node-to-output.ts, #23939). Shows\n// \"Jump to bottom\" when count is 0 (scrolled away but no new messages yet —\n// the dead zone where users previously thought chat stalled).\nfunction NewMessagesPill({\n  count,\n  onClick,\n}: {\n  count: number\n  onClick?: () => void\n}): React.ReactNode {\n  const [hover, setHover] = useState(false)\n  return (\n    <Box\n      position=\"absolute\"\n      bottom={0}\n      left={0}\n      right={0}\n      justifyContent=\"center\"\n    >\n      <Box\n        onClick={onClick}\n        onMouseEnter={() => setHover(true)}\n        onMouseLeave={() => setHover(false)}\n      >\n        <Text\n          backgroundColor={\n            hover ? 'userMessageBackgroundHover' : 'userMessageBackground'\n          }\n          dimColor\n        >\n          {' '}\n          {count > 0\n            ? `${count} new ${plural(count, 'message')}`\n            : 'Jump to bottom'}{' '}\n          {figures.arrowDown}{' '}\n        </Text>\n      </Box>\n    </Box>\n  )\n}\n\n// Context breadcrumb: when scrolled up into history, pin the current\n// conversation turn's prompt above the viewport so you know what Claude was\n// responding to. Normal-flow sibling BEFORE the ScrollBox (mirrors the pill\n// below it) — shrinks the ScrollBox by exactly 1 row via flex, stays outside\n// the DECSTBM scroll region. Click jumps back to the prompt.\n//\n// Height is FIXED at 1 row (truncate-end for long prompts). A variable-height\n// header (1 when short, 2 when wrapped) shifts the ScrollBox by 1 row every\n// time the sticky prompt switches during scroll — content jumps on screen\n// even with scrollTop unchanged (the DECSTBM region top shifts with the\n// ScrollBox, and the diff engine sees \"everything moved\"). Fixed height\n// keeps the ScrollBox anchored; only the header TEXT changes, not its box.\nfunction StickyPromptHeader({\n  text,\n  onClick,\n}: {\n  text: string\n  onClick: () => void\n}): React.ReactNode {\n  const [hover, setHover] = useState(false)\n  return (\n    <Box\n      flexShrink={0}\n      width=\"100%\"\n      height={1}\n      paddingRight={1}\n      backgroundColor={\n        hover ? 'userMessageBackgroundHover' : 'userMessageBackground'\n      }\n      onClick={onClick}\n      onMouseEnter={() => setHover(true)}\n      onMouseLeave={() => setHover(false)}\n    >\n      <Text color=\"subtle\" wrap=\"truncate-end\">\n        {figures.pointer} {text}\n      </Text>\n    </Box>\n  )\n}\n\n// Slash-command suggestion overlay — see promptOverlayContext.tsx for why\n// it's portaled. Scroll-smear from floating over the DECSTBM region is\n// repaired at the Ink layer (absoluteRectsPrev in render-node-to-output.ts).\n// The renderer clamps negative y to 0 for absolute elements (see\n// render-node-to-output.ts), so the top rows (best matches) stay visible\n// even when the overlay extends above the viewport. We omit minHeight and\n// flex-end here: they would create empty padding rows that shift visible\n// items down into the prompt area when the list has fewer items than max.\nfunction SuggestionsOverlay(): React.ReactNode {\n  const data = usePromptOverlay()\n  if (!data || data.suggestions.length === 0) return null\n  return (\n    <Box\n      position=\"absolute\"\n      bottom=\"100%\"\n      left={0}\n      right={0}\n      paddingX={2}\n      paddingTop={1}\n      flexDirection=\"column\"\n      opaque\n    >\n      <PromptInputFooterSuggestions\n        suggestions={data.suggestions}\n        selectedSuggestion={data.selectedSuggestion}\n        maxColumnWidth={data.maxColumnWidth}\n        overlay\n      />\n    </Box>\n  )\n}\n\n// Dialog portaled from PromptInput (AutoModeOptInDialog) — same clip-escape\n// pattern as SuggestionsOverlay. Renders later in tree order so it paints\n// over suggestions if both are ever up (they shouldn't be).\nfunction DialogOverlay(): React.ReactNode {\n  const node = usePromptOverlayDialog()\n  if (!node) return null\n  return (\n    <Box position=\"absolute\" bottom=\"100%\" left={0} right={0} opaque>\n      {node}\n    </Box>\n  )\n}\n"],"mappings":"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","ignoreList":[]}