@aragon-agent/cli 0.6.46 → 0.6.48

package/dist/ui/composer-rows.js

@@ -1,129 +0,0 @@
-/**
- * Composer layout (tui-paste-handling section 5.5) -- pure. No Ink, no React.
- *
- * THE ONE PLACE THAT MAPS A BUFFER INDEX TO A SCREEN CELL (I-9). The composer
- * used to hand its buffer to Ink one `<Text>` per logical line and let Yoga wrap
- * it, which is fine until the draft is taller than the frame: `AppShell` gives
- * the bottom chrome `flexShrink={0}`, so a tall composer does not grow the frame
- * -- Yoga takes the rows out of the transcript and `overflow: hidden` clips them
- * away, while `layout/budget.ts` keeps telling five consumers the composer is
- * three rows tall. Four hundred presses of `Shift+Enter` do it without pasting
- * anything.
- *
- * So the wrap happens HERE, the row count is a number this module returns, and
- * `budget.ts` is told that number (I-8).
- *
- * HARD WRAP BY DISPLAY COLUMN, NEVER `layout/wrap-rows.ts::wrapToRows` (D-15).
- * That function is a PROSE wrapper: it splits on `/\s+/` and rejoins with single
- * spaces, so it destroys indentation and makes the character-index-to-screen-cell
- * mapping the caret depends on impossible to state, let alone compute.
- */
-import { buildEditorVisualMap, graphemes, graphemeWidth } from './editor-navigation.js';
-import { tokenSpans } from './paste-tokens.js';
-/** Width of a displayed run, measured by complete graphemes. */
-export function displayWidth(text) {
-    return graphemes(text).reduce((width, part) => width + graphemeWidth(part.text), 0);
-}
-/**
- * Wrap `buffer` into rows, locate the caret, and select a window of at most
- * `maxRows` rows that contains it.
- *
- * The window is pinned to the BOTTOM -- where the user is typing -- and pulled up
- * only far enough to keep the caret visible. That is deterministic, which matters
- * because this function holds no state between calls: a scroll offset would have
- * to live in the reducer and would then need its own invalidation rules.
- */
-export function layoutComposer(input) {
-    const { buffer, active } = input;
-    const maxRows = input.maxRows >= 1 ? Math.floor(input.maxRows) : 1;
-    const map = buildEditorVisualMap(input);
-    const cursorRowAbs = active ? map.cursor.row : -1;
-    const cursorCol = map.cursor.column;
-    const spans = tokenSpans(buffer);
-    let spanIndex = 0;
-    const rows = map.rows.map((cells) => {
-        const segments = [];
-        for (const cell of cells) {
-            while (spanIndex < spans.length && spans[spanIndex].end <= cell.index)
-                spanIndex += 1;
-            const span = spans[spanIndex];
-            const kind = span && cell.index >= span.start && cell.index < span.end ? 'token' : 'text';
-            const last = segments[segments.length - 1];
-            if (last && last.kind === kind)
-                segments[segments.length - 1] = {
-                    text: last.text + cell.text, kind,
-                };
-            else
-                segments.push({ text: cell.text, kind });
-        }
-        return { segments };
-    });
-    const totalRows = rows.length;
-    const cap = Math.max(1, Math.min(maxRows, totalRows));
-    let start = Math.max(0, totalRows - cap);
-    if (cursorRowAbs >= 0) {
-        if (cursorRowAbs < start)
-            start = cursorRowAbs;
-        else if (cursorRowAbs >= start + cap)
-            start = Math.min(totalRows - cap, cursorRowAbs - cap + 1);
-    }
-    const windowed = rows.slice(start, start + cap);
-    return {
-        rows: windowed,
-        cursorRow: cursorRowAbs >= 0 ? cursorRowAbs - start : -1,
-        cursorCol,
-        totalRows,
-        hiddenAbove: start,
-        hiddenBelow: totalRows - start - windowed.length,
-    };
-}
-/**
- * Split one row at a display column so the renderer can draw an inverse caret on
- * exactly one cell.
- *
- * Lives here rather than in the component because it walks the SAME width table
- * `layoutComposer` walked (I-9): a second, subtly different measurement is how
- * the caret ends up drawn on a cell that does not hold the character it is on.
- */
-export function splitRowAtColumn(row, column) {
-    const before = [];
-    const after = [];
-    let at = null;
-    let x = 0;
-    const push = (list, text, kind) => {
-        const last = list[list.length - 1];
-        if (last && last.kind === kind)
-            list[list.length - 1] = { text: last.text + text, kind };
-        else
-            list.push({ text, kind });
-    };
-    const cells = [];
-    let leading = '';
-    for (const segment of row.segments) {
-        for (const { text: ch } of graphemes(segment.text)) {
-            if (graphemeWidth(ch) === 0) {
-                const last = cells[cells.length - 1];
-                if (last)
-                    cells[cells.length - 1] = { ...last, text: last.text + ch };
-                else
-                    leading += ch;
-            }
-            else {
-                cells.push({ text: leading + ch, kind: segment.kind });
-                leading = '';
-            }
-        }
-    }
-    // A zero-width-only row keeps its text before the explicitly budgeted space.
-    if (leading)
-        push(before, leading, row.segments[0]?.kind ?? 'text');
-    for (const cell of cells) {
-        const width = displayWidth(cell.text);
-        if (at === null && column >= x && column < x + width)
-            at = cell;
-        else
-            push(at === null ? before : after, cell.text, cell.kind);
-        x += width;
-    }
-    return { before, at, after };
-}

package/dist/ui/console-bridge.d.ts

@@ -1,19 +0,0 @@
-/**
- * Console bridge — invariant I-4 (spec §4.9).
- *
- * `patchConsole: true` makes Ink do `log.clear() → stdout.write(data) →
- * log(lastOutput)`. Under a fixed frame that write pushes the frame down a row
- * and permanently corrupts the line accounting described in §4.2: from then on
- * `eraseLines(previousLineCount)` is off by one and the frame slowly eats the
- * content above it.
- *
- * So full-screen mode runs with `patchConsole: false` and routes `console.*`
- * into the transcript as notice entries, where the output is actually READABLE
- * instead of merely being somewhere on screen. Inline mode keeps Ink's patching.
- */
-import type { NoticeLevel } from '../agent/reducer.js';
-/**
- * Hijack `console.*` for the lifetime of the returned restore function.
- * Returns a restore callback; calling it twice is harmless.
- */
-export declare function installConsoleBridge(sink: (level: NoticeLevel, text: string) => void): () => void;

package/dist/ui/console-bridge.js

@@ -1,52 +0,0 @@
-/**
- * Console bridge — invariant I-4 (spec §4.9).
- *
- * `patchConsole: true` makes Ink do `log.clear() → stdout.write(data) →
- * log(lastOutput)`. Under a fixed frame that write pushes the frame down a row
- * and permanently corrupts the line accounting described in §4.2: from then on
- * `eraseLines(previousLineCount)` is off by one and the frame slowly eats the
- * content above it.
- *
- * So full-screen mode runs with `patchConsole: false` and routes `console.*`
- * into the transcript as notice entries, where the output is actually READABLE
- * instead of merely being somewhere on screen. Inline mode keeps Ink's patching.
- */
-import { format } from 'node:util';
-const LEVEL_BY_METHOD = {
-    log: 'info',
-    info: 'info',
-    warn: 'warn',
-    error: 'error',
-    debug: 'info',
-};
-/**
- * Hijack `console.*` for the lifetime of the returned restore function.
- * Returns a restore callback; calling it twice is harmless.
- */
-export function installConsoleBridge(sink) {
-    const methods = Object.keys(LEVEL_BY_METHOD);
-    const originals = new Map();
-    for (const method of methods) {
-        originals.set(method, console[method].bind(console));
-        console[method] = (...args) => {
-            const text = format(...args);
-            if (text.length === 0)
-                return;
-            try {
-                sink(LEVEL_BY_METHOD[method], text);
-            }
-            catch {
-                // A failing sink must never turn a stray console.log into a crash.
-            }
-        };
-    }
-    let restored = false;
-    return () => {
-        if (restored)
-            return;
-        restored = true;
-        for (const [method, original] of originals) {
-            console[method] = original;
-        }
-    };
-}

package/dist/ui/density.d.ts

@@ -1,26 +0,0 @@
-/**
- * Entry spacing policy (spec §4.3).
- *
- * Replaces four unconditional `marginTop={1}` sites (`UserEntry`,
- * `AssistantEntry`, `ToolCard`, the notice branch in `Transcript`). Those spent
- * a blank row on EVERY entry, so a plain "ask -> read a file -> answer" turn was
- * 17 rows tall against a 13-16 row viewport: the user could only ever see the
- * current step.
- *
- * Blank space now marks the one boundary that means something — the start of a
- * new user turn. Everything inside a turn stays contiguous, and the left rail
- * (§4.3) provides the grouping the blank rows used to.
- *
- * Pure and free of React so `density.test.ts` can enumerate the whole matrix.
- */
-import type { Entry } from '../agent/reducer.js';
-import type { DensityMode } from '../config/schema.js';
-export type { DensityMode };
-/**
- * Blank rows to insert BEFORE `next`. `prev === undefined` means `next` is the
- * first item in the list.
- *
- * This is the ONLY place allowed to decide entry spacing: if a component also
- * sets its own `marginTop`, the two stack and the turn boundary becomes 2 rows.
- */
-export declare function separationRows(prev: Entry | undefined, next: Entry, mode: DensityMode): 0 | 1;

package/dist/ui/density.js

@@ -1,34 +0,0 @@
-/**
- * Entry spacing policy (spec §4.3).
- *
- * Replaces four unconditional `marginTop={1}` sites (`UserEntry`,
- * `AssistantEntry`, `ToolCard`, the notice branch in `Transcript`). Those spent
- * a blank row on EVERY entry, so a plain "ask -> read a file -> answer" turn was
- * 17 rows tall against a 13-16 row viewport: the user could only ever see the
- * current step.
- *
- * Blank space now marks the one boundary that means something — the start of a
- * new user turn. Everything inside a turn stays contiguous, and the left rail
- * (§4.3) provides the grouping the blank rows used to.
- *
- * Pure and free of React so `density.test.ts` can enumerate the whole matrix.
- */
-/**
- * Blank rows to insert BEFORE `next`. `prev === undefined` means `next` is the
- * first item in the list.
- *
- * This is the ONLY place allowed to decide entry spacing: if a component also
- * sets its own `marginTop`, the two stack and the turn boundary becomes 2 rows.
- */
-export function separationRows(prev, next, mode) {
-    if (!prev)
-        return 0;
-    if (mode === 'compact')
-        return 0;
-    // Consecutive tool calls read as one action; keep them tight.
-    if (prev.kind === 'tool' && next.kind === 'tool')
-        return 0;
-    if (next.kind === 'user')
-        return 1;
-    return 0;
-}

package/dist/ui/display-tab.d.ts

@@ -1,51 +0,0 @@
-/**
- * TAB expansion that agrees with the TERMINAL, not with UTF-16 (fix A'-2 of
- * paste-control-sequence-residue).
- *
- * WHY THIS IS A MODULE OF ITS OWN. A TAB has no width; it advances the pen to
- * the next tab stop, so what it occupies depends on where the line currently
- * is. That makes "one TAB" a property of a CURSOR, and the same character was
- * being read three different ways in this package:
- *
- * - `ui/editor-navigation.ts` painted it at FOUR-column stops in the composer,
- * - `entries/UserEntry.tsx` handed the raw byte to `<Text>`, so the terminal
- *   painted it at EIGHT-column stops in the transcript,
- * - `tools/terminal-output.ts` expanded it by UTF-16 code-unit count, so a
- *   pasted `中文<TAB>X` table came out two columns short.
- *
- * A user who pastes a TAB-indented block or an Excel/Word table therefore saw
- * the draft and the sent message disagree about their own text. One function,
- * used by the composer AND by every renderer of stored text, is what makes the
- * "before send" and "after send" rows character-identical.
- *
- * `input/` is the wrong home for it: `cli/input` may depend on `node:stream`
- * and nothing else (`.claude-index/index.md`), and column arithmetic needs the
- * width table. `ui/` already owns that (`selection/selection.ts` uses
- * `string-width` for exactly this reason).
- *
- * Pure, React-free, Ink-free.
- */
-/**
- * Tab stop width, matching every terminal's default.
- *
- * A COPY OF `tools/terminal-output.ts`'s number, on purpose and in the same
- * shape `composer-limits.ts` copies `budget.ts::HINT_MIN_ROWS`: importing the
- * tools module here would point an arrow from `ui/` into `tools/` for one
- * integer, and the two are asserted equal by a test instead. (`tools/` keeps
- * its own expander because its rows are clipped to 200 columns before anyone
- * looks at them, so a code-unit approximation there cannot reach a user.)
- */
-export declare const TAB_WIDTH = 8;
-/**
- * Expand every TAB in `text` to spaces up to the next `TAB_WIDTH` stop, given
- * the display column the first character will be painted at.
- *
- * `fromColumn` is a DISPLAY column, not an offset: a caller that has already
- * painted `中文` must pass 4. Lines are independent -- a `\n` resets the column
- * to zero, because the terminal's pen returns to column 0.
- *
- * Non-ASCII text is measured with `string-width`, which is the whole point: a
- * CJK glyph occupies two cells, and counting it as one space is what left
- * CJK-plus-TAB tables misaligned.
- */
-export declare function expandTabs(text: string, fromColumn?: number): string;

package/dist/ui/display-tab.js

@@ -1,82 +0,0 @@
-/**
- * TAB expansion that agrees with the TERMINAL, not with UTF-16 (fix A'-2 of
- * paste-control-sequence-residue).
- *
- * WHY THIS IS A MODULE OF ITS OWN. A TAB has no width; it advances the pen to
- * the next tab stop, so what it occupies depends on where the line currently
- * is. That makes "one TAB" a property of a CURSOR, and the same character was
- * being read three different ways in this package:
- *
- * - `ui/editor-navigation.ts` painted it at FOUR-column stops in the composer,
- * - `entries/UserEntry.tsx` handed the raw byte to `<Text>`, so the terminal
- *   painted it at EIGHT-column stops in the transcript,
- * - `tools/terminal-output.ts` expanded it by UTF-16 code-unit count, so a
- *   pasted `中文<TAB>X` table came out two columns short.
- *
- * A user who pastes a TAB-indented block or an Excel/Word table therefore saw
- * the draft and the sent message disagree about their own text. One function,
- * used by the composer AND by every renderer of stored text, is what makes the
- * "before send" and "after send" rows character-identical.
- *
- * `input/` is the wrong home for it: `cli/input` may depend on `node:stream`
- * and nothing else (`.claude-index/index.md`), and column arithmetic needs the
- * width table. `ui/` already owns that (`selection/selection.ts` uses
- * `string-width` for exactly this reason).
- *
- * Pure, React-free, Ink-free.
- */
-import stringWidth from 'string-width';
-/**
- * Tab stop width, matching every terminal's default.
- *
- * A COPY OF `tools/terminal-output.ts`'s number, on purpose and in the same
- * shape `composer-limits.ts` copies `budget.ts::HINT_MIN_ROWS`: importing the
- * tools module here would point an arrow from `ui/` into `tools/` for one
- * integer, and the two are asserted equal by a test instead. (`tools/` keeps
- * its own expander because its rows are clipped to 200 columns before anyone
- * looks at them, so a code-unit approximation there cannot reach a user.)
- */
-export const TAB_WIDTH = 8;
-/**
- * Expand every TAB in `text` to spaces up to the next `TAB_WIDTH` stop, given
- * the display column the first character will be painted at.
- *
- * `fromColumn` is a DISPLAY column, not an offset: a caller that has already
- * painted `中文` must pass 4. Lines are independent -- a `\n` resets the column
- * to zero, because the terminal's pen returns to column 0.
- *
- * Non-ASCII text is measured with `string-width`, which is the whole point: a
- * CJK glyph occupies two cells, and counting it as one space is what left
- * CJK-plus-TAB tables misaligned.
- */
-export function expandTabs(text, fromColumn = 0) {
-    if (text.indexOf('\t') === -1)
-        return text;
-    let out = '';
-    let column = Math.max(0, Math.floor(fromColumn));
-    let run = '';
-    for (const part of graphemesOf(text)) {
-        if (part === '\t') {
-            out += run;
-            run = '';
-            const width = TAB_WIDTH - (column % TAB_WIDTH);
-            out += ' '.repeat(width);
-            column += width;
-            continue;
-        }
-        run += part;
-        if (part === '\n')
-            column = 0;
-        else
-            column += stringWidth(part);
-    }
-    return out + run;
-}
-const segmenter = new Intl.Segmenter(undefined, { granularity: 'grapheme' });
-/**
- * Grapheme clusters rather than code units, so a combining mark or an emoji ZWJ
- * sequence advances the column once, exactly as the terminal draws it.
- */
-function graphemesOf(text) {
-    return Array.from(segmenter.segment(text), ({ segment }) => segment);
-}

package/dist/ui/editor-navigation.d.ts

@@ -1,55 +0,0 @@
-export interface EditorGrapheme {
-    readonly text: string;
-    readonly index: number;
-    readonly end: number;
-}
-/** Segment text without changing its UTF-16 offsets or stored whitespace. */
-export declare function graphemes(text: string): EditorGrapheme[];
-/** Snap an arbitrary UTF-16 offset to a complete grapheme boundary. */
-export declare function snapGrapheme(text: string, cursor: number, right?: boolean): number;
-/** Move one complete grapheme, leaving the two buffer edges unchanged. */
-export declare function stepGrapheme(text: string, cursor: number, direction: 'left' | 'right'): number;
-/** Width of one grapheme (ASCII avoids the Unicode width-table lookup). */
-export declare function graphemeWidth(text: string): number;
-export interface VisualCell extends EditorGrapheme {
-    readonly column: number;
-    readonly width: number;
-}
-export interface VisualPosition {
-    readonly index: number;
-    readonly row: number;
-    readonly column: number;
-}
-export interface EditorVisualMap {
-    readonly rows: VisualCell[][];
-    readonly positions: VisualPosition[];
-    readonly cursor: VisualPosition;
-}
-/**
- * Map graphemes to hard-wrapped rows, sharing tab stops and caret reservation.
- *
- * THE TAB STOP IS THE TERMINAL'S (`TAB_WIDTH`), NOT AN EDITOR-SIZED FOUR. It
- * used to be four, while the transcript handed the raw `\t` to `<Text>` and
- * the terminal painted it at eight: the same pasted table sat one column off
- * from itself before and after sending. A tab that would cross the right edge
- * is still clipped to the row (the caret cannot point past the last cell), so
- * a tab STRADDLING the wrap is the one shape where the draft and the stored
- * text can differ by the remainder of the advance.
- */
-export declare function buildEditorVisualMap(input: {
-    buffer: string;
-    cols: number;
-    cursor: number;
-    active?: boolean;
-}): EditorVisualMap;
-/** Move to the closest boundary at or left of the preferred display column. */
-export declare function moveVisualCursor(input: {
-    buffer: string;
-    cursor: number;
-    cols: number;
-    direction: 'up' | 'down';
-    preferredVisualColumn?: number;
-}): {
-    cursor: number;
-    preferredVisualColumn: number;
-} | null;

package/dist/ui/editor-navigation.js

@@ -1,96 +0,0 @@
-/** Shared UTF-16 grapheme boundaries and terminal-cell layout for the editor. */
-import stringWidth from 'string-width';
-import { TAB_WIDTH } from './display-tab.js';
-const segmenter = new Intl.Segmenter(undefined, { granularity: 'grapheme' });
-/** Segment text without changing its UTF-16 offsets or stored whitespace. */
-export function graphemes(text) {
-    return Array.from(segmenter.segment(text), ({ segment, index }) => ({
-        text: segment, index, end: index + segment.length,
-    }));
-}
-/** Snap an arbitrary UTF-16 offset to a complete grapheme boundary. */
-export function snapGrapheme(text, cursor, right = false) {
-    const clamped = Math.max(0, Math.min(text.length, cursor));
-    for (const part of segmenter.segment(text)) {
-        const end = part.index + part.segment.length;
-        if (clamped > part.index && clamped < end)
-            return right ? end : part.index;
-        if (part.index >= clamped)
-            break;
-    }
-    return clamped;
-}
-/** Move one complete grapheme, leaving the two buffer edges unchanged. */
-export function stepGrapheme(text, cursor, direction) {
-    if (direction === 'left')
-        return snapGrapheme(text, Math.max(0, cursor - 1));
-    return snapGrapheme(text, Math.min(text.length, cursor + 1), true);
-}
-/** Width of one grapheme (ASCII avoids the Unicode width-table lookup). */
-export function graphemeWidth(text) {
-    if (text.length === 1 && text >= ' ' && text <= '~')
-        return 1;
-    return stringWidth(text);
-}
-/**
- * Map graphemes to hard-wrapped rows, sharing tab stops and caret reservation.
- *
- * THE TAB STOP IS THE TERMINAL'S (`TAB_WIDTH`), NOT AN EDITOR-SIZED FOUR. It
- * used to be four, while the transcript handed the raw `\t` to `<Text>` and
- * the terminal painted it at eight: the same pasted table sat one column off
- * from itself before and after sending. A tab that would cross the right edge
- * is still clipped to the row (the caret cannot point past the last cell), so
- * a tab STRADDLING the wrap is the one shape where the draft and the stored
- * text can differ by the remainder of the advance.
- */
-export function buildEditorVisualMap(input) {
-    const cols = Math.max(1, Math.floor(input.cols));
-    const cursor = snapGrapheme(input.buffer, input.cursor);
-    const rows = [[]];
-    const positions = [];
-    let column = 0;
-    const breakRow = () => { rows.push([]); column = 0; };
-    const locate = (index) => {
-        positions.push({ index, row: rows.length - 1, column });
-    };
-    for (const part of graphemes(input.buffer)) {
-        if (part.text === '\n') {
-            if (input.active !== false && part.index === cursor && column >= cols)
-                breakRow();
-            locate(part.index);
-            breakRow();
-            continue;
-        }
-        let width = part.text === '\t' ? Math.min(cols, TAB_WIDTH - column % TAB_WIDTH)
-            : graphemeWidth(part.text);
-        if (column > 0 && column + width > cols) {
-            breakRow();
-            if (part.text === '\t')
-                width = Math.min(cols, TAB_WIDTH);
-        }
-        locate(part.index);
-        rows[rows.length - 1].push({ ...part,
-            text: part.text === '\t' ? ' '.repeat(width) : part.text, column, width });
-        column += width;
-    }
-    if (input.active !== false && cursor === input.buffer.length && column >= cols)
-        breakRow();
-    locate(input.buffer.length);
-    const caret = positions.find((position) => position.index === cursor);
-    return { rows, positions, cursor: caret };
-}
-/** Move to the closest boundary at or left of the preferred display column. */
-export function moveVisualCursor(input) {
-    const map = buildEditorVisualMap(input);
-    const row = map.cursor.row + (input.direction === 'up' ? -1 : 1);
-    if (row < 0 || row >= map.rows.length)
-        return null;
-    const preferredVisualColumn = input.preferredVisualColumn ?? map.cursor.column;
-    const candidates = map.positions.filter((position) => position.row === row);
-    let target = candidates[0];
-    for (const position of candidates) {
-        if (position.column <= preferredVisualColumn)
-            target = position;
-    }
-    return target ? { cursor: target.index, preferredVisualColumn } : null;
-}

package/dist/ui/editor-reducer.d.ts

@@ -1,108 +0,0 @@
-/**
- * Composer editor state — F3 of tui-input-flicker-fix (§3.4).
- *
- * Ink creates its container with tag `0` — a LEGACY React root
- * (`ink/build/ink.js:59-61`). In a legacy root, `setState` called outside a
- * React event handler is NOT batched: each call schedules and immediately
- * flushes a synchronous render. `useInput`'s callback runs from a stdin
- * `'data'` listener, which is outside React entirely, so `PromptInput.insert`'s
- * five `setState` calls became five commits, five whole-tree Yoga layouts, and
- * — through Ink's 32 ms leading+trailing throttle — TWO full-frame repaints per
- * printable character (§2 R3). The flicker got worse the faster the user typed,
- * which is exactly what the report described.
- *
- * Collapsing the five always-together pieces of state into one reducer makes a
- * keystroke cost one commit. `fileMatches` deliberately stays a separate
- * `useState` in the component: it is written from the debounced async glob
- * effect, not from the key handler, so folding it in here would couple two
- * unrelated update sources.
- *
- * THE RULE A REVIEWER SHOULD CHECK LINE BY LINE: every branch of the `useInput`
- * callback performs at most ONE `dispatch` and then returns.
- *
- * Extracted from the component so it is unit-testable without mounting Ink.
- */
-import { type PasteRecord } from './paste-tokens.js';
-export interface EditorState {
-    buffer: string;
-    cursor: number;
-    preferredVisualColumn?: number;
-    historyIndex: number | null;
-    dismissed: boolean;
-    sel: number;
-    /**
-     * Payloads for the collapse tokens currently in `buffer`
-     * (tui-paste-handling section 5.3).
-     *
-     * Pruned to `referencedIds(buffer)` on EVERY buffer-changing action and
-     * emptied by `clear` (I-7). Without both, a payload outlives the draft that
-     * referenced it, unbounded, for the whole session.
-     */
-    pastes: ReadonlyMap<number, PasteRecord>;
-}
-/**
- * One run of an `input` chunk that mixed typing and pasting.
- *
- * THE `id` IS ALLOCATED BY THE CALLER (P1-5). React may run a reducer more than
- * once for a single action -- eager evaluation in `dispatchSetState`, base-queue
- * replay after a bailout, StrictMode -- so a counter read and written inside one
- * would skip ids and produce two computed states differing in the token TEXT.
- * `PromptInput` calls `allocatePasteId()` while building these segments, and the
- * reducer stays a pure function of `(state, action)`.
- */
-export type InputSegment = {
-    readonly kind: 'text';
-    readonly text: string;
-} | {
-    readonly kind: 'paste';
-    readonly text: string;
-    readonly id: number;
-};
-/**
- * A `type` and not an `interface` because it is a discriminated union — the one
- * documented exception to this package's interface-first convention.
- */
-export type EditorAction = {
-    type: 'insert';
-    text: string;
-} | {
-    type: 'replace';
-    buffer: string;
-    cursor: number;
-} | {
-    type: 'backspace';
-} | {
-    type: 'delete';
-} | {
-    type: 'moveCursor';
-    cursor: number;
-    preferredVisualColumn?: number;
-} | {
-    type: 'recall';
-    buffer: string;
-    cursor: number;
-    historyIndex: number | null;
-} | {
-    type: 'select';
-    sel: number;
-} | {
-    type: 'dismiss';
-} | {
-    type: 'clear';
-}
-/** Only local reducer-planned states may be adopted; prune token payloads again. */
- | {
-    type: 'adopt';
-    state: EditorState;
-}
-/**
- * ONE chunk of stdin, already split into ordered runs. The only new action,
- * and it is what keeps the one-dispatch-per-key rule true for a chunk that
- * carried both a paste and the keystrokes beside it.
- */
- | {
-    type: 'input';
-    segments: InputSegment[];
-};
-export declare const INITIAL_EDITOR_STATE: EditorState;
-export declare function editorReducer(state: EditorState, action: EditorAction): EditorState;