@aragon-agent/cli 0.6.11 → 0.6.13

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;
@@ -86,6 +90,11 @@ export type EditorAction = {
 } | {
     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

package/dist/ui/editor-reducer.js

@@ -23,6 +23,7 @@
  * Extracted from the component so it is unit-testable without mounting Ink.
  */
 import { expandRangeOverTokens, formatPasteToken, makePasteRecord, referencedIds, shouldCollapse, snapOutOfToken, } from './paste-tokens.js';
+import { snapGrapheme, stepGrapheme } from './editor-navigation.js';
 const NO_PASTES = new Map();
 export const INITIAL_EDITOR_STATE = {
     buffer: '',
@@ -42,7 +43,9 @@ export const INITIAL_EDITOR_STATE = {
  * typing again, so suggestions should come back), and re-homes the selection
  * (the candidate list is about to be recomputed).
  */
-const DRAFT_FLAGS = { historyIndex: null, dismissed: false, sel: 0 };
+const DRAFT_FLAGS = {
+    historyIndex: null, dismissed: false, sel: 0, preferredVisualColumn: undefined,
+};
 /**
  * Drop payloads the buffer no longer references (I-7).
  *
@@ -82,15 +85,18 @@ function withPrune(next) {
 }
 export function editorReducer(state, action) {
     switch (action.type) {
+        case 'adopt':
+            return withPrune(action.state);
         case 'insert': {
             // D-8: typing can never land INSIDE a token. A no-op on a buffer with no
             // tokens, which is every buffer until the first collapse.
-            const cursor = snapOutOfToken(state.buffer, state.cursor);
+            const cursor = snapOutOfToken(state.buffer, snapGrapheme(state.buffer, state.cursor));
+            const buffer = state.buffer.slice(0, cursor) + action.text + state.buffer.slice(cursor);
             return withPrune({
                 ...state,
                 ...DRAFT_FLAGS,
-                buffer: state.buffer.slice(0, cursor) + action.text + state.buffer.slice(cursor),
-                cursor: cursor + action.text.length,
+                buffer,
+                cursor: snapGrapheme(buffer, cursor + action.text.length, true),
             });
         }
         case 'replace':
@@ -98,24 +104,29 @@ export function editorReducer(state, action) {
                 ...state,
                 ...DRAFT_FLAGS,
                 buffer: action.buffer,
-                cursor: action.cursor,
+                cursor: snapGrapheme(action.buffer, action.cursor),
             });
-        case 'backspace': {
-            if (state.cursor <= 0)
+        case 'backspace':
+        case 'delete': {
+            const cursor = snapGrapheme(state.buffer, state.cursor);
+            const backwards = action.type === 'backspace';
+            if (backwards ? cursor <= 0 : cursor >= state.buffer.length)
                 return state;
             // G5: one `Backspace` immediately after `...lines]` removes the whole
             // token and releases its payload, in ONE dispatch.
-            const range = expandRangeOverTokens(state.buffer, state.cursor - 1, state.cursor);
+            const other = stepGrapheme(state.buffer, cursor, backwards ? 'left' : 'right');
+            const range = expandRangeOverTokens(state.buffer, backwards ? other : cursor, backwards ? cursor : other);
+            const buffer = state.buffer.slice(0, range.from) + state.buffer.slice(range.to);
             return withPrune({
                 ...state,
                 ...DRAFT_FLAGS,
-                buffer: state.buffer.slice(0, range.from) + state.buffer.slice(range.to),
-                cursor: range.from,
+                buffer,
+                cursor: snapGrapheme(buffer, range.from),
             });
         }
         case 'input': {
             let buffer = state.buffer;
-            let cursor = snapOutOfToken(buffer, state.cursor);
+            let cursor = snapOutOfToken(buffer, snapGrapheme(buffer, state.cursor));
             let pastes = null;
             for (const segment of action.segments) {
                 const collapse = segment.kind === 'paste' && shouldCollapse(segment.text);
@@ -127,7 +138,7 @@ export function editorReducer(state, action) {
                     pastes.set(record.id, record);
                 }
                 buffer = buffer.slice(0, cursor) + text + buffer.slice(cursor);
-                cursor += text.length;
+                cursor = snapGrapheme(buffer, cursor + text.length, true);
             }
             return withPrune({
                 ...state,
@@ -137,11 +148,15 @@ export function editorReducer(state, action) {
                 ...(pastes ? { pastes } : {}),
             });
         }
-        case 'moveCursor':
+        case 'moveCursor': {
             // NO DRAFT-FLAG RESET. Moving the caret is not an edit: clearing
             // `historyIndex` here would end a history walk the moment the user pressed
             // ← to look at what they recalled.
-            return state.cursor === action.cursor ? state : { ...state, cursor: action.cursor };
+            const cursor = snapGrapheme(state.buffer, action.cursor);
+            const preferredVisualColumn = action.preferredVisualColumn;
+            return state.cursor === cursor && state.preferredVisualColumn === preferredVisualColumn
+                ? state : { ...state, cursor, preferredVisualColumn };
+        }
         case 'recall':
             // `historyIndex` is SET, not reset, which is why recall cannot reuse
             // `replace` — the two differ in exactly the field that keeps the walk
@@ -153,7 +168,8 @@ export function editorReducer(state, action) {
             return withPrune({
                 ...state,
                 buffer: action.buffer,
-                cursor: action.cursor,
+                cursor: snapGrapheme(action.buffer, action.cursor),
+                preferredVisualColumn: undefined,
                 historyIndex: action.historyIndex,
             });
         case 'select':

package/dist/ui/enter-frames.d.ts

@@ -1,37 +1,21 @@
-/**
- * Reading Enter frames back out of an Ink `input` string
- * (tui-shift-enter-copy-queue 3.5) -- pure.
- *
- * The stdin filter rewrites a modified Enter into `ENTER_NEWLINE_FRAME` inline,
- * in stream order, exactly the way it frames a paste. This module is the only
- * place that takes those frames apart again, and it handles BOTH newline
- * sources the composer can see in one `input` string:
- *
- *  - `ENTER_NEWLINE_FRAME` -- Shift+Enter / Alt+Enter / CSI-u Enter, translated
- *    by the filter; and
- *  - a bare `\n` -- Ctrl+J, which Ink parses to `name: 'enter'` with
- *    `input === '\n'` and NO `key.return`, so it reaches this branch as an
- *    ordinary (control) character that must still mean "newline".
- *
- * I-12, THE BROADCAST OBLIGATION, APPLIES TO THESE FRAMES TOO. `useInput`
- * re-emits every chunk to every mounted handler, `stripPasteFrames` does not
- * know this frame, and a NUL appended into `SettingsScreen`'s API-key field
- * renders as nothing and silently breaks authentication -- the exact accident
- * class that function's own doc records. `stripEnterFrames` is the equivalent
- * guard for overlays with no paste model of their own.
- */
-import { type FrameSegment } from './paste-frames.js';
+export type ComposerFrame = {
+    kind: 'text';
+    text: string;
+} | {
+    kind: 'paste';
+    text: string;
+} | {
+    kind: 'newline';
+} | {
+    kind: 'submit';
+};
 /** True when this `input` carries at least one Enter frame -- the branch guard. */
 export declare function hasEnterFrame(input: string): boolean;
 /**
- * Split an `input` string into ordered text runs and newline runs.
- *
- * Text-only by construction (paste frames are `mergeWithPasteRuns`'s job), so
- * the paste id never has to exist here -- `PromptInput` allocates ids for paste
- * segments while building the reducer's action, exactly as the paste branch
- * does (P1-5: the reducer stays pure and this stays a function of its input).
+ * Decode paste regions before interpreting CR/LF or newline frames as keys.
+ * Paste IDs remain the caller's responsibility.
  */
-export declare function splitEnterFrames(input: string): FrameSegment[];
+export declare function splitEnterFrames(input: string): ComposerFrame[];
 /**
  * Merge newline runs with the paste frames that share the same `input`.
  *
@@ -48,7 +32,7 @@ export declare function splitEnterFrames(input: string): FrameSegment[];
  * Paste segments carry NO id here (P1-5); the caller assigns one per segment
  * only when it builds the reducer's action.
  */
-export declare function mergeWithPasteRuns(input: string, runs: FrameSegment[]): FrameSegment[];
+export declare function mergeWithPasteRuns(input: string, runs: ComposerFrame[]): ComposerFrame[];
 /**
  * Remove every Enter frame for a consumer that has no newline model of its
  * own, replacing each frame with `'\n'` (tui-shift-enter-copy-queue 3.5, the

package/dist/ui/enter-frames.js

@@ -1,25 +1,3 @@
-/**
- * Reading Enter frames back out of an Ink `input` string
- * (tui-shift-enter-copy-queue 3.5) -- pure.
- *
- * The stdin filter rewrites a modified Enter into `ENTER_NEWLINE_FRAME` inline,
- * in stream order, exactly the way it frames a paste. This module is the only
- * place that takes those frames apart again, and it handles BOTH newline
- * sources the composer can see in one `input` string:
- *
- *  - `ENTER_NEWLINE_FRAME` -- Shift+Enter / Alt+Enter / CSI-u Enter, translated
- *    by the filter; and
- *  - a bare `\n` -- Ctrl+J, which Ink parses to `name: 'enter'` with
- *    `input === '\n'` and NO `key.return`, so it reaches this branch as an
- *    ordinary (control) character that must still mean "newline".
- *
- * I-12, THE BROADCAST OBLIGATION, APPLIES TO THESE FRAMES TOO. `useInput`
- * re-emits every chunk to every mounted handler, `stripPasteFrames` does not
- * know this frame, and a NUL appended into `SettingsScreen`'s API-key field
- * renders as nothing and silently breaks authentication -- the exact accident
- * class that function's own doc records. `stripEnterFrames` is the equivalent
- * guard for overlays with no paste model of their own.
- */
 import { ENTER_NEWLINE_FRAME, PASTE_CLOSE, PASTE_OPEN } from '../input/limits.js';
 import { sanitisePaste } from '../input/paste-parse.js';
 import { sanitiseTyped } from './paste-frames.js';
@@ -28,10 +6,10 @@ export function hasEnterFrame(input) {
     return input.includes(ENTER_NEWLINE_FRAME);
 }
 /**
- * Split one Enter-frame-free span into ordered text / newline segments.
+ * Split one paste-free span into ordered text, newline and submit intents.
  *
  * Every newline source -- frame or bare `\n` -- yields ONE
- * `{ kind: 'text', text: '\n' }` segment, so the editor's existing `input`
+ * `{ kind: 'newline' }` segment, so the editor's existing `input`
  * action inserts it through the same path typing uses and the draft's row
  * budget applies unchanged. Non-newline text is accumulated and passed through
  * `sanitiseTyped` (I-14): a chunk that carries a frame can also carry the
@@ -51,13 +29,19 @@ function splitEnterSpan(span) {
     while (i < span.length) {
         if (span.startsWith(ENTER_NEWLINE_FRAME, i)) {
             pushText();
-            segments.push({ kind: 'text', text: '\n' });
+            segments.push({ kind: 'newline' });
             i += ENTER_NEWLINE_FRAME.length;
             continue;
         }
+        if (span[i] === '\r') {
+            pushText();
+            segments.push({ kind: 'submit' });
+            i += 1;
+            continue;
+        }
         if (span[i] === '\n') {
             pushText();
-            segments.push({ kind: 'text', text: '\n' });
+            segments.push({ kind: 'newline' });
             i += 1;
             continue;
         }
@@ -68,15 +52,12 @@ function splitEnterSpan(span) {
     return segments;
 }
 /**
- * Split an `input` string into ordered text runs and newline runs.
- *
- * Text-only by construction (paste frames are `mergeWithPasteRuns`'s job), so
- * the paste id never has to exist here -- `PromptInput` allocates ids for paste
- * segments while building the reducer's action, exactly as the paste branch
- * does (P1-5: the reducer stays pure and this stays a function of its input).
+ * Decode paste regions before interpreting CR/LF or newline frames as keys.
+ * Paste IDs remain the caller's responsibility.
  */
 export function splitEnterFrames(input) {
-    return splitEnterSpan(input);
+    return input.includes(PASTE_OPEN)
+        ? mergeWithPasteRuns(input, []) : splitEnterSpan(input);
 }
 /**
  * Merge newline runs with the paste frames that share the same `input`.