mistagent 0.1.0

package/dist/src/contexts/KeypressContext.js

@@ -0,0 +1,792 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+/**
+ * KeypressContext — raw stdin keypress parser and event system.
+ *
+ * Bypasses Ink's useInput entirely and parses raw stdin data using a generator
+ * (emitKeys), identical to the approach in the CLI reference implementation.
+ *
+ * Data flow:
+ *   stdin.on('data')
+ *     → createDataListener (buffers chars, drives emitKeys generator)
+ *       → emitKeys* (ANSI escape sequence parser → Key objects)
+ *         → bufferPaste (bracketed paste → single 'paste' event)
+ *           → bufferBackslashEnter (backslash+return → shift+return)
+ *             → [optional] bufferFastReturn (quick returns → newline in non-Kitty mode)
+ *               → nonKeyboardEventFilter (drop mouse / focus events)
+ *                 → broadcast (priority-ordered handlers)
+ */
+import { useStdin } from 'ink';
+import { createContext, useCallback, useContext, useEffect, useRef, } from 'react';
+// ── Constants ──────────────────────────────────────────
+const ESC = '\u001B';
+export const BACKSLASH_ENTER_TIMEOUT = 5;
+export const ESC_TIMEOUT = 50;
+export const PASTE_TIMEOUT = 30_000;
+export const FAST_RETURN_TIMEOUT = 30;
+// ── Priority enum ──────────────────────────────────────
+export var KeypressPriority;
+(function (KeypressPriority) {
+    KeypressPriority[KeypressPriority["Low"] = -100] = "Low";
+    KeypressPriority[KeypressPriority["Normal"] = 0] = "Normal";
+    KeypressPriority[KeypressPriority["High"] = 100] = "High";
+    KeypressPriority[KeypressPriority["Critical"] = 200] = "Critical";
+})(KeypressPriority || (KeypressPriority = {}));
+// ── KEY_INFO_MAP ───────────────────────────────────────
+const KEY_INFO_MAP = {
+    '[200~': { name: 'paste-start' },
+    '[201~': { name: 'paste-end' },
+    '[[A': { name: 'f1' },
+    '[[B': { name: 'f2' },
+    '[[C': { name: 'f3' },
+    '[[D': { name: 'f4' },
+    '[[E': { name: 'f5' },
+    '[1~': { name: 'home' },
+    '[2~': { name: 'insert' },
+    '[3~': { name: 'delete' },
+    '[4~': { name: 'end' },
+    '[5~': { name: 'pageup' },
+    '[6~': { name: 'pagedown' },
+    '[7~': { name: 'home' },
+    '[8~': { name: 'end' },
+    '[11~': { name: 'f1' },
+    '[12~': { name: 'f2' },
+    '[13~': { name: 'f3' },
+    '[14~': { name: 'f4' },
+    '[15~': { name: 'f5' },
+    '[17~': { name: 'f6' },
+    '[18~': { name: 'f7' },
+    '[19~': { name: 'f8' },
+    '[20~': { name: 'f9' },
+    '[21~': { name: 'f10' },
+    '[23~': { name: 'f11' },
+    '[24~': { name: 'f12' },
+    '[A': { name: 'up' },
+    '[B': { name: 'down' },
+    '[C': { name: 'right' },
+    '[D': { name: 'left' },
+    '[E': { name: 'clear' },
+    '[F': { name: 'end' },
+    '[H': { name: 'home' },
+    '[P': { name: 'f1' },
+    '[Q': { name: 'f2' },
+    '[R': { name: 'f3' },
+    '[S': { name: 'f4' },
+    OA: { name: 'up' },
+    OB: { name: 'down' },
+    OC: { name: 'right' },
+    OD: { name: 'left' },
+    OE: { name: 'clear' },
+    OF: { name: 'end' },
+    OH: { name: 'home' },
+    OP: { name: 'f1' },
+    OQ: { name: 'f2' },
+    OR: { name: 'f3' },
+    OS: { name: 'f4' },
+    OZ: { name: 'tab', shift: true },
+    '[[5~': { name: 'pageup' },
+    '[[6~': { name: 'pagedown' },
+    '[9u': { name: 'tab' },
+    '[13u': { name: 'return' },
+    '[27u': { name: 'escape' },
+    '[32u': { name: 'space' },
+    '[127u': { name: 'backspace' },
+    '[57414u': { name: 'return' }, // Numpad Enter
+    '[a': { name: 'up', shift: true },
+    '[b': { name: 'down', shift: true },
+    '[c': { name: 'right', shift: true },
+    '[d': { name: 'left', shift: true },
+    '[e': { name: 'clear', shift: true },
+    '[2$': { name: 'insert', shift: true },
+    '[3$': { name: 'delete', shift: true },
+    '[5$': { name: 'pageup', shift: true },
+    '[6$': { name: 'pagedown', shift: true },
+    '[7$': { name: 'home', shift: true },
+    '[8$': { name: 'end', shift: true },
+    '[Z': { name: 'tab', shift: true },
+    Oa: { name: 'up', ctrl: true },
+    Ob: { name: 'down', ctrl: true },
+    Oc: { name: 'right', ctrl: true },
+    Od: { name: 'left', ctrl: true },
+    Oe: { name: 'clear', ctrl: true },
+    '[2^': { name: 'insert', ctrl: true },
+    '[3^': { name: 'delete', ctrl: true },
+    '[5^': { name: 'pageup', ctrl: true },
+    '[6^': { name: 'pagedown', ctrl: true },
+    '[7^': { name: 'home', ctrl: true },
+    '[8^': { name: 'end', ctrl: true },
+};
+const NUMPAD_MAP = {
+    Oj: '*', Ok: '+', Om: '-', Oo: '/',
+    Op: '0', Oq: '1', Or: '2', Os: '3', Ot: '4',
+    Ou: '5', Ov: '6', Ow: '7', Ox: '8', Oy: '9',
+    On: '.',
+};
+const MAC_ALT_KEY_CHARACTER_MAP = {
+    '\u222B': 'b', // "∫" back one word
+    '\u0192': 'f', // "ƒ" forward one word
+    '\u00B5': 'm', // "µ"
+    '\u03A9': 'z', // "Ω" Option+z
+    '\u00B8': 'Z', // "¸" Option+Shift+z
+    '\u2202': 'd', // "∂" delete word forward
+};
+// ── Helpers ────────────────────────────────────────────
+const kUTF16SurrogateThreshold = 0x10000;
+function charLengthAt(str, i) {
+    if (str.length <= i)
+        return 1;
+    const code = str.codePointAt(i);
+    return code !== undefined && code >= kUTF16SurrogateThreshold ? 2 : 1;
+}
+// ── SGR / X11 mouse sequence detection ─────────────────
+const SGR_MOUSE_REGEX = /^\x1b\[<(\d+);(\d+);(\d+)([mM])/;
+const X11_MOUSE_REGEX = /^\x1b\[M([\s\S]{3})/;
+const FOCUS_IN = `${ESC}[I`;
+const FOCUS_OUT = `${ESC}[O`;
+function isMouseSequence(seq) {
+    return SGR_MOUSE_REGEX.test(seq) || X11_MOUSE_REGEX.test(seq);
+}
+// ── Filter pipeline ────────────────────────────────────
+function nonKeyboardEventFilter(keypressHandler) {
+    return (key) => {
+        if (!isMouseSequence(key.sequence) && key.sequence !== FOCUS_IN && key.sequence !== FOCUS_OUT) {
+            return keypressHandler(key);
+        }
+    };
+}
+function bufferFastReturn(keypressHandler) {
+    let lastKeyTime = 0;
+    return (key) => {
+        const now = Date.now();
+        if (key.name === 'return' && now - lastKeyTime <= FAST_RETURN_TIMEOUT) {
+            return keypressHandler({
+                ...key,
+                name: 'return',
+                shift: true,
+                alt: false,
+                ctrl: false,
+                cmd: false,
+                sequence: '\r',
+                insertable: true,
+            });
+        }
+        else {
+            const result = keypressHandler(key);
+            lastKeyTime = now;
+            return result;
+        }
+    };
+}
+function bufferBackslashEnter(keypressHandler) {
+    const bufferer = (function* () {
+        while (true) {
+            const key = yield;
+            if (key == null)
+                continue;
+            if (key.sequence !== '\\') {
+                keypressHandler(key);
+                continue;
+            }
+            const timeoutId = setTimeout(() => bufferer.next(null), BACKSLASH_ENTER_TIMEOUT);
+            const nextKey = yield;
+            clearTimeout(timeoutId);
+            if (nextKey === null) {
+                keypressHandler(key);
+            }
+            else if (nextKey.name === 'return') {
+                keypressHandler({ ...nextKey, shift: true, sequence: '\r' });
+            }
+            else {
+                keypressHandler(key);
+                keypressHandler(nextKey);
+            }
+        }
+    })();
+    bufferer.next();
+    return (key) => { bufferer.next(key); };
+}
+function bufferPaste(keypressHandler) {
+    const bufferer = (function* () {
+        while (true) {
+            let key = yield;
+            if (key === null)
+                continue;
+            if (key.name !== 'paste-start') {
+                keypressHandler(key);
+                continue;
+            }
+            // Collect paste content. Note: createDataListener already extracts
+            // bracketed paste at the string level, so this loop is only a fallback
+            // for edge cases (e.g. OSC 52 paste or generator-based paste-start).
+            // Use a single timeout for the entire paste, not per character.
+            let buffer = '';
+            const timeoutId = setTimeout(() => bufferer.next(null), PASTE_TIMEOUT);
+            while (true) {
+                key = yield;
+                if (key === null)
+                    break;
+                if (key.name === 'paste-end')
+                    break;
+                buffer += key.sequence;
+            }
+            clearTimeout(timeoutId);
+            if (buffer.length > 0) {
+                keypressHandler({
+                    name: 'paste',
+                    shift: false, alt: false, ctrl: false, cmd: false,
+                    insertable: true,
+                    sequence: buffer,
+                });
+            }
+        }
+    })();
+    bufferer.next();
+    return (key) => { bufferer.next(key); };
+}
+// ── emitKeys generator ─────────────────────────────────
+// Bracketed paste markers (byte-level constants for raw Buffer matching)
+const PASTE_START_BUF = Buffer.from('\x1b[200~');
+const PASTE_END_BUF = Buffer.from('\x1b[201~');
+// Threshold for synthetic paste detection (no bracketed paste markers)
+const SYNTHETIC_PASTE_THRESHOLD = 20;
+/**
+ * Creates the stdin data listener that operates on **raw Buffers**.
+ *
+ * Ink's setRawMode calls stdin.setEncoding('utf8'), which installs a
+ * StringDecoder that permanently corrupts ANSI escape sequences at multi-byte
+ * UTF-8 chunk boundaries (e.g. PASTE_END \x1b[201~ gets destroyed when \x1b
+ * is merged with preceding incomplete CJK bytes → U+FFFD).
+ *
+ * We patch stdin.setEncoding to a no-op before setRawMode, so stdin delivers
+ * raw Buffers. We then find paste markers at the byte level before decoding
+ * to UTF-8, which avoids the corruption entirely.
+ */
+function createDataListener(keypressHandler) {
+    const parser = emitKeys(keypressHandler);
+    parser.next();
+    let timeoutId;
+    // When a bracketed paste spans multiple data chunks, we accumulate raw bytes.
+    let pasteAccumulator = null;
+    let pasteTimeoutId;
+    const emitPaste = (content) => {
+        const str = content.toString('utf8');
+        if (str.length > 0) {
+            keypressHandler({
+                name: 'paste',
+                shift: false, alt: false, ctrl: false, cmd: false,
+                insertable: true,
+                sequence: str,
+            });
+        }
+    };
+    /** Feed a string through the emitKeys generator character by character. */
+    const feedParser = (str) => {
+        for (const char of str) {
+            parser.next(char);
+        }
+    };
+    /** Flush the paste accumulator, stripping any trailing partial PASTE_END bytes. */
+    const flushAccumulator = () => {
+        if (pasteAccumulator === null)
+            return;
+        const content = Buffer.concat(pasteAccumulator);
+        pasteAccumulator = null;
+        const trimmed = stripTrailingPartialMarker(content, PASTE_END_BUF);
+        emitPaste(trimmed);
+    };
+    /**
+     * Search for PASTE_END_BUF in a combined buffer that spans the junction of
+     * prevTail (last N bytes of previous accumulator chunk) and newBuf.
+     *
+     * Returns:
+     *   { found: true, prevKeep: number, newSkip: number }
+     *     — prevKeep: how many bytes of prevTail to keep (before the marker)
+     *     — newSkip: how many bytes into newBuf the marker ends
+     *   { found: false } — no cross-boundary match
+     */
+    const findCrossBoundaryEnd = (prevTail, newBuf) => {
+        const marker = PASTE_END_BUF;
+        // The marker could start at any offset within prevTail, as long as part
+        // of it falls in newBuf. Check each possible split point.
+        for (let splitAt = 1; splitAt < marker.length; splitAt++) {
+            // splitAt bytes of the marker are at the end of prevTail,
+            // (marker.length - splitAt) bytes are at the start of newBuf.
+            const tailPortion = marker.subarray(0, splitAt);
+            const headPortion = marker.subarray(splitAt);
+            if (prevTail.length < splitAt)
+                continue;
+            if (newBuf.length < headPortion.length)
+                continue;
+            const tailMatch = prevTail
+                .subarray(prevTail.length - splitAt)
+                .equals(tailPortion);
+            const headMatch = newBuf
+                .subarray(0, headPortion.length)
+                .equals(headPortion);
+            if (tailMatch && headMatch) {
+                return {
+                    found: true,
+                    prevKeep: prevTail.length - splitAt,
+                    newSkip: headPortion.length,
+                };
+            }
+        }
+        return { found: false };
+    };
+    return (data) => {
+        const buf = Buffer.isBuffer(data) ? data : Buffer.from(data);
+        clearTimeout(timeoutId);
+        // ── Fast path: currently accumulating a multi-chunk bracketed paste ──
+        if (pasteAccumulator !== null) {
+            clearTimeout(pasteTimeoutId);
+            // First: check if PASTE_END spans the boundary between previous chunk
+            // tail and the start of this new chunk.
+            const lastChunk = pasteAccumulator[pasteAccumulator.length - 1];
+            const tailLen = Math.min(lastChunk.length, PASTE_END_BUF.length - 1);
+            const prevTail = lastChunk.subarray(lastChunk.length - tailLen);
+            const crossResult = findCrossBoundaryEnd(prevTail, buf);
+            if (crossResult.found) {
+                if (crossResult.prevKeep < tailLen) {
+                    const trimmed = lastChunk.subarray(0, lastChunk.length - tailLen + crossResult.prevKeep);
+                    pasteAccumulator[pasteAccumulator.length - 1] = trimmed;
+                }
+                // Emit the accumulated paste content
+                const content = Buffer.concat(pasteAccumulator);
+                pasteAccumulator = null;
+                emitPaste(content);
+                // Process anything after the marker in this chunk
+                const remainder = buf.subarray(crossResult.newSkip);
+                if (remainder.length > 0) {
+                    feedParser(remainder.toString('utf8'));
+                    timeoutId = setTimeout(() => parser.next(''), ESC_TIMEOUT);
+                }
+                return;
+            }
+            // Check for full PASTE_END within this chunk
+            const endIdx = buf.indexOf(PASTE_END_BUF);
+            if (endIdx !== -1) {
+                if (endIdx > 0)
+                    pasteAccumulator.push(buf.subarray(0, endIdx));
+                const content = Buffer.concat(pasteAccumulator);
+                pasteAccumulator = null;
+                emitPaste(content);
+                // Process anything after the paste-end marker
+                const remainder = buf.subarray(endIdx + PASTE_END_BUF.length);
+                if (remainder.length > 0) {
+                    feedParser(remainder.toString('utf8'));
+                    timeoutId = setTimeout(() => parser.next(''), ESC_TIMEOUT);
+                }
+            }
+            else {
+                pasteAccumulator.push(Buffer.from(buf));
+                pasteTimeoutId = setTimeout(flushAccumulator, PASTE_TIMEOUT);
+            }
+            return;
+        }
+        // ── Check for bracketed paste start in this chunk ──
+        const startIdx = buf.indexOf(PASTE_START_BUF);
+        if (startIdx !== -1) {
+            // Process any data before the paste-start marker normally
+            if (startIdx > 0) {
+                feedParser(buf.subarray(0, startIdx).toString('utf8'));
+            }
+            const afterStart = buf.subarray(startIdx + PASTE_START_BUF.length);
+            const endIdx = afterStart.indexOf(PASTE_END_BUF);
+            if (endIdx !== -1) {
+                emitPaste(afterStart.subarray(0, endIdx));
+                // Process anything after paste-end
+                const remainder = afterStart.subarray(endIdx + PASTE_END_BUF.length);
+                if (remainder.length > 0) {
+                    feedParser(remainder.toString('utf8'));
+                    timeoutId = setTimeout(() => parser.next(''), ESC_TIMEOUT);
+                }
+            }
+            else {
+                pasteAccumulator = [Buffer.from(afterStart)];
+                pasteTimeoutId = setTimeout(flushAccumulator, PASTE_TIMEOUT);
+            }
+            return;
+        }
+        // ── Decode to string for non-paste paths ──
+        const str = buf.toString('utf8');
+        // ── Synthetic paste detection (no bracketed paste markers) ──
+        if (str.length >= SYNTHETIC_PASTE_THRESHOLD) {
+            const escapeCount = (str.match(/\x1b/g) || []).length;
+            const printableRatio = 1 - (escapeCount / str.length);
+            if (printableRatio > 0.8) {
+                const cleaned = str.replace(/\x1b(?:\[[0-9;?]*[a-zA-Z~]|.)/g, '');
+                if (cleaned.length > 0) {
+                    emitPaste(Buffer.from(cleaned, 'utf8'));
+                    return;
+                }
+            }
+        }
+        // ── Normal path: feed through emitKeys generator ──
+        feedParser(str);
+        if (str.length !== 0) {
+            timeoutId = setTimeout(() => parser.next(''), ESC_TIMEOUT);
+        }
+    };
+}
+/**
+ * Strip any trailing bytes that are a prefix of the given marker.
+ * Used when flush-by-timeout fires and the tail might hold a partial PASTE_END.
+ */
+function stripTrailingPartialMarker(buf, marker) {
+    // Check for partial marker at the tail: from longest possible prefix down to 1 byte.
+    for (let len = marker.length - 1; len >= 1; len--) {
+        if (buf.length < len)
+            continue;
+        if (buf.subarray(buf.length - len).equals(marker.subarray(0, len))) {
+            return buf.subarray(0, buf.length - len);
+        }
+    }
+    return buf;
+}
+function* emitKeys(keypressHandler) {
+    const lang = process.env['LANG'] || '';
+    const lcAll = process.env['LC_ALL'] || '';
+    const isGreek = lang.startsWith('el') || lcAll.startsWith('el');
+    while (true) {
+        let ch = yield;
+        let sequence = ch;
+        let escaped = false;
+        let name = undefined;
+        let shift = false;
+        let alt = false;
+        let ctrl = false;
+        let cmd = false;
+        let code = undefined;
+        let insertable = false;
+        if (ch === ESC) {
+            escaped = true;
+            ch = yield;
+            sequence += ch;
+            if (ch === ESC) {
+                ch = yield;
+                sequence += ch;
+            }
+        }
+        if (escaped && (ch === 'O' || ch === '[' || ch === ']')) {
+            code = ch;
+            let modifier = 0;
+            if (ch === ']') {
+                // OSC sequence
+                let buffer = '';
+                while (true) {
+                    const next = yield;
+                    if (next === '' || next === '\u0007')
+                        break;
+                    if (next === ESC) {
+                        const afterEsc = yield;
+                        if (afterEsc === '' || afterEsc === '\\')
+                            break;
+                        buffer += next + afterEsc;
+                        continue;
+                    }
+                    buffer += next;
+                }
+                // Check for OSC 52 (clipboard)
+                const match = /^52;[cp];(.*)$/.exec(buffer);
+                if (match) {
+                    try {
+                        const decoded = Buffer.from(match[1], 'base64').toString('utf-8');
+                        keypressHandler({
+                            name: 'paste', shift: false, alt: false, ctrl: false, cmd: false,
+                            insertable: true, sequence: decoded,
+                        });
+                    }
+                    catch { /* ignore */ }
+                }
+                continue;
+            }
+            else if (ch === 'O') {
+                ch = yield;
+                sequence += ch;
+                if (ch >= '0' && ch <= '9') {
+                    modifier = parseInt(ch, 10) - 1;
+                    ch = yield;
+                    sequence += ch;
+                }
+                code += ch;
+            }
+            else if (ch === '[') {
+                ch = yield;
+                sequence += ch;
+                if (ch === '[') {
+                    code += ch;
+                    ch = yield;
+                    sequence += ch;
+                }
+                const cmdStart = sequence.length - 1;
+                while (ch >= '0' && ch <= '9') {
+                    ch = yield;
+                    sequence += ch;
+                }
+                if (ch === ';') {
+                    while (ch === ';') {
+                        ch = yield;
+                        sequence += ch;
+                        while (ch >= '0' && ch <= '9') {
+                            ch = yield;
+                            sequence += ch;
+                        }
+                    }
+                }
+                else if (ch === '<') {
+                    // SGR mouse mode
+                    ch = yield;
+                    sequence += ch;
+                    while (ch === '' || ch === ';' || (ch >= '0' && ch <= '9')) {
+                        ch = yield;
+                        sequence += ch;
+                    }
+                }
+                else if (ch === 'M') {
+                    // X11 mouse
+                    ch = yield;
+                    sequence += ch;
+                    ch = yield;
+                    sequence += ch;
+                    ch = yield;
+                    sequence += ch;
+                }
+                const cmd = sequence.slice(cmdStart);
+                let match;
+                if ((match = /^(\d+)(?:;(\d+))?(?:;(\d+))?([~^$u])$/.exec(cmd))) {
+                    if (match[1] === '27' && match[3] && match[4] === '~') {
+                        code += match[3] + 'u';
+                        modifier = parseInt(match[2] ?? '1', 10) - 1;
+                    }
+                    else {
+                        code += match[1] + match[4];
+                        modifier = parseInt(match[2] ?? '1', 10) - 1;
+                    }
+                }
+                else if ((match = /^(\d+)?(?:;(\d+))?([A-Za-z])$/.exec(cmd))) {
+                    code += match[3];
+                    modifier = parseInt(match[2] ?? match[1] ?? '1', 10) - 1;
+                }
+                else {
+                    code += cmd;
+                }
+            }
+            shift = !!(modifier & 1);
+            alt = !!(modifier & 2);
+            ctrl = !!(modifier & 4);
+            cmd = !!(modifier & 8);
+            const keyInfo = KEY_INFO_MAP[code];
+            if (keyInfo) {
+                name = keyInfo.name;
+                if (keyInfo.shift)
+                    shift = true;
+                if (keyInfo.ctrl)
+                    ctrl = true;
+                if (name === 'space' && !ctrl && !cmd && !alt) {
+                    sequence = ' ';
+                    insertable = true;
+                }
+            }
+            else {
+                const numpadChar = NUMPAD_MAP[code];
+                if (numpadChar) {
+                    name = numpadChar;
+                    if (!ctrl && !cmd && !alt) {
+                        sequence = numpadChar;
+                        insertable = true;
+                    }
+                }
+                else {
+                    name = 'undefined';
+                    if ((ctrl || cmd || alt) && (code.endsWith('u') || code.endsWith('~'))) {
+                        const codeNumber = parseInt(code.slice(1, -1), 10);
+                        if (codeNumber >= 'a'.charCodeAt(0) && codeNumber <= 'z'.charCodeAt(0)) {
+                            name = String.fromCharCode(codeNumber);
+                        }
+                    }
+                }
+            }
+        }
+        else if (ch === '\r') {
+            name = 'return';
+            alt = escaped;
+        }
+        else if (escaped && ch === '\n') {
+            name = 'return';
+            alt = escaped;
+        }
+        else if (ch === '\t') {
+            name = 'tab';
+            alt = escaped;
+        }
+        else if (ch === '\b' || ch === '\x7f') {
+            name = 'backspace';
+            alt = escaped;
+        }
+        else if (ch === ESC) {
+            name = 'escape';
+            alt = escaped;
+        }
+        else if (ch === ' ') {
+            name = 'space';
+            alt = escaped;
+            insertable = true;
+        }
+        else if (!escaped && ch <= '\x1a') {
+            name = String.fromCharCode(ch.charCodeAt(0) + 'a'.charCodeAt(0) - 1);
+            ctrl = true;
+        }
+        else if (/^[0-9A-Za-z]$/.exec(ch) !== null) {
+            name = ch.toLowerCase();
+            shift = /^[A-Z]$/.exec(ch) !== null;
+            alt = escaped;
+            insertable = true;
+        }
+        else if (MAC_ALT_KEY_CHARACTER_MAP[ch]) {
+            if (isGreek && ch === '\u03A9') {
+                insertable = true;
+            }
+            else {
+                const mapped = MAC_ALT_KEY_CHARACTER_MAP[ch];
+                name = mapped.toLowerCase();
+                shift = mapped !== name;
+                alt = true;
+            }
+        }
+        else if (sequence === `${ESC}${ESC}`) {
+            name = 'escape';
+            alt = true;
+            keypressHandler({
+                name: 'escape', shift, alt, ctrl, cmd, insertable: false, sequence: ESC,
+            });
+        }
+        else if (escaped) {
+            name = ch.length ? undefined : 'escape';
+            alt = true;
+        }
+        else {
+            insertable = true;
+        }
+        if ((sequence.length !== 0 && (name !== undefined || escaped)) ||
+            charLengthAt(sequence, 0) === sequence.length) {
+            keypressHandler({
+                name: name || '',
+                shift, alt, ctrl, cmd, insertable, sequence,
+            });
+        }
+    }
+}
+const KeypressContext = createContext(undefined);
+export function useKeypressContext() {
+    const context = useContext(KeypressContext);
+    if (!context) {
+        throw new Error('useKeypressContext must be used within a KeypressProvider');
+    }
+    return context;
+}
+// ── Provider ───────────────────────────────────────────
+export function KeypressProvider({ children }) {
+    const { stdin, setRawMode } = useStdin();
+    // Simple priority map: Map<priority, Set<handler>>
+    const subscribersToPriority = useRef(new Map()).current;
+    const priorityToHandlers = useRef(new Map()).current;
+    const sortedPriorities = useRef([]);
+    const subscribe = useCallback((handler, priority = KeypressPriority.Normal) => {
+        const p = typeof priority === 'boolean'
+            ? (priority ? KeypressPriority.High : KeypressPriority.Normal)
+            : priority;
+        subscribersToPriority.set(handler, p);
+        let set = priorityToHandlers.get(p);
+        if (!set) {
+            set = new Set();
+            priorityToHandlers.set(p, set);
+            sortedPriorities.current = Array.from(priorityToHandlers.keys()).sort((a, b) => b - a);
+        }
+        set.add(handler);
+    }, [subscribersToPriority, priorityToHandlers]);
+    const unsubscribe = useCallback((handler) => {
+        const p = subscribersToPriority.get(handler);
+        if (p !== undefined) {
+            const set = priorityToHandlers.get(p);
+            if (set) {
+                set.delete(handler);
+                if (set.size === 0) {
+                    priorityToHandlers.delete(p);
+                    sortedPriorities.current = Array.from(priorityToHandlers.keys()).sort((a, b) => b - a);
+                }
+            }
+            subscribersToPriority.delete(handler);
+        }
+    }, [subscribersToPriority, priorityToHandlers]);
+    const broadcast = useCallback((key) => {
+        for (const p of sortedPriorities.current) {
+            const set = priorityToHandlers.get(p);
+            if (!set)
+                continue;
+            // Stack behavior: last subscribed handler runs first
+            const handlers = Array.from(set).reverse();
+            for (const handler of handlers) {
+                if (handler(key) === true)
+                    return;
+            }
+        }
+    }, [priorityToHandlers]);
+    useEffect(() => {
+        // Prevent Ink from installing StringDecoder on stdin.
+        // Ink's handleSetRawMode calls stdin.setEncoding('utf8'), which permanently
+        // installs a StringDecoder that corrupts ANSI escape sequences at multi-byte
+        // UTF-8 chunk boundaries (PASTE_END \x1b[201~ is destroyed when \x1b is
+        // merged with preceding incomplete CJK bytes → U+FFFD). By patching
+        // setEncoding to a no-op BEFORE setRawMode, stdin delivers raw Buffers.
+        const origSetEncoding = stdin.setEncoding.bind(stdin);
+        stdin.setEncoding = (() => stdin);
+        const wasRaw = stdin.isRaw;
+        if (!wasRaw)
+            setRawMode(true);
+        // Remove Ink's internal 'readable' listener on stdin.
+        // Ink's App component attaches a 'readable' listener when setRawMode(true) is
+        // called. That listener runs parseKeypresses() → emitInput() for every character,
+        // causing thousands of synchronous parse+emit cycles for large pastes.
+        const readableListeners = stdin.listeners('readable');
+        const removedReadableListeners = [...readableListeners];
+        for (const listener of removedReadableListeners) {
+            stdin.removeListener('readable', listener);
+        }
+        // Enable bracketed paste mode so the terminal wraps pasted content
+        // with \x1b[200~ ... \x1b[201~ markers.
+        process.stdout.write('\x1b[?2004h');
+        // Ensure terminal state is restored on unexpected exit
+        const cleanupTerminal = () => {
+            try {
+                process.stdout.write('\x1b[?2004l');
+            }
+            catch { /* ignore */ }
+        };
+        process.on('exit', cleanupTerminal);
+        // Build the filter pipeline (innermost applied first)
+        let processor = nonKeyboardEventFilter(broadcast);
+        processor = bufferFastReturn(processor);
+        processor = bufferBackslashEnter(processor);
+        processor = bufferPaste(processor);
+        const dataListener = createDataListener(processor);
+        stdin.on('data', dataListener);
+        // After removing Ink's 'readable' listener, the stream may be stuck in
+        // paused mode (flowing=false). Explicitly resume so 'data' events fire
+        // for all incoming bytes — without this, the PTY can deliver partial data.
+        stdin.resume();
+        return () => {
+            stdin.removeListener('data', dataListener);
+            // Restore Ink's listeners and encoding function on cleanup
+            stdin.setEncoding = origSetEncoding;
+            for (const listener of removedReadableListeners) {
+                stdin.addListener('readable', listener);
+            }
+            process.removeListener('exit', cleanupTerminal);
+            // Disable bracketed paste mode
+            process.stdout.write('\x1b[?2004l');
+            if (!wasRaw)
+                setRawMode(false);
+        };
+    }, [stdin, setRawMode, broadcast]);
+    return (_jsx(KeypressContext.Provider, { value: { subscribe, unsubscribe }, children: children }));
+}
+//# sourceMappingURL=KeypressContext.js.map