@aragon-agent/cli 0.6.46 → 0.6.48

package/dist/ui/layout/virtual-window.js

@@ -1,488 +0,0 @@
-/**
- * Viewport virtualisation maths (tui-render-performance L3 / R1). Pure,
- * React-free, unit-tested.
- *
- * THE STRUCTURAL FIX. Ink's `renderNodeToOutput` has no early-out for clipped
- * subtrees: for every `ink-text` node it runs `squashTextNodes`, `widestLine`
- * and possibly `wrapText` — all O(chars) — and `Output.get()` then evaluates
- * `widestLine` a SECOND time before it is allowed to skip an out-of-clip
- * operation. A clipped 50 000-character entry therefore costs two full string
- * scans per frame and buys nothing. Bounding the ENTRY COUNT (`transcriptWindow`)
- * never bounded that, because one entry can be fifty thousand lines.
- *
- * So entries outside the visible band are not mounted at all. They are replaced
- * by two spacer boxes whose heights come from a height cache, which makes the
- * per-frame cost O(visible rows) instead of O(characters ever produced).
- *
- * V-4 — `offset` counts rows FROM THE BOTTOM (`layout/scroll.ts:1-13`), and that
- * is what makes virtualisation safe here for free: a height correction on an
- * entry ABOVE the viewport changes the content height and therefore
- * `overflowLines`, while `offset` — and hence what the user is looking at — is
- * unchanged. No scroll-anchoring compensation pass is required. Do NOT
- * "simplify" `offset` to count from the top.
- *
- * V-4 AS AMENDED BY tui-selection-and-scroll-follow (§4.3.1a). There is now
- * exactly ONE compensation pass — `follow-state.ts`'s Rule A — and it is
- * deliberately restricted to rows appended AT THE TAIL, published by
- * `Transcript.tsx` from the height table below. Everything the paragraph above
- * describes still self-compensates and is still not compensated for again.
- * The restriction is the whole of V-4's survival: an offset that reacted to
- * TOTAL measured height would turn every above-the-viewport correction into a
- * jump, would read a horizon front-drop as new output — and, because
- * `selectWindow` takes `offset` as an INPUT, would close a loop from the offset
- * through the mounted set and the measured heights back to the offset.
- */
-import stringWidth from 'string-width';
-import { governanceCardRows } from './governance-card.js';
-import { FAST_LIMITS } from '../../fast/limits.js';
-import { COMPACTION_LIMITS } from '../../compaction/limits.js';
-import { GUTTER_WIDTH } from './Gutter.js';
-import { expandTabs } from '../display-tab.js';
-import { USER_ENTRY_MAX_ROWS } from '../composer-limits.js';
-import { isLiveTeamCard } from '../team-status.js';
-import { invocationCardRows } from './invocation-card.js';
-export const VIRTUAL_LIMITS = {
-    /**
-     * Entries kept mounted on each side of the visible band.
-     *
-     * V-2 — must stay `>= 2`, so a one-row scroll can never expose an entry whose
-     * height has never been measured at the very edge of the viewport.
-     */
-    overscan: 2,
-    /** Height-cache ceiling (LRU). Four thousand numbers, not four thousand strings. */
-    heightEntries: 4096,
-};
-/**
- * A cheap content version: it changes exactly when the rendered content does.
- *
- * DERIVED, NEVER HASHED. Hashing a 256 KiB string once per entry per frame would
- * recreate the very cost this module exists to remove, so every field below is
- * an O(1) read of a length or a scalar.
- *
- * I-L3-1 — this must change whenever the rendered output changes. The only lossy
- * case is a same-LENGTH text replacement, which the reducer cannot produce: all
- * text fields are append-only (`appendBounded` only ever elides the middle,
- * which changes the length). A future NON-APPEND mutation MUST extend the
- * revision, or the entry freezes at a stale height AND a stale rendered subtree
- * with nothing anywhere reporting it. `virtual-window.test.ts` enumerates every
- * kind against every mutating action.
- */
-export function entryRevision(entry) {
-    switch (entry.kind) {
-        // A card's shape is fixed at creation; the suffix only tells "card" from "plain" (and
-        // the three row-bearing parts), which is what makes a `queued -> user` rewrite re-measure.
-        case 'user':
-            return entry.invocation
-                ? `i${entry.invocation.input.length}.${entry.invocation.inputHidden > 0 ? 1 : 0}.${entry.invocation.note ? 1 : 0}`
-                : 'u';
-        case 'notice':
-            return 'n';
-        // `thinkingMs` is O(1) and it CHANGES THE ROW: sealing the clock turns
-        // `* thought` into `* thought for 12s`, and with thinking hidden that row is
-        // the entry's whole rendered height.
-        case 'assistant':
-            return `a${entry.text.length}.${entry.thinking?.length ?? 0}.${entry.streaming ? 1 : 0}.${entry.aborted ? 1 : 0}.${entry.thinkingMs ?? -1}`;
-        // `patch.lineCount` is PRECOMPUTED for exactly this term: summing
-        // `hunks[].lines.length` per entry per frame is the cost the height cache
-        // exists to remove, and I-L3-1 forbids hashing.
-        // `liveSeq` IS A COUNTER AND NOT `live.length`, and that is precisely the
-        // NON-APPEND mutation I-L3-1 above says must extend the revision: a
-        // fixed-size tail evicting its oldest row while appending a new one of the
-        // same width leaves the joined length unchanged, so a length term would go
-        // on matching while the card's content changed under it.
-        //
-        // SIX TERMS NOW, the longest revision in this file (P2-12). Still O(1) per
-        // entry per frame, which is the property I-L3-1 requires -- but the next
-        // field makes it seven, and a term that is not O(1) would put the cost this
-        // module exists to remove back on every frame.
-        case 'tool':
-            return `t${entry.status}.${entry.argsRaw.length}.${entry.preview?.length ?? 0}.${entry.durationMs ?? -1}.${entry.patch?.lineCount ?? -1}.${entry.liveSeq ?? -1}`;
-        case 'team':
-            return `m${entry.active ? 1 : 0}.${entry.runs.length}.${entry.runs
-                .map((r) => r.phase[0])
-                .join('')}.${entry.runs.reduce((acc, r) => acc + r.toolCalls, 0)}`;
-        case 'todo':
-            // REVISION MUST COVER EVERY FIELD THAT CAN CHANGE THE HEIGHT (§6.10.1). A
-            // criterion going `pending` -> `failed` changes NONE of `items.length`,
-            // `doneCount` or `total`, yet it adds an evidence row; without
-            // `checkedCount` and `failedCount` here the height cache would keep the old
-            // measurement and the cache would be silently wrong - textbook form of "add a
-            // field, forget the revision".
-            return `d${entry.live ? 1 : 0}.${entry.doneCount}.${entry.total}.${entry.items.length}`
-                + `.a${entry.acceptance
-                    ? `${entry.acceptance.items.length}.${entry.acceptance.checkedCount}` +
-                        `.${entry.acceptance.failedCount}`
-                    : '-'}`;
-        /**
-         * The retry card is ONE ROW IN EVERY PHASE, so its revision carries the phase
-         * and the counter but deliberately NOT the countdown: `resumeAt` changes the
-         * rendered SECONDS once a second while the height stays 1, and folding it in
-         * here would invalidate the height cache 30 times per backoff to re-measure a
-         * number that cannot change the answer.
-         *
-         * `phase` and `attempt` ARE in, because they change the row's text and a stale
-         * measurement would be wrong in a way nothing reports (I-L3-1).
-         */
-        case 'retry':
-            return `r${entry.phase}.${entry.attempt}.${entry.maxRetries}`;
-        /**
-         * `status`, `live` and the TEXT LENGTH, because all three change the rows the
-         * card draws: `advice` renders a body, everything else renders one line, and
-         * the body's length decides how many rows it wraps to. `durationMs` is in the
-         * header, which is `wrap="truncate"`, so it can never change the height.
-         */
-        case 'fast':
-            return `f${entry.status}.${entry.live ? 1 : 0}.${entry.text?.length ?? 0}.${entry.detail?.length ?? 0}`;
-        /**
-         * `live`, the SUMMARY LENGTH and `mode`, because all three change the rows the
-         * card draws: a live card renders a headline and no body, a settled one
-         * renders the summary (whose length decides how many rows it wraps to), and
-         * `mode` selects between the "summarized N messages" and "dropped N WITHOUT a
-         * summary" detail lines. `durationMs` is inside the `wrap="truncate"`
-         * headline, so it can never change the height.
-         */
-        case 'compaction':
-            return `c${entry.live ? 1 : 0}.${entry.summary?.length ?? 0}.${entry.mode}.${entry.applied ? 1 : 0}`;
-        /**
-         * `rowsSeen`, AND NEVER `rows.length` (background-service-supervision P0-3).
-         *
-         * The service tail is a FIXED-SIZE RING: it evicts its oldest row while
-         * appending a new one, so the joined length is unchanged while the content is
-         * not. That is verbatim the NON-APPEND mutation I-L3-1 above says must extend
-         * the revision, and it is the same trap — and the same fix — as the `tool`
-         * branch's `liveSeq` two cases up. A length term would go on matching while
-         * the card changed underneath it, and the card would freeze at a stale height
-         * AND a stale rendered subtree with nothing anywhere reporting it.
-         *
-         * `status` and the presence of a URL are in because both change the rows the
-         * card draws; `exitCode` is in because the terminal row names it.
-         */
-        case 'service':
-            return `v${entry.status}.${entry.rowsSeen}.${entry.url ? 1 : 0}.${entry.exitCode ?? -1}.${entry.terminal ? 1 : 0}`;
-        // A governance card is IMMUTABLE once appended (it is a settled record), so its
-        // revision only has to tell two cards apart: the shape terms below are what decide
-        // its height (`governanceCardRows`), and they cannot change without a new entry.
-        case 'governance':
-            return `g${entry.card.rows.length}.${entry.card.notes.length}.${entry.card.headline.length}`;
-        default:
-            return 'x';
-    }
-}
-/**
- * The height-cache key.
- *
- * V-5 — `cols` is part of the key, so a resize invalidates every entry. The
- * frame after a resize renders from estimates and re-measures lazily: one
- * reflow, no crash, no stale layout.
- *
- * `flags` carries the render-affecting switches that are neither per-entry nor
- * part of `density` — today only `thinkingVisible` (Ctrl+T). It is a parameter
- * rather than a fifth positional scalar so a future switch costs one character
- * at the call site instead of a signature change at four.
- */
-export function heightKey(entry, cols, expanded, density, flags = '') {
-    return `${entry.id}|${entryRevision(entry)}|${cols}|${expanded ? 1 : 0}|${density}|${flags}`;
-}
-/**
- * Rows a string occupies at `usable` columns, wrapping included. At least 1.
- *
- * COUNTED IN DISPLAY COLUMNS, NOT UTF-16 CODE UNITS, and the difference is a
- * correctness bug rather than a nicety: a CJK glyph is one code unit and two
- * cells, and a TAB is one code unit and up to `TAB_WIDTH` cells. Counting code
- * units therefore UNDER-estimates, which this file's own note names as the
- * unsafe direction ("an over-estimate makes the scroll position slightly
- * conservative and self-corrects ... an under-estimate can put the newest
- * output off the bottom of a viewport the user believes is pinned"). It also
- * had to change together with the renderers: a stored `\t` is now expanded at
- * paint time, so measuring the unexpanded string would keep the estimate short
- * while the painted row got taller.
- */
-function wrappedRows(text, usable) {
-    const width = Math.max(1, usable);
-    let rows = 0;
-    let start = 0;
-    for (;;) {
-        const end = text.indexOf('\n', start);
-        const line = end === -1 ? text.slice(start) : text.slice(start, end);
-        rows += Math.max(1, Math.ceil(displayColumns(line) / width));
-        if (end === -1)
-            return rows;
-        start = end + 1;
-    }
-}
-/**
- * Printable ASCII with no TAB: one code unit is one cell, so the width table is
- * not consulted at all.
- *
- * THE FAST PATH IS LOAD-BEARING, not a micro-optimisation. `stringWidth`
- * strips ANSI and walks the East-Asian width table for every code point, and
- * this function runs over EVERY unmeasured entry of a 10 000-entry document
- * (`render-budget.test.tsx` mounts exactly that); measuring them all with the
- * table turned that test into a timeout. Transcript text is overwhelmingly
- * ASCII, so the branch is taken almost always.
- */
-const PLAIN_ASCII = /^[\x20-\x7e]*$/;
-/** Display columns of one logical line: TABs expanded, CJK counted twice. */
-function displayColumns(line) {
-    if (line.indexOf('\t') === -1 && PLAIN_ASCII.test(line))
-        return line.length;
-    // `expandTabs` mirrors what `entries/*` paints; `stringWidth` is the width
-    // table the composer already wraps with, so the two agree on CJK and emoji.
-    return stringWidth(expandTabs(line));
-}
-/** Collapsed preview rows in `ToolCard`; duplicated as a NUMBER, not imported. */
-const TOOL_COLLAPSED_LINES = 8;
-/** Collapsed diff rows in `DiffView`; duplicated for the same reason as above. */
-const DIFF_COLLAPSED_LINES = 12;
-/** Live tail rows in `ToolCard`; duplicated as a NUMBER, for the same reason. */
-const TOOL_LIVE_TAIL_ROWS = 8;
-/** Tail rows a COLLAPSED `ServiceCard` draws; duplicated for the same reason. */
-const SERVICE_COLLAPSED_TAIL_ROWS = 2;
-/** Tail rows an EXPANDED `ServiceCard` draws; the snapshot cap (8). */
-const SERVICE_EXPANDED_TAIL_ROWS = 8;
-/**
- * The progress row the live `ServiceCard` draws when `progress` or `stalled` is
- * set (long-task-jobs §4.9), duplicated as the number `1` for the same reason as
- * the two constants above: `virtual-window.ts` counts lines, `ServiceCard.tsx`
- * draws them, and the pairing is kept by a test (AC-27) rather than by an import.
- */
-const SERVICE_PROGRESS_ROWS = 1;
-/**
- * Pure UPPER-BOUND estimate of an entry's height, used until a real measurement
- * exists.
- *
- * Upper bound rather than best guess, and deliberately so: an over-estimate
- * makes the scroll position slightly conservative and self-corrects the frame
- * after the entry is measured, while an under-estimate can put the newest output
- * off the bottom of a viewport the user believes is pinned.
- */
-export function estimateEntryRows(entry, cols, density, expanded, thinkingVisible = true) {
-    const usable = Math.max(1, cols - GUTTER_WIDTH);
-    // `separationRows` needs the PRECEDING entry, which a per-entry estimate does
-    // not have. One row is its maximum, so charging it unconditionally keeps this
-    // an upper bound (`compact` never spends it at all).
-    const separation = density === 'comfortable' ? 1 : 0;
-    switch (entry.kind) {
-        case 'user':
-            // A CARD HAS ITS OWN, BOUNDED HEIGHT (tui-invocation-cards I-4): the same
-            // `invocationCardRows` the painter is built from, never the command line's wrapped rows.
-            if (entry.invocation) {
-                return separation + invocationCardRows(entry.invocation, usable, wrappedRows);
-            }
-            // MIRRORS `UserEntry`'s RENDER CAP (+1 for the `... +N more lines` tail).
-            // THESE TWO NUMBERS ARE ONE NUMBER (I-13). Capping the renderer alone
-            // would leave this function believing a 5 000-line message is 5 000 rows
-            // tall -- and unlike an ordinary over-estimate that failure does NOT
-            // self-correct: this file's own note above records that "an entry
-            // estimated at 400 rows is exactly the one that never gets mounted", and
-            // an unmounted entry is never measured.
-            return (separation + Math.min(wrappedRows(entry.text, usable), USER_ENTRY_MAX_ROWS + 1));
-        case 'notice':
-            return separation + wrappedRows(entry.text, usable);
-        case 'assistant': {
-            // THE PARAMETER'S `true` DEFAULT IS A FAIL-SAFE FOR A FORGOTTEN CALLER,
-            // NOT THE PLAN FOR THE ONE THERE IS (P1-6a). `Transcript.tsx` holds
-            // `thinkingVisible` as a prop and MUST pass it: with thinking hidden by
-            // default, an unpassed flag inflates every assistant entry that thought by
-            // `1 + wrappedRows(thinking)` — hundreds of rows at `thinkingLevel: high`
-            // against a real height of one. The self-correction argument does not
-            // rescue that, because an entry is only measured once `selectWindow`
-            // mounts it, and an entry estimated at 400 rows is exactly the one that
-            // never gets mounted.
-            const thinking = !entry.thinking
-                ? 0
-                : thinkingVisible
-                    ? 1 + wrappedRows(entry.thinking, usable)
-                    : // The collapsed `thought for Ns` marker is exactly one row, and it is
-                        // suppressed while the entry is still streaming (the activity line is
-                        // the live surface then).
-                        entry.streaming
-                            ? 0
-                            : 1;
-            const body = entry.text.length > 0 ? wrappedRows(entry.text, usable) : 1;
-            return separation + thinking + body + (entry.aborted ? 1 : 0);
-        }
-        case 'tool': {
-            const settled = entry.status === 'done' || entry.status === 'error';
-            // WHEN A PATCH IS PRESENT IT, NOT THE PREVIEW, IS WHAT DRAWS (§3.4): the
-            // stored preview is one line by then, so estimating from it would report a
-            // 3-row card for a 12-row diff — an UNDER-estimate, the direction this
-            // file names as unsafe.
-            if (settled && entry.patch) {
-                const rows = entry.patch.lineCount + Math.max(0, entry.patch.hunks.length - 1);
-                const shown = expanded ? rows : Math.min(rows, DIFF_COLLAPSED_LINES);
-                // card header + `+N -M` summary + rows + footer
-                return separation + 1 + 1 + shown + 1;
-            }
-            // THE ONE-LINE `if (!entry.preview || !settled)` THIS REPLACES COVERED TWO
-            // CASES, and both must survive the split (P1-4): not settled, and settled
-            // with nothing to draw (an aborted call, a tool that returned an empty
-            // string). A `!settled` block alone would drop the second into
-            // `wrappedRows(entry.preview, usable)` with `undefined`.
-            if (!settled) {
-                const live = entry.live?.length ?? 0;
-                if (live === 0)
-                    return separation + 1;
-                // Header + tail rows + the unconditional stall/`(running)` footer row.
-                //
-                // ROWS ARE COUNTED, NOT WRAPPED, which is legitimate only because every
-                // live row is rendered `wrap="truncate"` AND clipped at
-                // `LIVE_ROW_MAX_CHARS` on the way into the store -- the same argument
-                // `DiffView.tsx:6-11` makes for itself, and the same coupling: if a
-                // future change lets a live row wrap, this silently UNDER-counts, the
-                // direction this file names as the one the layout cannot absorb.
-                return separation + 1 + Math.min(live, TOOL_LIVE_TAIL_ROWS) + 1;
-            }
-            if (!entry.preview) {
-                return separation + 1;
-            }
-            const lines = wrappedRows(entry.preview, usable);
-            const shown = expanded ? lines : Math.min(lines, TOOL_COLLAPSED_LINES);
-            // header + body + the `+N lines (Ctrl+O)` / `(Ctrl+O to collapse)` footer
-            return separation + 1 + shown + 1;
-        }
-        case 'team':
-            // A LIVE DISPATCH CARD IS NOT DRAWN AT ALL (tui-subagent-double-roster A-2):
-            // the roster is the only live subagent surface, so this entry owes the window
-            // ZERO rows. Estimating it at its real height while `EntryView` renders nothing
-            // would make `selectWindow` reserve four rows for a card that is not on screen -
-            // blank space at the bottom of every dispatch frame, and a window boundary that
-            // disagrees with what the printer measures.
-            if (isLiveTeamCard(entry))
-                return 0;
-            return separation + 1 + entry.runs.length + (expanded ? entry.runs.length * 3 + 1 : 1);
-        case 'todo': {
-            // THE ACCEPTANCE BLOCK'S ROWS, EXACTLY (§6.10.1): one title row plus one row
-            // per criterion plus one row per FAILED criterion's evidence. Exact because
-            // every one of those lines is `wrap="truncate"`; the moment one of them wraps,
-            // this stops being an equality and becomes an upper bound - and the failure
-            // mode is scroll drift, which nothing reports.
-            const acceptance = entry.acceptance;
-            const acceptanceRows = acceptance && acceptance.total > 0
-                ? 1 + acceptance.items.length + acceptance.failedCount
-                : 0;
-            return separation + 1 + entry.items.length + acceptanceRows;
-        }
-        // ONE ROW, ALWAYS. The card is `wrap="truncate"` in every phase, so this is an
-        // exact height rather than an upper bound.
-        case 'retry':
-            return separation + 1;
-        // ADDING THE CASE TO ONLY ONE OF THIS FILE'S TWO SWITCHES YIELDS A
-        // TRANSCRIPT WHOSE SCROLL ARITHMETIC DISAGREES WITH WHAT IT DREW, which
-        // manifests as drift rather than as an error (RV-13). Header row, then
-        // either the wrapped critique (clamped to `cardTextRows`) or one status
-        // line — an upper bound, which is what this function owes its caller.
-        case 'fast': {
-            const body = entry.status === 'advice' && entry.text
-                ? Math.min(FAST_LIMITS.cardTextRows, wrappedRows(entry.text, usable))
-                : 1;
-            return separation + 1 + body;
-        }
-        // THE SECOND SWITCH, and adding the case to only one of the two yields a
-        // transcript whose scroll arithmetic disagrees with what it drew — drift
-        // rather than an error (C-9 / RV-13). Headline row, one detail row, then the
-        // summary clamped to `cardTextRows` (or unclamped when expanded) plus the
-        // `+N more lines` footer. An UPPER BOUND, which is what this function owes
-        // its caller.
-        case 'compaction': {
-            const lines = entry.summary ? wrappedRows(entry.summary, usable) : 0;
-            const body = expanded ? lines : Math.min(lines, COMPACTION_LIMITS.cardTextRows);
-            const footer = lines > body || (expanded && lines > COMPACTION_LIMITS.cardTextRows) ? 1 : 0;
-            return separation + 1 + 1 + body + footer;
-        }
-        /**
-         * THE THIRD SWITCH, and adding the case to only one of this file's two
-         * yields a transcript whose scroll arithmetic disagrees with what it drew —
-         * drift rather than an error (P0-3 / RV-13). Both `default` branches swallow
-         * an unknown kind silently, and `virtual-window.test.ts` hand-enumerates
-         * kinds, so neither omission turns anything red on its own.
-         *
-         * A terminal record is exactly one row. A live card is the status row, the
-         * URL row when there is one, and the tail — counted, not wrapped, which is
-         * legitimate only because every row is `wrap="truncate"` AND clipped at
-         * `LIVE_ROW_MAX_CHARS` on the way into the ring, the same coupling the
-         * `tool` branch above records for itself.
-         */
-        case 'service': {
-            if (entry.terminal)
-                return separation + 1;
-            const url = entry.url ? 1 : 0;
-            const tail = expanded
-                ? Math.min(entry.rows.length, SERVICE_EXPANDED_TAIL_ROWS)
-                : Math.min(entry.rows.length, SERVICE_COLLAPSED_TAIL_ROWS);
-            // THE PROGRESS ROW IS ONE MORE LINE (long-task-jobs AC-27), and it is only
-            // ever one because `ServiceCard` draws it with `wrap="truncate"` and the
-            // supervisor clips it to `PROC_LIMITS.waitProgressChars`. A `stalled` badge
-            // REPLACES it rather than adding to it - the two can never both be drawn,
-            // so this stays a single term.
-            const progress = entry.progress || entry.stalled ? SERVICE_PROGRESS_ROWS : 0;
-            return separation + 1 + progress + url + tail;
-        }
-        // EXACT, not an upper bound: every line of the card is `wrap="truncate"`, so its
-        // height is a function of its data alone (`layout/governance-card.ts`). It has to
-        // be added to BOTH of this file's switches - one alone yields scroll drift.
-        case 'governance':
-            return separation + governanceCardRows(entry.card);
-        default:
-            return separation + 1;
-    }
-}
-/** Choose which entries to mount, and how tall the two spacers must be. */
-export function selectWindow(input) {
-    const { entries, heightOf } = input;
-    const n = entries.length;
-    if (n === 0) {
-        return { startIndex: 0, endIndex: 0, leadingRows: 0, trailingRows: 0, totalRows: 0 };
-    }
-    const heights = new Array(n);
-    let totalRows = 0;
-    for (let i = 0; i < n; i += 1) {
-        const h = heightOf(i);
-        const rows = Number.isFinite(h) && h > 0 ? Math.floor(h) : 1;
-        heights[i] = rows;
-        totalRows += rows;
-    }
-    // A viewport of 0 is the FIRST FRAME, before `measureElement` has run. Falling
-    // back to 1 keeps the live tail mounted through it, so the first paint is real
-    // content rather than a blank rectangle that only fills in on the second.
-    const viewport = Math.max(1, Math.floor(input.viewportRows) || 0);
-    const offset = Math.max(0, Math.floor(input.offset) || 0);
-    const overscan = Math.max(VIRTUAL_LIMITS.overscan, Math.floor(input.overscan) || 0);
-    const bottom = totalRows + (input.trailingContentRows ?? 0) - offset;
-    const top = bottom - viewport;
-    let start = n - 1;
-    let acc = 0;
-    for (let i = 0; i < n; i += 1) {
-        const next = acc + heights[i];
-        if (next > top) {
-            start = i;
-            break;
-        }
-        acc = next;
-    }
-    let end = n;
-    acc = 0;
-    for (let i = 0; i < n; i += 1) {
-        if (acc >= bottom) {
-            end = i;
-            break;
-        }
-        acc += heights[i];
-    }
-    start = Math.max(0, start - overscan);
-    end = Math.min(n, end + overscan);
-    // V-3 — while pinned, the LAST entry is always inside the window, whatever its
-    // height. The live tail must be real content and never a spacer, or a
-    // streaming answer renders as a growing blank rectangle.
-    if (offset <= 0)
-        end = n;
-    if (end <= start)
-        end = Math.min(n, start + 1);
-    let leadingRows = 0;
-    for (let i = 0; i < start; i += 1)
-        leadingRows += heights[i];
-    let trailingRows = 0;
-    for (let i = end; i < n; i += 1)
-        trailingRows += heights[i];
-    return { startIndex: start, endIndex: end, leadingRows, trailingRows, totalRows };
-}

package/dist/ui/layout/wrap-rows.d.ts

@@ -1,26 +0,0 @@
-/**
- * `wrapToRows` — the prose wrapper for `OverlayFrame`'s controlled (mode A)
- * content (plan-mode §6.6).
- *
- * Mode A's contract is *one element per row, each already `wrap="truncate"`*,
- * and `sliceWindow` counts ELEMENTS, not lines. Help and Settings satisfy that
- * naturally because their content is a list of short rows. A plan is not: its
- * summary runs to 600 characters and a step detail to 400, so handing either
- * over as a single `<Text>` renders the whole paragraph as one truncated line —
- * the single worst failure available to a plan review card, and one that also
- * makes the frame's `1-14/22` position indicator a false statement.
- *
- * The repo had no wrapper before this (no `wrapText`, no `wordWrap`), so here is
- * one: pure, no Ink, unit-tested.
- */
-/**
- * Break `text` into lines of at most `width` columns.
- *
- * Prefers spaces; hard-breaks any single token longer than `width` (a URL or a
- * long path, which must not be dropped and cannot be wrapped politely).
- * Width is measured in terminal cells and hard breaks preserve graphemes. A
- * single grapheme wider than the limit stays intact on its own row.
- * Existing newlines are honoured as paragraph breaks. Returns `[]` for empty
- * input so callers can splice the result without an emptiness branch.
- */
-export declare function wrapToRows(text: string, width: number): string[];

package/dist/ui/layout/wrap-rows.js

@@ -1,88 +0,0 @@
-import { graphemes, graphemeWidth } from '../editor-navigation.js';
-/**
- * `wrapToRows` — the prose wrapper for `OverlayFrame`'s controlled (mode A)
- * content (plan-mode §6.6).
- *
- * Mode A's contract is *one element per row, each already `wrap="truncate"`*,
- * and `sliceWindow` counts ELEMENTS, not lines. Help and Settings satisfy that
- * naturally because their content is a list of short rows. A plan is not: its
- * summary runs to 600 characters and a step detail to 400, so handing either
- * over as a single `<Text>` renders the whole paragraph as one truncated line —
- * the single worst failure available to a plan review card, and one that also
- * makes the frame's `1-14/22` position indicator a false statement.
- *
- * The repo had no wrapper before this (no `wrapText`, no `wordWrap`), so here is
- * one: pure, no Ink, unit-tested.
- */
-/**
- * Break `text` into lines of at most `width` columns.
- *
- * Prefers spaces; hard-breaks any single token longer than `width` (a URL or a
- * long path, which must not be dropped and cannot be wrapped politely).
- * Width is measured in terminal cells and hard breaks preserve graphemes. A
- * single grapheme wider than the limit stays intact on its own row.
- * Existing newlines are honoured as paragraph breaks. Returns `[]` for empty
- * input so callers can splice the result without an emptiness branch.
- */
-export function wrapToRows(text, width) {
-    if (typeof text !== 'string' || text.length === 0)
-        return [];
-    const limit = Math.max(1, Math.floor(width));
-    const rows = [];
-    for (const paragraph of text.split('\n')) {
-        if (paragraph.trim().length === 0) {
-            // A blank line in the source is a deliberate separator; keep it as a row
-            // rather than collapsing it, or the summary and the steps run together.
-            rows.push('');
-            continue;
-        }
-        rows.push(...wrapParagraph(paragraph, limit));
-    }
-    return rows;
-}
-function wrapParagraph(paragraph, limit) {
-    const rows = [];
-    let current = '';
-    let currentWidth = 0;
-    for (const word of paragraph.split(/\s+/).filter((w) => w.length > 0)) {
-        const parts = graphemes(word);
-        const wordWidth = parts.reduce((sum, part) => sum + graphemeWidth(part.text), 0);
-        if (wordWidth > limit) {
-            // Flush what we have, then chop the over-long token into full-width
-            // pieces. Its tail becomes the new `current` so the next word can still
-            // join it.
-            if (current.length > 0) {
-                rows.push(current);
-                current = '';
-                currentWidth = 0;
-            }
-            for (const part of parts) {
-                const cells = graphemeWidth(part.text);
-                if (current && currentWidth + cells > limit) {
-                    rows.push(current);
-                    current = '';
-                    currentWidth = 0;
-                }
-                current += part.text;
-                currentWidth += cells;
-            }
-            continue;
-        }
-        if (current.length === 0) {
-            current = word;
-            currentWidth = wordWidth;
-        }
-        else if (currentWidth + 1 + wordWidth <= limit) {
-            current = `${current} ${word}`;
-            currentWidth += 1 + wordWidth;
-        }
-        else {
-            rows.push(current);
-            current = word;
-            currentWidth = wordWidth;
-        }
-    }
-    if (current.length > 0)
-        rows.push(current);
-    return rows;
-}

package/dist/ui/live-clamp.d.ts

@@ -1,14 +0,0 @@
-/** Keep the newest thinking lines visible while an assistant entry streams. */
-export interface LiveClamp {
-    text: string;
-    /** Rows dropped off the FRONT. `0` means the text was returned untouched. */
-    hiddenRows: number;
-}
-/**
- * Keep the LAST `maxRows` rows of `text`; report how many were dropped.
- *
- * Rows, not wrapped display lines: this runs per frame on a streaming entry, and
- * a wrap-aware count would need the column width and a second full scan of a
- * string this function exists to avoid scanning twice.
- */
-export declare function clampLiveText(text: string, maxRows: number): LiveClamp;

package/dist/ui/live-clamp.js

@@ -1,46 +0,0 @@
-/** Keep the newest thinking lines visible while an assistant entry streams. */
-/**
- * Keep the LAST `maxRows` rows of `text`; report how many were dropped.
- *
- * Rows, not wrapped display lines: this runs per frame on a streaming entry, and
- * a wrap-aware count would need the column width and a second full scan of a
- * string this function exists to avoid scanning twice.
- */
-export function clampLiveText(text, maxRows) {
-    if (!Number.isFinite(maxRows) || maxRows <= 0)
-        return { text: '', hiddenRows: rowCount(text) };
-    const keep = Math.floor(maxRows);
-    // Cheap reject: a string with fewer than `keep` newlines cannot have more than
-    // `keep` rows, and this is the path every ordinary entry takes.
-    let newlines = 0;
-    for (let i = 0; i < text.length; i += 1) {
-        if (text.charCodeAt(i) === 10)
-            newlines += 1;
-    }
-    if (newlines + 1 <= keep)
-        return { text, hiddenRows: 0 };
-    // Walk back from the end to the `keep`-th newline rather than splitting the
-    // whole string: the point of the clamp is to stop touching the head at all.
-    let cut = text.length;
-    let seen = 0;
-    for (let i = text.length - 1; i >= 0; i -= 1) {
-        if (text.charCodeAt(i) === 10) {
-            seen += 1;
-            if (seen === keep) {
-                cut = i + 1;
-                break;
-            }
-        }
-    }
-    return { text: text.slice(cut), hiddenRows: newlines + 1 - keep };
-}
-function rowCount(text) {
-    if (text.length === 0)
-        return 0;
-    let n = 1;
-    for (let i = 0; i < text.length; i += 1) {
-        if (text.charCodeAt(i) === 10)
-            n += 1;
-    }
-    return n;
-}