@aragon-agent/cli 0.6.47 → 0.6.48

package/dist/ui/layout/team-row.js

@@ -1,246 +0,0 @@
-/**
- * Panel row geometry — the ONE authority for how a subagent row is measured and
- * what it says (tui-subagent-panel §4.2 / §6.1).
- *
- * WHY THIS FILE EXISTS. The roster used to place its right-hand columns by
- * `flexGrow`, and a fixed-height parent box makes Yoga stretch the column to its
- * widest CHILD instead of to the available width: on a 100-column terminal inside
- * the band slot the row measured 48 (spec §0.1, cases 3/4), so `grep  22.1s` sat
- * hard against the description and the right half of the row was blank. Flex
- * cannot fix that, because the number it needs - "how wide is this terminal" - is
- * not part of the layout it is given. So the widths are COMPUTED here, by a total
- * pure function, and the component only places fixed-width boxes at the offsets
- * this module names.
- *
- * THE FIVE CELLS, in drawing order:
- *
- *     marker(1+status+1) label(8) description(flex) gap(2) activity(n) clock(8)
- *
- * `description` is the ONLY flexible cell, and it is the one that absorbs every
- * width pressure - the same degradation discipline `StatusBar` documents for its
- * left cluster. The two right-hand cells are fixed and `flexShrink={0}`, so their
- * absolute offsets follow from `rowWidth = parentWidth` and the sum of the fixed
- * cells in front of them, and never from how a particular frame allocates slack.
- *
- * ASCII ONLY: `src/ui/**` is inside `glyphs.test.ts`'s static scan.
- *
- * THE ACTIVITY HELPERS LIVE HERE TOO (v2 implementation note, recorded in the
- * spec's "implementation findings"). `teamRowCells` has to compose the activity
- * text with the supervisor badge, which is what `activityWithBadge` already does;
- * leaving those in `TeamPanel.tsx` would make this module and the component
- * import each other. `TeamPanel` therefore RE-EXPORTS every symbol below, so the
- * existing import sites (three test files) keep their import path unchanged.
- */
-import { describeToolActivity, sanitizeActivity } from '../../team/activity.js';
-import { TEAM_LIMITS } from '../../team/limits.js';
-import { formatDuration } from '../../agent/usage.js';
-import { fitCells } from './cells.js';
-import { childElapsedMs, childStatus, statusMarkerCell, statusMarkerWidth } from '../team-status.js';
-/** The clock cell: wide enough for `125m07s` (7) with one column of headroom. */
-export const TEAM_CLOCK_CELLS = 8;
-/** `run.label.padEnd(8).slice(0,8)` — unchanged from the row this replaces. */
-export const TEAM_LABEL_CELLS = 8;
-/** The two spaces in front of the activity cell. */
-export const TEAM_GAP_CELLS = 2;
-/**
- * The description column's floor: below this the row is unreadable, so the
- * activity cell gives way instead (`activityDropCols`).
- */
-export const TEAM_MIN_DESCRIPTION_CELLS = 12;
-/**
- * The concession to code units vs terminal columns, inherited verbatim from the
- * `WIDE_CHAR_ALLOWANCE` comment on the row this replaces: this budget is
- * denominated in code units while the terminal is denominated in columns, and CJK
- * and emoji occupy two columns per unit, so the budget is halved against the
- * reserve rather than spent to the last cell. Erring small costs a few characters
- * of prose; erring large costs the clock column.
- */
-const WIDE_CHAR_ALLOWANCE = 2;
-/** The marker cell of the Unicode tier, used as the default by callers that pass no tier. */
-const DEFAULT_MARKER_CELLS = 3;
-function nonNegativeInt(value) {
-    return Number.isFinite(value) ? Math.max(0, Math.floor(value)) : 0;
-}
-/**
- * How many characters the activity cell may spend at this width.
- *
- * `TEAM_LIMITS.activityChars` is a STORAGE ceiling; a terminal has a COLUMN
- * budget, and the two are not the same number. Below
- * `TEAM_LIMITS.activityDropCols` the cell gives way ENTIRELY (returns 0) rather
- * than shrinking to its 12-character floor: at 40 columns those twelve characters
- * would push the description below its own floor, and "who is doing what" outranks
- * "what they are writing right now" exactly when there is room for one of them.
- * That is a semantic change to a shipped assertion (`activityBudget(40)` used to
- * return 12) and is recorded in the spec's §10 collateral table.
- *
- * `markerCells` defaults to the Unicode tier so the three existing single-argument
- * call sites keep compiling; the panel passes the real tier's width.
- */
-export function activityBudget(cols, markerCells = DEFAULT_MARKER_CELLS) {
-    if (!Number.isFinite(cols) || cols < TEAM_LIMITS.activityDropCols)
-        return 0;
-    const fixed = markerCells + TEAM_LABEL_CELLS + TEAM_GAP_CELLS + TEAM_CLOCK_CELLS
-        + TEAM_MIN_DESCRIPTION_CELLS;
-    const spare = Math.floor((cols - fixed) / WIDE_CHAR_ALLOWANCE);
-    return Math.max(TEAM_LIMITS.activityMinChars, Math.min(TEAM_LIMITS.activityChars, spare));
-}
-/**
- * The row's cell widths. A TOTAL function: every cell is a non-negative integer
- * and the five of them never sum past `cols`, for any `cols >= 0` and either
- * glyph tier (I-3, `team-row-geometry.test.ts`'s property test).
- *
- * THE LADDER IS THE SPECIFICATION (§4.2.2), in the order the cells give way:
- *   1. a wide enough terminal gets the business budget;
- *   2. below `activityDropCols` the activity cell is 0;
- *   3. description still negative -> the gap goes;
- *   4. still negative -> the label shrinks to `max(3, cols - marker - clock)`;
- *   5. still negative -> the clock shrinks (`cols < marker + 3 + clock`);
- *   6. the residue (a terminal narrower than the marker itself) is clamped so the
- *      sum stays inside `cols` — unreachable on a real device, where native mode
- *      degrades to the placeholder below 40x12, but the function is total because
- *      the property test runs `cols = 1..400`.
- */
-export function teamRowGeometry(cols, glyphs) {
-    const width = nonNegativeInt(cols);
-    const markerCells = 1 + statusMarkerWidth(glyphs) + 1;
-    const cells = {
-        marker: Math.min(markerCells, width),
-        label: TEAM_LABEL_CELLS,
-        gap: TEAM_GAP_CELLS,
-        activity: activityBudget(width, markerCells),
-        clock: TEAM_CLOCK_CELLS,
-        minDescription: TEAM_MIN_DESCRIPTION_CELLS,
-    };
-    const sum = () => cells.marker + cells.label + cells.gap + cells.activity + cells.clock;
-    if (sum() > width)
-        cells.gap = 0;
-    if (sum() > width)
-        cells.label = Math.max(3, width - cells.marker - cells.clock);
-    if (sum() > width)
-        cells.clock = Math.max(0, Math.min(TEAM_CLOCK_CELLS, width - cells.marker - cells.label));
-    if (sum() > width)
-        cells.label = Math.max(0, Math.min(cells.label, width - cells.marker));
-    cells.minDescription = sum() >= width ? 0 : TEAM_MIN_DESCRIPTION_CELLS;
-    return cells;
-}
-/**
- * The clock cell's text: this child's elapsed time, or empty when it never
- * started (a `queued` row has no clock to show, and `0ms` would be a lie).
- */
-export function teamClockText(run, at) {
-    return run.startedAt === undefined ? '' : formatDuration(childElapsedMs(run, at));
-}
-/** The past-tense word the supervisor badge and status line render. */
-export function interventionWord(action) {
-    switch (action) {
-        case 'nudge':
-            return 'nudged';
-        case 'replace':
-            return 'replaced';
-        case 'abandon':
-            return 'abandoned';
-        default:
-            return 'waited';
-    }
-}
-/**
- * The row's supervisor badge (subagent-overseer-v2 AC-5): what the supervisor
- * last did to THIS child and how long ago, e.g. `nudged 2m03s`.
- *
- * `lastIntervention.at` is ABSOLUTE epoch ms (R-P2-3), the same units as
- * `startedAt`, so this is one subtraction - no second clock convention.
- */
-export function overseerBadge(run, at) {
-    const last = run.lastIntervention;
-    if (last === undefined)
-        return '';
-    return `${interventionWord(last.action)} ${formatDuration(Math.max(0, at - last.at))}`;
-}
-/**
- * The middle cell: what this child is doing right now, in a few words.
- *
- * Two width policies, answering different questions. `wide` decides WHICH FACT to
- * show - a whole path or its basename, a whole command line or its program name -
- * mirroring `StatusBar`'s `statusCompactCols` degradation rather than inventing a
- * second threshold. `activityBudget(cols)` decides HOW MUCH OF IT FITS, and it is
- * a continuous function of width rather than a threshold, because the failure it
- * prevents - a row wider than the terminal - is continuous.
- */
-export function activityLine(run, cols, markerCells) {
-    const wide = cols >= TEAM_LIMITS.activityWideCols;
-    const budget = activityBudget(cols, markerCells);
-    switch (run.phase) {
-        case 'queued':
-            return 'queued';
-        case 'starting':
-            // The one row that legitimately restarts its clock, saying why (P2-4):
-            // F-2 ranks the running group by `startedAt` and a retry re-stamps it.
-            return run.retries ? 'starting (retry)' : 'starting';
-        case 'thinking':
-            // Clamped AT RENDER, against this terminal's budget. `run.activity` was
-            // clamped at STORE against `activityChars`; that is a ceiling, not a fit.
-            return run.activity ? `writing: ${sanitizeActivity(run.activity, budget)}` : 'thinking';
-        case 'tool':
-        case 'waiting':
-            return run.lastTool
-                ? sanitizeActivity(describeToolActivity(run.lastTool, run.activityArgs, wide), budget)
-                : run.phase === 'waiting'
-                    ? 'waiting for mail'
-                    : 'tool';
-        case 'done':
-            // `compacted N` ON THE SETTLED ROW ONLY (hardening §3.4.4 / W3). A running
-            // row is already competing for `activityBudget(cols)` with the child's own
-            // prose, and a marker that displaces what the child is DOING right now
-            // buys nothing - the dispatch report carries the same fact for good.
-            return run.compactions
-                ? `done  ${run.turns} turns  compacted ${run.compactions}`
-                : `done  ${run.turns} turns`;
-        case 'failed':
-            return 'failed';
-        case 'aborted':
-            return 'aborted';
-    }
-}
-/**
- * The activity cell WITH the badge composed in (AC-5 / risk table): the badge
- * rides the SAME allocation the prose uses, so a row can never grow past its
- * terminal; on a narrow terminal the badge degrades to the action word alone -
- * the who-acted fact outranks the what-they-are-doing tail exactly when there is
- * room for only one.
- */
-export function activityWithBadge(run, cols, at, markerCells) {
-    const last = run.lastIntervention;
-    if (last === undefined)
-        return activityLine(run, cols, markerCells);
-    const badge = overseerBadge(run, at);
-    if (cols < TEAM_LIMITS.activityWideCols)
-        return interventionWord(last.action);
-    return sanitizeActivity(`${badge}; ${activityLine(run, cols, markerCells)}`, activityBudget(cols, markerCells));
-}
-/**
- * The five text fragments of one row.
- *
- * The description is normalized here rather than in the component because
- * truncation preserves explicit newlines and the band reserves exactly ONE row
- * for a child: a description carrying a newline would make the row two rows tall
- * and every row below it would land one row lower than `band.teamRows` allows.
- */
-export function teamRowCells(run, cols, at, glyphs) {
-    const geometry = teamRowGeometry(cols, glyphs);
-    // THE TEXT IS CLAMPED TO THE SAME WIDTH THE GEOMETRY ALLOCATED, so a cell's content
-    // measures no more than its box. `activityWithBadge` already clamps to the business
-    // budget; this is the belt-and-braces that also covers the two cases the budget alone
-    // cannot express - a ZERO-width cell (below `activityDropCols`, where the answer is
-    // "no activity column at all", not "a nine-character word in a zero-column box") and
-    // a wide character straddling the edge.
-    const activity = geometry.activity === 0
-        ? ''
-        : fitCells(activityWithBadge(run, cols, at, geometry.marker), geometry.activity, glyphs.ellipsis);
-    return {
-        marker: statusMarkerCell(childStatus(run), glyphs),
-        label: run.label.padEnd(TEAM_LABEL_CELLS).slice(0, TEAM_LABEL_CELLS),
-        description: run.description.replace(/\s+/g, ' '),
-        activity,
-        clock: teamClockText(run, at),
-    };
-}

package/dist/ui/layout/todo-layout.d.ts

@@ -1,62 +0,0 @@
-import type { TodoSnapshot } from '../../todo/types.js';
-export interface TodoRailLayoutInput {
-    cols: number;
-    panelEnabled: boolean;
-    overlayOpen: boolean;
-    itemCount: number;
-    viewportBudget: number;
-    teamRows: number;
-    queueRows?: number;
-    popupRows: number;
-    composerBaseRows?: number;
-}
-export interface TodoRailLayout {
-    visible: boolean;
-    reason: 'visible' | 'disabled' | 'overlay' | 'empty' | 'narrow' | 'short';
-    width: number;
-    rows: number;
-    contentCols: number;
-    popupMaxHeight: number;
-}
-/** Allocate columns and rows from the same team/menu projections as the renderers.
- * Invalid geometry becomes zero, excess team/menu rows are clamped. Menu capacity
- * never depends on menu occupancy or rail visibility, preventing feedback loops.
- */
-export declare function buildTodoRailLayout(input: TodoRailLayoutInput): TodoRailLayout;
-export interface AcceptanceChipInput {
-    snapshot: TodoSnapshot | null;
-    /** Rows the rail (in-band or full-screen) actually drew; 0 means it drew none. */
-    railRows: number;
-    width: number;
-}
-/**
- * Does the acceptance count still need the status-bar chip
- * (todo-acceptance-criteria §6.11)?
- *
- * HERE, NEXT TO `buildTodoRailLayout`, because it answers the same question from
- * the same inputs: "what did the rail actually draw". Putting it in `App` - a
- * 3,215-line registered oversize file - would give one fact a second owner, which
- * is precisely what `scrollback/band.ts`'s "one number, one owner" rule exists to
- * prevent (P1-8 / C-9).
- *
- * THE RULE IS ABOUT THE RAIL, NOT ABOUT THE SECTION: while the section is `visible`
- * or `summary` the rail is already reporting the count, so a chip would repeat it in
- * the same glance (RV-P2-4). Only two situations leave the count unreported - no rail
- * at all, and the single `rows === 3 && footer` corner where the panel is up but the
- * section could not be fitted.
- */
-export declare function acceptanceChip(input: AcceptanceChipInput): {
-    checked: number;
-    total: number;
-    failed: number;
-} | null;
-/**
- * Which rung the acceptance section reached in the rail, for `/perf`'s band line
- * (§6.9.6).
- *
- * `n/a` means "this plan has no criteria", which is a different fact from `absent`
- * ("the plan has criteria and the rail could not show them"). Both come from the
- * same `buildPlanSections` call the rail rendered with, so the readout cannot
- * disagree with the screen.
- */
-export declare function acceptanceRung(input: AcceptanceChipInput): 'visible' | 'summary' | 'absent' | 'n/a';

package/dist/ui/layout/todo-layout.js

@@ -1,102 +0,0 @@
-import { TODO_LIMITS } from '../../todo/limits.js';
-import { derivePlanPhase } from '../../todo/acceptance.js';
-import { buildPlanSections } from '../../todo/plan-sections.js';
-import { todoRailWidth } from './rail.js';
-/** Allocate columns and rows from the same team/menu projections as the renderers.
- * Invalid geometry becomes zero, excess team/menu rows are clamped. Menu capacity
- * never depends on menu occupancy or rail visibility, preventing feedback loops.
- */
-export function buildTodoRailLayout(input) {
-    const cols = nonNegativeInt(input.cols);
-    const budget = nonNegativeInt(input.viewportBudget);
-    const teamRows = Math.min(budget, nonNegativeInt(input.teamRows));
-    const popupMaxHeight = Math.max(0, budget - teamRows - nonNegativeInt(input.queueRows ?? 0) - 1
-        - nonNegativeInt(input.composerBaseRows ?? 0));
-    const popupRows = popupMaxHeight < 3 ? 0 : Math.min(nonNegativeInt(input.popupRows), popupMaxHeight);
-    const rows = budget;
-    const width = todoRailWidth(cols);
-    const reason = !input.panelEnabled ? 'disabled'
-        : input.overlayOpen ? 'overlay'
-            : nonNegativeInt(input.itemCount) === 0 ? 'empty'
-                : width === 0 ? 'narrow'
-                    : rows < TODO_LIMITS.panelMinRows ? 'short'
-                        : 'visible';
-    const visible = reason === 'visible';
-    return { visible, reason, width, rows, contentCols: cols - (visible ? width : 0), popupMaxHeight };
-}
-function nonNegativeInt(value) {
-    return Number.isFinite(value) ? Math.max(0, Math.floor(value)) : 0;
-}
-/**
- * Does the acceptance count still need the status-bar chip
- * (todo-acceptance-criteria §6.11)?
- *
- * HERE, NEXT TO `buildTodoRailLayout`, because it answers the same question from
- * the same inputs: "what did the rail actually draw". Putting it in `App` - a
- * 3,215-line registered oversize file - would give one fact a second owner, which
- * is precisely what `scrollback/band.ts`'s "one number, one owner" rule exists to
- * prevent (P1-8 / C-9).
- *
- * THE RULE IS ABOUT THE RAIL, NOT ABOUT THE SECTION: while the section is `visible`
- * or `summary` the rail is already reporting the count, so a chip would repeat it in
- * the same glance (RV-P2-4). Only two situations leave the count unreported - no rail
- * at all, and the single `rows === 3 && footer` corner where the panel is up but the
- * section could not be fitted.
- */
-export function acceptanceChip(input) {
-    const acceptance = input.snapshot?.acceptance;
-    if (!acceptance || acceptance.total === 0)
-        return null;
-    const chip = {
-        checked: acceptance.checkedCount,
-        total: acceptance.total,
-        failed: acceptance.failedCount,
-    };
-    if (input.railRows <= 0)
-        return chip;
-    return acceptanceSectionOf(input) === 'absent' ? chip : null;
-}
-/**
- * Which rung the acceptance section reached in the rail, for `/perf`'s band line
- * (§6.9.6).
- *
- * `n/a` means "this plan has no criteria", which is a different fact from `absent`
- * ("the plan has criteria and the rail could not show them"). Both come from the
- * same `buildPlanSections` call the rail rendered with, so the readout cannot
- * disagree with the screen.
- */
-export function acceptanceRung(input) {
-    const acceptance = input.snapshot?.acceptance;
-    if (!acceptance || acceptance.total === 0)
-        return 'n/a';
-    // No rail drawn at all: the section is not on screen, and saying `absent` is the
-    // one honest answer for that.
-    if (input.railRows <= 0)
-        return 'absent';
-    return acceptanceSectionOf(input) ?? 'absent';
-}
-/**
- * The section's reason for a given rail, or `null` when the plan has no criteria.
- *
- * `showGauge` is assumed TRUE. That is the conservative direction for the ROW BUDGET -
- * it can only make the rail look shorter - and it cannot change the REASON at all: the
- * compact rung (rows < 6, where the real gauge is always off) ignores `available`
- * entirely, and the full rung spends the difference on item rows. So this readout can
- * never disagree with the rail about `visible` / `summary` / `absent`, and the chip
- * therefore never duplicates a count the rail is already showing (RV-P2-4).
- */
-function acceptanceSectionOf(input) {
-    const snapshot = input.snapshot;
-    const acceptance = snapshot?.acceptance;
-    if (!snapshot || !acceptance || acceptance.total === 0)
-        return null;
-    const sections = buildPlanSections({
-        rows: input.railRows,
-        width: input.width,
-        phase: derivePlanPhase(snapshot.items, acceptance.items),
-        todoCount: snapshot.items.length,
-        acceptanceCount: acceptance.total,
-        showGauge: true,
-    });
-    return sections.acceptance?.reason ?? null;
-}

package/dist/ui/layout/useTerminalSize.d.ts

@@ -1,13 +0,0 @@
-/**
- * Terminal size hook (spec §4.11).
- *
- * Ink recomputes its own layout on resize, but the React layer needs the new
- * `rows` to update `height={frameHeight(rows)}`. Without this hook the frame
- * keeps its old height after the window grows and leaves a dead band at the
- * bottom of the screen.
- */
-export interface TerminalSize {
-    rows: number;
-    cols: number;
-}
-export declare function useTerminalSize(): TerminalSize;

package/dist/ui/layout/useTerminalSize.js

@@ -1,50 +0,0 @@
-/**
- * Terminal size hook (spec §4.11).
- *
- * Ink recomputes its own layout on resize, but the React layer needs the new
- * `rows` to update `height={frameHeight(rows)}`. Without this hook the frame
- * keeps its old height after the window grows and leaves a dead band at the
- * bottom of the screen.
- */
-import { useEffect, useState } from 'react';
-import { useStdout } from 'ink';
-import { FALLBACK_COLS, FALLBACK_ROWS } from './frame.js';
-/** Coalesce the burst of resize events a window drag produces. */
-const RESIZE_THROTTLE_MS = 50;
-function readSize(stdout) {
-    const rows = stdout?.rows;
-    const cols = stdout?.columns;
-    return {
-        rows: rows && rows > 0 ? rows : FALLBACK_ROWS,
-        cols: cols && cols > 0 ? cols : FALLBACK_COLS,
-    };
-}
-export function useTerminalSize() {
-    const { stdout } = useStdout();
-    const [size, setSize] = useState(() => readSize(stdout));
-    useEffect(() => {
-        const stream = stdout;
-        if (!stream || typeof stream.on !== 'function')
-            return undefined;
-        let timer = null;
-        const onResize = () => {
-            if (timer)
-                clearTimeout(timer);
-            timer = setTimeout(() => {
-                timer = null;
-                const next = readSize(stream);
-                setSize((prev) => (prev.rows === next.rows && prev.cols === next.cols ? prev : next));
-            }, RESIZE_THROTTLE_MS);
-        };
-        stream.on('resize', onResize);
-        return () => {
-            if (timer)
-                clearTimeout(timer);
-            if (typeof stream.off === 'function')
-                stream.off('resize', onResize);
-            else if (typeof stream.removeListener === 'function')
-                stream.removeListener('resize', onResize);
-        };
-    }, [stdout]);
-    return size;
-}

package/dist/ui/layout/viewport-geometry.d.ts

@@ -1,29 +0,0 @@
-/**
- * Viewport geometry, published downward (tui-render-performance L3).
- *
- * `ScrollViewport`'s header records (P1-7) why it — and not its parent — owns
- * the metrics and the scroll offset: holding the offset in two places creates a
- * measure -> setState -> re-render -> measure loop whose convergence is provable
- * but whose frame count is not.
- *
- * Virtualisation needs those same three numbers one level DOWN, in
- * `TranscriptList`. So the viewport PUBLISHES rather than lifting: a `useMemo`d
- * context value, no new state, no second owner, no extra layout pass.
- */
-export interface ViewportGeometry {
-    /** Visible height of the clipping box, in rows. `0` before the first measure. */
-    viewportRows: number;
-    /** Rows hidden BELOW the viewport (`layout/scroll.ts` semantics; V-4). */
-    offset: number;
-    /** Natural (unclipped) height of the content, in rows. */
-    contentRows: number;
-    trailingContentRows?: number;
-}
-/**
- * The default is the UNMEASURED geometry, and consumers must treat it as such:
- * a `TranscriptList` rendered outside a `ScrollViewport` (including
- * test that mounts it bare) sees `viewportRows: 0`, which `selectWindow` reads
- * as "first frame" and answers by pinning the live tail.
- */
-export declare const ViewportGeometryContext: import("react").Context<ViewportGeometry>;
-export declare function useViewportGeometry(): ViewportGeometry;

package/dist/ui/layout/viewport-geometry.js

@@ -1,28 +0,0 @@
-/**
- * Viewport geometry, published downward (tui-render-performance L3).
- *
- * `ScrollViewport`'s header records (P1-7) why it — and not its parent — owns
- * the metrics and the scroll offset: holding the offset in two places creates a
- * measure -> setState -> re-render -> measure loop whose convergence is provable
- * but whose frame count is not.
- *
- * Virtualisation needs those same three numbers one level DOWN, in
- * `TranscriptList`. So the viewport PUBLISHES rather than lifting: a `useMemo`d
- * context value, no new state, no second owner, no extra layout pass.
- */
-import { createContext, useContext } from 'react';
-/**
- * The default is the UNMEASURED geometry, and consumers must treat it as such:
- * a `TranscriptList` rendered outside a `ScrollViewport` (including
- * test that mounts it bare) sees `viewportRows: 0`, which `selectWindow` reads
- * as "first frame" and answers by pinning the live tail.
- */
-export const ViewportGeometryContext = createContext({
-    viewportRows: 0,
-    offset: 0,
-    contentRows: 0,
-    trailingContentRows: 0,
-});
-export function useViewportGeometry() {
-    return useContext(ViewportGeometryContext);
-}

package/dist/ui/layout/virtual-window.d.ts

@@ -1,112 +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 type { Entry } from '../../agent/reducer.js';
-import type { DensityMode } from '../density.js';
-export declare 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.
-     */
-    readonly overscan: 2;
-    /** Height-cache ceiling (LRU). Four thousand numbers, not four thousand strings. */
-    readonly heightEntries: 4096;
-};
-export type HeightKey = string;
-/**
- * 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 declare function entryRevision(entry: Entry): string;
-/**
- * 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 declare function heightKey(entry: Entry, cols: number, expanded: boolean, density: DensityMode, flags?: string): HeightKey;
-/**
- * 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 declare function estimateEntryRows(entry: Entry, cols: number, density: DensityMode, expanded: boolean, thinkingVisible?: boolean): number;
-export interface WindowSelection {
-    /** First mounted entry, inclusive. */
-    startIndex: number;
-    /** One past the last mounted entry. */
-    endIndex: number;
-    /** Spacer rows above the mounted slice. */
-    leadingRows: number;
-    /** Spacer rows below the mounted slice. */
-    trailingRows: number;
-    /** Sum of every entry height, measured or estimated. */
-    totalRows: number;
-}
-export interface SelectWindowInput {
-    trailingContentRows?: number;
-    entries: readonly Entry[];
-    /** Measured, else estimated; never 0 for a real entry. */
-    heightOf: (index: number) => number;
-    viewportRows: number;
-    /** Rows hidden BELOW the viewport — the existing `scroll.ts` semantic (V-4). */
-    offset: number;
-    /** `>= 2` (V-2). Lower values are raised rather than honoured. */
-    overscan: number;
-}
-/** Choose which entries to mount, and how tall the two spacers must be. */
-export declare function selectWindow(input: SelectWindowInput): WindowSelection;