@aragon-agent/cli 0.6.47 → 0.6.48

package/dist/ui/paste-frames.js

@@ -1,117 +0,0 @@
-/**
- * Reading paste frames back out of an Ink `input` string
- * (tui-paste-handling section 5.4) -- pure.
- *
- * The stdin filter writes `PASTE_OPEN + payload + PASTE_CLOSE` inline, in stream
- * order (I-5). This module is the only place that takes those markers apart.
- */
-import { PASTE_CLOSE, PASTE_OPEN } from '../input/limits.js';
-import { sanitisePaste } from '../input/paste-parse.js';
-import { stripControlSequences } from '../input/control-sequences.js';
-/**
- * Remove every C0 byte, DEL and C1 byte from text that arrived OUTSIDE a frame
- * (I-14). NO CR -> LF conversion, and that omission is the point.
- *
- * WHY THIS IS NOT OPTIONAL. Ink drains its whole buffer in one size-less
- * `read()` (`App.js:135`), so the `input` string carrying a frame can also carry
- * the keystroke bytes that arrived beside it -- most often the `\r` of a user who
- * pastes and immediately presses Enter, since Ink's 32 ms render throttle and a
- * large transcript's Yoga pass both outlast the filter's 15 ms burst window.
- * Splicing that run in verbatim puts a raw CR back into the draft and re-opens
- * the corruption this whole feature exists to remove.
- *
- * Note what it does NOT do. It does not turn a coalesced `\r` into a newline and
- * it does not submit: a keystroke that merged with a frame has already lost its
- * identity as a key (`parseKeypress` saw the concatenation, not the key), so the
- * only two honest options are "insert something wrong" and "drop it". Dropping is
- * recoverable and benign -- the user presses Enter again -- while inserting a
- * control byte is not. Printable characters survive untouched.
- */
-export function sanitiseTyped(text) {
-    return text.replace(/[\u0000-\u001F\u007F-\u009F]/g, '');
-}
-/**
- * Split an `input` string into ordered text runs and paste runs.
- *
- * Text runs are returned already through `sanitiseTyped` (I-14); paste runs are
- * returned through `sanitisePaste`, which keeps TAB and `\n` because they are
- * content inside a payload.
- *
- * RE-SANITISING THE PAYLOAD IS DEFENCE IN DEPTH, NOT A SECOND OPINION. The
- * filter already ran `sanitisePaste` and it is idempotent, so the normal path is
- * byte-identical. What it buys is that G2 ("no pasted byte is ever executed as a
- * terminal control") becomes a property of the COMPOSER rather than a property
- * of whoever produced the frame -- which matters for the branch below, where an
- * unmatched `PASTE_OPEN` turns arbitrary trailing bytes into a paste segment.
- *
- * An unmatched `PASTE_OPEN` -- impossible from our own filter, but cheap to
- * survive -- yields its remainder as a paste segment rather than leaking NULs.
- */
-export function splitPasteFrames(input) {
-    const segments = [];
-    const pushText = (raw) => {
-        const text = sanitiseTyped(raw);
-        if (text.length > 0)
-            segments.push({ kind: 'text', text });
-    };
-    const pushPaste = (raw) => {
-        const text = sanitisePaste(raw);
-        if (text.length > 0)
-            segments.push({ kind: 'paste', text });
-    };
-    let i = 0;
-    while (i < input.length) {
-        const open = input.indexOf(PASTE_OPEN, i);
-        if (open === -1) {
-            pushText(input.slice(i));
-            break;
-        }
-        pushText(input.slice(i, open));
-        const bodyStart = open + PASTE_OPEN.length;
-        const close = input.indexOf(PASTE_CLOSE, bodyStart);
-        if (close === -1) {
-            pushPaste(input.slice(bodyStart));
-            break;
-        }
-        pushPaste(input.slice(bodyStart, close));
-        i = close + PASTE_CLOSE.length;
-    }
-    return segments;
-}
-/** True when this `input` carries at least one frame -- the branch guard. */
-export function hasPasteFrame(input) {
-    return input.includes(PASTE_OPEN);
-}
-/**
- * Turn a possibly-framed `input` into plain text for a consumer that has no
- * paste model of its own: unwrap the frames, keep the payload, drop the markers,
- * and run BOTH halves through `sanitiseTyped`.
- *
- * ANY `useInput` CONSUMER THAT APPENDS `input` TO A STRING MUST CALL THIS (I-12),
- * and the list is pinned by a source scan rather than by review discipline
- * because the failure is invisible: NUL renders as nothing.
- *
- * `useInput` is a BROADCAST -- `use-input.js` re-emits every chunk to every
- * mounted handler -- so `SettingsScreen` and `QuestionOverlay` see the frame the
- * composer was sent. An API key is ~100 characters with no line break, which trips
- * Tier 2's burst rule and gets framed; nothing downstream removes the NULs
- * (`String.prototype.trim()` does not treat U+0000 as whitespace), the field is
- * rendered through `maskDot` so the damage is invisible, and the value is handed
- * to `registerSecret()` and `controller.setApiKey()`. The user is told the
- * settings were saved and every request afterwards fails to authenticate with
- * nothing on screen to explain it.
- *
- * This is strictly better than v0.6.3 for both consumers: a pasted key carrying a
- * stray CR or an ANSI sequence is now cleaned rather than stored raw. The
- * unframed branch strips escape SEQUENCES before the control sweep, because
- * deleting only the introducer left `[0m` in the stored value -- and in a
- * settings field that residue is invisible behind `maskDot` while the value
- * handed to `registerSecret()` is silently wrong.
- */
-export function stripPasteFrames(input) {
-    if (!hasPasteFrame(input))
-        return sanitiseTyped(stripControlSequences(input));
-    return splitPasteFrames(input)
-        .map((segment) => (segment.kind === 'paste' ? sanitiseTyped(segment.text) : segment.text))
-        .join('');
-}

package/dist/ui/paste-tokens.d.ts

@@ -1,90 +0,0 @@
-/**
- * The paste token vocabulary (tui-paste-handling section 5.3) -- pure. No Ink,
- * no React, no I/O.
- *
- * A large paste is replaced IN THE BUFFER by a display token,
- * `[Pasted text #1 +15 lines]`, and its payload is held beside the buffer in the
- * editor's `pastes` map until the message is sent (D-7). An inline token rather
- * than an out-of-band attachment is what lets the user place a paste relative to
- * their own words -- "explain this: [Pasted text #1 +218 lines] -- why does it
- * retry?" -- which is also the shape the requirement's example asks for.
- *
- * The token is ATOMIC FOR EDITING and NOT for cursor movement (D-8). Delete and
- * kill ranges snap outward to cover a whole token and the caret snaps out before
- * an insert, which removes every realistic way to corrupt one; arrows still step
- * by character, because re-deriving `moveVertical`, `home`/`end` and word jumps
- * around a synthetic unit buys a correctness the user cannot notice.
- */
-export interface PasteRecord {
-    readonly id: number;
-    /** The sanitised payload, byte-for-byte what `expandPastes` sends. */
-    readonly text: string;
-    readonly lines: number;
-    readonly chars: number;
-}
-/**
- * A FACTORY, NOT A SHARED CONSTANT (P2-2).
- *
- * A module-level `/g` RegExp carries `lastIndex` between calls, so `re.test(x)`
- * returns false on every second call with the same input -- a bug that presents
- * as "token detection works, then randomly does not". Callers must use
- * `matchAll` or `replace` (both safe) on a FRESH instance; nothing in this module
- * may call `.test()` or `.exec()` on a `/g` regex it did not just create.
- *
- * Strict, anchored to its own literal shape, ASCII-only. Group 1 is the id.
- */
-export declare function pasteTokenRe(): RegExp;
-export declare function allocatePasteId(): number;
-/** Test-only reset. Never called from application code. */
-export declare function resetPasteIdsForTest(): void;
-export declare function makePasteRecord(id: number, text: string): PasteRecord;
-/**
- * `[Pasted text #3 +218 lines]`, or `[Pasted text #4 +1204 chars]` for a paste
- * that is one very long line.
- *
- * "+1 lines" is not a sentence, and for a one-liner the number the user cares
- * about is its length rather than its line count.
- */
-export declare function formatPasteToken(record: PasteRecord): string;
-/** Above EITHER inline bound the paste is collapsed into a token (G3 / G4). */
-export declare function shouldCollapse(text: string): boolean;
-interface TokenSpan {
-    readonly start: number;
-    readonly end: number;
-    readonly id: number;
-}
-/** Every token in the buffer, in order. */
-export declare function tokenSpans(buffer: string): TokenSpan[];
-/** The token containing or touching `index`, or `null`. */
-export declare function tokenAt(buffer: string, index: number): TokenSpan | null;
-/**
- * Move a caret that landed STRICTLY INSIDE a token to its nearer edge (D-8).
- *
- * An index at either edge, or outside every token, is returned unchanged -- so
- * this is a no-op on a buffer with no tokens, which is every buffer today.
- */
-export declare function snapOutOfToken(buffer: string, cursor: number): number;
-/**
- * Grow `[from, to)` so it covers every token it partially overlaps (G5).
- *
- * This is what makes `Backspace` immediately after `...lines]` remove the whole
- * token in ONE keystroke, and what stops `Ctrl+W` / `Ctrl+U` / `Ctrl+K` leaving
- * half a token -- and therefore an unparseable label -- behind.
- */
-export declare function expandRangeOverTokens(buffer: string, from: number, to: number): {
-    from: number;
-    to: number;
-};
-/**
- * Replace every token whose id is present in `pastes`; leave the rest verbatim.
- *
- * A user who literally TYPES `[Pasted text #3 +9 lines]` while paste #3 exists in
- * the same draft will have it expanded. That is bounded (ids are per process, the
- * map is per draft) and harmless (they get text that is already in their own
- * draft), and the alternative -- an unguessable nonce in the label -- would trade
- * a case nobody hits for a label nobody can read.
- */
-export declare function expandPastes(buffer: string, pastes: ReadonlyMap<number, PasteRecord>): string;
-/** Ids still referenced by the buffer -- the input to I-7's prune. */
-export declare function referencedIds(buffer: string): Set<number>;
-export {};

package/dist/ui/paste-tokens.js

@@ -1,147 +0,0 @@
-/**
- * The paste token vocabulary (tui-paste-handling section 5.3) -- pure. No Ink,
- * no React, no I/O.
- *
- * A large paste is replaced IN THE BUFFER by a display token,
- * `[Pasted text #1 +15 lines]`, and its payload is held beside the buffer in the
- * editor's `pastes` map until the message is sent (D-7). An inline token rather
- * than an out-of-band attachment is what lets the user place a paste relative to
- * their own words -- "explain this: [Pasted text #1 +218 lines] -- why does it
- * retry?" -- which is also the shape the requirement's example asks for.
- *
- * The token is ATOMIC FOR EDITING and NOT for cursor movement (D-8). Delete and
- * kill ranges snap outward to cover a whole token and the caret snaps out before
- * an insert, which removes every realistic way to corrupt one; arrows still step
- * by character, because re-deriving `moveVertical`, `home`/`end` and word jumps
- * around a synthetic unit buys a correctness the user cannot notice.
- */
-import { PASTE_INLINE_MAX_CHARS, PASTE_INLINE_MAX_LINES } from './composer-limits.js';
-/**
- * A FACTORY, NOT A SHARED CONSTANT (P2-2).
- *
- * A module-level `/g` RegExp carries `lastIndex` between calls, so `re.test(x)`
- * returns false on every second call with the same input -- a bug that presents
- * as "token detection works, then randomly does not". Callers must use
- * `matchAll` or `replace` (both safe) on a FRESH instance; nothing in this module
- * may call `.test()` or `.exec()` on a `/g` regex it did not just create.
- *
- * Strict, anchored to its own literal shape, ASCII-only. Group 1 is the id.
- */
-export function pasteTokenRe() {
-    return /\[Pasted text #(\d+) \+\d+ (?:lines|chars)\]/g;
-}
-/**
- * The process-monotonic id counter (D-14).
- *
- * CALLED FROM THE COMPONENT, NEVER FROM THE REDUCER (P1-5). React is explicitly
- * allowed to run a reducer more than once for one action -- eager evaluation in
- * `dispatchSetState`, base-queue replay after a bailout, StrictMode double
- * invocation -- and a counter mutated inside one would skip ids and produce two
- * states that differ in the token TEXT, not merely in identity. Allocating in the
- * handler also makes the rendered token deterministic for a unit test.
- *
- * Monotonic for the PROCESS rather than per draft, so two drafts never show `#1`
- * for different content in one session.
- */
-let nextPasteId = 1;
-export function allocatePasteId() {
-    const id = nextPasteId;
-    nextPasteId += 1;
-    return id;
-}
-/** Test-only reset. Never called from application code. */
-export function resetPasteIdsForTest() {
-    nextPasteId = 1;
-}
-export function makePasteRecord(id, text) {
-    return { id, text, lines: text.split('\n').length, chars: [...text].length };
-}
-/**
- * `[Pasted text #3 +218 lines]`, or `[Pasted text #4 +1204 chars]` for a paste
- * that is one very long line.
- *
- * "+1 lines" is not a sentence, and for a one-liner the number the user cares
- * about is its length rather than its line count.
- */
-export function formatPasteToken(record) {
-    return record.lines > 1
-        ? `[Pasted text #${record.id} +${record.lines} lines]`
-        : `[Pasted text #${record.id} +${record.chars} chars]`;
-}
-/** Above EITHER inline bound the paste is collapsed into a token (G3 / G4). */
-export function shouldCollapse(text) {
-    return text.split('\n').length > PASTE_INLINE_MAX_LINES || [...text].length > PASTE_INLINE_MAX_CHARS;
-}
-/** Every token in the buffer, in order. */
-export function tokenSpans(buffer) {
-    const spans = [];
-    for (const m of buffer.matchAll(pasteTokenRe())) {
-        const start = m.index ?? 0;
-        spans.push({ start, end: start + m[0].length, id: Number(m[1]) });
-    }
-    return spans;
-}
-/** The token containing or touching `index`, or `null`. */
-export function tokenAt(buffer, index) {
-    for (const span of tokenSpans(buffer)) {
-        if (index >= span.start && index <= span.end)
-            return span;
-    }
-    return null;
-}
-/**
- * Move a caret that landed STRICTLY INSIDE a token to its nearer edge (D-8).
- *
- * An index at either edge, or outside every token, is returned unchanged -- so
- * this is a no-op on a buffer with no tokens, which is every buffer today.
- */
-export function snapOutOfToken(buffer, cursor) {
-    for (const span of tokenSpans(buffer)) {
-        if (cursor <= span.start || cursor >= span.end)
-            continue;
-        return cursor - span.start <= span.end - cursor ? span.start : span.end;
-    }
-    return cursor;
-}
-/**
- * Grow `[from, to)` so it covers every token it partially overlaps (G5).
- *
- * This is what makes `Backspace` immediately after `...lines]` remove the whole
- * token in ONE keystroke, and what stops `Ctrl+W` / `Ctrl+U` / `Ctrl+K` leaving
- * half a token -- and therefore an unparseable label -- behind.
- */
-export function expandRangeOverTokens(buffer, from, to) {
-    let lo = Math.min(from, to);
-    let hi = Math.max(from, to);
-    for (const span of tokenSpans(buffer)) {
-        if (span.start < hi && lo < span.end) {
-            lo = Math.min(lo, span.start);
-            hi = Math.max(hi, span.end);
-        }
-    }
-    return { from: lo, to: hi };
-}
-/**
- * Replace every token whose id is present in `pastes`; leave the rest verbatim.
- *
- * A user who literally TYPES `[Pasted text #3 +9 lines]` while paste #3 exists in
- * the same draft will have it expanded. That is bounded (ids are per process, the
- * map is per draft) and harmless (they get text that is already in their own
- * draft), and the alternative -- an unguessable nonce in the label -- would trade
- * a case nobody hits for a label nobody can read.
- */
-export function expandPastes(buffer, pastes) {
-    if (pastes.size === 0)
-        return buffer;
-    return buffer.replace(pasteTokenRe(), (match, idText) => {
-        const record = pastes.get(Number(idText));
-        return record ? record.text : match;
-    });
-}
-/** Ids still referenced by the buffer -- the input to I-7's prune. */
-export function referencedIds(buffer) {
-    const ids = new Set();
-    for (const m of buffer.matchAll(pasteTokenRe()))
-        ids.add(Number(m[1]));
-    return ids;
-}

package/dist/ui/render-cache.d.ts

@@ -1,81 +0,0 @@
-/**
- * Render caches (tui-render-performance L2 / R2 + R3).
- *
- * Ink has no output caching: every frame re-walks the whole mounted tree,
- * re-measures every text node and re-serialises the frame. The two most
- * expensive PURE computations in that walk were being redone from scratch on
- * every one of them:
- *
- *   - `cli-highlight`'s `highlight()` ran INSIDE `CodeBlock`'s render body, so a
- *     200-line fenced block was a complete highlight.js tokenise, 30 times a
- *     second, for as long as it stayed mounted;
- *   - `Markdown` re-split and re-regexed the whole answer into one React element
- *     per line on every render.
- *
- * Cached text depends on its input and, for highlighting, the color level. Theme and
- * glyphs are applied at render time and are never cached, because a themed
- * React element in a cache makes `/theme` a no-op until the entry evicts (K-5) —
- * exactly the class of silent bug this package writes comments to avoid.
- *
- * Caches are MODULE-LEVEL on purpose: settled transcript text is identical
- * across component instances and across mount/unmount cycles, so per-instance
- * caches would miss precisely when a scroll brings an old entry back.
- */
-import { type MdBlock } from './markdown-blocks.js';
-import { type Glyphs } from './glyphs.js';
-import type { TermCapabilities } from './capabilities.js';
-export declare const RENDER_CACHE_LIMITS: {
-    readonly highlightEntries: 128;
-    readonly highlightBytes: number;
-    /**
-     * Above this, skip highlighting entirely.
-     *
-     * highlight.js is superlinear in the length of a single block, and a
-     * multi-megabyte "code block" is almost always a pasted log rather than
-     * source. Rendering it plain costs the user nothing they would have been able
-     * to read; tokenising it costs the whole frame budget.
-     */
-    readonly highlightMaxChars: 20000;
-    readonly markdownEntries: 256;
-    readonly markdownBytes: number;
-    readonly linesEntries: 512;
-};
-export interface RenderCacheStats {
-    markdownEntries: number;
-    markdownBytes: number;
-    highlightEntries: number;
-    highlightBytes: number;
-    lineEntries: number;
-    hits: number;
-    misses: number;
-}
-/**
- * Syntax-highlight `code`, memoised on `(colorLevel, lang, code)`.
- *
- * `cli-highlight` emits chalk-level ANSI that does not depend on `theme.*`, so
- * unlike a rendered element this string IS safe to cache across a `/theme`
- * switch — the same property it has had since before this cache existed.
- */
-export declare function highlightCached(code: string, lang: string): string;
-/** Parse a markdown document into blocks, memoised on the whole text. */
-export declare function parseMarkdownCached(text: string): MdBlock[];
-/**
- * `text.split('\n')`, memoised.
- *
- * READ-ONLY BY CONTRACT. The returned array is shared with every other holder of
- * the same string, so a caller that sorts or splices it in place corrupts an
- * unrelated card. The `readonly string[]` return type is the enforcement.
- */
-export declare function splitLinesCached(text: string): readonly string[];
-/**
- * The glyph set for a terminal.
- *
- * `pickGlyphs` already returns one of two module constants, so this adds no
- * caching of its own — it exists so that every render-layer memoisation the
- * transcript depends on is reachable from one module, and so the components can
- * stop calling `pickGlyphs` once per entry per frame through six import paths.
- */
-export declare function glyphsFor(caps: TermCapabilities): Glyphs;
-/** Drop everything. `/perf reset`, and the test suite between cases. */
-export declare function clearRenderCaches(): void;
-export declare function renderCacheStats(): RenderCacheStats;

package/dist/ui/render-cache.js

@@ -1,196 +0,0 @@
-/**
- * Render caches (tui-render-performance L2 / R2 + R3).
- *
- * Ink has no output caching: every frame re-walks the whole mounted tree,
- * re-measures every text node and re-serialises the frame. The two most
- * expensive PURE computations in that walk were being redone from scratch on
- * every one of them:
- *
- *   - `cli-highlight`'s `highlight()` ran INSIDE `CodeBlock`'s render body, so a
- *     200-line fenced block was a complete highlight.js tokenise, 30 times a
- *     second, for as long as it stayed mounted;
- *   - `Markdown` re-split and re-regexed the whole answer into one React element
- *     per line on every render.
- *
- * Cached text depends on its input and, for highlighting, the color level. Theme and
- * glyphs are applied at render time and are never cached, because a themed
- * React element in a cache makes `/theme` a no-op until the entry evicts (K-5) —
- * exactly the class of silent bug this package writes comments to avoid.
- *
- * Caches are MODULE-LEVEL on purpose: settled transcript text is identical
- * across component instances and across mount/unmount cycles, so per-instance
- * caches would miss precisely when a scroll brings an old entry back.
- */
-import { highlight } from 'cli-highlight';
-import { syntaxColorLevel } from './color-runtime.js';
-import { parseMarkdownBlocks } from './markdown-blocks.js';
-import { pickGlyphs } from './glyphs.js';
-export const RENDER_CACHE_LIMITS = {
-    highlightEntries: 128,
-    highlightBytes: 2 * 1024 * 1024,
-    /**
-     * Above this, skip highlighting entirely.
-     *
-     * highlight.js is superlinear in the length of a single block, and a
-     * multi-megabyte "code block" is almost always a pasted log rather than
-     * source. Rendering it plain costs the user nothing they would have been able
-     * to read; tokenising it costs the whole frame budget.
-     */
-    highlightMaxChars: 20_000,
-    markdownEntries: 256,
-    markdownBytes: 4 * 1024 * 1024,
-    linesEntries: 512,
-};
-/**
- * Insertion-ordered LRU with both an entry-count and an approximate byte budget.
- *
- * TWO BUDGETS, NOT ONE. An entry count alone is unbounded in memory (one 5 MB
- * answer), and a byte budget alone is unbounded in Map overhead (a hundred
- * thousand one-character keys). Every cache here can be fed by the model, so
- * both directions have to be closed.
- */
-class LruCache {
-    maxEntries;
-    maxBytes;
-    map = new Map();
-    total = 0;
-    hits = 0;
-    misses = 0;
-    constructor(maxEntries, maxBytes) {
-        this.maxEntries = maxEntries;
-        this.maxBytes = maxBytes;
-    }
-    get(key) {
-        const hit = this.map.get(key);
-        if (hit === undefined) {
-            this.misses += 1;
-            return undefined;
-        }
-        // Re-insert to move the key to the young end of the insertion order.
-        this.map.delete(key);
-        this.map.set(key, hit);
-        this.hits += 1;
-        return hit.value;
-    }
-    set(key, value, bytes) {
-        const existing = this.map.get(key);
-        if (existing)
-            this.total -= existing.bytes;
-        this.map.delete(key);
-        this.map.set(key, { value, bytes });
-        this.total += bytes;
-        while (this.map.size > this.maxEntries || this.total > this.maxBytes) {
-            const oldest = this.map.keys().next();
-            if (oldest.done)
-                break;
-            const entry = this.map.get(oldest.value);
-            if (entry)
-                this.total -= entry.bytes;
-            this.map.delete(oldest.value);
-        }
-        return value;
-    }
-    clear() {
-        this.map.clear();
-        this.total = 0;
-        this.hits = 0;
-        this.misses = 0;
-    }
-    get size() {
-        return this.map.size;
-    }
-    get bytes() {
-        return this.total;
-    }
-}
-const highlightCache = new LruCache(RENDER_CACHE_LIMITS.highlightEntries, RENDER_CACHE_LIMITS.highlightBytes);
-const markdownCache = new LruCache(RENDER_CACHE_LIMITS.markdownEntries, RENDER_CACHE_LIMITS.markdownBytes);
-/**
- * `text.split('\n')` results.
- *
- * Bounded by ENTRY COUNT ONLY, and the byte budget is set to the markdown one
- * because the arrays are views over strings the transcript already holds — they
- * add pointer overhead, not a second copy of the text.
- */
-const lineCache = new LruCache(RENDER_CACHE_LIMITS.linesEntries, RENDER_CACHE_LIMITS.markdownBytes);
-/**
- * Syntax-highlight `code`, memoised on `(colorLevel, lang, code)`.
- *
- * `cli-highlight` emits chalk-level ANSI that does not depend on `theme.*`, so
- * unlike a rendered element this string IS safe to cache across a `/theme`
- * switch — the same property it has had since before this cache existed.
- */
-export function highlightCached(code, lang) {
-    if (code.length === 0)
-        return code;
-    if (code.length > RENDER_CACHE_LIMITS.highlightMaxChars)
-        return code;
-    // The delimiter is written as an ESCAPE and never as a literal control
-    // character: a raw NUL byte makes the whole file "binary" to grep and
-    // ripgrep, which silently hides every definition in it from the tool this
-    // codebase navigates itself with. NUL rather than a space because a space
-    // still lets ("a b", "ts") and ("b", "ts a") collide on one key.
-    const key = `${syntaxColorLevel()}\u0000${lang}\u0000${code}`;
-    const hit = highlightCache.get(key);
-    if (hit !== undefined)
-        return hit;
-    let rendered = code;
-    try {
-        rendered = highlight(code, { language: lang || undefined, ignoreIllegals: true });
-    }
-    catch {
-        rendered = code;
-    }
-    return highlightCache.set(key, rendered, key.length + rendered.length);
-}
-/** Parse a markdown document into blocks, memoised on the whole text. */
-export function parseMarkdownCached(text) {
-    const hit = markdownCache.get(text);
-    if (hit !== undefined)
-        return hit;
-    return markdownCache.set(text, parseMarkdownBlocks(text), text.length * 2);
-}
-/**
- * `text.split('\n')`, memoised.
- *
- * READ-ONLY BY CONTRACT. The returned array is shared with every other holder of
- * the same string, so a caller that sorts or splices it in place corrupts an
- * unrelated card. The `readonly string[]` return type is the enforcement.
- */
-export function splitLinesCached(text) {
-    if (text.length === 0)
-        return EMPTY_LINES;
-    const hit = lineCache.get(text);
-    if (hit !== undefined)
-        return hit;
-    return lineCache.set(text, text.split('\n'), text.length);
-}
-const EMPTY_LINES = [];
-/**
- * The glyph set for a terminal.
- *
- * `pickGlyphs` already returns one of two module constants, so this adds no
- * caching of its own — it exists so that every render-layer memoisation the
- * transcript depends on is reachable from one module, and so the components can
- * stop calling `pickGlyphs` once per entry per frame through six import paths.
- */
-export function glyphsFor(caps) {
-    return pickGlyphs(caps);
-}
-/** Drop everything. `/perf reset`, and the test suite between cases. */
-export function clearRenderCaches() {
-    highlightCache.clear();
-    markdownCache.clear();
-    lineCache.clear();
-}
-export function renderCacheStats() {
-    return {
-        markdownEntries: markdownCache.size,
-        markdownBytes: markdownCache.bytes,
-        highlightEntries: highlightCache.size,
-        highlightBytes: highlightCache.bytes,
-        lineEntries: lineCache.size,
-        hits: markdownCache.hits + highlightCache.hits + lineCache.hits,
-        misses: markdownCache.misses + highlightCache.misses + lineCache.misses,
-    };
-}

package/dist/ui/render-governor.d.ts

@@ -1,54 +0,0 @@
-/**
- * Adaptive render governor (tui-render-performance L4 / R7). Pure, React-free.
- *
- * Neither the streaming coalescer nor Ink adapts when a frame overruns its
- * budget: the coalescer keeps its 33 ms timer, Ink keeps its 32 ms throttle, and
- * the event loop saturates. Renders then queue behind each other on Node's
- * single thread and KEYSTROKES QUEUE BEHIND THE RENDERS — which is what turns a
- * slow frame into an unresponsive terminal.
- *
- * The ladder is the safety net under L1/L2/L3, not a substitute for them: it
- * cannot make a frame cheaper, only rarer. Its job is to turn any residual
- * pathology from a freeze into a visibly slower but still interactive UI.
- *
- * I-L4-1 — the governor changes only HOW OFTEN the view updates. Never what is
- * dispatched, never the order, never the final state. `mergeDeltas` already
- * guarantees that a longer window is simply a larger merge and that any
- * non-delta action flushes the pending run first, so the same event sequence
- * must produce the same final `ViewState` at every rung
- * (`render-governor.test.ts`).
- */
-/** Coalescing intervals, in ms. Rung 0 is the pre-feature `COALESCE_MS`. */
-export declare const GOVERNOR_LADDER: readonly [33, 50, 80, 125, 200, 320];
-/** Step up when a commit costs more than this fraction of the current interval. */
-export declare const GOVERNOR_UP_RATIO = 0.7;
-/**
- * Consecutive cheap frames required before stepping back down.
- *
- * Hysteresis, and it has to be asymmetric: stepping up on one expensive frame
- * and down on one cheap one would oscillate through the whole ladder while a
- * long answer streams past a couple of code blocks.
- */
-export declare const GOVERNOR_DOWN_STREAK = 8;
-export interface GovernorState {
-    rung: number;
-    cheapStreak: number;
-}
-export declare function initialGovernor(): GovernorState;
-/**
- * The coalescing interval for a state.
- *
- * Clamped to `maxIntervalMs` in BOTH directions: `maxRenderIntervalMs = 33`
- * flattens the ladder to one rung, which is the documented way to get the
- * pre-feature cadence without reaching for the kill switch.
- */
-export declare function intervalOf(state: GovernorState, maxIntervalMs: number): number;
-/**
- * Fold one commit's cost into the ladder.
- *
- * `lastCommitMs` covers React reconciliation AND Ink's yoga layout, because Ink
- * computes layout in `onRender`, which React runs before layout effects. It does
- * NOT cover Ink's serialisation and the stdout write, which happen after. In
- * practice layout dominates, and the ladder's job is DIRECTION, not accuracy.
- */
-export declare function stepGovernor(state: GovernorState, lastCommitMs: number, maxIntervalMs: number): GovernorState;