@aragon-agent/cli 0.6.47 → 0.6.48

package/dist/input/stdin-filter.js

@@ -1,657 +0,0 @@
-/**
- * Stdin filter (mouse-wheel-region-routing section 4.2 / 5.2, extended by
- * tui-paste-handling section 5.1).
- *
- * WHY A WRAPPER AND NOT A SECOND LISTENER. Ink 5.2.1 owns stdin in a way that
- * forbids a second reader: `components/App.js` calls `setEncoding('utf8')`,
- * `ref()`, `setRawMode(true)`, subscribes to `'readable'` and drains with
- * `read()`. Attaching our own `'data'` listener to the same `process.stdin`
- * would switch the stream into flowing mode and RACE Ink's `read()` for chunks
- * -- some keystrokes would reach Ink, some would not, non-deterministically
- * (D-3). So the filter REPLACES the stream Ink is given: it reads the real
- * stdin, strips every mouse report, frames every paste, and writes the
- * remainder into a `PassThrough` that carries the surface Ink requires.
- *
- * ONE CHANNEL, NOT TWO, AND THAT NOW COVERS PASTES AS WELL (D-2 / D-3). A second
- * chained filter would need a second `PassThrough` and would reopen the ordering
- * hazard this note closes; a side-channel paste emit would apply the payload
- * BEFORE text that preceded it in the same chunk, because `wrapper.write` is
- * asynchronous and a synchronous emit is not. The paste therefore travels
- * INLINE, wrapped in `PASTE_OPEN` / `PASTE_CLOSE` (I-5).
- *
- * ORDERING IS AN INVARIANT, NOT A CONVENTION (I-8). The caller must build this
- * filter BEFORE anything writes `\x1b[?1000h` or `\x1b[?2004h`. Reporting or
- * bracketed paste enabled while Ink still holds the raw stream does not degrade
- * the feature -- it types `[<0;12;5M` or `[200~` into the user's message, which
- * is strictly worse than the bug being fixed.
- *
- * THE HANDLE ANSWERS EXACTLY ONE QUESTION: "is a stream wrapped?" (I-11 / D-17).
- * It stopped being the answer to "is the mouse on?" the moment paste could build
- * a filter on its own -- `paste` defaults to `true`, so `aragon --no-mouse`
- * builds one. `cli.tsx` reads its own `mouseOn` / `pasteOn` booleans; this module
- * is told which features it is running and never derives them.
- */
-import { PassThrough } from 'node:stream';
-import { MAX_PENDING_MOUSE_CHARS, splitMouseEvents, isMousePrefix, } from './mouse-events.js';
-import { ENTER_NEWLINE_FRAME, INDEX_KEY_FRAME, PASTE_ASSEMBLY_MAX_MS, PASTE_BURST_MS, PASTE_CLOSE, PASTE_MARKER_RESCAN_TTL_MS, PASTE_MAX_BYTES, PASTE_OPEN, formatPasteSize, } from './limits.js';
-import { PASTE_BEGIN_MARK, PASTE_END_MARK, classifyChunk, isPastePrefix, sanitisePaste, trailingPastePrefixLength, } from './paste-parse.js';
-import { hasPasteOnlySequence } from './control-sequences.js';
-import { splitCursorReports, trailingCprPrefixLength } from './cursor-report.js';
-import { splitEnterSequences, trailingEnterPrefixLength } from './enter-sequences.js';
-import { splitCsiUKeys, trailingCsiUPrefixLength, translateCsiUKey } from './csiu-keys.js';
-import { splitWin32KeySequences, trailingWin32PrefixLength, translateWin32Key, } from './win32-input-mode.js';
-/**
- * How long a possible-prefix tail is held before being flushed as text.
- *
- * This is what stops a lone `\x1b` -- the Esc key, which aborts a run -- from
- * being held hostage waiting for a `[` that will never arrive. Worst-case Esc
- * latency becomes 12 ms, and only for the keystroke that is literally a bare
- * ESC; every other key resolves both prefix tests to false immediately.
- */
-const PENDING_FLUSH_MS = 12;
-/**
- * Ceiling on the held-back tail, shared by both prefix families.
- *
- * NO CHANGE IS NEEDED HERE FOR PASTE (P2-5). `MAX_PENDING_MOUSE_CHARS` is 32 and
- * the longest paste marker is 6, so 32 already covers both. v1 of the design said
- * the ceiling "becomes `max(MAX_PENDING_MOUSE_CHARS, PASTE_BEGIN_MARK.length)`",
- * which is the same number written in a way that invites someone to edit the
- * constant.
- *
- * TAKEN FROM THE MODULE THAT OWNS IT rather than written again: this file already
- * imports from `mouse-events.js`, so there is no cycle to dodge here and no
- * reason for a second copy of a number whose only justification is that it equals
- * that one.
- */
-const MAX_PENDING_CHARS = MAX_PENDING_MOUSE_CHARS;
-/** Assign a method onto the PassThrough without widening its public type. */
-function define(target, name, value) {
-    Object.defineProperty(target, name, { value, writable: true, configurable: true });
-}
-const byteLength = (s) => Buffer.byteLength(s, 'utf8');
-/**
- * Length of the trailing run of `text` that is a proper prefix of a mouse
- * report, or 0. Shortest match wins, mirroring `trailingPastePrefixLength`.
- *
- * MEASURED SEPARATELY FROM THE PASTE FAMILY, and the longer hold wins.
- * `isMousePrefix` does not match `\x1b[2`, which IS a prefix of both paste
- * markers, so a single combined test would leak half a marker into the draft.
- */
-function trailingMousePrefixLength(text) {
-    const max = Math.min(text.length, MAX_PENDING_CHARS);
-    for (let k = 1; k <= max; k += 1) {
-        if (isMousePrefix(text.slice(text.length - k)))
-            return k;
-    }
-    return 0;
-}
-export function createStdinFilter(real, features, bridge, onWarn) {
-    const enhancedKeys = features.enhancedKeys === true;
-    const wrapper = new PassThrough();
-    const listeners = new Set();
-    let pending = '';
-    let flushTimer = null;
-    let burstTimer = null;
-    let assemblyTimer = null;
-    let disposed = false;
-    let finished = false;
-    let paste = { kind: 'idle' };
-    /**
-     * The probe window (R3). While true a possible report prefix is held until the
-     * probe settles instead of being flushed after `PENDING_FLUSH_MS`, because a
-     * half `ESC[12` reaching Ink hits an undefined branch of its key parser.
-     */
-    let expectingCursorReport = false;
-    let discardBracketed = false;
-    let outputBatch = null;
-    /**
-     * A marker head that has ALREADY been released to Ink, kept for one more
-     * chunk (defect 2: the torn-marker rescue in `onData`).
-     *
-     * WHY IT EXISTS. `flushPending` releases a lone ESC after 12 ms because the
-     * Esc key must not be held hostage. When the split point lands inside a paste
-     * marker -- `ESC` in one read and `[200~hello` in the next, which is ordinary
-     * for a Windows console, SSH or tmux under load -- `feed` can no longer find
-     * the marker and `[200~` is typed into the draft. Nothing downstream can undo
-     * that: the marker has to be recognised BEFORE its bytes become text.
-     *
-     * WHAT IT CANNOT DO, STATED HONESTLY. The released ESC has already reached Ink
-     * as an Esc key press and this filter cannot retract a write. The rescue
-     * guarantees the marker CHARACTERS never become draft text; it does NOT undo
-     * that keypress (an armed interrupt gesture, a dismissed popup).
-     */
-    let rescuedPrefix = null;
-    const writeInput = (text) => {
-        if (disposed || outputBatch?.refused)
-            return;
-        if (outputBatch)
-            outputBatch.chunks.push(text);
-        else
-            wrapper.write(text);
-    };
-    // --- The surface Ink reads off the stream it is handed. ------------------
-    // `isRawModeSupported()` reads `props.stdin.isTTY` (App.js:34), so this has
-    // to be a DELEGATING GETTER rather than a snapshot: a stdin that is not a TTY
-    // must still report so through the wrapper, or Ink throws instead of falling
-    // back.
-    Object.defineProperty(wrapper, 'isTTY', {
-        get: () => real.isTTY,
-        configurable: true,
-    });
-    define(wrapper, 'setRawMode', (mode) => {
-        real.setRawMode?.(mode);
-        return wrapper;
-    });
-    define(wrapper, 'ref', () => {
-        real.ref?.();
-        return wrapper;
-    });
-    define(wrapper, 'unref', () => {
-        real.unref?.();
-        return wrapper;
-    });
-    const emit = (event) => {
-        for (const listener of [...listeners])
-            listener(event);
-    };
-    const clearTimer = (t) => {
-        if (t)
-            clearTimeout(t);
-        return null;
-    };
-    /** `.unref()` so a held tail can never keep the process alive on its own. */
-    const arm = (fn, ms) => {
-        if (finished || disposed)
-            return null;
-        const t = setTimeout(fn, ms);
-        t.unref?.();
-        return t;
-    };
-    // -----------------------------------------------------------------------
-    // Paste emission
-    // -----------------------------------------------------------------------
-    /**
-     * Write one frame, or refuse the paste and say so.
-     *
-     * D-11: above `PASTE_MAX_BYTES` the body is DROPPED and the user gets a toast
-     * naming the size and the limit. Truncating would lose their data and look
-     * like success. The body stops being accumulated the moment it goes over
-     * (`overflow`), so memory stays bounded while the rest of the payload is still
-     * being consumed -- consuming it is not optional, because the alternative is
-     * two megabytes of the user's file arriving as keystrokes.
-     */
-    const emitPaste = (body, bytes, overflow) => {
-        if (disposed)
-            return;
-        if (overflow || bytes > PASTE_MAX_BYTES) {
-            if (outputBatch?.refused)
-                return;
-            if (outputBatch)
-                outputBatch.refused = true;
-            const text = `Paste too large (${formatPasteSize(bytes)}); limit is ` +
-                `${formatPasteSize(PASTE_MAX_BYTES)}. Nothing was inserted.`;
-            onWarn?.(text);
-            bridge?.notify?.('warn', text);
-            return;
-        }
-        const payload = sanitisePaste(body);
-        if (payload.length === 0)
-            return;
-        // ONE `write()` call, at the position the paste occupied in the stream.
-        writeInput(PASTE_OPEN + payload + PASTE_CLOSE);
-    };
-    const flushBurst = () => {
-        burstTimer = clearTimer(burstTimer);
-        if (paste.kind !== 'burst')
-            return;
-        const { body, bytes } = paste;
-        paste = { kind: 'idle' };
-        emitPaste(body, bytes, false);
-    };
-    const flushBracketed = (reason) => {
-        assemblyTimer = clearTimer(assemblyTimer);
-        if (paste.kind !== 'bracketed')
-            return;
-        const { body, bytes, overflow } = paste;
-        paste = { kind: 'idle' };
-        if (discardBracketed) {
-            discardBracketed = false;
-            if (outputBatch)
-                outputBatch.refused = true;
-            return;
-        }
-        if (reason === 'timeout') {
-            // I-4: an unterminated marker must never wedge input. Emitting what
-            // arrived is strictly better than holding the keyboard hostage.
-            onWarn?.('bracketed paste never terminated; flushing what arrived');
-        }
-        emitPaste(body, bytes, overflow);
-    };
-    // -----------------------------------------------------------------------
-    // The scan (section 5.1, and the ORDER below is the specification)
-    // -----------------------------------------------------------------------
-    /**
-     * Text that reached the pass-through: a sequence a KEYBOARD cannot produce
-     * first (R-2), then Tier 2 classification, then mouse stripping, then Ink.
-     *
-     * MOUSE PARSING IS SUSPENDED FOR THE DURATION OF ANY PASTE BODY (I-3), burst
-     * and bracketed alike. The Tier 2 population is precisely the terminals with
-     * no bracketed paste, and the likeliest thing such a user pastes into a TUI
-     * dev tool is a terminal log full of `\x1b[<0;12;5M`-shaped bytes. Eating
-     * those would corrupt their data silently. v1 covered only Tier 1, which left
-     * the loss in place for exactly the terminals Tier 2 exists to serve (P1-7).
-     */
-    const handleText = (text, holdTail) => {
-        if (text.length === 0)
-            return;
-        if (paste.kind === 'burst') {
-            paste = { kind: 'burst', body: paste.body + text, bytes: paste.bytes + byteLength(text) };
-            burstTimer = clearTimer(burstTimer);
-            burstTimer = arm(flushBurst, PASTE_BURST_MS);
-            return;
-        }
-        // A SEQUENCE A KEYBOARD CANNOT PRODUCE IS A PASTE, FRAMED OR NOT (R-2).
-        //
-        // WHY THE CLASSIFIER BELOW IS NOT ENOUGH. `classifyChunk` needs either a
-        // line break or a chunk with no control byte but TAB, and a SINGLE-LINE
-        // paste carrying ESC satisfies neither -- so it travels the keystroke path
-        // with `sanitisePaste` never called. Measured on the real component that
-        // cost either a draft holding `[38;2;18;52;86m` ALONGSIDE A LIVE ESC (which
-        // then reached the model, the history and the session file) or an uncaught
-        // `TypeError` in Ink's parser, because `parse-keypress.js` maps `ESC [ 3 2 m`
-        // to a ctrl key whose `name` is undefined. Framing it here routes it through
-        // the ONE cleaning path every other paste already takes.
-        if (features.paste && hasPasteOnlySequence(text)) {
-            paste = { kind: 'burst', body: text, bytes: byteLength(text) };
-            burstTimer = clearTimer(burstTimer);
-            burstTimer = arm(flushBurst, PASTE_BURST_MS);
-            return;
-        }
-        if (features.paste && classifyChunk(text) === 'paste') {
-            paste = { kind: 'burst', body: text, bytes: byteLength(text) };
-            burstTimer = clearTimer(burstTimer);
-            burstTimer = arm(flushBurst, PASTE_BURST_MS);
-            return;
-        }
-        // FOURTH PREFIX FAMILY: the terminal's answer to `ESC[6n`
-        // (tui-bottom-anchored-live-region §4.5). AFTER the paste tests, and that order
-        // is the specification: a user who pastes a terminal log containing `ESC[12;1R`
-        // is pasting DATA, and a paste body is the one place such a sequence is kept
-        // verbatim (I-3, the same rule that suspends mouse parsing inside a body).
-        if (features.cursorReport) {
-            const report = splitCursorReports(text);
-            text = report.text;
-            if (report.pending.length > 0) {
-                // Not text yet: it joins the cross-chunk buffer the mouse family uses.
-                // `holdTail` false means a paste marker follows in this very chunk, so no
-                // later byte can complete the prefix and holding it would reorder it (I-5).
-                if (holdTail)
-                    pending += report.pending;
-                else
-                    writeInput(report.pending);
-            }
-            if (text.length === 0)
-                return;
-        }
-        // Ink conflates DEL Backspace with CSI Delete. Normalize only keyboard
-        // text, after burst classification, preserving ESC for Alt+Backspace.
-        text = text.replace(/\x7f/g, '\x08');
-        if (!features.mouse) {
-            writeInput(text);
-            return;
-        }
-        const split = splitMouseEvents(text);
-        if (split.text.length > 0)
-            writeInput(split.text);
-        for (const event of split.events)
-            emit(event);
-        if (split.pending.length === 0)
-            return;
-        // `holdTail` is false when a paste marker follows this run in the SAME
-        // chunk: no later byte can complete the mouse prefix, so holding it would
-        // reorder it behind the paste. Appending (never prepending) is what keeps
-        // `pending` in stream order when both prefix families fire at once.
-        if (holdTail)
-            pending += split.pending;
-        else
-            writeInput(split.pending);
-    };
-    /**
-     * THE ENHANCED-KEY WALK, OUTSIDE PASTES ONLY. win32-input-mode records are
-     * split first (their bodies are digits/semicolons, so no paste marker or
-     * CSI-u sequence can live inside one), then CSI-u sequences in the
-     * remaining text, and only then the legacy Enter family. Each translated
-     * key terminates a heuristic burst exactly like an Enter frame does -- a
-     * keystroke mid-burst is the definition of "not a paste".
-     */
-    const writeEnhancedKey = (legacy) => {
-        if (legacy.length === 0)
-            return;
-        flushBurst();
-        writeInput(legacy);
-    };
-    const handleOutsidePaste = (text, holdTail) => {
-        const win32 = enhancedKeys ? splitWin32KeySequences(text)
-            : [{ kind: 'text', text }];
-        for (let w = 0; w < win32.length; w += 1) {
-            const wSeg = win32[w];
-            const wLast = holdTail && w === win32.length - 1;
-            if (wSeg.kind === 'key') {
-                writeEnhancedKey(translateWin32Key(wSeg.record));
-                continue;
-            }
-            const csiu = enhancedKeys ? splitCsiUKeys(wSeg.text)
-                : [{ kind: 'text', text: wSeg.text }];
-            for (let c = 0; c < csiu.length; c += 1) {
-                const cSeg = csiu[c];
-                if (cSeg.kind === 'key') {
-                    writeEnhancedKey(translateCsiUKey(cSeg.key));
-                    continue;
-                }
-                const segments = splitEnterSequences(cSeg.text);
-                for (let index = 0; index < segments.length; index += 1) {
-                    const segment = segments[index];
-                    if (segment.kind === 'text') {
-                        handleText(segment.text, wLast && c === csiu.length - 1
-                            && index === segments.length - 1);
-                        continue;
-                    }
-                    // A key terminates the heuristic paste before its internal frame is written.
-                    writeEnhancedKey(segment.kind === 'submit' ? '\r' : ENTER_NEWLINE_FRAME);
-                }
-            }
-        }
-    };
-    /**
-     * win32-input-mode records that arrived INSIDE a paste frame (R-4).
-     *
-     * DATA FIDELITY, NOT POLISH. Every character of a `?9001h` session arrives as
-     * `ESC [ vk ; sc ; char ; down ; mods ; rep _`, and once the frame opens
-     * nothing translated them: `sanitisePaste` then removed each record's ESC and
-     * left 15 visible characters of digits per key. Translating them is also what
-     * keeps the fix honest in the OTHER direction -- a whole-sequence stripper
-     * deletes such a record outright, so "clean" would have meant the user's
-     * characters silently vanishing. A record carrying a key FRAME (modified
-     * Enter, Ctrl+I) becomes the byte that frame stands for, because a frame
-     * inside a body is content and never a key.
-     */
-    const translateInPaste = (text) => {
-        if (!enhancedKeys || !text.includes('\x1b['))
-            return text;
-        let out = '';
-        for (const segment of splitWin32KeySequences(text)) {
-            if (segment.kind === 'text') {
-                out += segment.text;
-                continue;
-            }
-            const legacy = translateWin32Key(segment.record);
-            if (legacy === ENTER_NEWLINE_FRAME)
-                out += '\n';
-            else if (legacy === INDEX_KEY_FRAME)
-                out += '\t';
-            else
-                out += legacy;
-        }
-        return out;
-    };
-    const appendBracketed = (text) => {
-        if (paste.kind !== 'bracketed' || text.length === 0 || discardBracketed)
-            return;
-        const body = translateInPaste(text);
-        const bytes = paste.bytes + byteLength(body);
-        const overflow = paste.overflow || bytes > PASTE_MAX_BYTES;
-        paste = {
-            kind: 'bracketed',
-            body: overflow ? paste.body : paste.body + body,
-            bytes,
-            overflow,
-        };
-    };
-    const feed = (raw) => {
-        let rest = raw;
-        while (rest.length > 0) {
-            if (paste.kind === 'bracketed') {
-                const end = rest.indexOf(PASTE_END_MARK);
-                if (end === -1) {
-                    // Hold a trailing strict prefix of the END marker for the next chunk.
-                    // NO 12 ms FLUSH TIMER HERE: inside a body every byte is payload, so
-                    // nothing is being kept from the keyboard, and `assemblyTimer` is the
-                    // bound that matters (I-4).
-                    const hold = trailingPastePrefixLength(rest);
-                    appendBracketed(rest.slice(0, rest.length - hold));
-                    pending = rest.slice(rest.length - hold);
-                    return;
-                }
-                appendBracketed(rest.slice(0, end));
-                flushBracketed('end');
-                rest = rest.slice(end + PASTE_END_MARK.length);
-                continue;
-            }
-            // idle | burst. BOTH markers are consumed unconditionally, in every mode
-            // and whether or not this process enabled DEC 2004 (I-16): something else
-            // may have left it on, and a stray END typed into the draft is the same
-            // failure arriving from outside.
-            const begin = rest.indexOf(PASTE_BEGIN_MARK);
-            const strayEnd = rest.indexOf(PASTE_END_MARK);
-            const first = begin === -1 ? strayEnd : strayEnd === -1 ? begin : Math.min(begin, strayEnd);
-            if (first === -1) {
-                // THIRD PREFIX FAMILY: a torn CSI-u Enter sequence
-                // (tui-shift-enter-copy-queue 3.4). `keep = max(...)` holds the longest
-                // tail any family might still complete; the three families share only
-                // the ESC / ESC-[ head bytes, which the max keeps for whoever needs
-                // them. The existing 12 ms flush and the 32-char ceiling bound the
-                // hold, so no new timer is needed.
-                const keep = Math.max(trailingPastePrefixLength(rest), features.mouse ? trailingMousePrefixLength(rest) : 0, features.cursorReport ? trailingCprPrefixLength(rest) : 0, trailingEnterPrefixLength(rest), enhancedKeys ? trailingWin32PrefixLength(rest) : 0, enhancedKeys ? trailingCsiUPrefixLength(rest) : 0);
-                const tail = rest.slice(rest.length - keep);
-                handleOutsidePaste(rest.slice(0, rest.length - keep), true);
-                pending += tail;
-                return;
-            }
-            handleOutsidePaste(rest.slice(0, first), false);
-            if (begin === -1 || first < begin) {
-                rest = rest.slice(first + PASTE_END_MARK.length);
-                continue;
-            }
-            // P2-4: the burst is flushed FIRST, so two bodies can never be
-            // concatenated into one token out of order.
-            flushBurst();
-            paste = { kind: 'bracketed', body: '', bytes: 0, overflow: false };
-            assemblyTimer = clearTimer(assemblyTimer);
-            assemblyTimer = arm(() => flushBracketed('timeout'), PASTE_ASSEMBLY_MAX_MS);
-            rest = rest.slice(first + PASTE_BEGIN_MARK.length);
-        }
-    };
-    /**
-     * Hand a held tail to the ordinary text path, remembering it when it could
-     * still be the head of a paste marker.
-     *
-     * THE TAIL IS RELEASED EXACTLY AS BEFORE. Remembering it costs no latency: a
-     * real Esc keypress still reaches Ink after `PENDING_FLUSH_MS`, and the
-     * remembered head is only ever consulted for the NEXT chunk.
-     */
-    const flushTailAsText = (text) => {
-        rescuedPrefix = isPastePrefix(text) ? { text, at: Date.now() } : null;
-        handleOutsidePaste(text, false);
-    };
-    const flushPending = () => {
-        flushTimer = clearTimer(flushTimer);
-        if (pending.length === 0 || disposed)
-            return;
-        // The probe owes us an answer: releasing a half report now would type it into
-        // the draft. `setExpectingCursorReport(false)` flushes whatever is left.
-        if (expectingCursorReport)
-            return;
-        const text = pending;
-        pending = '';
-        // A tail that never completed is ordinary text; it goes through the same
-        // scan so a burst already open keeps coalescing it.
-        flushTailAsText(text);
-    };
-    /**
-     * One-shot rescue of a marker whose ESC was already flushed as text.
-     *
-     * Returns the string `feed` should scan -- the remembered head followed by
-     * this chunk -- when the chunk COMPLETES that head into a whole marker, and
-     * `null` otherwise. On `null` the chunk travels the normal path: the head has
-     * already been emitted, so re-feeding it would type its bytes twice, and
-     * holding the chunk instead would swallow characters the user really typed.
-     *
-     * STARTS WITH, NOT CONTAINS. A marker completed at the junction starts at
-     * index 0 of the joined text; one starting anywhere later lies wholly inside
-     * `chunk` (the head holds an ESC at index 0 and nothing else that could begin
-     * a marker), and `feed` finds that on its own. Only the junction case needs
-     * re-scanning, and it is the only case where prepending cannot duplicate a
-     * byte that Ink has already seen.
-     *
-     * ONE-SHOT BY CONSTRUCTION: the remembered head is cleared here on every call,
-     * whether or not the rescue fired, so at most one chunk is ever re-scanned
-     * against it and no stale head can outlive its `PASTE_MARKER_RESCAN_TTL_MS`.
-     */
-    const takeRescuedPrefix = (carried, chunk) => {
-        const rescue = rescuedPrefix;
-        rescuedPrefix = null;
-        if (rescue === null || carried.length > 0 || !features.paste)
-            return null;
-        if (Date.now() - rescue.at > PASTE_MARKER_RESCAN_TTL_MS)
-            return null;
-        const joined = rescue.text + chunk;
-        const completes = joined.startsWith(PASTE_BEGIN_MARK) || joined.startsWith(PASTE_END_MARK);
-        return completes ? joined : null;
-    };
-    const onData = (chunk) => {
-        if (disposed || finished)
-            return;
-        flushTimer = clearTimer(flushTimer);
-        const decoded = typeof chunk === 'string' ? chunk : chunk.toString('utf8');
-        // Stripped on BOTH paths, because a NUL in a payload must never be able to
-        // forge a `PASTE_OPEN` frame boundary.
-        const cleaned = decoded.replace(/\u0000/g, '');
-        const carried = pending;
-        pending = '';
-        // A rejected paste must not leave earlier text or a later Enter executable.
-        const batch = { chunks: [], refused: false };
-        outputBatch = batch;
-        try {
-            feed(takeRescuedPrefix(carried, cleaned) ?? (carried + cleaned));
-        }
-        finally {
-            outputBatch = null;
-        }
-        if (batch.refused) {
-            burstTimer = clearTimer(burstTimer);
-            if (paste.kind === 'bracketed') {
-                // Keep consuming an unfinished body so its next chunk cannot become keys.
-                discardBracketed = true;
-                paste = { kind: 'bracketed', body: '', bytes: 0, overflow: false };
-            }
-            else {
-                pending = '';
-                paste = { kind: 'idle' };
-                assemblyTimer = clearTimer(assemblyTimer);
-            }
-            return;
-        }
-        if (disposed || finished)
-            return;
-        for (const text of batch.chunks)
-            wrapper.write(text);
-        if (paste.kind === 'bracketed' || pending.length === 0)
-            return;
-        if (pending.length > MAX_PENDING_CHARS && !expectingCursorReport) {
-            // A malformed sequence that looks like a prefix forever must never wedge
-            // input: past the ceiling the tail becomes ordinary text. NOT DURING THE
-            // PROBE WINDOW THOUGH (L8): there the ceiling could push half a report into
-            // Ink, which is the failure this whole family exists to prevent. The window
-            // is bounded by the probe timeout, after which the ceiling applies again.
-            const text = pending;
-            pending = '';
-            flushTailAsText(text);
-            return;
-        }
-        flushTimer = arm(flushPending, PENDING_FLUSH_MS);
-    };
-    // P2-7: a closed stdin must still terminate Ink's reader, or it waits forever
-    // on a stream that will never produce another byte.
-    const onEnd = () => {
-        if (finished || disposed)
-            return;
-        finished = true;
-        flushTimer = clearTimer(flushTimer);
-        burstTimer = clearTimer(burstTimer);
-        assemblyTimer = clearTimer(assemblyTimer);
-        const tail = pending;
-        pending = '';
-        if (paste.kind === 'bracketed') {
-            appendBracketed(tail);
-            flushBracketed('timeout');
-        }
-        else {
-            // The pending prefix belongs to the currently open burst, if any.
-            handleOutsidePaste(tail, false);
-            flushBurst();
-        }
-        wrapper.end();
-    };
-    // `setEncoding('utf8')` on the REAL stream so Node's StringDecoder handles
-    // multi-byte boundaries for us -- the scan works on characters, and a UTF-8
-    // sequence split across two chunks would otherwise become two mojibake
-    // characters before it ever reached `splitMouseEvents`.
-    real.setEncoding?.('utf8');
-    real.on('data', onData);
-    real.once('end', onEnd);
-    real.once('close', onEnd);
-    return {
-        stdin: wrapper,
-        source: {
-            subscribe(listener) {
-                listeners.add(listener);
-                return () => listeners.delete(listener);
-            },
-        },
-        setExpectingCursorReport(on) {
-            if (expectingCursorReport === on)
-                return;
-            expectingCursorReport = on;
-            if (on || disposed)
-                return;
-            // Settled: nothing that is still held was a report. Release it as text, so a
-            // probe that never got an answer costs its own timeout and not a dead keyboard.
-            flushTimer = clearTimer(flushTimer);
-            flushPending();
-        },
-        dispose() {
-            if (disposed)
-                return;
-            disposed = true;
-            flushTimer = clearTimer(flushTimer);
-            burstTimer = clearTimer(burstTimer);
-            assemblyTimer = clearTimer(assemblyTimer);
-            real.removeListener('data', onData);
-            real.removeListener('end', onEnd);
-            real.removeListener('close', onEnd);
-            listeners.clear();
-            // I-7: a live `'data'` listener on stdin keeps the event loop alive, and
-            // `aragon` would hang on exit instead of returning to the shell.
-            real.pause?.();
-            real.unref?.();
-        },
-    };
-}
-/**
- * Build a filter, or `null` if construction throws.
- *
- * The `null` return is the whole point (P0-1): a construction failure must
- * degrade to "the wheel is inert and pastes are keystrokes" -- a supported,
- * tested rung of the fail-safe ladder -- rather than leaving `?1000h` or `?2004h`
- * on with no filter in front of Ink. `cli.tsx` derives BOTH `mouseOn` and
- * `pasteOn` from the returned handle for exactly that reason.
- */
-export function tryCreateStdinFilter(real, features, onError, bridge) {
-    try {
-        return createStdinFilter(real, features, bridge, onError);
-    }
-    catch (err) {
-        onError?.(err instanceof Error ? err.message : String(err));
-        return null;
-    }
-}