@deepseek-harness-tui/dsh-tui 0.8.0 → 0.8.2

package/lib/types/components/MessageList.js

@@ -37,7 +37,7 @@ const DEFAULT_ROW_HEIGHT = 2;
 /** Cold-start estimate of the header block above the rows; corrected by the
  *  first layout measurement. */
 const DEFAULT_HEADER_LINES = 14;
-export function MessageList({ rows, expanded, expandedRows, selectedId, onToggleRow, model, diffLayout = 'auto', showAll, onToggleAll, onLoadOlder, thinkingVisible = true, registerRowRef, scrollHandle, forceMountRowId, newSinceRowId, onUnseenCount, failureHintRowId, failureHint, }) {
+export function MessageList({ rows, expanded, expandedRows, selectedId, onToggleRow, model, diffLayout = 'auto', thinkingFold = 'preview', showAll, onToggleAll, onLoadOlder, thinkingVisible = true, registerRowRef, scrollHandle, forceMountRowId, newSinceRowId, onUnseenCount, failureHintRowId, failureHint, }) {
     const hiddenCount = rows.length - MAX_RENDERED_ROWS;
     // The thinking filter runs BEFORE virtualization so window indices line up.
     const visibleRows = (showAll || hiddenCount <= 0
@@ -65,7 +65,7 @@ export function MessageList({ rows, expanded, expandedRows, selectedId, onToggle
         return undefined;
     };
     // --- layout virtualization ---------------------------------------------
-    const { columns } = useTerminalSize();
+    const { columns, rows: termRows } = useTerminalSize();
     // Measured row heights, remembered after a row unmounts so virtualization
     // can compute total content height. Bounded: row ids grow monotonically
     // and rows are never removed from the transcript (foldRows keeps the
@@ -75,6 +75,31 @@ export function MessageList({ rows, expanded, expandedRows, selectedId, onToggle
     const HEIGHTS_CACHE_MAX = 5000;
     const heightsRef = React.useRef(new Map());
     const localRefs = React.useRef(new Map());
+    /** Row ids that have been mounted (and therefore painted into the
+     *  terminal) at least once. The sticky window may skip a row ONLY after
+     *  this: an unpainted row above the window has no scrollback copy, so
+     *  skipping it would erase it from the user's history entirely — preset
+     *  history at boot (session resume) landed exactly there. Cleared when
+     *  the list head changes identity (rewind / new session / loadOlder
+     *  prepends restored rows that must paint again). */
+    const paintedOnceRef = React.useRef(new Set());
+    const paintedBaseRef = React.useRef(undefined);
+    /** Window-expansion hold: after the window WIDENS (new rows mounted),
+     *  refuse to tighten for a short hold so the mounted rows actually reach
+     *  the terminal. React commits within one ink frame coalesce — a render
+     *  that mounts rows followed by the measure-tick re-render that drops
+     *  them paints only the DROPPED layout, and never-mounted rows have no
+     *  scrollback copy (preset history at boot vanished — CI
+     *  repro-inline-scrollback). After the hold, tightening is visually
+     *  free: those rows sit in scrollback and the diff skips them. */
+    const lastStartRef = React.useRef(-1);
+    const holdUntilRef = React.useRef(0);
+    const listHeadId = visibleRows[0]?.id;
+    if (listHeadId !== undefined && paintedBaseRef.current !== undefined && listHeadId !== paintedBaseRef.current) {
+        paintedOnceRef.current = new Set();
+    }
+    if (listHeadId !== undefined)
+        paintedBaseRef.current = listHeadId;
     /** Content-space offset of visibleRows[0] (header + dividers), measured. */
     const baseRef = React.useRef(null);
     const measureQueuedRef = React.useRef(false);
@@ -128,7 +153,60 @@ export function MessageList({ rows, expanded, expandedRows, selectedId, onToggle
     // back to the real bottom: a self-sustaining ping-pong that blanks the
     // transcript mid-stream.
     if (sticky && visibleRows.length > 0) {
+        // Sticky (follow-bottom): the viewport shows the TAIL of the content —
+        // mount exactly the tail window the floor walk covers, not everything
+        // from the scrollTop scan. Main-screen ScrollBox reports its viewport
+        // as the CONTENT height (the terminal itself is the scroller), so both
+        // the scan and an unclamped floor walk mount EVERY row in long
+        // sessions — and React's commit traverses every fiber of every mounted
+        // row per frame (measured as the dominant long-session stall). The
+        // user only ever sees terminal rows: clamp the walk-back coverage to
+        // the TERMINAL viewport plus overscan.
         start = Math.min(start, visibleRows.length - 1);
+        // Blank-band guard: sticky scrollTop tracks the renderer's FRESH Yoga
+        // scrollHeight, while these offsets use per-row heights measured one to
+        // two commits late. During fast streaming the accurate scrollTop scans
+        // deeper through the underestimated offsets than the real viewport does,
+        // unmounting rows that are still on screen (visible spacer band). Walk
+        // backwards from the tail with the known heights and mount at least one
+        // terminal viewport plus overscan of content above it, so the window
+        // can never open a gap inside what the user is looking at.
+        let covered = Math.min(viewport, termRows) + OVERSCAN_LINES;
+        let floor = visibleRows.length - 1;
+        while (floor > 0 && covered > 0) {
+            covered -= heightOf(visibleRows[floor]);
+            floor--;
+        }
+        // The walk exhausted the whole list: every row is within coverage —
+        // floor+1 here would drop row 0 (its content then has no terminal copy
+        // anywhere; preset history lost its head — CI repro-inline-scrollback).
+        start = floor === 0 && covered > 0 ? 0 : floor + 1;
+        // Paint-at-least-once: extend the window over any row that has never
+        // been mounted. A row the window skips keeps only its terminal/scrollback
+        // copy — a row that was never painted has NO copy anywhere, so preset
+        // history (session resume, repro-inline-scrollback's #39 family) would
+        // vanish from the user's scrollback. Extending mounts everything above
+        // on the first frame (topPad 0, full paint), then the set fills and the
+        // window tightens to the tail.
+        const paintedOnce = paintedOnceRef.current;
+        for (let i = 0; i < start; i++) {
+            if (!paintedOnce.has(visibleRows[i].id)) {
+                start = i;
+                break;
+            }
+        }
+        // Expansion hold — AFTER the extension so it tracks the FINAL window:
+        // never tighten within the hold window after a widen. React commits
+        // inside one ink frame coalesce; a mount followed by the measure-tick
+        // re-render that drops the row paints only the DROPPED layout, and the
+        // row's painted-once mark (set at the first commit) is a lie.
+        if (lastStartRef.current >= 0 && start > lastStartRef.current && performance.now() < holdUntilRef.current) {
+            start = lastStartRef.current;
+        }
+        if (lastStartRef.current < 0 || start < lastStartRef.current) {
+            holdUntilRef.current = performance.now() + 120;
+        }
+        lastStartRef.current = start;
     }
     if (forceMountRowId !== undefined && forceMountRowId !== null) {
         const idx = visibleRows.findIndex(row => row.id === forceMountRowId);
@@ -137,6 +215,15 @@ export function MessageList({ rows, expanded, expandedRows, selectedId, onToggle
             end = Math.max(end, idx + 1);
         }
     }
+    // The newest failed tool call carries the trajectory footnote
+    // (failureHint). Virtualization must not unmount it: before the window
+    // clamp the row was always mounted, now keep mounting it explicitly while
+    // the hint is live (verify-trace-scene's footnote check).
+    if (failureHintRowId !== undefined && failureHintRowId !== null) {
+        const idx = visibleRows.findIndex(row => row.id === failureHintRowId);
+        if (idx !== -1)
+            start = Math.min(start, idx);
+    }
     const topPad = offsets[start] ?? 0;
     const mountedBottom = end < visibleRows.length ? offsets[end] : total;
     const bottomPad = total - mountedBottom;
@@ -170,6 +257,12 @@ export function MessageList({ rows, expanded, expandedRows, selectedId, onToggle
     // mounted coverage so burst scrolls never show blank spacer.
     React.useLayoutEffect(() => {
         let changed = false;
+        // Mounted ⇒ painted: record rows eligible for window skipping.
+        const paintedOnce = paintedOnceRef.current;
+        for (const id of localRefs.current.keys()) {
+            if (!paintedOnce.has(id))
+                paintedOnce.add(id);
+        }
         for (const [id, el] of localRefs.current) {
             const h = el.yogaNode?.getComputedHeight();
             if (h !== undefined && h > 0 && heightsRef.current.get(id) !== h) {
@@ -195,7 +288,16 @@ export function MessageList({ rows, expanded, expandedRows, selectedId, onToggle
         }
         if (scrollHandle) {
             if (sticky || (start === 0 && end >= visibleRows.length)) {
-                scrollHandle.setClampBounds(undefined, undefined);
+                // Sticky still needs the MIN clamp: the first wheel-up breaks sticky
+                // on the DOM (ScrollBox.scrollBy) several frames before React
+                // commits a new mount window, and the drain frames in between paint
+                // unmounted spacer rows as a blank band. Clamping to the currently
+                // mounted top shows the edge content until React catches up - same
+                // behavior as the steady-state scroll path. The MAX clamp stays
+                // disabled: sticky follow pushes scrollTop to each frame's new
+                // maxScroll, which a stale mounted max would clamp away.
+                const min = start > 0 ? Math.max(0, base + topPad - viewport) : undefined;
+                scrollHandle.setClampBounds(min, undefined);
             }
             else {
                 const min = Math.max(0, base + topPad - viewport);
@@ -232,10 +334,10 @@ export function MessageList({ rows, expanded, expandedRows, selectedId, onToggle
                 // spacing; only the very first row of the whole list has none.
                 const addMargin = margins.get(row.id) === true;
                 const tool = row.tool;
-                return (_jsx(MemoRow, { rowId: row.id, kind: row.kind, text: row.text, executionTarget: row.executionTarget, streaming: row.streaming === true, durationMs: row.durationMs, time: row.time, addMargin: addMargin, isSelected: selectedId === row.id, isExpanded: expandedRows.has(row.id), expanded: expanded, model: model, diffLayout: diffLayout, background: rowBackground(row.id), toolCallId: tool?.callId, toolName: tool?.name, toolArgsText: tool?.argsText, toolArgsFull: tool?.argsFull, toolStatus: tool?.status, toolResultText: tool?.resultText, toolResultFull: tool?.resultFull, toolErrorText: tool?.errorText, toolFootnote: failureHintRowId === row.id ? failureHint : undefined, toolCallView: tool?.callView, toolResultView: tool?.resultView, toolStartedAt: tool?.startedAt, toolDurationMs: tool?.durationMs, nowSec: tool?.status === 'running' ? nowSec : undefined, onToggleRow: onToggleRow, setRowRef: setRowRef }, row.id));
+                return (_jsx(MemoRow, { rowId: row.id, kind: row.kind, text: row.text, executionTarget: row.executionTarget, streaming: row.streaming === true, durationMs: row.durationMs, time: row.time, addMargin: addMargin, isSelected: selectedId === row.id, isExpanded: expandedRows.has(row.id), expanded: expanded, model: model, diffLayout: diffLayout, thinkingFold: thinkingFold, background: rowBackground(row.id), toolCallId: tool?.callId, toolName: tool?.name, toolArgsText: tool?.argsText, toolArgsFull: tool?.argsFull, toolStatus: tool?.status, toolResultText: tool?.resultText, toolResultFull: tool?.resultFull, toolErrorText: tool?.errorText, toolFootnote: failureHintRowId === row.id ? failureHint : undefined, toolCallView: tool?.callView, toolResultView: tool?.resultView, toolStartedAt: tool?.startedAt, toolDurationMs: tool?.durationMs, nowSec: tool?.status === 'running' ? nowSec : undefined, onToggleRow: onToggleRow, setRowRef: setRowRef }, row.id));
             }), bottomPad > 0 && _jsx(Box, { height: bottomPad, flexShrink: 0 })] }));
 }
-function TranscriptRow({ rowId, kind, text, executionTarget, streaming, durationMs, time, addMargin, isSelected, isExpanded, expanded, model, diffLayout, background, toolCallId, toolName, toolArgsText, toolArgsFull, toolStatus, toolResultText, toolResultFull, toolErrorText, toolFootnote, toolCallView, toolResultView, toolStartedAt, toolDurationMs, onToggleRow, setRowRef, }) {
+function TranscriptRow({ rowId, kind, text, executionTarget, streaming, durationMs, time, addMargin, isSelected, isExpanded, expanded, model, diffLayout, thinkingFold, background, toolCallId, toolName, toolArgsText, toolArgsFull, toolStatus, toolResultText, toolResultFull, toolErrorText, toolFootnote, toolCallView, toolResultView, toolStartedAt, toolDurationMs, onToggleRow, setRowRef, }) {
     const ref = React.useCallback((el) => {
         setRowRef(rowId, el);
     }, [setRowRef, rowId]);
@@ -248,7 +350,10 @@ function TranscriptRow({ rowId, kind, text, executionTarget, streaming, duration
         case 'assistant':
             return streaming ? (_jsxs(Box, { alignItems: "flex-start", flexDirection: "row", marginTop: addMargin ? 1 : 0, width: "100%", backgroundColor: background, children: [_jsx(Box, { minWidth: 2, children: _jsx(Text, { color: "text", children: "\u25CF" }) }), _jsx(Box, { flexDirection: "column", children: _jsx(StreamingMarkdown, { children: stripNarration(text) }) })] })) : (_jsxs(Box, { width: "100%", flexDirection: "column", backgroundColor: background, ref: ref, children: [expanded && (_jsx(Box, { flexDirection: "row", justifyContent: "flex-end", gap: 1, marginTop: 1, children: _jsx(MessageMetadata, { timestamp: time, model: model }) })), _jsx(AssistantTextMessage, { text: stripNarration(text), addMargin: addMargin, isSelected: isSelected, isExpanded: isExpanded, onClick: onClick })] }));
         case 'reasoning':
-            return (_jsx(Box, { flexDirection: "column", ref: ref, children: _jsx(AssistantThinkingMessage, { thinking: text, addMargin: addMargin, 
+            return (_jsx(Box, { flexDirection: "column", ref: ref, children: _jsx(AssistantThinkingMessage, { thinking: text, addMargin: addMargin, preview: streaming &&
+                        thinkingFold === 'preview' &&
+                        !expanded &&
+                        !isExpanded, 
                     // Streaming reasoning shows expanded live, then folds
                     // automatically once the turn settles (unless Ctrl+O or a
                     // single-row expansion keeps it open).

package/lib/types/components/PromptInput.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"PromptInput.d.ts","sourceRoot":"","sources":["../../../src/components/PromptInput.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,OAAO,CAAA;AASzB,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,2BAA2B,CAAA;AAkDxD;;;;;GAKG;AACH,MAAM,WAAW,gBAAgB;IAC/B,OAAO,IAAI,OAAO,CAAA;IAClB,KAAK,IAAI,IAAI,CAAA;CACd;AAED,MAAM,WAAW,gBAAgB;IAC/B,OAAO,EAAE,OAAO,CAAA;IAChB,0EAA0E;IAC1E,QAAQ,EAAE,OAAO,CAAA;IACjB,YAAY,IAAI,IAAI,CAAA;IACpB;;;OAGG;IACH,YAAY,CAAC,IAAI,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAA;IACrD,6EAA6E;IAC7E,eAAe,EAAE,OAAO,CAAA;IACxB;;;;OAIG;IACH,QAAQ,CAAC,EAAE,MAAM,GAAG,IAAI,CAAA;IACxB,cAAc,CAAC,IAAI,IAAI,CAAA;IACvB,8EAA8E;IAC9E,eAAe,CAAC,IAAI,IAAI,CAAA;IACxB,0EAA0E;IAC1E,aAAa,CAAC,EAAE,KAAK,CAAC,SAAS,CAAC,gBAAgB,GAAG,IAAI,CAAC,CAAA;CACzD;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,wBAAgB,WAAW,CAAC,EAC1B,OAAO,EACP,QAAQ,EACR,YAAY,EACZ,YAAY,EACZ,eAAe,EACf,QAAQ,EACR,cAAc,EACd,eAAe,EACf,aAAa,GACd,EAAE,gBAAgB,qBAg5BlB"}
+{"version":3,"file":"PromptInput.d.ts","sourceRoot":"","sources":["../../../src/components/PromptInput.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,OAAO,CAAA;AASzB,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,2BAA2B,CAAA;AAkDxD;;;;;GAKG;AACH,MAAM,WAAW,gBAAgB;IAC/B,OAAO,IAAI,OAAO,CAAA;IAClB,KAAK,IAAI,IAAI,CAAA;CACd;AAED,MAAM,WAAW,gBAAgB;IAC/B,OAAO,EAAE,OAAO,CAAA;IAChB,0EAA0E;IAC1E,QAAQ,EAAE,OAAO,CAAA;IACjB,YAAY,IAAI,IAAI,CAAA;IACpB;;;OAGG;IACH,YAAY,CAAC,IAAI,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAA;IACrD,6EAA6E;IAC7E,eAAe,EAAE,OAAO,CAAA;IACxB;;;;OAIG;IACH,QAAQ,CAAC,EAAE,MAAM,GAAG,IAAI,CAAA;IACxB,cAAc,CAAC,IAAI,IAAI,CAAA;IACvB,8EAA8E;IAC9E,eAAe,CAAC,IAAI,IAAI,CAAA;IACxB,0EAA0E;IAC1E,aAAa,CAAC,EAAE,KAAK,CAAC,SAAS,CAAC,gBAAgB,GAAG,IAAI,CAAC,CAAA;CACzD;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,wBAAgB,WAAW,CAAC,EAC1B,OAAO,EACP,QAAQ,EACR,YAAY,EACZ,YAAY,EACZ,eAAe,EACf,QAAQ,EACR,cAAc,EACd,eAAe,EACf,aAAa,GACd,EAAE,gBAAgB,qBA65BlB"}

package/lib/types/components/PromptInput.js

@@ -116,6 +116,7 @@ export function PromptInput({ channel, helpOpen, onToggleHelp, onRunCommand, sel
     const [selectedCommand, setSelectedCommand] = React.useState(0);
     const history = React.useRef([]);
     const historyIndex = React.useRef(-1);
+    const historyDraft = React.useRef('');
     // ctrl+r history fill: replace the input when a new fill arrives, then
     // tell the caller to clear it.
     const lastFill = React.useRef(null);
@@ -528,11 +529,17 @@ export function PromptInput({ channel, helpOpen, onToggleHelp, onRunCommand, sel
             if (!tryRunCommand(value))
                 submitText(value);
         };
+        // Ctrl+J is the only portable multiline fallback when a terminal cannot
+        // report modifiers on Enter. The parser names its bare LF `enter`, while
+        // the physical Enter key arrives as CR (`return`).
+        if (input === '\n' && event?.keypress.name === 'enter') {
+            insertAtCaret('\n');
+            return;
+        }
         // Whole-line input from Windows ConPTY pipelines (cmd batch -> node):
-        // the trailing CR/LF marks a complete line to submit. A bare Enter
-        // arrives as `\r`/`\n`/`\r\n` — treat it as Enter, NOT a direct
-        // submit. Only real multi-char piped lines keep the legacy
-        // direct-submit path.
+        // the trailing CR/LF marks a complete line to submit. A bare CR/CRLF is
+        // Enter, while real multi-char piped lines keep the legacy direct-submit
+        // path.
         if (input.includes('\n') || input.includes('\r')) {
             if (/^[\r\n]+$/.test(input)) {
                 handleEnter();
@@ -622,9 +629,13 @@ export function PromptInput({ channel, helpOpen, onToggleHelp, onRunCommand, sel
             }
             if (history.current.length === 0)
                 return;
-            historyIndex.current = historyIndex.current < 0
-                ? history.current.length - 1
-                : Math.max(0, historyIndex.current - 1);
+            if (historyIndex.current < 0) {
+                historyDraft.current = value;
+                historyIndex.current = history.current.length - 1;
+            }
+            else {
+                historyIndex.current = Math.max(0, historyIndex.current - 1);
+            }
             const entry = history.current[historyIndex.current] ?? '';
             setInput(entry);
             return;
@@ -649,11 +660,14 @@ export function PromptInput({ channel, helpOpen, onToggleHelp, onRunCommand, sel
             }
             if (historyIndex.current < 0)
                 return;
-            historyIndex.current += 1;
-            const entry = historyIndex.current >= history.current.length
-                ? ''
-                : (history.current[historyIndex.current] ?? '');
-            setInput(entry);
+            if (historyIndex.current >= history.current.length - 1) {
+                historyIndex.current = -1;
+                setInput(historyDraft.current);
+            }
+            else {
+                historyIndex.current += 1;
+                setInput(history.current[historyIndex.current] ?? '');
+            }
             return;
         }
         if (isMod(key) && key.leftArrow) {

package/lib/types/components/RewindPicker.d.ts

@@ -1,14 +1,26 @@
 import React from 'react';
 import type { ChatRow } from '../dsh-adapter/channel.js';
+import type { TuiRewindMode } from '../dsh-adapter/extension-events.js';
 /**
  * Double-Esc rewind picker (CC's "Double-tap esc to rewind the code and/or
  * conversation to a previous point in time"): lists the user's past messages
  * newest-first; selecting one and confirming rewinds the conversation to
  * that point (the message comes back into the input for re-editing).
+ *
+ * The confirm pane has two shapes: the plain one (Enter rewinds), and —
+ * when a plugin answered the tui/rewind-prompt decision with extra modes —
+ * a choice list whose option zero is always the built-in conversation-only
+ * rewind, followed by the plugin's modes (e.g. "also restore files").
  */
-export declare function RewindPicker({ rows, focusIndex, confirmRow, }: {
+export declare function RewindPicker({ rows, focusIndex, confirmRow, modes, modeIndex, busy, }: {
     rows: readonly ChatRow[];
     focusIndex: number;
     confirmRow: ChatRow | null;
+    /** Plugin-offered rewind modes (tui/rewind-prompt); null = plain confirm. */
+    modes?: readonly TuiRewindMode[] | null;
+    /** Focused option in the modes list (0 = conversation-only). */
+    modeIndex?: number;
+    /** True while the plugin decision is in flight. */
+    busy?: boolean;
 }): React.ReactNode;
 //# sourceMappingURL=RewindPicker.d.ts.map

package/lib/types/components/RewindPicker.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"RewindPicker.d.ts","sourceRoot":"","sources":["../../../src/components/RewindPicker.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,OAAO,CAAA;AAGzB,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,2BAA2B,CAAA;AAMxD;;;;;GAKG;AACH,wBAAgB,YAAY,CAAC,EAC3B,IAAI,EACJ,UAAU,EACV,UAAU,GACX,EAAE;IACD,IAAI,EAAE,SAAS,OAAO,EAAE,CAAA;IACxB,UAAU,EAAE,MAAM,CAAA;IAClB,UAAU,EAAE,OAAO,GAAG,IAAI,CAAA;CAC3B,GAAG,KAAK,CAAC,SAAS,CA+DlB"}
+{"version":3,"file":"RewindPicker.d.ts","sourceRoot":"","sources":["../../../src/components/RewindPicker.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,OAAO,CAAA;AAGzB,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,2BAA2B,CAAA;AACxD,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,oCAAoC,CAAA;AAMvE;;;;;;;;;;GAUG;AACH,wBAAgB,YAAY,CAAC,EAC3B,IAAI,EACJ,UAAU,EACV,UAAU,EACV,KAAY,EACZ,SAAa,EACb,IAAY,GACb,EAAE;IACD,IAAI,EAAE,SAAS,OAAO,EAAE,CAAA;IACxB,UAAU,EAAE,MAAM,CAAA;IAClB,UAAU,EAAE,OAAO,GAAG,IAAI,CAAA;IAC1B,6EAA6E;IAC7E,KAAK,CAAC,EAAE,SAAS,aAAa,EAAE,GAAG,IAAI,CAAA;IACvC,gEAAgE;IAChE,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB,mDAAmD;IACnD,IAAI,CAAC,EAAE,OAAO,CAAA;CACf,GAAG,KAAK,CAAC,SAAS,CA4GlB"}

package/lib/types/components/RewindPicker.js

@@ -10,9 +10,33 @@ import { listWindow } from './listWindow.js';
  * conversation to a previous point in time"): lists the user's past messages
  * newest-first; selecting one and confirming rewinds the conversation to
  * that point (the message comes back into the input for re-editing).
+ *
+ * The confirm pane has two shapes: the plain one (Enter rewinds), and —
+ * when a plugin answered the tui/rewind-prompt decision with extra modes —
+ * a choice list whose option zero is always the built-in conversation-only
+ * rewind, followed by the plugin's modes (e.g. "also restore files").
  */
-export function RewindPicker({ rows, focusIndex, confirmRow, }) {
+export function RewindPicker({ rows, focusIndex, confirmRow, modes = null, modeIndex = 0, busy = false, }) {
     if (confirmRow !== null) {
+        if (modes !== null) {
+            // Plugin modes: a described choice list (one extra row per
+            // description), windowed like the message list below.
+            const { rows: terminalRows } = useTerminalSize();
+            const rowCosts = [2, ...modes.map(mode => (mode.description === undefined ? 1 : 2))];
+            const { start, end } = listWindow(rowCosts, modeIndex, Math.max(terminalRows - 10, 2));
+            const options = [
+                { key: 'conversation', label: t('rewind-mode-default'), description: t('rewind-confirm-desc') },
+                ...modes.map(mode => ({
+                    key: mode.id,
+                    label: mode.label,
+                    ...(mode.description === undefined ? {} : { description: mode.description }),
+                })),
+            ];
+            return (_jsxs(Pane, { color: "permission", children: [_jsxs(Box, { flexDirection: "column", children: [_jsxs(Box, { marginBottom: 1, children: [_jsx(Text, { color: "remember", bold: true, children: t('rewind-confirm-title') }), _jsx(Text, { dimColor: true, children: preview(confirmRow.text) })] }), options.slice(start, end).map((option, index) => {
+                                const absoluteIndex = start + index;
+                                return (_jsx(ListItem, { isFocused: absoluteIndex === modeIndex, description: option.description, showScrollUp: absoluteIndex === start && start > 0, showScrollDown: absoluteIndex === end - 1 && end < options.length, children: option.label }, option.key));
+                            })] }), _jsx(Text, { dimColor: true, italic: true, children: _jsx(HintLine, { text: t('hint-select-exit') }) })] }));
+        }
         return (_jsx(Pane, { color: "permission", children: _jsxs(Box, { flexDirection: "column", children: [_jsx(Box, { marginBottom: 1, children: _jsx(Text, { color: "remember", bold: true, children: t('rewind-confirm-title') }) }), _jsx(ListItem, { isFocused: false, description: t('rewind-confirm-desc'), children: preview(confirmRow.text) }), _jsx(Text, { dimColor: true, italic: true, children: _jsx(HintLine, { text: t('hint-rewind-back') }) })] }) }));
     }
     const { rows: terminalRows } = useTerminalSize();
@@ -23,7 +47,7 @@ export function RewindPicker({ rows, focusIndex, confirmRow, }) {
     return (_jsxs(Pane, { color: "permission", children: [_jsxs(Box, { flexDirection: "column", children: [_jsxs(Box, { marginBottom: 1, children: [_jsx(Text, { color: "remember", bold: true, children: t('rewind-title') }), _jsx(Text, { dimColor: true, children: t('rewind-subtitle') })] }), rows.length === 0 ? (_jsx(ListItem, { isFocused: false, children: t('rewind-empty') })) : (rows.slice(start, end).map((row, index) => {
                         const absoluteIndex = start + index;
                         return (_jsx(ListItem, { isFocused: absoluteIndex === focusIndex, description: absoluteIndex === 0 ? t('rewind-last-message') : undefined, showScrollUp: absoluteIndex === start && start > 0, showScrollDown: absoluteIndex === end - 1 && end < rows.length, children: preview(row.text) }, row.id));
-                    }))] }), _jsx(Text, { dimColor: true, italic: true, children: _jsx(HintLine, { text: t('hint-select-exit') }) })] }));
+                    })), busy && _jsx(Text, { dimColor: true, children: t('rewind-waiting-plugins') })] }), _jsx(Text, { dimColor: true, italic: true, children: _jsx(HintLine, { text: t('hint-select-exit') }) })] }));
 }
 /** One-line preview of a message (newlines flattened, capped). */
 function preview(text) {

package/lib/types/components/StreamingMarkdown.d.ts

@@ -1,12 +1,6 @@
 import React from 'react';
-/**
- * Renders markdown during streaming by splitting at the last top-level block
- * boundary: everything before is stable (memoized, never re-parsed), only the
- * final block is re-parsed per delta, mirroring Claude Code's
- * `StreamingMarkdown.tsx`). marked.lexer() correctly handles unclosed code
- * fences as a single token, so block boundaries are always safe.
- */
-export declare function StreamingMarkdown({ children, }: {
+export declare function StreamingMarkdown({ children, dimColor, }: {
     children: string;
+    dimColor?: boolean;
 }): React.ReactNode;
 //# sourceMappingURL=StreamingMarkdown.d.ts.map

package/lib/types/components/StreamingMarkdown.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"StreamingMarkdown.d.ts","sourceRoot":"","sources":["../../../src/components/StreamingMarkdown.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,OAAO,CAAA;AAMzB;;;;;;GAMG;AACH,wBAAgB,iBAAiB,CAAC,EAChC,QAAQ,GACT,EAAE;IACD,QAAQ,EAAE,MAAM,CAAA;CACjB,GAAG,KAAK,CAAC,SAAS,CAoClB"}
+{"version":3,"file":"StreamingMarkdown.d.ts","sourceRoot":"","sources":["../../../src/components/StreamingMarkdown.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,OAAO,CAAA;AAmDzB,wBAAgB,iBAAiB,CAAC,EAChC,QAAQ,EACR,QAAgB,GACjB,EAAE;IACD,QAAQ,EAAE,MAAM,CAAA;IAChB,QAAQ,CAAC,EAAE,OAAO,CAAA;CACnB,GAAG,KAAK,CAAC,SAAS,CA0ClB"}

package/lib/types/components/StreamingMarkdown.js

@@ -3,6 +3,7 @@ import React from 'react';
 import { marked } from 'marked';
 import Box from '../ink/components/Box.js';
 import { stripPromptXMLTags } from '../cc/markdown.js';
+import { t } from '../i18n.js';
 import { Markdown } from './Markdown.js';
 /**
  * Renders markdown during streaming by splitting at the last top-level block
@@ -11,15 +12,56 @@ import { Markdown } from './Markdown.js';
  * `StreamingMarkdown.tsx`). marked.lexer() correctly handles unclosed code
  * fences as a single token, so block boundaries are always safe.
  */
-export function StreamingMarkdown({ children, }) {
-    const stablePrefixRef = React.useRef('');
+/**
+ * Tail budget for the unstable suffix during streaming. The sticky view only
+ * ever shows the last viewport of rows, but the suffix Text is re-wrapped
+ * every frame — an unbounded suffix (a single huge paragraph with no block
+ * boundary to advance the prefix) made that O(total) per frame. The suffix
+ * is clipped to this many characters (preferring a paragraph boundary),
+ * with a leading marker naming the dropped amount; settling renders the
+ * full text once through the non-streaming path.
+ *
+ * The cut point is STICKY (advances only when the suffix outgrows budget +
+ * step): a cut that slid every frame would break append-only growth, and
+ * the layout layer's incremental wrap would fall back to a full re-wrap of
+ * the whole tail on every token.
+ */
+const SUFFIX_TAIL_BUDGET = 3584;
+const SUFFIX_BOUNDARY_LOOKBACK = 2048;
+const SUFFIX_CUT_STEP = 1024;
+function clipSuffixTail(suffix, cut) {
+    const total = suffix.length;
+    if (total <= SUFFIX_TAIL_BUDGET) {
+        cut.current = 0;
+        return suffix;
+    }
+    // Advance the sticky cut only once the suffix outgrew the budget by a
+    // full step, preferring a paragraph boundary inside the lookback window.
+    if (total - cut.current > SUFFIX_TAIL_BUDGET + SUFFIX_CUT_STEP) {
+        const windowStart = total - SUFFIX_TAIL_BUDGET;
+        const boundary = suffix.lastIndexOf('\n\n', windowStart + SUFFIX_BOUNDARY_LOOKBACK);
+        cut.current = boundary !== -1 && boundary >= windowStart - SUFFIX_BOUNDARY_LOOKBACK
+            ? boundary + 2
+            : windowStart;
+    }
+    const dropped = cut.current;
+    return `${t('streaming-folded', { count: dropped })}\n\n${suffix.slice(cut.current)}`;
+}
+export function StreamingMarkdown({ children, dimColor = false, }) {
+    // The stable prefix is kept as ONE string identity across renders: a
+    // fresh substring per render would break Markdown's React.memo and
+    // re-layout the entire finished transcript tail on every token. The
+    // identity only changes when a new block boundary advances the prefix.
+    const prefixRef = React.useRef('');
+    const cutRef = React.useRef(0);
     const stripped = stripPromptXMLTags(children);
     // Reset if text was replaced (defensive; normally unmount handles this)
-    if (!stripped.startsWith(stablePrefixRef.current)) {
-        stablePrefixRef.current = '';
+    if (!stripped.startsWith(prefixRef.current)) {
+        prefixRef.current = '';
+        cutRef.current = 0;
     }
     // Lex only from current boundary — O(unstable length), not O(full text)
-    const boundary = stablePrefixRef.current.length;
+    const boundary = prefixRef.current.length;
     const tokens = marked.lexer(stripped.substring(boundary));
     // Last non-space token is the growing block; everything before is final
     let lastContentIdx = tokens.length - 1;
@@ -31,9 +73,9 @@ export function StreamingMarkdown({ children, }) {
         advance += tokens[i].raw.length;
     }
     if (advance > 0) {
-        stablePrefixRef.current = stripped.substring(0, boundary + advance);
+        prefixRef.current = stripped.substring(0, boundary + advance);
     }
-    const stablePrefix = stablePrefixRef.current;
-    const unstableSuffix = stripped.substring(stablePrefix.length);
-    return (_jsxs(Box, { flexDirection: "column", gap: 1, children: [stablePrefix && _jsx(Markdown, { children: stablePrefix }), unstableSuffix && _jsx(Markdown, { cacheTokens: false, children: unstableSuffix })] }));
+    const stablePrefix = prefixRef.current;
+    const unstableSuffix = clipSuffixTail(stripped.substring(stablePrefix.length), cutRef);
+    return (_jsxs(Box, { flexDirection: "column", gap: 1, children: [stablePrefix && _jsx(Markdown, { dimColor: dimColor, children: stablePrefix }), unstableSuffix && _jsx(Markdown, { dimColor: dimColor, cacheTokens: false, children: unstableSuffix })] }));
 }

package/lib/types/components/ToolUseLoader.d.ts

@@ -3,11 +3,16 @@ type Props = {
     isError: boolean;
     isUnresolved: boolean;
     shouldAnimate: boolean;
+    /** Raw tool id (bash/read/edit/…) — picks the category color for a settled dot. */
+    toolName?: string;
 };
 /**
- * The status dot on tool-call rows, mirroring Claude Code's ToolUseLoader:
- * blinking `●` while running, green on success, red on error, dim when queued.
+ * The status dot on tool-call rows. State shapes the glyph, the tool
+ * category picks the settled color: blinking `●` while running (attention),
+ * a smaller category-colored `•` once settled (quiet), and a red `✗` on
+ * error — a glyph swap, not just a hue, so failures read at a glance
+ * (Codex-style category colors; every color is a theme token).
  */
-export declare function ToolUseLoader({ isError, isUnresolved, shouldAnimate, }: Props): React.ReactNode;
+export declare function ToolUseLoader({ isError, isUnresolved, shouldAnimate, toolName, }: Props): React.ReactNode;
 export {};
 //# sourceMappingURL=ToolUseLoader.d.ts.map

package/lib/types/components/ToolUseLoader.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ToolUseLoader.d.ts","sourceRoot":"","sources":["../../../src/components/ToolUseLoader.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,OAAO,CAAA;AAMzB,KAAK,KAAK,GAAG;IACX,OAAO,EAAE,OAAO,CAAA;IAChB,YAAY,EAAE,OAAO,CAAA;IACrB,aAAa,EAAE,OAAO,CAAA;CACvB,CAAA;AAED;;;GAGG;AACH,wBAAgB,aAAa,CAAC,EAC5B,OAAO,EACP,YAAY,EACZ,aAAa,GACd,EAAE,KAAK,GAAG,KAAK,CAAC,SAAS,CAezB"}
+{"version":3,"file":"ToolUseLoader.d.ts","sourceRoot":"","sources":["../../../src/components/ToolUseLoader.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,OAAO,CAAA;AAOzB,KAAK,KAAK,GAAG;IACX,OAAO,EAAE,OAAO,CAAA;IAChB,YAAY,EAAE,OAAO,CAAA;IACrB,aAAa,EAAE,OAAO,CAAA;IACtB,mFAAmF;IACnF,QAAQ,CAAC,EAAE,MAAM,CAAA;CAClB,CAAA;AAmCD;;;;;;GAMG;AACH,wBAAgB,aAAa,CAAC,EAC5B,OAAO,EACP,YAAY,EACZ,aAAa,EACb,QAAQ,GACT,EAAE,KAAK,GAAG,KAAK,CAAC,SAAS,CAoBzB"}

package/lib/types/components/ToolUseLoader.js

@@ -1,17 +1,51 @@
 import { jsx as _jsx } from "react/jsx-runtime";
 import Box from '../ink/components/Box.js';
-import Text from '../ink/components/Text.js';
+import { Text } from '../ui.js';
 import { useBlink } from '../hooks/useBlink.js';
-import { BLACK_CIRCLE } from '../cc/figures.js';
+import { BLACK_CIRCLE, BULLET, MULTIPLICATION_X } from '../cc/figures.js';
+const CATEGORY_BY_TOOL = {
+    bash: 'exec',
+    powershell: 'exec',
+    pwsh: 'exec',
+    read: 'read',
+    grep: 'read',
+    glob: 'read',
+    search: 'read',
+    file_search: 'read',
+    edit: 'write',
+    write: 'write',
+    str_replace_editor: 'write',
+    multiedit: 'write',
+    web_search: 'web',
+    web_fetch: 'web',
+    browser: 'web',
+    subagent: 'task',
+    task: 'task',
+    job: 'task',
+    workflow: 'task',
+};
+const CATEGORY_TOKEN = {
+    exec: 'toolDotExec',
+    read: 'toolDotRead',
+    write: 'toolDotWrite',
+    web: 'toolDotWeb',
+    task: 'toolDotTask',
+    default: 'success',
+};
 /**
- * The status dot on tool-call rows, mirroring Claude Code's ToolUseLoader:
- * blinking `●` while running, green on success, red on error, dim when queued.
+ * The status dot on tool-call rows. State shapes the glyph, the tool
+ * category picks the settled color: blinking `●` while running (attention),
+ * a smaller category-colored `•` once settled (quiet), and a red `✗` on
+ * error — a glyph swap, not just a hue, so failures read at a glance
+ * (Codex-style category colors; every color is a theme token).
  */
-export function ToolUseLoader({ isError, isUnresolved, shouldAnimate, }) {
+export function ToolUseLoader({ isError, isUnresolved, shouldAnimate, toolName, }) {
     const [ref, isBlinking] = useBlink(shouldAnimate);
-    const color = isUnresolved ? undefined : isError ? 'error' : 'success';
-    const char = !shouldAnimate || isBlinking || isError || !isUnresolved
-        ? BLACK_CIRCLE
-        : ' ';
+    if (isError) {
+        return (_jsx(Box, { ref: ref, minWidth: 2, children: _jsx(Text, { color: "error", children: MULTIPLICATION_X }) }));
+    }
+    const category = CATEGORY_BY_TOOL[toolName ?? ''] ?? 'default';
+    const color = isUnresolved ? undefined : CATEGORY_TOKEN[category];
+    const char = shouldAnimate ? (isBlinking ? BLACK_CIRCLE : ' ') : BULLET;
     return (_jsx(Box, { ref: ref, minWidth: 2, children: _jsx(Text, { color: color, dimColor: isUnresolved, children: char }) }));
 }

package/lib/types/components/activityFrames.d.ts

@@ -13,7 +13,7 @@ export interface FramePreset {
 /** Named working-activity frame presets, keyed by preset name (`claude`, `moon`, `sand`, ...). */
 export declare const FRAME_PRESETS: Record<string, FramePreset>;
 /** The pi extension's default preset. */
-export declare const DEFAULT_PRESET = "moon";
+export declare const DEFAULT_PRESET = "moon8";
 /** Every selectable preset name, `random` first (the pi selector order). */
 export declare const PRESET_NAMES: readonly string[];
 /**

package/lib/types/components/activityFrames.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"activityFrames.d.ts","sourceRoot":"","sources":["../../../src/components/activityFrames.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAKH,kFAAkF;AAClF,MAAM,WAAW,WAAW;IAC1B,QAAQ,CAAC,MAAM,EAAE,SAAS,MAAM,EAAE,CAAA;IAClC,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAA;CAC5B;AAED,kGAAkG;AAClG,eAAO,MAAM,aAAa,EAAE,MAAM,CAAC,MAAM,EAAE,WAAW,CA6CrD,CAAA;AAED,yCAAyC;AACzC,eAAO,MAAM,cAAc,SAAS,CAAA;AAEpC,4EAA4E;AAC5E,eAAO,MAAM,YAAY,EAAE,SAAS,MAAM,EAA8C,CAAA;AAExF;;;;GAIG;AACH,wBAAgB,YAAY,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAElD;AAED;;;;GAIG;AACH,wBAAgB,aAAa,CAAC,IAAI,EAAE,MAAM,GAAG,SAAS,GAAG,WAAW,CASnE"}
+{"version":3,"file":"activityFrames.d.ts","sourceRoot":"","sources":["../../../src/components/activityFrames.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAKH,kFAAkF;AAClF,MAAM,WAAW,WAAW;IAC1B,QAAQ,CAAC,MAAM,EAAE,SAAS,MAAM,EAAE,CAAA;IAClC,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAA;CAC5B;AAED,kGAAkG;AAClG,eAAO,MAAM,aAAa,EAAE,MAAM,CAAC,MAAM,EAAE,WAAW,CAgDrD,CAAA;AAED,yCAAyC;AACzC,eAAO,MAAM,cAAc,UAAU,CAAA;AAErC,4EAA4E;AAC5E,eAAO,MAAM,YAAY,EAAE,SAAS,MAAM,EAA8C,CAAA;AAExF;;;;GAIG;AACH,wBAAgB,YAAY,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAElD;AAED;;;;GAIG;AACH,wBAAgB,aAAa,CAAC,IAAI,EAAE,MAAM,GAAG,SAAS,GAAG,WAAW,CASnE"}

package/lib/types/components/activityFrames.js

@@ -32,6 +32,9 @@ export const FRAME_PRESETS = {
     },
     hamburger: { frames: ['☱', '☲', '☴'], intervalMs: 220 },
     moon: { frames: ['◐', '◓', '◑', '◒'], intervalMs: 240 },
+    // kimi-code MoonLoader 同款：8 帧 emoji 月相，120ms 一帧，比半圆版更丝滑。
+    // 不带 \uFE0E：保留彩色 emoji 渲染（Windows Terminal 等现代终端效果最佳）。
+    moon8: { frames: ['🌑', '🌒', '🌓', '🌔', '🌕', '🌖', '🌗', '🌘'], intervalMs: 120 },
     comet: {
         frames: ['●    ', ' ●   ', '  ●  ', '   ● ', '    ●', '   ● ', '  ●  ', ' ●   '],
         intervalMs: 160,
@@ -55,7 +58,7 @@ export const FRAME_PRESETS = {
     toggle: { frames: ['⊶', '⊷'], intervalMs: 300 },
 };
 /** The pi extension's default preset. */
-export const DEFAULT_PRESET = 'moon';
+export const DEFAULT_PRESET = 'moon8';
 /** Every selectable preset name, `random` first (the pi selector order). */
 export const PRESET_NAMES = ['random', ...Object.keys(FRAME_PRESETS)];
 /**

package/lib/types/components/messages/AssistantThinkingMessage.d.ts

@@ -5,6 +5,10 @@ type Props = {
     addMargin: boolean;
     /** True when Ctrl+O transcript/verbose mode is on — show the full text. */
     verbose: boolean;
+    /** Streaming compact mode (thinkingFold=preview): a 3-row live ticker of
+     *  the model's latest reasoning lines instead of the full block —
+     *  kimicode-style constant height; the block never resizes mid-stream. */
+    preview?: boolean;
     /** Thinking wall-clock duration once the reasoning block settled (ms). */
     durationMs?: number;
     /** Message-selection mode highlight. */
@@ -18,6 +22,6 @@ type Props = {
  * reasoning duration, the label carries it (`∴ Thinking · 12s …`) — dsh-tui's
  * take on making thinking time visible in the transcript.
  */
-export declare function AssistantThinkingMessage({ thinking, addMargin, verbose, durationMs, isSelected, onClick, }: Props): React.ReactNode;
+export declare function AssistantThinkingMessage({ thinking, addMargin, verbose, preview, durationMs, isSelected, onClick, }: Props): React.ReactNode;
 export {};
 //# sourceMappingURL=AssistantThinkingMessage.d.ts.map

package/lib/types/components/messages/AssistantThinkingMessage.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"AssistantThinkingMessage.d.ts","sourceRoot":"","sources":["../../../../src/components/messages/AssistantThinkingMessage.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,OAAO,CAAA;AAMzB,KAAK,KAAK,GAAG;IACX,QAAQ,EAAE,MAAM,CAAA;IAChB,4DAA4D;IAC5D,SAAS,EAAE,OAAO,CAAA;IAClB,2EAA2E;IAC3E,OAAO,EAAE,OAAO,CAAA;IAChB,0EAA0E;IAC1E,UAAU,CAAC,EAAE,MAAM,CAAA;IACnB,wCAAwC;IACxC,UAAU,CAAC,EAAE,OAAO,CAAA;IACpB,OAAO,CAAC,IAAI,IAAI,CAAA;CACjB,CAAA;AAED;;;;;;GAMG;AACH,wBAAgB,wBAAwB,CAAC,EACvC,QAAQ,EACR,SAAS,EACT,OAAO,EACP,UAAU,EACV,UAAkB,EAClB,OAAO,GACR,EAAE,KAAK,GAAG,KAAK,CAAC,SAAS,CAuCzB"}
+{"version":3,"file":"AssistantThinkingMessage.d.ts","sourceRoot":"","sources":["../../../../src/components/messages/AssistantThinkingMessage.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,OAAO,CAAA;AAczB,KAAK,KAAK,GAAG;IACX,QAAQ,EAAE,MAAM,CAAA;IAChB,4DAA4D;IAC5D,SAAS,EAAE,OAAO,CAAA;IAClB,2EAA2E;IAC3E,OAAO,EAAE,OAAO,CAAA;IAChB;;8EAE0E;IAC1E,OAAO,CAAC,EAAE,OAAO,CAAA;IACjB,0EAA0E;IAC1E,UAAU,CAAC,EAAE,MAAM,CAAA;IACnB,wCAAwC;IACxC,UAAU,CAAC,EAAE,OAAO,CAAA;IACpB,OAAO,CAAC,IAAI,IAAI,CAAA;CACjB,CAAA;AAED;;;;;;GAMG;AACH,wBAAgB,wBAAwB,CAAC,EACvC,QAAQ,EACR,SAAS,EACT,OAAO,EACP,OAAe,EACf,UAAU,EACV,UAAkB,EAClB,OAAO,GACR,EAAE,KAAK,GAAG,KAAK,CAAC,SAAS,CAqFzB"}