@aragon-agent/cli 0.6.47 → 0.6.48

package/dist/input/control-sequences.d.ts

@@ -1,71 +0,0 @@
-/**
- * Control-SEQUENCE removal for text that crosses a boundary where a terminal
- * escape must never become content (paste-control-sequence-residue, fix A'-1).
- *
- * WHY A DELETE-THE-WHOLE-SEQUENCE RULE EXISTS. Deleting only the introducer
- * byte turns an escape into visible text: `ESC [ 3 8 ; 2 m` loses its ESC and
- * leaves `[38;2m`, which is a run of digits and semicolons somebody then reads
- * on screen and sends to the model. The bytes were never content; the sequence
- * has to go as a unit.
- *
- * WHY IT IS NOT `tools/terminal-output.ts`'s REGEXES MOVED HERE. Those four
- * regexes answer "what does this look like" for a terminal row that is still
- * being written, and they are fed text whose unfinished tail has ALREADY been
- * cut off and parked in a carry by the caller (`sanitizeChunk`,
- * `toDisplayRow`). Pasted text is one-shot: there is no next chunk, so a
- * truncated sequence needs a rule of its own. Measured against the stream
- * version of the same input, `ESC [ 3 8 ; 2 ; 1 8 ; 5 2 ; 8 6` followed by
- * prose loses the first letter of the prose (`n`), and an unterminated OSC
- * leaves its whole body behind.
- *
- * THE FOUR DECISIONS THIS MODULE ENCODES:
- *
- * 1. A sequence introduced by a real introducer byte (`0x1B`, `0x9B`, `0x9D`,
- *    ...) is removed as a unit; bare text that merely LOOKS like the inside of
- *    one (`[38;2;18;52;86m` typed or pasted without an ESC) is left exactly as
- *    it is, character for character.
- * 2. A string-type sequence (OSC / DCS / SOS / PM / APC) runs to BEL or ST, and
- *    an unterminated one is removed UP TO THE END OF ITS LINE. It never crosses
- *    `\n` and never guesses at a terminator: a truncated sequence is the most
- *    common shape in a clipboard, and the only safe reading of it is "the rest
- *    of this line was never text".
- * 3. A truncated CSI loses its introducer and its parameter bytes and NOTHING
- *    ELSE. `ESC [ 3 1 m` split mid-parameter is parameters, not prose, but the
- *    byte after them is the user's own character and must survive.
- * 4. A C1 CSI (`0x9B`) with no parameter byte at all is treated as the stray
- *    control byte it is most likely to be rather than as a sequence, because a
- *    lone `0x9B` followed by one letter is otherwise indistinguishable from a
- *    non-UTF-8 file's stray byte followed by content -- and consuming that
- *    letter would be the very data loss this module exists to prevent.
- *
- * Pure, ASCII-only, React-free, Ink-free, and TOTAL: it never throws and it
- * never reorders or mangles the bytes it keeps. No new dependency.
- */
-/**
- * Remove every escape/control sequence, keeping all other bytes in order.
- *
- * KEEPS `\t`, `\n` AND `\r`: they are line structure, and `\t` inside pasted
- * indentation is content the model is supposed to receive. Stray C0/C1 bytes
- * (and DEL) are NOT this function's job -- they are removed by the caller that
- * wants them gone, so one rule has one owner.
- */
-export declare function stripControlSequences(text: string): string;
-/**
- * True when `text` carries a sequence a KEYBOARD cannot physically produce.
- *
- * Used at the keystroke branch of the stdin filter: a single-line paste that
- * carries ESC fails `classifyChunk`'s two rules (no line break, and
- * `HAS_CONTROL_EXCEPT_TAB`) and would otherwise reach Ink as raw bytes --
- * either typing `[38;2;18;52;86m` with a live ESC into the draft, or throwing
- * an uncaught `TypeError` inside Ink's key parser.
- *
- * THREE THINGS MUST NOT MATCH, and the shapes below are why:
- * - SGR mouse reports (`ESC [ < 0 ; 1 ; 2 m`) are stripped by `splitMouseEvents`
- *   BEFORE this test, and `<` is not a parameter byte, so the SGR rule cannot
- *   see them anyway.
- * - Arrow / function / Home / End keys (`ESC [ A`, `ESC [ 1 ; 5 D`, `ESC [ 3 ~`,
- *   `ESC [ Z`) never end in `m`.
- * - `Alt`+letter (`ESC` followed by one character) has no introducer body, so
- *   the string-type rule does not fire.
- */
-export declare function hasPasteOnlySequence(text: string): boolean;

package/dist/input/control-sequences.js

@@ -1,222 +0,0 @@
-/**
- * Control-SEQUENCE removal for text that crosses a boundary where a terminal
- * escape must never become content (paste-control-sequence-residue, fix A'-1).
- *
- * WHY A DELETE-THE-WHOLE-SEQUENCE RULE EXISTS. Deleting only the introducer
- * byte turns an escape into visible text: `ESC [ 3 8 ; 2 m` loses its ESC and
- * leaves `[38;2m`, which is a run of digits and semicolons somebody then reads
- * on screen and sends to the model. The bytes were never content; the sequence
- * has to go as a unit.
- *
- * WHY IT IS NOT `tools/terminal-output.ts`'s REGEXES MOVED HERE. Those four
- * regexes answer "what does this look like" for a terminal row that is still
- * being written, and they are fed text whose unfinished tail has ALREADY been
- * cut off and parked in a carry by the caller (`sanitizeChunk`,
- * `toDisplayRow`). Pasted text is one-shot: there is no next chunk, so a
- * truncated sequence needs a rule of its own. Measured against the stream
- * version of the same input, `ESC [ 3 8 ; 2 ; 1 8 ; 5 2 ; 8 6` followed by
- * prose loses the first letter of the prose (`n`), and an unterminated OSC
- * leaves its whole body behind.
- *
- * THE FOUR DECISIONS THIS MODULE ENCODES:
- *
- * 1. A sequence introduced by a real introducer byte (`0x1B`, `0x9B`, `0x9D`,
- *    ...) is removed as a unit; bare text that merely LOOKS like the inside of
- *    one (`[38;2;18;52;86m` typed or pasted without an ESC) is left exactly as
- *    it is, character for character.
- * 2. A string-type sequence (OSC / DCS / SOS / PM / APC) runs to BEL or ST, and
- *    an unterminated one is removed UP TO THE END OF ITS LINE. It never crosses
- *    `\n` and never guesses at a terminator: a truncated sequence is the most
- *    common shape in a clipboard, and the only safe reading of it is "the rest
- *    of this line was never text".
- * 3. A truncated CSI loses its introducer and its parameter bytes and NOTHING
- *    ELSE. `ESC [ 3 1 m` split mid-parameter is parameters, not prose, but the
- *    byte after them is the user's own character and must survive.
- * 4. A C1 CSI (`0x9B`) with no parameter byte at all is treated as the stray
- *    control byte it is most likely to be rather than as a sequence, because a
- *    lone `0x9B` followed by one letter is otherwise indistinguishable from a
- *    non-UTF-8 file's stray byte followed by content -- and consuming that
- *    letter would be the very data loss this module exists to prevent.
- *
- * Pure, ASCII-only, React-free, Ink-free, and TOTAL: it never throws and it
- * never reorders or mangles the bytes it keeps. No new dependency.
- */
-/** ESC -- the introducer every terminal shares. */
-const ESC = 0x1b;
-/** LF. No rule in this module may consume it (decision 2). */
-const LF = 0x0a;
-/** BEL terminates an OSC. */
-const BEL = 0x07;
-/** `[` after ESC is CSI, and `\` after ESC is the two-byte ST. */
-const BRACKET = 0x5b;
-const BACKSLASH = 0x5c;
-/** The ASCII second byte of each string-type sequence (`ESC ]`, `ESC P`, ...). */
-const ESC_DCS = 0x50;
-const ESC_SOS = 0x58;
-const ESC_OSC = 0x5d;
-const ESC_PM = 0x5e;
-const ESC_APC = 0x5f;
-/** C1 introducers, as written by a source that is not UTF-8 clean. */
-const C1_CSI = 0x9b;
-const C1_ST = 0x9c;
-const C1_OSC = 0x9d;
-const C1_DCS = 0x90;
-const C1_SOS = 0x98;
-const C1_PM = 0x9e;
-const C1_APC = 0x9f;
-/** Every byte that can START a sequence this module removes. */
-const ANY_INTRODUCER = /[\u001b\u0090\u0098\u009b\u009d\u009e\u009f]/;
-/**
- * `CSI ... m` (SGR), in both encodings: `ESC [ digits ; m` and the single-byte
- * C1 form `0x9B digits ; m`. NO KEY PRESS PRODUCES ONE, which is what makes it
- * usable as the discriminator for an unframed paste in `stdin-filter.ts`.
- */
-const SGR_SEQUENCE = /\u001b\[[0-9;]*m|\u009b[0-9;]*m/;
-/**
- * A string-type introducer followed by at least one body byte. An `Alt`+key
- * press is exactly two bytes, so "introducer plus a body" is already outside
- * what a keyboard can emit.
- */
-const STRING_SEQUENCE = /(?:\u001b[\u0050\u0058\u005d\u005e\u005f]|[\u0090\u0098\u009d\u009e\u009f])[\s\S]/;
-/** CSI final byte: `@` through `~`. */
-function isFinalByte(code) {
-    return code >= 0x40 && code <= 0x7e;
-}
-/** CSI parameter byte: `0` through `?`. */
-function isParamByte(code) {
-    return code >= 0x30 && code <= 0x3f;
-}
-/**
- * CSI intermediate byte: `!` through `/`.
- *
- * SPACE (`0x20`) IS DELIBERATELY EXCLUDED (decision 3). The standard allows it,
- * but a pasted sequence cut mid-parameter is followed by ` ` and then prose,
- * and the first letter of that prose is a legal final byte -- so honouring the
- * space would silently eat it. `CSI Ps SP q` (cursor style) is the only shape
- * that gets worse, and no child process writes that to its stdout.
- */
-function isIntermediateByte(code) {
-    return code >= 0x21 && code <= 0x2f;
-}
-/** True for the C1 introducers that open a string, not a CSI. */
-function isC1StringIntroducer(code) {
-    return code === C1_OSC || code === C1_DCS || code === C1_SOS || code === C1_PM || code === C1_APC;
-}
-/**
- * End of the string-type sequence whose body starts at `from`.
- *
- * Stops AT the line break rather than past it, and reports "consumed to here"
- * for a body that never terminates (decision 2).
- */
-function stringEnd(text, from) {
-    let i = from;
-    while (i < text.length) {
-        const code = text.charCodeAt(i);
-        if (code === BEL || code === C1_ST)
-            return i + 1;
-        if (code === LF)
-            return i;
-        if (code === ESC && text.charCodeAt(i + 1) === BACKSLASH)
-            return i + 2;
-        i += 1;
-    }
-    return i;
-}
-/**
- * End of the CSI whose parameter run starts at `from`.
- *
- * `requireParams` implements decision 4: with no parameter byte at all, a C1
- * CSI is only the introducer byte, and its "final byte" is content.
- */
-function csiEnd(text, from, requireParams) {
-    let i = from;
-    let sawParams = false;
-    while (i < text.length && isParamByte(text.charCodeAt(i))) {
-        sawParams = true;
-        i += 1;
-    }
-    if (requireParams && !sawParams)
-        return from;
-    while (i < text.length && isIntermediateByte(text.charCodeAt(i)))
-        i += 1;
-    if (i < text.length && isFinalByte(text.charCodeAt(i)))
-        return i + 1;
-    return i;
-}
-/** End of the sequence starting with ESC at `index` (decision 1 / 3). */
-function escapeEnd(text, index) {
-    if (index + 1 >= text.length)
-        return index + 1;
-    const next = text.charCodeAt(index + 1);
-    if (next === BRACKET)
-        return csiEnd(text, index + 2, false);
-    if (next === ESC_OSC || next === ESC_DCS || next === ESC_SOS || next === ESC_PM
-        || next === ESC_APC) {
-        return stringEnd(text, index + 2);
-    }
-    if (next === LF)
-        return index + 1;
-    return index + 2;
-}
-/**
- * End of the sequence starting at `index`, or `-1` when no sequence starts
- * there.
- */
-function sequenceEnd(text, index) {
-    const code = text.charCodeAt(index);
-    if (code === ESC)
-        return escapeEnd(text, index);
-    if (code === C1_CSI)
-        return csiEnd(text, index + 1, true);
-    if (isC1StringIntroducer(code)) {
-        return index + 1 >= text.length ? index + 1 : stringEnd(text, index + 1);
-    }
-    return -1;
-}
-/**
- * Remove every escape/control sequence, keeping all other bytes in order.
- *
- * KEEPS `\t`, `\n` AND `\r`: they are line structure, and `\t` inside pasted
- * indentation is content the model is supposed to receive. Stray C0/C1 bytes
- * (and DEL) are NOT this function's job -- they are removed by the caller that
- * wants them gone, so one rule has one owner.
- */
-export function stripControlSequences(text) {
-    if (!ANY_INTRODUCER.test(text))
-        return text;
-    let out = '';
-    let kept = 0;
-    let i = 0;
-    while (i < text.length) {
-        const end = sequenceEnd(text, i);
-        if (end === -1) {
-            i += 1;
-            continue;
-        }
-        out += text.slice(kept, i);
-        i = end;
-        kept = end;
-    }
-    return kept === 0 ? text : out + text.slice(kept);
-}
-/**
- * True when `text` carries a sequence a KEYBOARD cannot physically produce.
- *
- * Used at the keystroke branch of the stdin filter: a single-line paste that
- * carries ESC fails `classifyChunk`'s two rules (no line break, and
- * `HAS_CONTROL_EXCEPT_TAB`) and would otherwise reach Ink as raw bytes --
- * either typing `[38;2;18;52;86m` with a live ESC into the draft, or throwing
- * an uncaught `TypeError` inside Ink's key parser.
- *
- * THREE THINGS MUST NOT MATCH, and the shapes below are why:
- * - SGR mouse reports (`ESC [ < 0 ; 1 ; 2 m`) are stripped by `splitMouseEvents`
- *   BEFORE this test, and `<` is not a parameter byte, so the SGR rule cannot
- *   see them anyway.
- * - Arrow / function / Home / End keys (`ESC [ A`, `ESC [ 1 ; 5 D`, `ESC [ 3 ~`,
- *   `ESC [ Z`) never end in `m`.
- * - `Alt`+letter (`ESC` followed by one character) has no introducer body, so
- *   the string-type rule does not fire.
- */
-export function hasPasteOnlySequence(text) {
-    return SGR_SEQUENCE.test(text) || STRING_SEQUENCE.test(text);
-}

package/dist/input/csiu-keys.d.ts

@@ -1,66 +0,0 @@
-/**
- * CSI-u key translation (posix keyboard-enhancement section of the Shift+Enter
- * newline fix).
- *
- * WHY THIS EXISTS. On macOS/Linux the only lever that makes Shift+Enter
- * distinguishable from Enter is asking the terminal to report modified keys in
- * the CSI-u encoding: kitty's disambiguate mode (`CSI > 1 u`, pushed and popped
- * with `CSI < u`) and xterm's `modifyOtherKeys=2` (`CSI > 4 ; 2 m`, reset with
- * `CSI > 4 m`). iTerm2, kitty, ghostty, WezTerm, foot and Alacritty implement
- * at least one of the two; a terminal implementing neither ignores both bytes,
- * which the conhost probe confirmed is a harmless no-op.
- *
- * WHAT CHANGES IN THE STREAM -- AND WHAT NEVER DOES. Both modes re-encode only
- * keys whose legacy encoding is ambiguous: Ctrl/Ctrl+Shift/Ctrl+Alt+letters and
- * digits, the Enter family, the Escape key (kitty), and Backspace with
- * modifiers. `modifyOtherKeys` is named for the OTHER keys: arrows, Home/End,
- * PgUp/PgDn and F-keys keep their standard `\x1b[1;mA` / `\x1b[m~` encodings,
- * and Shift+printable still types text. So the translator below only ever sees
- * codepoints below 128 plus a few named control codes; anything else (a kitty
- * functional-key code from a mode this app never pushes) passes through
- * untouched, which is exactly the pre-enhancement behaviour.
- *
- * THE CONTRACT mirrors `win32-input-mode.ts`: split, translate back to the
- * legacy bytes, with the modified-Enter family becoming `ENTER_NEWLINE_FRAME`.
- * Pure: no node/React imports.
- */
-/** Enable / disable the two CSI-u report modes (posix side). */
-export declare const CSI_U_ENABLE = "\u001B[>1u\u001B[>4;2m";
-export declare const CSI_U_DISABLE = "\u001B[<u\u001B[>4m";
-export interface CsiUKey {
-    /** The full original sequence, for pass-through. */
-    readonly seq: string;
-    /** First parameter's primary number (the key's codepoint). */
-    readonly code: number;
-    /** Optional `:alternate` sub-parameters of the key field (kitty/mok). */
-    readonly alternates: readonly number[];
-    /** Modifier parameter minus one (bit 1 shift, 2 alt, 4 ctrl), or 0. */
-    readonly mods: number;
-}
-export type CsiUSegment = {
-    kind: 'text';
-    text: string;
-} | {
-    kind: 'key';
-    key: CsiUKey;
-};
-/**
- * Split a chunk into text spans and CSI-u sequences.
- *
- * Grammar accepted: `ESC [ <params> u` where params are digits, `;` and `:`
- * only, and at least one field exists. `\x1b[13;2u` is INCLUDED: with
- * enhancement on, this module owns every `u`-terminated sequence and applies
- * the same Enter semantics `enter-sequences.ts` defines.
- */
-export declare function splitCsiUKeys(text: string): CsiUSegment[];
-/**
- * Translate one CSI-u sequence to the legacy bytes the same keypress would
- * have produced without the report modes (Enter family excepted: a modified
- * Enter becomes the newline frame). Unknown keys pass through unchanged.
- */
-export declare function translateCsiUKey(key: CsiUKey): string;
-/**
- * Length of the trailing run of `text` that could still complete into a
- * CSI-u sequence, or 0. Longest match, mirroring the other families.
- */
-export declare function trailingCsiUPrefixLength(text: string): number;

package/dist/input/csiu-keys.js

@@ -1,181 +0,0 @@
-/**
- * CSI-u key translation (posix keyboard-enhancement section of the Shift+Enter
- * newline fix).
- *
- * WHY THIS EXISTS. On macOS/Linux the only lever that makes Shift+Enter
- * distinguishable from Enter is asking the terminal to report modified keys in
- * the CSI-u encoding: kitty's disambiguate mode (`CSI > 1 u`, pushed and popped
- * with `CSI < u`) and xterm's `modifyOtherKeys=2` (`CSI > 4 ; 2 m`, reset with
- * `CSI > 4 m`). iTerm2, kitty, ghostty, WezTerm, foot and Alacritty implement
- * at least one of the two; a terminal implementing neither ignores both bytes,
- * which the conhost probe confirmed is a harmless no-op.
- *
- * WHAT CHANGES IN THE STREAM -- AND WHAT NEVER DOES. Both modes re-encode only
- * keys whose legacy encoding is ambiguous: Ctrl/Ctrl+Shift/Ctrl+Alt+letters and
- * digits, the Enter family, the Escape key (kitty), and Backspace with
- * modifiers. `modifyOtherKeys` is named for the OTHER keys: arrows, Home/End,
- * PgUp/PgDn and F-keys keep their standard `\x1b[1;mA` / `\x1b[m~` encodings,
- * and Shift+printable still types text. So the translator below only ever sees
- * codepoints below 128 plus a few named control codes; anything else (a kitty
- * functional-key code from a mode this app never pushes) passes through
- * untouched, which is exactly the pre-enhancement behaviour.
- *
- * THE CONTRACT mirrors `win32-input-mode.ts`: split, translate back to the
- * legacy bytes, with the modified-Enter family becoming `ENTER_NEWLINE_FRAME`.
- * Pure: no node/React imports.
- */
-import { ENTER_NEWLINE_FRAME, INDEX_KEY_FRAME } from './limits.js';
-/** Enable / disable the two CSI-u report modes (posix side). */
-export const CSI_U_ENABLE = '\x1b[>1u\x1b[>4;2m';
-export const CSI_U_DISABLE = '\x1b[<u\x1b[>4m';
-const isParamChar = (c) => (c >= '0' && c <= '9') || c === ';' || c === ':';
-/**
- * Split a chunk into text spans and CSI-u sequences.
- *
- * Grammar accepted: `ESC [ <params> u` where params are digits, `;` and `:`
- * only, and at least one field exists. `\x1b[13;2u` is INCLUDED: with
- * enhancement on, this module owns every `u`-terminated sequence and applies
- * the same Enter semantics `enter-sequences.ts` defines.
- */
-export function splitCsiUKeys(text) {
-    const segments = [];
-    let start = 0;
-    let index = 0;
-    while (index < text.length) {
-        if (text[index] !== '\x1b' || text[index + 1] !== '[') {
-            index += 1;
-            continue;
-        }
-        let end = index + 2;
-        while (end < text.length && isParamChar(text[end]))
-            end += 1;
-        if (end >= text.length || text[end] !== 'u') {
-            index += 1;
-            continue;
-        }
-        const key = parseKey(text.slice(index + 2, end), text.slice(index, end + 1));
-        if (!key) {
-            index += 1;
-            continue;
-        }
-        if (index > start)
-            segments.push({ kind: 'text', text: text.slice(start, index) });
-        segments.push({ kind: 'key', key });
-        index = end + 1;
-        start = index;
-    }
-    if (start < text.length)
-        segments.push({ kind: 'text', text: text.slice(start) });
-    return segments;
-}
-/** Parse the parameter body of a CSI-u sequence, or null when malformed. */
-function parseKey(body, seq) {
-    if (body.length === 0)
-        return null;
-    const fields = body.split(';');
-    const keyParts = fields[0]?.split(':').map(Number) ?? [];
-    if (keyParts.some((n) => !Number.isInteger(n) || n < 0 || n > 0x10ffff))
-        return null;
-    const code = keyParts[0];
-    if (code === undefined)
-        return null;
-    let mods = 0;
-    if (fields.length > 1) {
-        const modParts = fields[1]?.split(':').map(Number) ?? [];
-        if (modParts.some((n) => !Number.isInteger(n) || n < 0 || n > 64))
-            return null;
-        const m = modParts[0] ?? 0;
-        mods = Math.max(0, m - 1);
-    }
-    return { seq, code, alternates: keyParts.slice(1), mods };
-}
-/** Control code for Ctrl+letter (a-z -> 1-26), or the char itself. */
-function ctrlByte(char) {
-    if (char >= 97 && char <= 122)
-        return char - 96;
-    if (char >= 65 && char <= 90)
-        return char - 64;
-    return char;
-}
-/**
- * Translate one CSI-u sequence to the legacy bytes the same keypress would
- * have produced without the report modes (Enter family excepted: a modified
- * Enter becomes the newline frame). Unknown keys pass through unchanged.
- */
-export function translateCsiUKey(key) {
-    const m = key.mods;
-    const ctrl = (m & 4) !== 0;
-    const alt = (m & 2) !== 0;
-    const shift = (m & 1) !== 0;
-    if (key.code === 13)
-        return m === 0 ? '\r' : ENTER_NEWLINE_FRAME;
-    if (key.code === 27)
-        return alt ? '\x1b\x1b' : '\x1b';
-    if (key.code === 9) {
-        // A modified Tab codepoint (modifyOtherKeys shape) mirrors the VK_TAB
-        // decision in win32-input-mode.ts: ctrl (without shift/alt) is the
-        // project-indexer trigger frame, shift stays Shift+Tab.
-        if (ctrl && !shift && !alt)
-            return INDEX_KEY_FRAME;
-        return shift ? '\x1b[Z' : '\t';
-    }
-    // Ctrl+I under kitty disambiguate arrives as codepoint 105 with the ctrl
-    // modifier; the generic printable branch below would fold it back onto the
-    // legacy Tab byte, which is exactly the ambiguity the frame exists to break.
-    if (key.code === 105 && ctrl && !shift && !alt)
-        return INDEX_KEY_FRAME;
-    if (key.code === 127) {
-        // POST-normalisation bytes, same rationale as VK_BACK in win32-input-mode.
-        if (alt)
-            return '\x1b\x08';
-        return '\x08';
-    }
-    if (key.code === 32) {
-        // Ctrl+Space is 0x00 in legacy xterm; plain/alt space is the character.
-        if (ctrl)
-            return alt ? '\x1b\x00' : '\x00';
-        return alt ? '\x1b ' : ' ';
-    }
-    if (key.code >= 32 && key.code <= 126) {
-        const char = String.fromCharCode(key.code);
-        if (ctrl) {
-            const code = ctrlByte(key.code);
-            const text = code === key.code ? char : String.fromCharCode(code);
-            return alt ? `\x1b${text}` : text;
-        }
-        if (alt)
-            return `\x1b${char}`;
-        if (shift && key.alternates.length > 0) {
-            const shifted = key.alternates[0];
-            if (shifted !== undefined && shifted > 0)
-                return String.fromCodePoint(shifted);
-        }
-        return char;
-    }
-    // Functional-key codes only appear under modes this app never pushes
-    // (kitty flags 2+); pass them through so behaviour matches the un-enhanced
-    // stream instead of inventing a translation.
-    return key.seq;
-}
-/** True when `s` is a PROPER prefix of some CSI-u sequence. */
-function isCsiUPrefix(s) {
-    if (s.length < 3 || s[0] !== '\x1b' || s[1] !== '[')
-        return false;
-    for (let i = 2; i < s.length; i += 1) {
-        if (!isParamChar(s[i]))
-            return false;
-    }
-    return true;
-}
-/**
- * Length of the trailing run of `text` that could still complete into a
- * CSI-u sequence, or 0. Longest match, mirroring the other families.
- */
-export function trailingCsiUPrefixLength(text) {
-    const max = Math.min(text.length, 32);
-    for (let k = max; k >= 1; k -= 1) {
-        if (isCsiUPrefix(text.slice(text.length - k)))
-            return k;
-    }
-    return 0;
-}

package/dist/input/cursor-report.d.ts

@@ -1,61 +0,0 @@
-/**
- * Cursor Position Report parsing (tui-bottom-anchored-live-region §4.5).
- *
- * The bottom anchor needs one number the writer cannot compute: how many rows are
- * left below the cursor. `ESC[6n` is the only way to ask, and the terminal answers
- * with `ESC[<row>;<col>R` (DECXCPR adds a `?`: `ESC[?<row>;<col>R`) on STDIN —
- * the same stream the user types on. Two things follow, and both live here:
- *
- *  1. THE ANSWER MUST BE STRIPPED BEFORE INK SEES IT. A report that reaches Ink
- *     travels the keystroke path: `[` is 0x5B, so `PromptInput`'s control-sequence
- *     guard passes it through and the user's draft gets `[12;1R` typed into it (the
- *     same class of accident the mouse filter exists to prevent).
- *  2. THE ANSWER CAN ARRIVE IN TWO CHUNKS. ConPTY, tmux and a loaded SSH session
- *     all split reads at arbitrary points, and a half report (`ESC[12`) is worse
- *     than a whole one: `parse-keypress` has no branch for it.
- *
- * Pure functions only, mirroring `mouse-events.ts`: the filter owns the buffering
- * and the timers, this module owns the shapes.
- */
-/** The query for a Cursor Position Report (DSR 6). ASCII by construction. */
-export declare const CURSOR_REPORT_QUERY = "\u001B[6n";
-/** One parsed report. `row`/`col` are 1-based, exactly as the terminal sent them. */
-export interface CursorReport {
-    row: number;
-    col: number;
-}
-export interface CursorReportSplit {
-    /** Text that survives stripping — everything that is not a report. */
-    text: string;
-    /** Reports found in this chunk, in order. */
-    reports: CursorReport[];
-    /** Trailing bytes that could still become a report; hand them to the next chunk. */
-    pending: string;
-}
-/** True when `s` is a non-empty proper prefix of a possible report. */
-export declare function isCursorReportPrefix(s: string): boolean;
-/**
- * Split the reports out of one chunk.
- *
- * `pending` carries the tail that might still complete into a report. It is only
- * ever the LAST fragment: the scan is left to right, so anything before a complete
- * report is settled text.
- */
-export declare function splitCursorReports(text: string): CursorReportSplit;
-/**
- * Length of the trailing run of `text` that is a proper prefix of a report, or 0.
- *
- * LONGEST MATCH WINS, unlike the mouse family's shortest-wins rule. The families are
- * combined with `max()`, so only the longest answer ever survives, and a longer hold
- * is never wrong here: `ESC[1` can still become `ESC[12;1R`, while the shorter
- * answer `ESC` could not describe it. The bound is the longest report the terminals
- * we target emit (DECXCPR with a `?` and three-digit coordinates).
- */
-export declare function trailingCprPrefixLength(text: string): number;
-/** The query bytes, as a function so call sites read as an action rather than a literal. */
-export declare function formatCursorReportQuery(): string;
-/**
- * Rows left below a reported cursor row on a terminal of `rows` rows.
- * `0` means the cursor is already on the last row; `null` when the height is unknown.
- */
-export declare function spaceBelowFromReport(report: CursorReport, rows: number | undefined): number | null;