@aragon-agent/cli 0.6.47 → 0.6.48

package/dist/ui/theme.d.ts

@@ -1,96 +0,0 @@
-/**
- * Theme — palette + symbols used across the Ink component tree (spec §3.2).
- *
- * A real theming engine: distinct `WARM` / `COOL` / `LIGHT` hex palettes, an
- * `auto` resolution that is deterministic (`auto -> warm`, since terminals
- * cannot reliably report their background), color degradation across terminal
- * depth (truecolor -> 256 -> 16 -> monochrome), and an ASCII symbol swap for
- * terminals without Unicode support.
- *
- * Two things used to live here and no longer do (spec §4.1 / §4.5):
- *  - the three symbol tables moved to `glyphs.ts`, which is now the single
- *    source of truth for every user-visible character. `symbols` is a VIEW of
- *    `pickGlyphs(caps)`, so every existing `theme.symbols.x` consumer is
- *    unchanged;
- *  - the palette data moved to `palettes.ts`.
- */
-import type { ThemeName } from '../config/schema.js';
-import type { TermCapabilities } from './capabilities.js';
-import { type Glyphs } from './glyphs.js';
-/** A resolved color: a hex/name string, or `undefined` (Ink renders plain). */
-type Color = string | undefined;
-/**
- * Retained name for the symbol view on `Theme`. It is exactly `Glyphs`: the
- * split is by ownership (glyphs.ts owns the data), not by shape.
- */
-export type ThemeSymbols = Glyphs;
-export interface Theme {
-    name: ThemeName;
-    symbols: ThemeSymbols;
-    primary: Color;
-    accent: Color;
-    user: Color;
-    assistant: Color;
-    thinking: Color;
-    toolPending: Color;
-    toolRunning: Color;
-    toolDone: Color;
-    toolError: Color;
-    noticeInfo: Color;
-    noticeWarn: Color;
-    noticeError: Color;
-    muted: Color;
-    border: Color;
-    code: Color;
-    /** Composer border while the input holds a draft. */
-    focusBorder: Color;
-    /** Composer border while idle and empty (matches the legacy `border`). */
-    idleBorder: Color;
-    /** Hint lines, collapse notices, and the off-bottom indicator. */
-    hintFg: Color;
-    /** Single-color wordmark fallback below ansi-256. */
-    logoShadow: Color;
-    /**
-     * Drag-selection highlight (tui-selection-and-scroll-follow §4.4.4).
-     *
-     * Degraded like every other colour here, which means that below ansi-256 these
-     * are chalk colour NAMES rather than hex triples. `highlight.ts` tests for a
-     * hex shape and falls back to plain reverse video otherwise — the fallback a
-     * terminal that shallow would render anyway, and what the emulator's own
-     * selection looks like.
-     */
-    selectionBg: Color;
-    selectionFg: Color;
-    gradient: string[];
-    gauge: {
-        track: Color;
-        low: Color;
-        mid: Color;
-        high: Color;
-    };
-    diff: {
-        add: Color;
-        remove: Color;
-        meta: Color;
-        context: Color;
-    };
-    toast: {
-        info: Color;
-        warn: Color;
-        error: Color;
-        success: Color;
-    };
-    chip: {
-        fg: Color;
-        bg: Color;
-    };
-    /**
-     * The GOVERN posture colour (governance-mode section 10.7). Hex above ansi-256 and
-     * `undefined` at level 0 like every other token, but PINNED to `magenta` at 16 colours
-     * instead of the nearest-ANSI search: that search lands COOL's teal on cyan, which is
-     * `user`'s colour, and the badge exists to be unmistakable.
-     */
-    governAccent: Color;
-}
-export declare function getTheme(name: ThemeName, caps: TermCapabilities): Theme;
-export {};

package/dist/ui/theme.js

@@ -1,130 +0,0 @@
-/**
- * Theme — palette + symbols used across the Ink component tree (spec §3.2).
- *
- * A real theming engine: distinct `WARM` / `COOL` / `LIGHT` hex palettes, an
- * `auto` resolution that is deterministic (`auto -> warm`, since terminals
- * cannot reliably report their background), color degradation across terminal
- * depth (truecolor -> 256 -> 16 -> monochrome), and an ASCII symbol swap for
- * terminals without Unicode support.
- *
- * Two things used to live here and no longer do (spec §4.1 / §4.5):
- *  - the three symbol tables moved to `glyphs.ts`, which is now the single
- *    source of truth for every user-visible character. `symbols` is a VIEW of
- *    `pickGlyphs(caps)`, so every existing `theme.symbols.x` consumer is
- *    unchanged;
- *  - the palette data moved to `palettes.ts`.
- */
-import { pickGlyphs } from './glyphs.js';
-import { resolvePalette } from './palettes.js';
-// ---------------------------------------------------------------------------
-// Color degradation (truecolor -> 256 -> 16 -> monochrome)
-// ---------------------------------------------------------------------------
-/** The 16 standard ANSI colours as chalk names + representative RGB. */
-const ANSI16 = [
-    ['black', [0, 0, 0]],
-    ['red', [205, 49, 49]],
-    ['green', [13, 188, 121]],
-    ['yellow', [229, 229, 16]],
-    ['blue', [36, 114, 200]],
-    ['magenta', [188, 63, 188]],
-    ['cyan', [17, 168, 205]],
-    ['white', [229, 229, 229]],
-    ['gray', [102, 102, 102]],
-    ['redBright', [241, 76, 76]],
-    ['greenBright', [35, 209, 139]],
-    ['yellowBright', [245, 245, 67]],
-    ['blueBright', [59, 142, 234]],
-    ['magentaBright', [214, 112, 214]],
-    ['cyanBright', [41, 184, 219]],
-    ['whiteBright', [255, 255, 255]],
-];
-function hexToRgb(hex) {
-    let h = hex.replace('#', '').trim();
-    if (h.length === 3)
-        h = h[0] + h[0] + h[1] + h[1] + h[2] + h[2];
-    const n = Number.parseInt(h, 16);
-    return [(n >> 16) & 0xff, (n >> 8) & 0xff, n & 0xff];
-}
-/** Nearest of the 16 ANSI colours (chalk name) to an arbitrary hex. */
-function nearestAnsi16(hex) {
-    const [r, g, b] = hexToRgb(hex);
-    let best = ANSI16[0][0];
-    let bestDist = Infinity;
-    for (const [name, [cr, cg, cb]] of ANSI16) {
-        const d = (r - cr) ** 2 + (g - cg) ** 2 + (b - cb) ** 2;
-        if (d < bestDist) {
-            bestDist = d;
-            best = name;
-        }
-    }
-    return best;
-}
-/** Degrade a hex colour to the terminal's depth; `undefined` at level 0. */
-function degrade(hex, level) {
-    if (level === 0)
-        return undefined;
-    if (level === 1)
-        return nearestAnsi16(hex);
-    return hex; // level 2/3: Ink/chalk downsamples the hex as needed
-}
-// ---------------------------------------------------------------------------
-// getTheme (memoized)
-// ---------------------------------------------------------------------------
-const cache = new Map();
-export function getTheme(name, caps) {
-    const key = `${name}|${caps.colorLevel}|${caps.unicode}`;
-    const hit = cache.get(key);
-    if (hit)
-        return hit;
-    const palette = resolvePalette(name);
-    const level = caps.colorLevel;
-    const d = (hex) => degrade(hex, level);
-    const theme = {
-        name,
-        symbols: pickGlyphs(caps),
-        primary: d(palette.primary),
-        accent: d(palette.accent),
-        user: d(palette.user),
-        assistant: d(palette.assistant),
-        thinking: d(palette.thinking),
-        toolPending: d(palette.toolPending),
-        toolRunning: d(palette.toolRunning),
-        toolDone: d(palette.toolDone),
-        toolError: d(palette.toolError),
-        noticeInfo: d(palette.noticeInfo),
-        noticeWarn: d(palette.noticeWarn),
-        noticeError: d(palette.noticeError),
-        muted: d(palette.muted),
-        border: d(palette.border),
-        code: d(palette.code),
-        focusBorder: d(palette.focusBorder),
-        idleBorder: d(palette.idleBorder),
-        hintFg: d(palette.hintFg),
-        logoShadow: d(palette.logoShadow),
-        selectionBg: d(palette.selectionBg),
-        selectionFg: d(palette.selectionFg),
-        gradient: level >= 2 ? [...palette.gradient] : [],
-        gauge: {
-            track: d(palette.gauge.track),
-            low: d(palette.gauge.low),
-            mid: d(palette.gauge.mid),
-            high: d(palette.gauge.high),
-        },
-        diff: {
-            add: d(palette.diff.add),
-            remove: d(palette.diff.remove),
-            meta: d(palette.diff.meta),
-            context: d(palette.diff.context),
-        },
-        toast: {
-            info: d(palette.toast.info),
-            warn: d(palette.toast.warn),
-            error: d(palette.toast.error),
-            success: d(palette.toast.success),
-        },
-        chip: { fg: d(palette.chip.fg), bg: d(palette.chip.bg) },
-        governAccent: level === 1 ? 'magenta' : d(palette.governAccent),
-    };
-    cache.set(key, theme);
-    return theme;
-}

package/dist/ui/transcript-text.d.ts

@@ -1,41 +0,0 @@
-import type { Entry, UsageTotal } from '../agent/reducer.js';
-import type { Glyphs } from './glyphs.js';
-export interface TranscriptTextOptions {
-    /**
-     * Glyph set for the terminal being replayed into. The exit replay lands in
-     * the SAME terminal the TUI just left, so it degrades by the same rule; it
-     * used to spell 11 Unicode literals of its own and wrote mojibake straight
-     * into the user's normal buffer on a legacy console.
-     */
-    glyphs: Glyphs;
-    usageTotal: UsageTotal;
-    model: string;
-    provider: string;
-    elapsedMs: number;
-    /** Entries beyond this count collapse into a single "… N omitted" line. */
-    maxEntries?: number;
-    /**
-     * Entries the retain ring already removed from `ViewState`
-     * (tui-render-performance L1 / K-6).
-     *
-     * A DIFFERENT LOSS FROM `maxEntries`, and both have to be reported: that one
-     * omits the middle of a transcript this replay still holds in full, while this
-     * one names entries the process no longer has. A replay that silently starts
-     * mid-session is exactly the failure the retain ring would otherwise
-     * introduce.
-     */
-    droppedEntries?: number;
-}
-/**
- * The three figures every session summary carries: turns, tokens, cost.
- *
- * One implementation for the exit replay and the native-scroll exit summary
- * (tui-native-terminal-scroll §4.8), so the two can never disagree.
- */
-export declare function formatSessionStats(entries: readonly Entry[], usageTotal: UsageTotal, g: Pick<Glyphs, 'arrowUp' | 'arrowDown'>): {
-    turns: string;
-    tokens: string;
-    cost: string;
-};
-/** Render the whole session (summary line + entries) as plain text. */
-export declare function renderTranscriptText(entries: Entry[], opts: TranscriptTextOptions): string;

package/dist/ui/transcript-text.js

@@ -1,282 +0,0 @@
-import { formatCost, formatDuration, formatTokens, promptTokensOf } from '../agent/usage.js';
-import { formatRetryLine } from '../agent/retry-view.js';
-import { childStatus, outcomePhrase, rosterCounts, statusMarkerCell } from './team-status.js';
-import { expandTabs } from './display-tab.js';
-import { governanceCardLines } from './layout/governance-card.js';
-import { invocationCardLines } from './layout/invocation-card.js';
-const DEFAULT_MAX_ENTRIES = 200;
-const CONTINUATION_INDENT = '  ';
-const TOOL_INDENT = '  ';
-const MAX_ARG_CHARS = 60;
-/**
- * Prefix the first line with `marker`, indent the rest to line up under it.
- *
- * `expandTabs` RUNS BEFORE THE PREFIX IS ADDED, so a stored line lands on the
- * same columns the TUI drew it at. Without it this replay -- the only record
- * left once the alternate screen is torn down -- disagreed with the screen
- * about every TAB, because the terminal painted an eight-column stop under text
- * the composer had laid out at four.
- */
-function block(marker, text) {
-    const lines = expandTabs(text.replace(/\r\n/g, '\n')).split('\n');
-    const head = `${marker} ${lines[0] ?? ''}`.trimEnd();
-    const rest = lines.slice(1).map((l) => `${CONTINUATION_INDENT}${l}`.trimEnd());
-    return [head, ...rest];
-}
-/** A short, single-line rendering of the tool's arguments. */
-function argSummary(entry, glyphs) {
-    const source = entry.args ?? safeParse(entry.argsRaw);
-    if (!source)
-        return '';
-    const parts = [];
-    for (const value of Object.values(source)) {
-        if (typeof value === 'string')
-            parts.push(value);
-        else if (typeof value === 'number' || typeof value === 'boolean')
-            parts.push(String(value));
-        if (parts.length >= 2)
-            break;
-    }
-    const joined = parts.join(' ').replace(/\s+/g, ' ').trim();
-    if (joined.length === 0)
-        return '';
-    return joined.length > MAX_ARG_CHARS
-        ? `${joined.slice(0, MAX_ARG_CHARS - 1)}${glyphs.ellipsis}`
-        : joined;
-}
-function safeParse(raw) {
-    if (!raw || raw.trim().length === 0)
-        return null;
-    try {
-        const parsed = JSON.parse(raw);
-        return parsed && typeof parsed === 'object' ? parsed : null;
-    }
-    catch {
-        return null;
-    }
-}
-/**
- * The replay's glyph for a service, MIRRORING `ServiceCard::serviceGlyph`.
- *
- * The two ladders have to agree, and the cheap-looking shortcut here — "ready or
- * running is a tick, everything else is an error" — disagrees on the two states
- * a user reaches ON PURPOSE: a service they stopped with `Ctrl+C`, and one that
- * exited cleanly. Marking either as a failure in the record the user is left
- * with after the alternate screen is torn down is a lie about their own action.
- *
- * Duplicated rather than imported, as every other case in this file duplicates
- * its card's ladder: this module is deliberately free of React and ink, and
- * `serviceGlyph` lives in a `.tsx`.
- */
-function serviceTextGlyph(status, exitCode, glyphs) {
-    switch (status) {
-        case 'ready':
-            return glyphs.toolDone;
-        case 'running':
-            return glyphs.toolRunning;
-        case 'starting':
-        case 'stopped':
-            return glyphs.toolPending;
-        case 'exited':
-            return exitCode === 0 ? glyphs.toolDone : glyphs.toolError;
-        default:
-            return glyphs.toolError;
-    }
-}
-function renderEntry(entry, glyphs) {
-    switch (entry.kind) {
-        case 'queued':
-            return block('Queued but never sent:', entry.text);
-        case 'user':
-            return entry.invocation
-                ? [...block(glyphs.user, entry.text), ...invocationCardLines(entry.invocation)]
-                : block(glyphs.user, entry.text);
-        case 'assistant': {
-            const suffix = entry.aborted ? ' (aborted)' : '';
-            return block(glyphs.assistant, `${entry.text}${suffix}`);
-        }
-        case 'tool': {
-            const glyph = entry.isError || entry.status === 'error' ? glyphs.toolError : glyphs.toolDone;
-            const args = argSummary(entry, glyphs);
-            const duration = entry.durationMs === undefined ? '' : ` (${entry.durationMs}ms)`;
-            return [`${TOOL_INDENT}${glyph} ${entry.label || entry.name}${args ? ` ${args}` : ''}${duration}`];
-        }
-        case 'team': {
-            // Same rows as `TeamCard`, without colour (team-subagents §6.3). A
-            // dispatch is often the most expensive thing in a session, so leaving it
-            // out of the plain-text replay would make the exported transcript
-            // unaccountable for most of its own cost.
-            // ONE COUNTING AUTHORITY (`team-status.ts`), so the replay cannot disagree with
-            // the card it replays: `runs.length - ok` counted a cancelled child as a failed
-            // one, and a still-working one as a failure (tui-subagent-double-roster E3/E8).
-            // A cancellation therefore gets its own bucket instead of inflating `failed`.
-            const counts = rosterCounts(entry.runs);
-            const head = entry.active || (entry.aborted && entry.durationMs === undefined)
-                ? 'interrupted'
-                : `${entry.durationMs ?? 0}ms (${outcomePhrase(counts)})`;
-            const lines = [
-                `${TOOL_INDENT}team ${entry.runs.length} subagents ${head}`,
-                ...entry.runs.map((run) => {
-                    // The same five-state judgement the card uses: only a real failure takes
-                    // the cross, a cancelled child takes the warning and a running one the
-                    // running marker. `statusMarkerCell`, NOT the bare glyph: the ASCII tier
-                    // spells `[ok]`, `[x]` and `!` at three widths, and a replay whose label
-                    // column shifts from row to row is unreadable.
-                    const glyph = statusMarkerCell(childStatus(run), glyphs);
-                    const detail = run.error ? ` ${run.error}` : '';
-                    return `${TOOL_INDENT}${CONTINUATION_INDENT}${glyph} ${run.label} ${run.description}${detail}`;
-                }),
-            ];
-            return lines;
-        }
-        case 'retry': {
-            // A turn that spent three minutes retrying is exactly the kind of cost an
-            // exported transcript is supposed to account for — the same argument the
-            // `team` case above makes in its own words. This file's `default: return []`
-            // means the addition is a CHOICE rather than a compile requirement, and it is
-            // worth making: without it a replay of a session that lost two minutes to a
-            // 529 shows a gap and no reason for it.
-            const glyph = entry.phase === 'exhausted' ? glyphs.error : glyphs.retry;
-            return [
-                `${TOOL_INDENT}${glyph} ${formatRetryLine(entry, glyphs, Date.now())}`,
-            ];
-        }
-        case 'fast': {
-            // Reviews are real spend and real advice, and an exported transcript that
-            // omitted them would be unaccountable for both — the argument the `team`
-            // and `retry` cases above each make in their own words.
-            const glyph = entry.status === 'failed' ? glyphs.toolError : glyphs.toolDone;
-            const duration = entry.durationMs === undefined ? '' : ` (${entry.durationMs}ms)`;
-            const head = `${TOOL_INDENT}${glyph} fast review #${entry.reviewIndex} ${entry.model} ` +
-                `turn ${entry.turn}${duration}`;
-            if (entry.status === 'advice' && entry.text) {
-                return [head, ...entry.text.split('\n').map((l) => `${TOOL_INDENT}${CONTINUATION_INDENT}${l}`)];
-            }
-            const detail = entry.detail ? `: ${entry.detail}` : '';
-            return [`${head} ${entry.status}${detail}`];
-        }
-        case 'compaction': {
-            // A compaction is real spend AND a real, permanent loss of history, and an
-            // exported transcript that omitted it would be unaccountable for both —
-            // the argument the `team`, `retry` and `fast` cases above each make in
-            // their own words. It matters most here: this is the one entry kind whose
-            // presence explains why the messages the reader is looking for are gone.
-            const glyph = entry.applied ? glyphs.compaction : glyphs.toolError;
-            const duration = entry.durationMs === undefined ? '' : ` (${entry.durationMs}ms)`;
-            if (!entry.applied) {
-                const why = entry.reason ? `: ${entry.reason}` : '';
-                return [`${TOOL_INDENT}${glyph} context not compacted #${entry.index}${why}`];
-            }
-            const head = `${TOOL_INDENT}${glyph} context compacted #${entry.index} ` +
-                `${entry.messagesBefore} ${glyphs.arrowRight} ${entry.messagesAfter} messages, ` +
-                `${entry.tokensBefore} ${glyphs.arrowRight} ${entry.tokensAfter} tokens ` +
-                `[${entry.mode}] ${entry.model}${duration}`;
-            if (!entry.summary)
-                return [head];
-            return [
-                head,
-                ...entry.summary.split('\n').map((l) => `${TOOL_INDENT}${CONTINUATION_INDENT}${l}`),
-            ];
-        }
-        case 'service': {
-            // A service the agent started is real work with a real outcome, and an
-            // exported transcript that omitted it would be unaccountable for both —
-            // the argument the `team`, `retry`, `fast` and `compaction` cases above
-            // each make in their own words. It matters more here than for any of them:
-            // this replay is the user's ONLY record once the alternate screen is torn
-            // down (`cli.tsx`'s exit snapshot), and a service card dropped from it
-            // takes the URL the agent reported with it. This file's
-            // `default: return []` means the addition is a CHOICE rather than a
-            // compile requirement, which is exactly why it is easy to leave out
-            // (P0-3).
-            const glyph = serviceTextGlyph(entry.status, entry.exitCode, glyphs);
-            const where = entry.url ? ` ${entry.url}` : '';
-            const code = entry.exitCode === null || entry.exitCode === undefined
-                ? ''
-                : ` (exit code ${entry.exitCode})`;
-            return [
-                `${TOOL_INDENT}${glyph} service ${entry.serviceId} ${entry.command} ` +
-                    `${entry.status}${where}${code}`.trimEnd(),
-            ];
-        }
-        case 'governance': {
-            // A settlement card is the record of what a governed run decided and scored; an
-            // exported transcript that omitted it would be unaccountable for the run (the
-            // argument the `team`, `retry` and `fast` cases make in their own words). Same
-            // lines as the card, without colour.
-            const lines = governanceCardLines(entry.card, glyphs);
-            return lines.map((line, index) => `${TOOL_INDENT}${index === 0 ? glyphs.teamAgent : ' '} ${line}`.trimEnd());
-        }
-        case 'notice': {
-            const glyph = entry.level === 'error'
-                ? glyphs.error
-                : entry.level === 'warn'
-                    ? glyphs.warn
-                    : glyphs.info;
-            return block(`${TOOL_INDENT}${glyph}`, entry.text);
-        }
-        default:
-            return [];
-    }
-}
-/**
- * The three figures every session summary carries: turns, tokens, cost.
- *
- * One implementation for the exit replay and the native-scroll exit summary
- * (tui-native-terminal-scroll §4.8), so the two can never disagree.
- */
-export function formatSessionStats(entries, usageTotal, g) {
-    const turns = entries.filter((e) => e.kind === 'user').length;
-    // THE SAME PROMPT-SIDE TOTAL THE STATUS BAR SHOWS (context-usage-gauge-accuracy
-    // §3.6). This line is what a user compares against the bar they were watching a
-    // second earlier, so a different unit here would look like the exit summary
-    // losing tokens.
-    const tokens = `${formatTokens(promptTokensOf(usageTotal))}${g.arrowUp} ${formatTokens(usageTotal.outputTokens)}${g.arrowDown}`;
-    return {
-        turns: `${turns} ${turns === 1 ? 'turn' : 'turns'}`,
-        tokens,
-        cost: formatCost(usageTotal.costUsd),
-    };
-}
-/** Render the whole session (summary line + entries) as plain text. */
-export function renderTranscriptText(entries, opts) {
-    const g = opts.glyphs;
-    const stats = formatSessionStats(entries, opts.usageTotal, g);
-    const summary = [
-        'aragon',
-        `${opts.provider}:${opts.model}`,
-        stats.turns,
-        stats.tokens,
-        stats.cost,
-        formatDuration(Math.max(0, opts.elapsedMs)),
-    ].join(` ${g.midDot} `);
-    const max = opts.maxEntries ?? DEFAULT_MAX_ENTRIES;
-    const lines = [summary];
-    const dropped = opts.droppedEntries ?? 0;
-    if (dropped > 0) {
-        lines.push(`${g.ellipsis} ${dropped} earlier ${dropped === 1 ? 'entry' : 'entries'} dropped by ` +
-            `transcriptRetain ${g.midDot} raise it or /save sooner`);
-    }
-    const historyCount = entries.filter((entry) => entry.kind !== 'queued').length;
-    const omitted = max > 1 ? Math.max(0, historyCount - max) : 0;
-    const head = Math.ceil(max / 2);
-    const tailStart = historyCount - (max - head);
-    let historyIndex = 0;
-    let reported = false;
-    for (const entry of entries) {
-        if (entry.kind === 'queued') {
-            lines.push(...renderEntry(entry, g));
-            continue;
-        }
-        const index = historyIndex++;
-        if (omitted > 0 && index >= head && index < tailStart) {
-            if (!reported) {
-                lines.push(`${g.ellipsis} ${omitted} entries omitted ${g.midDot} use /save before exiting`);
-                reported = true;
-            }
-            continue;
-        }
-        lines.push(...renderEntry(entry, g));
-    }
-    return `${lines.join('\n')}\n`;
-}

package/dist/ui/use-height-store.d.ts

@@ -1,31 +0,0 @@
-/**
- * The transcript height cache (tui-render-performance L3).
- *
- * Virtualisation needs a height for entries it is NOT mounting. Measured
- * heights are authoritative; entries that have never been on screen fall back to
- * `estimateEntryRows`, and both are memoised on the same `heightKey` so a
- * `cols` change or a content change invalidates them together (V-5).
- *
- * THE MAP LIVES IN A REF, NOT IN STATE, and the version counter is bumped at
- * most once per frame through a microtask and ONLY when a value actually
- * changed. K-2 is the failure this shape exists to prevent: a naive
- * measure -> setState -> re-measure store never converges, and the symptom is a
- * hung terminal rather than an error. In steady state — settled entries at a
- * fixed width — this produces zero extra renders.
- */
-import { type HeightKey } from './layout/virtual-window.js';
-export interface HeightStoreStats {
-    measured: number;
-    estimated: number;
-}
-export interface HeightStore {
-    /** Bumped at most once per frame, and only when a measurement changed. */
-    version: number;
-    /** Measured rows, else the memoised estimate, computing it once if needed. */
-    resolve: (key: HeightKey, estimate: () => number) => number;
-    /** Called from `MeasuredEntry`'s layout effect. Idempotent per (key, value). */
-    report: (key: HeightKey, rows: number) => void;
-    stats: () => HeightStoreStats;
-    clear: () => void;
-}
-export declare function useHeightStore(): HeightStore;

package/dist/ui/use-height-store.js

@@ -1,76 +0,0 @@
-/**
- * The transcript height cache (tui-render-performance L3).
- *
- * Virtualisation needs a height for entries it is NOT mounting. Measured
- * heights are authoritative; entries that have never been on screen fall back to
- * `estimateEntryRows`, and both are memoised on the same `heightKey` so a
- * `cols` change or a content change invalidates them together (V-5).
- *
- * THE MAP LIVES IN A REF, NOT IN STATE, and the version counter is bumped at
- * most once per frame through a microtask and ONLY when a value actually
- * changed. K-2 is the failure this shape exists to prevent: a naive
- * measure -> setState -> re-measure store never converges, and the symptom is a
- * hung terminal rather than an error. In steady state — settled entries at a
- * fixed width — this produces zero extra renders.
- */
-import { useCallback, useEffect, useRef, useState } from 'react';
-import { VIRTUAL_LIMITS } from './layout/virtual-window.js';
-/** Drop the oldest keys once a map passes the ceiling (insertion-ordered LRU). */
-function trim(map) {
-    while (map.size > VIRTUAL_LIMITS.heightEntries) {
-        const oldest = map.keys().next();
-        if (oldest.done)
-            break;
-        map.delete(oldest.value);
-    }
-}
-export function useHeightStore() {
-    const measured = useRef(new Map());
-    const estimated = useRef(new Map());
-    const [version, setVersion] = useState(0);
-    const scheduled = useRef(false);
-    const mounted = useRef(true);
-    useEffect(() => () => {
-        mounted.current = false;
-    }, []);
-    const report = useCallback((key, rows) => {
-        const value = Number.isFinite(rows) && rows > 0 ? Math.floor(rows) : 0;
-        if (value <= 0)
-            return;
-        if (measured.current.get(key) === value)
-            return;
-        measured.current.set(key, value);
-        trim(measured.current);
-        // An estimate that has been superseded is dead weight; dropping it here is
-        // what keeps `stats()` honest for `/perf`.
-        estimated.current.delete(key);
-        if (scheduled.current)
-            return;
-        scheduled.current = true;
-        queueMicrotask(() => {
-            scheduled.current = false;
-            if (mounted.current)
-                setVersion((v) => v + 1);
-        });
-    }, []);
-    const resolve = useCallback((key, estimate) => {
-        const hit = measured.current.get(key);
-        if (hit !== undefined)
-            return hit;
-        const cached = estimated.current.get(key);
-        if (cached !== undefined)
-            return cached;
-        const value = Math.max(1, Math.floor(estimate()));
-        estimated.current.set(key, value);
-        trim(estimated.current);
-        return value;
-    }, []);
-    const stats = useCallback(() => ({ measured: measured.current.size, estimated: estimated.current.size }), []);
-    const clear = useCallback(() => {
-        measured.current.clear();
-        estimated.current.clear();
-        if (mounted.current)
-            setVersion((v) => v + 1);
-    }, []);
-    return { version, resolve, report, stats, clear };
-}