@aragon-agent/cli 0.6.12 → 0.6.13

package/dist/ui/clipboard.js

@@ -1,91 +1,157 @@
-/**
- * Clipboard (tui-selection-and-scroll-follow §4.4.5) — the SINGLE clipboard path
- * for the package. `/copy` and the selection release both come through here.
- *
- * Two mechanisms, both attempted, and the return value names the better one so
- * the toast can say what was SENT rather than claiming a success neither one can
- * confirm:
- *
- *  1. **OSC 52.** It reaches the clipboard of the machine the USER is sitting
- *     at, which is the only correct target over SSH, and it is the only mechanism
- *     that works with no helper binary installed. `/copy` gained SSH support the
- *     moment it moved onto this module.
- *  2. **The platform binary** (`clip` / `pbcopy` / `xclip`), moved here unchanged
- *     from `commands/builtins.ts`, for the local case and for terminals that
- *     ignore OSC 52 (tmux without `set -g set-clipboard on`, R-7).
- *
- * IT TAKES A WRITE *DOOR*, NOT A STREAM, and that is P1-6 rather than taste. In
- * full-screen mode stdout is a `Proxy` in front of the frame differ; an
- * unrecognised chunk there takes `passThrough(true)`, which increments
- * `fallbacks` and — on the first one — raises `onFirstFallback`, wired to
- * `console.warn(FRAME_FALLBACK_NOTICE)`. Sending OSC 52 through the proxy would
- * therefore print a diagnostic at a user who did nothing wrong the first time
- * they copied anything, and would permanently corrupt a counter documented to
- * mean "something wrote to stdout behind Ink's back". The caller supplies
- * `writeForeign` instead, and this module cannot pick the wrong door.
- */
+/** The only clipboard writer. Interaction callers share clipboard-task's coordinator. */
 import { spawn } from 'node:child_process';
 import process from 'node:process';
-/**
- * Ceiling on an OSC 52 payload, in bytes of the ORIGINAL text.
- *
- * xterm's default limit is around 100 000 BASE64 characters and tmux / screen
- * are stricter, so 56 000 source bytes (~74 700 base64) stays inside all three
- * with room to spare. Past it the sequence is skipped rather than truncated: a
- * terminal that drops an over-long OSC 52 leaves the clipboard holding whatever
- * was there before, and half a selection is worse than none.
- */
 export const MAX_OSC52_BYTES = 56_000;
-/** `\x1b]52;c;<base64>\x07` — `c` is the CLIPBOARD selection, not PRIMARY. */
+const CLEANUP_GRACE_MS = 500;
+// clip.exe preserves a supplied BOM and guesses BOM-less UTF-16 incorrectly for
+// short CJK text. Decode stdin explicitly; never interpolate clipboard content.
+const WINDOWS_CLIPBOARD_COMMAND = "$ErrorActionPreference='Stop'; "
+    + '$reader=[IO.StreamReader]::new([Console]::OpenStandardInput(),'
+    + '[Text.UTF8Encoding]::new($false),$false); Set-Clipboard -Value $reader.ReadToEnd()';
+/** Encode the full clipboard selection as UTF-8, without truncating its payload. */
 export function osc52(text) {
-    return `\x1b]52;c;${Buffer.from(text, 'utf-8').toString('base64')}\x07`;
+    return `\x1b]52;c;${Buffer.from(text, 'utf8').toString('base64')}\x07`;
 }
-/** Best-effort clipboard copy via the platform's clipboard CLI. */
-function copyNative(text) {
-    const cmd = process.platform === 'win32'
-        ? { file: 'clip', args: [] }
-        : process.platform === 'darwin'
-            ? { file: 'pbcopy', args: [] }
-            : { file: 'xclip', args: ['-selection', 'clipboard'] };
+function sendOsc52(text, options, fallbackReason) {
+    if (options.signal?.aborted)
+        return { status: 'failed', reason: 'cancelled' };
+    if (Buffer.byteLength(text, 'utf8') > MAX_OSC52_BYTES) {
+        return { status: 'failed', reason: 'too-large' };
+    }
+    if (!options.write)
+        return { status: 'failed', reason: fallbackReason ?? 'unavailable' };
     try {
-        const child = spawn(cmd.file, cmd.args, { stdio: ['pipe', 'ignore', 'ignore'] });
-        child.on('error', () => {
-            /* swallow — clipboard is best-effort, and a missing xclip is ordinary */
-        });
-        child.stdin?.end(text);
-        return true;
+        options.write(osc52(text));
+        return { status: 'sent', via: 'osc52', ...(fallbackReason ? { fallbackReason } : {}) };
     }
     catch {
-        return false;
+        return { status: 'failed', reason: 'write' };
     }
 }
-/**
- * Put `text` on the clipboard and report the best mechanism that was reached.
- *
- * `write` is the foreign-write door (see the module header). Omit it and OSC 52
- * is skipped entirely, which is the correct behaviour for a caller that has no
- * terminal to write to.
- *
- * NEITHER MECHANISM IS DETECTABLE. `spawn` returning without throwing does not
- * mean `xclip` exists, and an OSC 52 sequence a terminal ignores is
- * indistinguishable from one it honours. The return value therefore names what
- * was ATTEMPTED, and every caller's user-facing text is worded accordingly.
- */
-export function copyText(text, write) {
-    if (text.length === 0)
-        return 'none';
-    let sentOsc52 = false;
-    if (write && Buffer.byteLength(text, 'utf-8') <= MAX_OSC52_BYTES) {
+function settledTask(result) {
+    return { result: Promise.resolve(result), released: Promise.resolve() };
+}
+function spawnNative() {
+    const windows = process.platform === 'win32';
+    const file = windows ? 'powershell.exe' : process.platform === 'darwin' ? 'pbcopy' : 'xclip';
+    const args = windows
+        ? ['-NoProfile', '-NonInteractive', '-STA', '-Command', WINDOWS_CLIPBOARD_COMMAND]
+        : file === 'xclip' ? ['-selection', 'clipboard'] : [];
+    return spawn(file, args, {
+        stdio: ['pipe', 'ignore', 'ignore'], shell: false, windowsHide: true,
+    });
+}
+/** Owns a writer through close, even when its user-facing result timed out earlier. */
+class NativeClipboardTask {
+    child;
+    text;
+    options;
+    result;
+    released;
+    resolveResult;
+    resolveReleased;
+    settled = false;
+    closed = false;
+    stopping = false;
+    failure;
+    timer;
+    cleanupTimer;
+    constructor(child, text, options) {
+        this.child = child;
+        this.text = text;
+        this.options = options;
+        this.result = new Promise((resolve) => { this.resolveResult = resolve; });
+        this.released = new Promise((resolve) => { this.resolveReleased = resolve; });
+        child.on('error', this.onError);
+        child.once('close', this.onClose);
+        child.stdin?.on('error', this.onStdinError);
+        options.signal?.addEventListener('abort', this.onAbort, { once: true });
+        this.timer = setTimeout(() => this.stop('timeout'), options.timeoutMs ?? 1500);
+        if (options.signal?.aborted) {
+            this.onAbort();
+            return;
+        }
+        if (!child.stdin) {
+            this.stop('write');
+            return;
+        }
         try {
-            write(osc52(text));
-            sentOsc52 = true;
+            child.stdin.end(Buffer.from(text, 'utf8'));
         }
         catch {
-            // A closed or broken stdout must never turn a copy into a crash.
+            this.stop('write');
         }
     }
-    const sentNative = copyNative(text);
-    if (sentOsc52)
-        return 'osc52';
-    return sentNative ? 'native' : 'none';
+    settle(result) {
+        if (this.settled)
+            return;
+        this.settled = true;
+        clearTimeout(this.timer);
+        clearTimeout(this.cleanupTimer);
+        this.resolveResult(result);
+    }
+    stop(reason) {
+        if (this.closed || this.stopping)
+            return;
+        this.stopping = true;
+        this.failure = reason;
+        clearTimeout(this.timer);
+        // No fallback before close: even a successful kill request is not proof of exit.
+        if (!this.settled) {
+            this.cleanupTimer = setTimeout(() => {
+                this.settle({ status: 'failed', reason });
+            }, CLEANUP_GRACE_MS);
+        }
+        try {
+            this.child.stdin?.destroy();
+        }
+        catch { /* Keep error listeners until close. */ }
+        try {
+            this.child.kill();
+        }
+        catch { /* A failed kill must not release the writer lock. */ }
+    }
+    onAbort = () => {
+        this.settle({ status: 'failed', reason: 'cancelled' });
+        this.stop('cancelled');
+    };
+    onError = () => { this.stop('unavailable'); };
+    onStdinError = () => { this.stop('write'); };
+    onClose = (code) => {
+        this.closed = true;
+        clearTimeout(this.timer);
+        clearTimeout(this.cleanupTimer);
+        this.options.signal?.removeEventListener('abort', this.onAbort);
+        if (!this.settled) {
+            const result = code === 0 && !this.failure
+                ? { status: 'confirmed', via: 'native' }
+                : sendOsc52(this.text, this.options, this.failure ?? 'write');
+            this.settle(result);
+        }
+        this.child.removeListener('error', this.onError);
+        this.child.stdin?.removeListener('error', this.onStdinError);
+        this.resolveReleased();
+    };
+}
+/** Start a copy without rejecting; result and writer release are separate signals. */
+export function startClipboardTask(text, options = {}) {
+    if (options.signal?.aborted)
+        return settledTask({ status: 'failed', reason: 'cancelled' });
+    if (text.length === 0)
+        return settledTask({ status: 'failed', reason: 'empty' });
+    const remote = options.remote ?? Boolean(process.env.SSH_CONNECTION || process.env.SSH_TTY);
+    if (remote)
+        return settledTask(sendOsc52(text, options));
+    let child;
+    try {
+        child = spawnNative();
+    }
+    catch {
+        return settledTask(sendOsc52(text, options, 'unavailable'));
+    }
+    return new NativeClipboardTask(child, text, options);
+}
+/** Promise convenience wrapper; interactive callers must use the shared coordinator. */
+export function copyText(text, options = {}) {
+    return startClipboardTask(text, options).result;
 }

package/dist/ui/composer-limits.d.ts

@@ -22,10 +22,9 @@ export declare const USER_ENTRY_MAX_ROWS = 40;
 /**
  * Ceiling on the composer's DRAFT rows at a given terminal height.
  *
- * Non-decreasing in `terminalRows`. Returning `Infinity` reduces the whole
- * height-bound layer to the rung below it (section 12, S4), which is what makes
- * that stage revertible on its own.
+ * Non-decreasing in `terminalRows`, with one quarter of the terminal available
+ * to the draft and an absolute six-row ceiling shared by rendering and budgets.
  */
 export declare function draftMaxRows(terminalRows: number): number;
-/** The terminal height at which `draftMaxRows` steps from 3 to 6. Pinned by test. */
+/** Compatibility export for the shared hint visibility threshold. */
 export declare const DRAFT_MAX_ROWS_HINT_TIER = 20;

package/dist/ui/composer-limits.js

@@ -33,18 +33,13 @@ const DRAFT_TIER_MIN_ROWS = 20;
 /**
  * Ceiling on the composer's DRAFT rows at a given terminal height.
  *
- * Non-decreasing in `terminalRows`. Returning `Infinity` reduces the whole
- * height-bound layer to the rung below it (section 12, S4), which is what makes
- * that stage revertible on its own.
+ * Non-decreasing in `terminalRows`, with one quarter of the terminal available
+ * to the draft and an absolute six-row ceiling shared by rendering and budgets.
  */
 export function draftMaxRows(terminalRows) {
     if (!Number.isFinite(terminalRows))
         return 3;
-    if (terminalRows >= 30)
-        return 10;
-    if (terminalRows >= DRAFT_TIER_MIN_ROWS)
-        return 6;
-    return 3;
+    return Math.max(1, Math.min(6, Math.floor(terminalRows / 4)));
 }
-/** The terminal height at which `draftMaxRows` steps from 3 to 6. Pinned by test. */
+/** Compatibility export for the shared hint visibility threshold. */
 export const DRAFT_MAX_ROWS_HINT_TIER = DRAFT_TIER_MIN_ROWS;

package/dist/ui/composer-rows.d.ts

@@ -44,7 +44,7 @@ export interface ComposerLayoutInput {
     readonly maxRows: number;
     readonly active: boolean;
 }
-/** Total display width of a run, using the same table the layout used. */
+/** Width of a displayed run, measured by complete graphemes. */
 export declare function displayWidth(text: string): number;
 /**
  * Wrap `buffer` into rows, locate the caret, and select a window of at most

package/dist/ui/composer-rows.js

@@ -18,65 +18,11 @@
  * 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 stringWidth from 'string-width';
+import { buildEditorVisualMap, graphemes, graphemeWidth } from './editor-navigation.js';
 import { tokenSpans } from './paste-tokens.js';
-/**
- * Columns a TAB advances to.
- *
- * TABS ARE EXPANDED TO SPACES FOR DISPLAY ONLY -- the buffer keeps the tab, so
- * the model receives exactly what was pasted. The alternative is to emit the raw
- * tab and let the terminal expand it, which puts the terminal's tab stop (8) and
- * this module's column arithmetic in disagreement: the row would overflow its box
- * and the terminal would wrap it a second time, which is the corruption the whole
- * feature exists to remove.
- */
-const TAB_WIDTH = 4;
-/**
- * Display width of one code point.
- *
- * The ASCII fast path matters: `layoutComposer` runs on every keystroke and a
- * recalled prompt-history entry can be thousands of characters, so one
- * `string-width` call per character would be the cost this package spent
- * `tui-render-performance` removing.
- */
-function charWidth(ch) {
-    const code = ch.codePointAt(0) ?? 0;
-    if (code >= 0x20 && code < 0x7f)
-        return 1;
-    return stringWidth(ch);
-}
-/** Total display width of a run, using the same table the layout used. */
+/** Width of a displayed run, measured by complete graphemes. */
 export function displayWidth(text) {
-    let w = 0;
-    for (const ch of text)
-        w += charWidth(ch);
-    return w;
-}
-/** Normalize only the visual projection; the editor keeps its UTF-16 index. */
-function visualCursor(buffer, cursor) {
-    let index = Math.max(0, Math.min(buffer.length, cursor));
-    const code = buffer.charCodeAt(index);
-    const previous = buffer.charCodeAt(index - 1);
-    if (code >= 0xdc00 && code <= 0xdfff && previous >= 0xd800 && previous <= 0xdbff)
-        index -= 1;
-    if (index === buffer.length || buffer[index] === '\n')
-        return index;
-    const ch = String.fromCodePoint(buffer.codePointAt(index));
-    if (ch === '\t' || charWidth(ch) > 0)
-        return index;
-    const start = buffer.lastIndexOf('\n', index - 1) + 1;
-    let nearest = -1;
-    let i = start;
-    while (i < buffer.length && buffer[i] !== '\n') {
-        const point = String.fromCodePoint(buffer.codePointAt(i));
-        if (point === '\t' || charWidth(point) > 0) {
-            if (i > index)
-                return nearest >= 0 ? nearest : i;
-            nearest = i;
-        }
-        i += point.length;
-    }
-    return nearest >= 0 ? nearest : i;
+    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
@@ -89,88 +35,29 @@ function visualCursor(buffer, cursor) {
  */
 export function layoutComposer(input) {
     const { buffer, active } = input;
-    const cursor = visualCursor(buffer, input.cursor);
-    const cols = Math.max(1, Math.floor(input.cols));
     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;
-    /** Monotonic in `index`, which is why the pointer is safe. */
-    const kindAt = (index) => {
-        while (spanIndex < spans.length && spans[spanIndex].end <= index)
-            spanIndex += 1;
-        const span = spans[spanIndex];
-        return span && index >= span.start && index < span.end ? 'token' : 'text';
-    };
-    const rows = [];
-    let segments = [];
-    let col = 0;
-    let cursorRowAbs = -1;
-    let cursorCol = 0;
-    const breakRow = () => {
-        rows.push({ segments });
-        segments = [];
-        col = 0;
-    };
-    const append = (text, width, kind) => {
-        const last = segments[segments.length - 1];
-        if (last && last.kind === kind)
-            segments[segments.length - 1] = { text: last.text + text, kind };
-        else
-            segments.push({ text, kind });
-        col += width;
-    };
-    const ensureRoom = (width) => {
-        if (col > 0 && col + width > cols)
-            breakRow();
-    };
-    const length = buffer.length;
-    let i = 0;
-    while (i <= length) {
-        const atCursor = active && i === cursor && cursorRowAbs === -1;
-        if (i === length) {
-            if (atCursor) {
-                ensureRoom(1);
-                cursorRowAbs = rows.length;
-                cursorCol = col;
-            }
-            break;
-        }
-        const ch = String.fromCodePoint(buffer.codePointAt(i));
-        if (ch === '\n') {
-            if (atCursor) {
-                ensureRoom(1);
-                cursorRowAbs = rows.length;
-                cursorCol = col;
-            }
-            breakRow();
-            i += 1;
-            continue;
-        }
-        const kind = kindAt(i);
-        if (ch === '\t') {
-            let advance = TAB_WIDTH - (col % TAB_WIDTH);
-            if (col > 0 && col + advance > cols) {
-                breakRow();
-                advance = TAB_WIDTH;
-            }
-            if (atCursor) {
-                cursorRowAbs = rows.length;
-                cursorCol = col;
-            }
-            append(' '.repeat(advance), advance, kind);
-            i += 1;
-            continue;
-        }
-        const width = charWidth(ch);
-        ensureRoom(width);
-        if (atCursor) {
-            cursorRowAbs = rows.length;
-            cursorCol = col;
+    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 });
         }
-        append(ch, width, kind);
-        i += ch.length;
-    }
-    rows.push({ segments });
+        return { segments };
+    });
     const totalRows = rows.length;
     const cap = Math.max(1, Math.min(maxRows, totalRows));
     let start = Math.max(0, totalRows - cap);
@@ -213,8 +100,8 @@ export function splitRowAtColumn(row, column) {
     const cells = [];
     let leading = '';
     for (const segment of row.segments) {
-        for (const ch of segment.text) {
-            if (charWidth(ch) === 0) {
+        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 };

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

@@ -0,0 +1,45 @@
+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. */
+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

@@ -0,0 +1,85 @@
+/** Shared UTF-16 grapheme boundaries and terminal-cell layout for the editor. */
+import stringWidth from 'string-width';
+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. */
+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, 4 - column % 4)
+            : graphemeWidth(part.text);
+        if (column > 0 && column + width > cols) {
+            breakRow();
+            if (part.text === '\t')
+                width = Math.min(cols, 4);
+        }
+        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

@@ -26,6 +26,7 @@ import { type PasteRecord } from './paste-tokens.js';
 export interface EditorState {
     buffer: string;
     cursor: number;
+    preferredVisualColumn?: number;
     historyIndex: number | null;
     dismissed: boolean;
     sel: number;
@@ -70,9 +71,12 @@ export type EditorAction = {
     cursor: number;
 } | {
     type: 'backspace';
+} | {
+    type: 'delete';
 } | {
     type: 'moveCursor';
     cursor: number;
+    preferredVisualColumn?: number;
 } | {
     type: 'recall';
     buffer: string;