@aragon-agent/cli 0.6.47 → 0.6.48

package/dist/input/limits.d.ts

@@ -1,118 +0,0 @@
-/**
- * Structural bounds for paste handling (tui-paste-handling D-10 / section 8).
- *
- * THESE ARE STRUCTURAL, NOT POLICY. The package convention recorded in
- * `.claude-index/index.md` is that `limits.ts` carries the numbers an
- * implementation needs to stay bounded, while `config/schema.ts` carries the
- * preferences a user is allowed to have. The only user-facing key this feature
- * adds is the boolean `paste`; a tunable collapse threshold is a preference
- * nobody has asked for, and a kill switch is what a bug report actually needs.
- *
- * The two framing constants below are the only bytes that cross from the stdin
- * filter into the composer, so they are load-bearing in a way a threshold is
- * not: see `PASTE_OPEN`.
- */
-/**
- * Ceiling on ONE paste. Above it the body is dropped and the user is told,
- * never truncated (D-11): a truncated paste loses data and looks like success.
- */
-export declare const PASTE_MAX_BYTES: number;
-/** Ceiling on every live payload in one draft, summed. Above it a paste is refused. */
-export declare const PASTE_DRAFT_MAX_BYTES: number;
-/** Ceiling on collapsed blocks in one draft. Above it a paste is refused. */
-export declare const PASTE_MAX_BLOCKS = 32;
-/**
- * Tier 2's single-line rule: a chunk of at least this many printable characters
- * with no line break is a paste.
- *
- * Safe because coalescing a keyboard burst into 25 characters inside one
- * event-loop turn needs roughly 1 500 WPM. It is a statement about what a
- * KEYBOARD can emit, not about what text looks like.
- */
-export declare const PASTE_MIN_BURST_CHARS = 25;
-/** Tier 2 coalescing window. Ordinary typing never opens it, so never pays it. */
-export declare const PASTE_BURST_MS = 15;
-/**
- * How long an unterminated Tier 1 body is held before it is force-flushed.
- *
- * I-4: an unterminated `\x1b[200~` must never be able to wedge keyboard input,
- * which is the rule `MAX_PENDING_MOUSE_CHARS` already encodes for mouse reports.
- */
-export declare const PASTE_ASSEMBLY_MAX_MS = 2000;
-/**
- * How long a paste-marker head that was ALREADY released to the pass-through as
- * ordinary text may still be recognised as the head of a marker (defect 2: the
- * torn-marker rescue in `stdin-filter.ts`).
- *
- * STRUCTURAL, NOT POLICY: no config key exposes it, because it bounds what the
- * byte stream can physically do -- a marker split across two reads -- and not
- * what a user prefers. What it does NOT do is delay a keystroke: the 12 ms
- * pending-flush window in `stdin-filter.ts` still releases a lone ESC exactly as
- * before, and this window only governs whether that release may be spliced back
- * in front of the next chunk so an assembled marker is consumed, not typed.
- *
- * THE FALSE POSITIVE IS THE TRADE-OFF, AND IT IS ACCEPTED. Firing the rescue
- * wrongly needs the user to press Esc and then TYPE the literal characters
- * `[200~` or `[201~` inside this window -- a sequence no keyboard produces, and
- * at worst five characters of lost typing. Paying that buys a fix for visible
- * `[200~` / `[201~` garbage in the draft, which is the failure the whole paste
- * feature exists to prevent.
- */
-export declare const PASTE_MARKER_RESCAN_TTL_MS = 250;
-/**
- * The inline frame the filter writes into the stream Ink reads (D-3 / I-5).
- *
- * ON THE SAME STREAM, NOT A SIDE CHANNEL. `wrapper.write(text)` is delivered
- * asynchronously; a synchronous side-channel emit would apply the paste BEFORE
- * text that preceded it in the same chunk. Framing preserves order by
- * construction.
- *
- * NUL is the delimiter because no terminal delivers it for any key, and because
- * `sanitisePaste` strips every NUL out of every payload -- so a payload can
- * never forge a frame boundary.
- */
-export declare const PASTE_OPEN = "\0[";
-export declare const PASTE_CLOSE = "\0]";
-/**
- * The inline frame that carries ONE newline intent from the stdin filter to the
- * composer (tui-shift-enter-copy-queue 3.2).
- *
- * SAME FAMILY AS `PASTE_OPEN`, with the same guarantee and for the same reason:
- * NUL is the delimiter because no terminal delivers it for any key, and because
- * `sanitisePaste` strips every NUL out of every payload -- so pasted text can
- * never forge this frame either. A newline intent is single, atomic and carries
- * no payload, so one constant replaces the OPEN/CLOSE pair.
- */
-export declare const ENTER_NEWLINE_FRAME = "\0n";
-/**
- * The inline frame that carries ONE "Ctrl+I was pressed" intent from the stdin
- * filter to `App` (project-indexer Ctrl+I trigger).
- *
- * WHY A FRAME AND NOT `key.ctrl && input === 'i'`. Legacy terminals encode
- * Ctrl+I as the same byte as Tab (0x09), so by the time the stream reaches Ink
- * the two are indistinguishable. Under win32-input-mode (`?9001h`) and kitty
- * CSI-u the modifiers ARE known at translation time, and both translators emit
- * this frame instead of the legacy Tab byte. Same NUL-delimiter guarantee as
- * `ENTER_NEWLINE_FRAME`: no terminal delivers NUL for a key and pasted text is
- * stripped of NUL, so a payload can never forge it. Terminals without keyboard
- * enhancement keep the legacy collapse — Ctrl+I there is Tab, documented in the
- * README keybindings table.
- */
-export declare const INDEX_KEY_FRAME = "\0i";
-/**
- * The one channel from the stdin filter to `App`'s notice dispatch (P1-3 / I-15).
- *
- * The filter is constructed in `cli.tsx` BEFORE `render()`, so it has no
- * `dispatch`. Its only other outlet is the logger, and a limit that writes only
- * to a log file is indistinguishable -- from the user's chair -- from a paste
- * that silently did nothing, which is exactly what D-11 exists to rule out.
- *
- * Same late-bound shape as `selectionBridge` / `updateBridge` / `terminalBridge`:
- * `cli.tsx` creates the object, `App` assigns `notify` on mount and clears it on
- * unmount, and the filter calls `bridge.notify?.(...)`.
- */
-export interface PasteBridge {
-    notify: ((level: 'warn' | 'error', text: string) => void) | null;
-}
-/** Human-readable byte size for the refusal toast (`4.1 MB`, `812.0 KB`, `7 B`). */
-export declare function formatPasteSize(bytes: number): string;

package/dist/input/limits.js

@@ -1,109 +0,0 @@
-/**
- * Structural bounds for paste handling (tui-paste-handling D-10 / section 8).
- *
- * THESE ARE STRUCTURAL, NOT POLICY. The package convention recorded in
- * `.claude-index/index.md` is that `limits.ts` carries the numbers an
- * implementation needs to stay bounded, while `config/schema.ts` carries the
- * preferences a user is allowed to have. The only user-facing key this feature
- * adds is the boolean `paste`; a tunable collapse threshold is a preference
- * nobody has asked for, and a kill switch is what a bug report actually needs.
- *
- * The two framing constants below are the only bytes that cross from the stdin
- * filter into the composer, so they are load-bearing in a way a threshold is
- * not: see `PASTE_OPEN`.
- */
-/**
- * Ceiling on ONE paste. Above it the body is dropped and the user is told,
- * never truncated (D-11): a truncated paste loses data and looks like success.
- */
-export const PASTE_MAX_BYTES = 2 * 1024 * 1024;
-/** Ceiling on every live payload in one draft, summed. Above it a paste is refused. */
-export const PASTE_DRAFT_MAX_BYTES = 8 * 1024 * 1024;
-/** Ceiling on collapsed blocks in one draft. Above it a paste is refused. */
-export const PASTE_MAX_BLOCKS = 32;
-/**
- * Tier 2's single-line rule: a chunk of at least this many printable characters
- * with no line break is a paste.
- *
- * Safe because coalescing a keyboard burst into 25 characters inside one
- * event-loop turn needs roughly 1 500 WPM. It is a statement about what a
- * KEYBOARD can emit, not about what text looks like.
- */
-export const PASTE_MIN_BURST_CHARS = 25;
-/** Tier 2 coalescing window. Ordinary typing never opens it, so never pays it. */
-export const PASTE_BURST_MS = 15;
-/**
- * How long an unterminated Tier 1 body is held before it is force-flushed.
- *
- * I-4: an unterminated `\x1b[200~` must never be able to wedge keyboard input,
- * which is the rule `MAX_PENDING_MOUSE_CHARS` already encodes for mouse reports.
- */
-export const PASTE_ASSEMBLY_MAX_MS = 2_000;
-/**
- * How long a paste-marker head that was ALREADY released to the pass-through as
- * ordinary text may still be recognised as the head of a marker (defect 2: the
- * torn-marker rescue in `stdin-filter.ts`).
- *
- * STRUCTURAL, NOT POLICY: no config key exposes it, because it bounds what the
- * byte stream can physically do -- a marker split across two reads -- and not
- * what a user prefers. What it does NOT do is delay a keystroke: the 12 ms
- * pending-flush window in `stdin-filter.ts` still releases a lone ESC exactly as
- * before, and this window only governs whether that release may be spliced back
- * in front of the next chunk so an assembled marker is consumed, not typed.
- *
- * THE FALSE POSITIVE IS THE TRADE-OFF, AND IT IS ACCEPTED. Firing the rescue
- * wrongly needs the user to press Esc and then TYPE the literal characters
- * `[200~` or `[201~` inside this window -- a sequence no keyboard produces, and
- * at worst five characters of lost typing. Paying that buys a fix for visible
- * `[200~` / `[201~` garbage in the draft, which is the failure the whole paste
- * feature exists to prevent.
- */
-export const PASTE_MARKER_RESCAN_TTL_MS = 250;
-/**
- * The inline frame the filter writes into the stream Ink reads (D-3 / I-5).
- *
- * ON THE SAME STREAM, NOT A SIDE CHANNEL. `wrapper.write(text)` is delivered
- * asynchronously; a synchronous side-channel emit would apply the paste BEFORE
- * text that preceded it in the same chunk. Framing preserves order by
- * construction.
- *
- * NUL is the delimiter because no terminal delivers it for any key, and because
- * `sanitisePaste` strips every NUL out of every payload -- so a payload can
- * never forge a frame boundary.
- */
-export const PASTE_OPEN = '\u0000[';
-export const PASTE_CLOSE = '\u0000]';
-/**
- * The inline frame that carries ONE newline intent from the stdin filter to the
- * composer (tui-shift-enter-copy-queue 3.2).
- *
- * SAME FAMILY AS `PASTE_OPEN`, with the same guarantee and for the same reason:
- * NUL is the delimiter because no terminal delivers it for any key, and because
- * `sanitisePaste` strips every NUL out of every payload -- so pasted text can
- * never forge this frame either. A newline intent is single, atomic and carries
- * no payload, so one constant replaces the OPEN/CLOSE pair.
- */
-export const ENTER_NEWLINE_FRAME = '\u0000n';
-/**
- * The inline frame that carries ONE "Ctrl+I was pressed" intent from the stdin
- * filter to `App` (project-indexer Ctrl+I trigger).
- *
- * WHY A FRAME AND NOT `key.ctrl && input === 'i'`. Legacy terminals encode
- * Ctrl+I as the same byte as Tab (0x09), so by the time the stream reaches Ink
- * the two are indistinguishable. Under win32-input-mode (`?9001h`) and kitty
- * CSI-u the modifiers ARE known at translation time, and both translators emit
- * this frame instead of the legacy Tab byte. Same NUL-delimiter guarantee as
- * `ENTER_NEWLINE_FRAME`: no terminal delivers NUL for a key and pasted text is
- * stripped of NUL, so a payload can never forge it. Terminals without keyboard
- * enhancement keep the legacy collapse — Ctrl+I there is Tab, documented in the
- * README keybindings table.
- */
-export const INDEX_KEY_FRAME = '\u0000i';
-/** Human-readable byte size for the refusal toast (`4.1 MB`, `812.0 KB`, `7 B`). */
-export function formatPasteSize(bytes) {
-    if (bytes >= 1024 * 1024)
-        return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
-    if (bytes >= 1024)
-        return `${(bytes / 1024).toFixed(1)} KB`;
-    return `${bytes} B`;
-}

package/dist/input/mouse-events.d.ts

@@ -1,87 +0,0 @@
-/**
- * Mouse-report parser (mouse-wheel-region-routing §5.1) — pure, stream-free.
- *
- * The alternate screen has no native scrollback, so every modern terminal turns
- * on DEC private mode 1007 (*alternate scroll*) and translates each wheel notch
- * into a burst of arrow keys. Arrow keys carry NO POINTER POSITION, which is
- * why region routing is impossible from that channel and why the CLI asks for
- * real SGR mouse reporting instead (`\x1b[?1000h\x1b[?1006h`).
- *
- * Asking for it is only half the job. Ink 5.2.1 has no mouse branch at all:
- * `parse-keypress.js` fails to match `\x1b[<64;40;12M`, `use-input.js` strips
- * the leading ESC, and `PromptInput`'s `isControlSeq` guard passes the
- * remainder (`[` is 0x5B, >= 0x20) straight into `insert()`. So an unfiltered
- * mouse report is not ignored — it is TYPED INTO THE USER'S MESSAGE. This
- * module exists so `stdin-mouse-filter.ts` can remove every byte of every
- * report before Ink ever sees the chunk (invariant I-1).
- *
- * Every mouse report is CONSUMED here whatever it turns out to be; what changed
- * with tui-selection-and-scroll-follow is that press / drag / release are now
- * EMITTED as well as consumed, so `SelectionController` can build a selection
- * out of them (§4.4.2). They were previously recognized and thrown away.
- */
-export interface WheelEvent {
-    readonly kind: 'wheel';
-    readonly dir: 'up' | 'down';
-    /** 1-based terminal column, as reported. */
-    readonly x: number;
-    /** 1-based terminal row, as reported. */
-    readonly y: number;
-    readonly shift: boolean;
-    readonly alt: boolean;
-    readonly ctrl: boolean;
-}
-export interface ButtonEvent {
-    readonly kind: 'press' | 'drag' | 'release';
-    /** 0 = left, 1 = middle, 2 = right. Never 3 — see `decodeReport`. */
-    readonly button: 0 | 1 | 2;
-    /** 1-based terminal column, as reported. */
-    readonly x: number;
-    /** 1-based terminal row, as reported. */
-    readonly y: number;
-    readonly shift: boolean;
-    readonly alt: boolean;
-    readonly ctrl: boolean;
-}
-export type MouseEvent = WheelEvent | ButtonEvent;
-export interface MouseSplit {
-    /** Mouse events, in arrival order. Unrecognized reports are dropped, not returned. */
-    readonly events: MouseEvent[];
-    /** Everything that was not a mouse report — forward this to Ink verbatim. */
-    readonly text: string;
-    /** Trailing strict prefix of a possible report; feed it back in with the next chunk. */
-    readonly pending: string;
-}
-/**
- * Which wire encoding a report arrived in. It is a PARAMETER rather than a
- * remembered rule because the rule it expresses is invariant I-11 and the cost
- * of forgetting it is a permanently frozen viewport (see `decodeReport`).
- */
-export type MouseEncoding = 'sgr' | 'x10';
-/**
- * Ceiling on the held-back tail. A malformed sequence that looks like a prefix
- * forever must never be able to wedge input: past this length the tail is
- * flushed as ordinary text and parsing resumes from the next byte.
- */
-export declare const MAX_PENDING_MOUSE_CHARS = 32;
-/**
- * True when `s` is a PROPER prefix of a possible mouse report (never a full
- * one). Nothing a keyboard produces matches beyond `\x1b` and `\x1b[`, which is
- * why the filter's flush timer is a rare path rather than a latency tax on
- * typing: ordinary text and pasted blocks contain no `\x1b[<`.
- */
-export declare function isMousePrefix(s: string): boolean;
-/**
- * Split a decoded stdin chunk into mouse events, passthrough text, and a
- * trailing prefix to carry into the next chunk.
- *
- * The caller is expected to feed `pending + nextChunk` back in; ConPTY does
- * split writes mid-sequence, and a report torn across two chunks would
- * otherwise leak its tail into the composer (R-6).
- *
- * ONE CHANNEL, NOT TWO (§4.4.2). Widening this list to carry buttons alongside
- * wheel notches is what keeps ARRIVAL ORDER intact between them; a second
- * channel would let a press overtake the notch that preceded it, and the
- * selection would then be anchored against rows that had already scrolled.
- */
-export declare function splitMouseEvents(buffer: string): MouseSplit;

package/dist/input/mouse-events.js

@@ -1,212 +0,0 @@
-/**
- * Mouse-report parser (mouse-wheel-region-routing §5.1) — pure, stream-free.
- *
- * The alternate screen has no native scrollback, so every modern terminal turns
- * on DEC private mode 1007 (*alternate scroll*) and translates each wheel notch
- * into a burst of arrow keys. Arrow keys carry NO POINTER POSITION, which is
- * why region routing is impossible from that channel and why the CLI asks for
- * real SGR mouse reporting instead (`\x1b[?1000h\x1b[?1006h`).
- *
- * Asking for it is only half the job. Ink 5.2.1 has no mouse branch at all:
- * `parse-keypress.js` fails to match `\x1b[<64;40;12M`, `use-input.js` strips
- * the leading ESC, and `PromptInput`'s `isControlSeq` guard passes the
- * remainder (`[` is 0x5B, >= 0x20) straight into `insert()`. So an unfiltered
- * mouse report is not ignored — it is TYPED INTO THE USER'S MESSAGE. This
- * module exists so `stdin-mouse-filter.ts` can remove every byte of every
- * report before Ink ever sees the chunk (invariant I-1).
- *
- * Every mouse report is CONSUMED here whatever it turns out to be; what changed
- * with tui-selection-and-scroll-follow is that press / drag / release are now
- * EMITTED as well as consumed, so `SelectionController` can build a selection
- * out of them (§4.4.2). They were previously recognized and thrown away.
- */
-/**
- * Ceiling on the held-back tail. A malformed sequence that looks like a prefix
- * forever must never be able to wedge input: past this length the tail is
- * flushed as ordinary text and parsing resumes from the next byte.
- */
-export const MAX_PENDING_MOUSE_CHARS = 32;
-const ESC = '\x1b';
-/** `\x1b[<b;x;yM` (press) or `…m` (release) — the only form we request. */
-const SGR_REPORT = /^\x1b\[<(\d+);(\d+);(\d+)([Mm])/;
-/** A strict prefix of an SGR report: `\x1b[<` plus digits and semicolons. */
-const SGR_PREFIX = /^\x1b\[<[\d;]*$/;
-/**
- * True when `s` is a PROPER prefix of a possible mouse report (never a full
- * one). Nothing a keyboard produces matches beyond `\x1b` and `\x1b[`, which is
- * why the filter's flush timer is a rare path rather than a latency tax on
- * typing: ordinary text and pasted blocks contain no `\x1b[<`.
- */
-export function isMousePrefix(s) {
-    return /^\x1B(\[(<[\d;]*|M[\s\S]{0,2})?)?$/.test(s);
-}
-function modifiers(b) {
-    return { shift: (b & 4) !== 0, alt: (b & 8) !== 0, ctrl: (b & 16) !== 0 };
-}
-/**
- * Decode one report, or `null` when it is a report we consume without acting on.
- *
- * THE ORDER OF THESE TESTS IS THE SPECIFICATION, not a presentation choice.
- * Button 66 (wheel-left) has `b & 1 === 0` and would decode as `'up'`, so the
- * horizontal test has to precede the direction decode; and `b & 32` (motion) has
- * to precede the `final` test, because a drag is reported with `M` exactly as a
- * press is.
- *
- * ═══════════════════════════════════════════════════════════════════════════
- * I-11 — BUTTON EVENTS COME FROM THE SGR PATH ONLY. X10 stays wheel-only, which
- * is exactly the contract it has today.
- *
- * `matchX10` reconstructs a legacy report and hard-codes `final = 'M'`, because
- * X10 HAS NO SEPARATE RELEASE FORM AT ALL — it encodes a release as button 3 of
- * a press. Fed through the table below, an X10 release would become a `press`
- * that is never followed by a `release`, whose `button` is 3 while the type says
- * `0 | 1 | 2`, and whose consequence is a `hold` that is set and never cleared:
- * content anchoring never lets go, the resume timer's third condition never
- * passes, and the transcript is frozen for the rest of the session with nothing
- * raised anywhere.
- *
- * This costs nothing real (D-16): we never REQUEST X10 — `?1006h` is over a
- * decade old and every terminal that implements `?1000` implements it — and a
- * terminal that ignored the SGR request also has no usable drag coordinates past
- * column 223 (R-2). X10 exists in this parser only so a stray report cannot
- * reach the user's draft.
- * ═══════════════════════════════════════════════════════════════════════════
- */
-function decodeReport(b, x, y, final, encoding) {
-    // 1. Wheel. Buttons 64-67 in both encodings.
-    if ((b & 64) !== 0) {
-        // Horizontal wheel (66 = left, 67 = right). Consumed and dropped (non-goal).
-        if ((b & 3) >= 2)
-            return null;
-        // Wheel buttons are press-only; a terminal that ever sent a release for one
-        // must not produce a second step for the same physical notch.
-        if (final !== 'M')
-            return null;
-        return { kind: 'wheel', dir: (b & 1) === 1 ? 'down' : 'up', x, y, ...modifiers(b) };
-    }
-    if (encoding !== 'sgr')
-        return null; // I-11
-    // 2. Motion while a button is held (`?1002h`). `3` is "no button", which
-    //    `?1002` should never send and `?1003` sends constantly — dropping it is
-    //    what keeps an any-event terminal from painting a selection with no button
-    //    down at all.
-    if ((b & 32) !== 0) {
-        const button = b & 3;
-        if (button === 3)
-            return null;
-        return { kind: 'drag', button: button, x, y, ...modifiers(b) };
-    }
-    // 3. Release. In SGR the final byte carries the transition, so this is
-    //    unambiguous — unlike X10, which is why step 1's guard exists.
-    //
-    //    A release whose button field reads `3` is a terminal saying "some button
-    //    came up" without naming it. It is mapped to button 0 rather than dropped:
-    //    the ONE thing a release must always do is let go of `hold`, and dropping
-    //    it would leave the viewport frozen — the exact failure I-11 is about. A
-    //    spurious button-0 release is harmless, because a selection can only exist
-    //    if button 0 was pressed in the first place.
-    if (final === 'm') {
-        const button = b & 3;
-        return { kind: 'release', button: (button === 3 ? 0 : button), x, y, ...modifiers(b) };
-    }
-    // 4. Press.
-    const button = b & 3;
-    if (button === 3)
-        return null;
-    return { kind: 'press', button: button, x, y, ...modifiers(b) };
-}
-/**
- * X10 legacy reports (`\x1b[M` + three chars, each `code - 32`).
- *
- * We never request this encoding — `?1006h` is over a decade old and every
- * terminal that implements `?1000` implements it — but a terminal that ignored
- * the SGR request would fall back to it, and a leaked `\x1b[M` + garbage is
- * exactly the draft corruption I-1 exists to prevent. So it is consumed
- * unconditionally; the coordinates are only trusted when all three bytes are
- * plausible, because `setEncoding('utf8')` mangles raw bytes above 0x7F.
- */
-function matchX10(s) {
-    if (s.length < 6)
-        return { kind: 'partial' };
-    const codes = [s.charCodeAt(3), s.charCodeAt(4), s.charCodeAt(5)];
-    if (codes.some((c) => c < 32 || c > 255))
-        return { kind: 'complete', length: 6, event: null };
-    const [b, x, y] = codes;
-    return {
-        kind: 'complete',
-        length: 6,
-        // `'x10'` is what makes I-11 a property of the code rather than of somebody's
-        // memory: this encoding yields wheel events or nothing, ever.
-        event: decodeReport(b - 32, x - 32, y - 32, 'M', 'x10'),
-    };
-}
-/** Classify the escape sequence starting at `s[0] === ESC`. */
-function matchReport(s) {
-    if (s.length === 1)
-        return { kind: 'partial' }; // lone ESC so far
-    if (s[1] !== '[')
-        return { kind: 'none' };
-    if (s.length === 2)
-        return { kind: 'partial' }; // `\x1b[`
-    if (s[2] === '<') {
-        const m = SGR_REPORT.exec(s);
-        if (m) {
-            const b = Number(m[1]);
-            const x = Number(m[2]);
-            const y = Number(m[3]);
-            return { kind: 'complete', length: m[0].length, event: decodeReport(b, x, y, m[4], 'sgr') };
-        }
-        return SGR_PREFIX.test(s) ? { kind: 'partial' } : { kind: 'none' };
-    }
-    if (s[2] === 'M')
-        return matchX10(s);
-    return { kind: 'none' };
-}
-/**
- * Split a decoded stdin chunk into mouse events, passthrough text, and a
- * trailing prefix to carry into the next chunk.
- *
- * The caller is expected to feed `pending + nextChunk` back in; ConPTY does
- * split writes mid-sequence, and a report torn across two chunks would
- * otherwise leak its tail into the composer (R-6).
- *
- * ONE CHANNEL, NOT TWO (§4.4.2). Widening this list to carry buttons alongside
- * wheel notches is what keeps ARRIVAL ORDER intact between them; a second
- * channel would let a press overtake the notch that preceded it, and the
- * selection would then be anchored against rows that had already scrolled.
- */
-export function splitMouseEvents(buffer) {
-    const events = [];
-    let text = '';
-    let i = 0;
-    while (i < buffer.length) {
-        const esc = buffer.indexOf(ESC, i);
-        if (esc === -1) {
-            text += buffer.slice(i);
-            return { events, text, pending: '' };
-        }
-        text += buffer.slice(i, esc);
-        const rest = buffer.slice(esc);
-        const m = matchReport(rest);
-        if (m.kind === 'complete') {
-            if (m.event)
-                events.push(m.event);
-            i = esc + m.length;
-            continue;
-        }
-        if (m.kind === 'partial') {
-            // A tail that never resolves must not hold input hostage: past the
-            // ceiling it is ordinary text, and parsing continues after the ESC.
-            if (rest.length > MAX_PENDING_MOUSE_CHARS) {
-                text += rest;
-                return { events, text, pending: '' };
-            }
-            return { events, text, pending: rest };
-        }
-        // Not a mouse report — an arrow key, a paste, anything. Emit the ESC and
-        // resume scanning after it so the rest of the sequence reaches Ink intact.
-        text += ESC;
-        i = esc + 1;
-    }
-    return { events, text, pending: '' };
-}

package/dist/input/paste-parse.d.ts

@@ -1,83 +0,0 @@
-/**
- * Paste recognition primitives (tui-paste-handling section 5.1) -- pure,
- * stream-free, no timers.
- *
- * WHY THIS LIVES BELOW INK. `ink/build/components/App.js:131-138` reads stdin on
- * `'readable'` and emits each chunk as one `'input'` event;
- * `parse-keypress.js:145-148` maps the exact string `'\r'` to `name: 'return'`,
- * which `PromptInput` reads as "send the message". A 15-line paste on a Windows
- * console routinely arrives as a dozen chunks that are exactly `"\r"`, and each
- * one SUBMITS THE DRAFT AS IT STOOD. No component-level heuristic can undo a
- * `key.return` that has already fired, so recognition has to happen on the byte
- * stream, in front of Ink -- the same lesson `mouse-events.ts` records.
- *
- * Two tiers feed one framing (D-4). Tier 1 is bracketed paste and is exact;
- * Tier 2 is a heuristic on chunk SHAPE for the terminals that ignore
- * `DECSET 2004`. Both are about what a keyboard can physically emit.
- */
-/** `DECSET 2004` wraps a paste in these two markers. */
-export declare const PASTE_BEGIN_MARK = "\u001B[200~";
-export declare const PASTE_END_MARK = "\u001B[201~";
-/** The longest tail worth holding back while a marker might still complete. */
-export declare const PASTE_MARK_LENGTH: number;
-/**
- * True when `s` is a PROPER prefix of either paste marker (never a whole one).
- *
- * Both markers are held, in every mode, whether or not THIS process enabled DEC
- * 2004 (I-16): the user's shell, `tmux` or a wrapper script may have left it on,
- * and an unconsumed marker is a literal `[200~` typed into the draft -- the
- * exact failure the feature exists to prevent.
- */
-export declare function isPastePrefix(s: string): boolean;
-/**
- * Length of the trailing run of `text` that is a proper prefix of a paste
- * marker, or 0. Shortest match wins, so only the bytes that could still become a
- * marker are held back.
- */
-export declare function trailingPastePrefixLength(text: string): number;
-/**
- * Tier 2: is this chunk a paste, or keystrokes?
- *
- * The PRIMARY rule -- "longer than one character AND contains a line break" --
- * is exactly the shape defect A needs, so the two coincide: any chunk that could
- * submit the draft by accident is classified as a paste. A lone `\r` is the
- * Enter key and stays `'keys'`.
- *
- * The SECONDARY rule needs `PASTE_MIN_BURST_CHARS` printable characters in one
- * chunk. It excludes chunks carrying any C0 byte but TAB, which is what keeps an
- * arrow-key burst (`\x1b[B\x1b[B...`, and every wheel notch translated by
- * alternate scroll) out of the paste path.
- */
-export declare function classifyChunk(text: string, minBurstChars?: number): 'paste' | 'keys';
-/**
- * Make a payload safe to put in a buffer and draw through `<Text>` (G2).
- *
- * 1. CRLF and lone CR both become exactly ONE `\n` -- terminals send CR for a
- *    newline in pasted text, and a lone LF is dropped by Ink's key parser
- *    entirely, so both have to be normalised here or a pasted line break either
- *    submits the message or silently vanishes.
- * 2. Every escape SEQUENCE is removed AS A SEQUENCE (`stripControlSequences`).
- *    Deleting only the introducer byte is what produced the reported defect:
- *    `ESC [ 3 8 ; 2 ; 1 8 ; 5 2 ; 8 6 m` minus its ESC is `[38;2;18;52;86m`,
- *    a run of digits Ink then writes to the terminal as ordinary text -- and it
- *    reached the model, the prompt history and the session file too, because
- *    this function is the only cleaning the payload ever gets.
- * 3. Every remaining C0 byte except `\n` and `\t` is removed. Ink writes
- *    `<Text>` children to the terminal without escaping anything, so a
- *    surviving `\r` overwrites the row it is drawn on and a surviving `ESC`
- *    repaints the frame colours. Sequences are gone by this point, so what is
- *    left for this step is a stray byte, never half of one.
- * 4. DEL and every C1 byte (U+0080..U+009F) go too, and that is NOT padding:
- *    U+009B is the single-byte CSI and U+0085 is NEL, and a terminal that
- *    decodes them acts on them exactly as it acts on `ESC [`. A file pasted out
- *    of a non-UTF-8 editor walks straight through a "strip C0" rule.
- * 5. TAB is KEPT. Indentation is content, and it is what the model receives.
- *    Expanding it is the RENDERERS' job (`ui/display-tab.ts`), so the model
- *    keeps the original indentation while the screen, the composer and the
- *    terminal all agree on what column a TAB lands on.
- *
- * Applied to PAYLOAD ONLY, never to keystrokes, so `Ctrl+A` and Escape keep
- * working. Non-ASCII text (CJK, emoji) is untouched. Idempotent, so the
- * second pass in `ui/paste-frames.ts` stays a byte-identical no-op.
- */
-export declare function sanitisePaste(raw: string): string;