@aragon-agent/cli 0.6.3 → 0.6.4

package/dist/ui/paste-tokens.js

@@ -0,0 +1,147 @@
+/**
+ * The paste token vocabulary (tui-paste-handling section 5.3) -- pure. No Ink,
+ * no React, no I/O.
+ *
+ * A large paste is replaced IN THE BUFFER by a display token,
+ * `[Pasted text #1 +15 lines]`, and its payload is held beside the buffer in the
+ * editor's `pastes` map until the message is sent (D-7). An inline token rather
+ * than an out-of-band attachment is what lets the user place a paste relative to
+ * their own words -- "explain this: [Pasted text #1 +218 lines] -- why does it
+ * retry?" -- which is also the shape the requirement's example asks for.
+ *
+ * The token is ATOMIC FOR EDITING and NOT for cursor movement (D-8). Delete and
+ * kill ranges snap outward to cover a whole token and the caret snaps out before
+ * an insert, which removes every realistic way to corrupt one; arrows still step
+ * by character, because re-deriving `moveVertical`, `home`/`end` and word jumps
+ * around a synthetic unit buys a correctness the user cannot notice.
+ */
+import { PASTE_INLINE_MAX_CHARS, PASTE_INLINE_MAX_LINES } from './composer-limits.js';
+/**
+ * A FACTORY, NOT A SHARED CONSTANT (P2-2).
+ *
+ * A module-level `/g` RegExp carries `lastIndex` between calls, so `re.test(x)`
+ * returns false on every second call with the same input -- a bug that presents
+ * as "token detection works, then randomly does not". Callers must use
+ * `matchAll` or `replace` (both safe) on a FRESH instance; nothing in this module
+ * may call `.test()` or `.exec()` on a `/g` regex it did not just create.
+ *
+ * Strict, anchored to its own literal shape, ASCII-only. Group 1 is the id.
+ */
+export function pasteTokenRe() {
+    return /\[Pasted text #(\d+) \+\d+ (?:lines|chars)\]/g;
+}
+/**
+ * The process-monotonic id counter (D-14).
+ *
+ * CALLED FROM THE COMPONENT, NEVER FROM THE REDUCER (P1-5). React is explicitly
+ * allowed to run a reducer more than once for one action -- eager evaluation in
+ * `dispatchSetState`, base-queue replay after a bailout, StrictMode double
+ * invocation -- and a counter mutated inside one would skip ids and produce two
+ * states that differ in the token TEXT, not merely in identity. Allocating in the
+ * handler also makes the rendered token deterministic for a unit test.
+ *
+ * Monotonic for the PROCESS rather than per draft, so two drafts never show `#1`
+ * for different content in one session.
+ */
+let nextPasteId = 1;
+export function allocatePasteId() {
+    const id = nextPasteId;
+    nextPasteId += 1;
+    return id;
+}
+/** Test-only reset. Never called from application code. */
+export function resetPasteIdsForTest() {
+    nextPasteId = 1;
+}
+export function makePasteRecord(id, text) {
+    return { id, text, lines: text.split('\n').length, chars: [...text].length };
+}
+/**
+ * `[Pasted text #3 +218 lines]`, or `[Pasted text #4 +1204 chars]` for a paste
+ * that is one very long line.
+ *
+ * "+1 lines" is not a sentence, and for a one-liner the number the user cares
+ * about is its length rather than its line count.
+ */
+export function formatPasteToken(record) {
+    return record.lines > 1
+        ? `[Pasted text #${record.id} +${record.lines} lines]`
+        : `[Pasted text #${record.id} +${record.chars} chars]`;
+}
+/** Above EITHER inline bound the paste is collapsed into a token (G3 / G4). */
+export function shouldCollapse(text) {
+    return text.split('\n').length > PASTE_INLINE_MAX_LINES || [...text].length > PASTE_INLINE_MAX_CHARS;
+}
+/** Every token in the buffer, in order. */
+export function tokenSpans(buffer) {
+    const spans = [];
+    for (const m of buffer.matchAll(pasteTokenRe())) {
+        const start = m.index ?? 0;
+        spans.push({ start, end: start + m[0].length, id: Number(m[1]) });
+    }
+    return spans;
+}
+/** The token containing or touching `index`, or `null`. */
+export function tokenAt(buffer, index) {
+    for (const span of tokenSpans(buffer)) {
+        if (index >= span.start && index <= span.end)
+            return span;
+    }
+    return null;
+}
+/**
+ * Move a caret that landed STRICTLY INSIDE a token to its nearer edge (D-8).
+ *
+ * An index at either edge, or outside every token, is returned unchanged -- so
+ * this is a no-op on a buffer with no tokens, which is every buffer today.
+ */
+export function snapOutOfToken(buffer, cursor) {
+    for (const span of tokenSpans(buffer)) {
+        if (cursor <= span.start || cursor >= span.end)
+            continue;
+        return cursor - span.start <= span.end - cursor ? span.start : span.end;
+    }
+    return cursor;
+}
+/**
+ * Grow `[from, to)` so it covers every token it partially overlaps (G5).
+ *
+ * This is what makes `Backspace` immediately after `...lines]` remove the whole
+ * token in ONE keystroke, and what stops `Ctrl+W` / `Ctrl+U` / `Ctrl+K` leaving
+ * half a token -- and therefore an unparseable label -- behind.
+ */
+export function expandRangeOverTokens(buffer, from, to) {
+    let lo = Math.min(from, to);
+    let hi = Math.max(from, to);
+    for (const span of tokenSpans(buffer)) {
+        if (span.start < hi && lo < span.end) {
+            lo = Math.min(lo, span.start);
+            hi = Math.max(hi, span.end);
+        }
+    }
+    return { from: lo, to: hi };
+}
+/**
+ * Replace every token whose id is present in `pastes`; leave the rest verbatim.
+ *
+ * A user who literally TYPES `[Pasted text #3 +9 lines]` while paste #3 exists in
+ * the same draft will have it expanded. That is bounded (ids are per process, the
+ * map is per draft) and harmless (they get text that is already in their own
+ * draft), and the alternative -- an unguessable nonce in the label -- would trade
+ * a case nobody hits for a label nobody can read.
+ */
+export function expandPastes(buffer, pastes) {
+    if (pastes.size === 0)
+        return buffer;
+    return buffer.replace(pasteTokenRe(), (match, idText) => {
+        const record = pastes.get(Number(idText));
+        return record ? record.text : match;
+    });
+}
+/** Ids still referenced by the buffer -- the input to I-7's prune. */
+export function referencedIds(buffer) {
+    const ids = new Set();
+    for (const m of buffer.matchAll(pasteTokenRe()))
+        ids.add(Number(m[1]));
+    return ids;
+}

package/dist/ui/screen.d.ts

@@ -49,6 +49,22 @@ export interface AltScreenOptions {
      * pre-existing test emits exactly the bytes it emitted before (AC-8 / T-34).
      */
     readonly motion?: boolean;
+    /**
+     * TRUE MEANS "A FILTER THAT CONSUMES `\x1b[200~` IS ALREADY INSTALLED", NOT
+     * "the user wants paste support" — the same discipline `mouse` carries (I-1 /
+     * I-8).
+     *
+     * Enabling DEC 2004 without a filter in front of Ink does not degrade the
+     * feature: it types `[200~` and `[201~` into the user's message on EVERY paste,
+     * which is strictly worse than the bug being fixed. `cli.tsx` passes
+     * `pasteOn && mode === 'fullscreen'`, and NOT `filter !== null && config.paste`
+     * — after the gate widened, the handle no longer answers any question except
+     * "is a stream wrapped?" (D-17 / I-11).
+     *
+     * Optional, defaulting to `false`, so every pre-existing caller and every
+     * pre-existing assertion emits exactly the bytes it emitted before.
+     */
+    readonly bracketedPaste?: boolean;
 }
 /**
  * Enter the alternate screen. A non-TTY stdout is a hard no-op (tests, pipes,

package/dist/ui/screen.js

@@ -55,6 +55,32 @@ const disableMouse = (motion) => `\x1b[?1006l${motion ? '\x1b[?1002l' : ''}\x1b[
  */
 const SAVE_ALT_SCROLL_OFF = '\x1b[?1007s\x1b[?1007l';
 const RESTORE_ALT_SCROLL = '\x1b[?1007r';
+/**
+ * Bracketed paste (DEC private mode 2004) — the terminal wraps a paste in
+ * `\x1b[200~` / `\x1b[201~`, which makes Tier 1 detection EXACT rather than a
+ * heuristic on chunk shape (tui-paste-handling D-6 / L2).
+ *
+ * WHY THIS IS FORCED OFF ON EXIT RATHER THAN SAVED AND RESTORED (P1-8). DEC 1007
+ * above is the same class of state — global, not ours — and gets the OPPOSITE
+ * treatment, so the asymmetry has to be written down or the next reader will
+ * "fix" the inconsistency:
+ *
+ *  - `\x1b[?2004r` on a terminal that does not implement XTSAVE is a NO-OP, which
+ *    leaves 2004 ON. A shell that does not itself speak bracketed paste then
+ *    shows a literal `[200~` on every paste until the user runs `reset` — the
+ *    exact I-1 failure, arriving from the restore path.
+ *  - Forcing `?2004l` has no such failure mode. Every shell that DOES use
+ *    bracketed paste (bash >= 4.4 readline, zsh ZLE, fish, PSReadLine) re-arms it
+ *    when it draws its next prompt, so the state the user sees after `aragon`
+ *    exits is the state they had. Every shell that does not use it was already
+ *    off.
+ *
+ * So: 1007 is saved because getting it wrong silently changes a preference; 2004
+ * is forced because getting it wrong visibly breaks pasting, and the forced value
+ * is the one every consumer re-establishes for itself.
+ */
+const ENABLE_BRACKETED_PASTE = '\x1b[?2004h';
+const DISABLE_BRACKETED_PASTE = '\x1b[?2004l';
 const NOOP_HANDLE = { restore() { }, setMouseCapture() { } };
 function safeWrite(stdout, data) {
     try {
@@ -73,7 +99,12 @@ export function enterAltScreen(stdout, options = { mouse: false }) {
         return NOOP_HANDLE;
     const mouse = options.mouse === true;
     const motion = options.motion === true;
-    safeWrite(stdout, ENTER_ALT + CLEAR_VISIBLE + CURSOR_HOME + (mouse ? enableMouse(motion) : SAVE_ALT_SCROLL_OFF));
+    const bracketedPaste = options.bracketedPaste === true;
+    safeWrite(stdout, ENTER_ALT +
+        CLEAR_VISIBLE +
+        CURSOR_HOME +
+        (mouse ? enableMouse(motion) : SAVE_ALT_SCROLL_OFF) +
+        (bracketedPaste ? ENABLE_BRACKETED_PASTE : ''));
     /**
      * THE CURRENT capture state, not the one the session started in (I-10).
      *
@@ -93,6 +124,12 @@ export function enterAltScreen(stdout, options = { mouse: false }) {
      */
     let savedAltScroll = mouse ? false : true;
     const setMouseCapture = (on) => {
+        // IT MUST NOT TOUCH DEC 2004 (I-16 / P2-7). `/mouse off` releases the
+        // pointer; it says nothing about pasting, and a user who turns the mouse off
+        // mid-session to select text with their terminal must not silently lose Tier
+        // 1 detection as well. The two modes are written by different call sites and
+        // unwound by different flags in `restore()`.
+        //
         // A session that never installed a filter has nothing to release, and
         // enabling reporting without one types `[<0;12;5M` into the user's message
         // on every click (I-8). It stays a no-op in both directions.
@@ -134,7 +171,13 @@ export function enterAltScreen(stdout, options = { mouse: false }) {
             // read here rather than the startup `mouse` flag, so a session that ran
             // `/mouse off` exits with exactly one outstanding save restored and
             // nothing left reporting.
-            const tail = (captured ? disableMouse(motion) : '') + (savedAltScroll ? RESTORE_ALT_SCROLL : '');
+            //
+            // DEC 2004 IS UNWOUND FROM THE STARTUP FLAG, not from a runtime one, and
+            // that is deliberate: `setMouseCapture` never touches it (I-16), so this
+            // session either enabled it at entry or never did.
+            const tail = (captured ? disableMouse(motion) : '') +
+                (bracketedPaste ? DISABLE_BRACKETED_PASTE : '') +
+                (savedAltScroll ? RESTORE_ALT_SCROLL : '');
             safeWrite(stdout, tail + SHOW_CURSOR + LEAVE_ALT);
         },
         setMouseCapture,

package/dist/ui/selection/selection-controller.d.ts

@@ -27,7 +27,7 @@
  *    same `decorate` call. What you see is what you get by construction, rather
  *    than by a staleness check that can be wrong.
  */
-import type { MouseSource } from '../../input/stdin-mouse-filter.js';
+import type { MouseSource } from '../../input/stdin-filter.js';
 import type { Theme } from '../theme.js';
 import type { TermCapabilities } from '../capabilities.js';
 import type { CopyVia } from '../clipboard.js';

package/dist/ui/transcript-text.js

@@ -51,6 +51,34 @@ function safeParse(raw) {
         return null;
     }
 }
+/**
+ * The replay's glyph for a service, MIRRORING `ServiceCard::serviceGlyph`.
+ *
+ * The two ladders have to agree, and the cheap-looking shortcut here — "ready or
+ * running is a tick, everything else is an error" — disagrees on the two states
+ * a user reaches ON PURPOSE: a service they stopped with `Ctrl+C`, and one that
+ * exited cleanly. Marking either as a failure in the record the user is left
+ * with after the alternate screen is torn down is a lie about their own action.
+ *
+ * Duplicated rather than imported, as every other case in this file duplicates
+ * its card's ladder: this module is deliberately free of React and ink, and
+ * `serviceGlyph` lives in a `.tsx`.
+ */
+function serviceTextGlyph(status, exitCode, glyphs) {
+    switch (status) {
+        case 'ready':
+            return glyphs.toolDone;
+        case 'running':
+            return glyphs.toolRunning;
+        case 'starting':
+        case 'stopped':
+            return glyphs.toolPending;
+        case 'exited':
+            return exitCode === 0 ? glyphs.toolDone : glyphs.toolError;
+        default:
+            return glyphs.toolError;
+    }
+}
 function renderEntry(entry, glyphs) {
     switch (entry.kind) {
         case 'user':
@@ -134,6 +162,27 @@ function renderEntry(entry, glyphs) {
                 ...entry.summary.split('\n').map((l) => `${TOOL_INDENT}${CONTINUATION_INDENT}${l}`),
             ];
         }
+        case 'service': {
+            // A service the agent started is real work with a real outcome, and an
+            // exported transcript that omitted it would be unaccountable for both —
+            // the argument the `team`, `retry`, `fast` and `compaction` cases above
+            // each make in their own words. It matters more here than for any of them:
+            // this replay is the user's ONLY record once the alternate screen is torn
+            // down (`cli.tsx`'s exit snapshot), and a service card dropped from it
+            // takes the URL the agent reported with it. This file's
+            // `default: return []` means the addition is a CHOICE rather than a
+            // compile requirement, which is exactly why it is easy to leave out
+            // (P0-3).
+            const glyph = serviceTextGlyph(entry.status, entry.exitCode, glyphs);
+            const where = entry.url ? ` ${entry.url}` : '';
+            const code = entry.exitCode === null || entry.exitCode === undefined
+                ? ''
+                : ` (exit code ${entry.exitCode})`;
+            return [
+                `${TOOL_INDENT}${glyph} service ${entry.serviceId} ${entry.command} ` +
+                    `${entry.status}${where}${code}`.trimEnd(),
+            ];
+        }
         case 'notice': {
             const glyph = entry.level === 'error'
                 ? glyphs.error

package/dist/ui/use-wheel-routing.d.ts

@@ -20,7 +20,7 @@
  * the wheel spins: one gesture, one `setState`, one render.
  */
 import type { Overlay } from '../agent/reducer.js';
-import type { MouseSource } from '../input/stdin-mouse-filter.js';
+import type { MouseSource } from '../input/stdin-filter.js';
 import type { ScrollIntent } from './layout/scroll.js';
 /**
  * Rows a PgUp/PgDn — and a Shift+wheel notch — moves inside a controlled

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aragon-agent/cli",
-  "version": "0.6.3",
+  "version": "0.6.4",
   "description": "AragonAgent CLI — a Claude-Code / Codex-style interactive terminal UI (TUI) on top of the @aragon-agent/core engine. Installable and runnable via npm / npx.",
   "license": "MIT",
   "author": "AragonAgent contributors",
@@ -56,7 +56,7 @@
     "prepublishOnly": "npm run build"
   },
   "dependencies": {
-    "@aragon-agent/core": "^0.2.15",
+    "@aragon-agent/core": "^0.2.16",
     "chalk": "^5.6.2",
     "cli-highlight": "^2.0.0",
     "commander": "^12.1.0",

package/dist/input/stdin-mouse-filter.d.ts

@@ -1,47 +0,0 @@
-/**
- * Stdin mouse filter (mouse-wheel-region-routing §4.2 / §5.2).
- *
- * 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, and writes the remainder into a
- * `PassThrough` that carries the surface Ink requires.
- *
- * ORDERING IS AN INVARIANT, NOT A CONVENTION (I-8). The caller must build this
- * filter BEFORE anything writes `\x1b[?1000h`. Reporting enabled while Ink
- * still holds the raw stream does not degrade the feature — it types
- * `[<0;12;5M` into the user's message on every click, which is strictly worse
- * than the bug this feature fixes. `cli.tsx::runInteractive` is the only caller
- * and passes `filter !== null` to `enterAltScreen`.
- */
-import { type MouseEvent } from './mouse-events.js';
-export interface MouseSource {
-    /**
-     * Returns an unsubscribe function. Multiple subscribers are allowed — the
-     * wheel router and (since tui-selection-and-scroll-follow) the selection
-     * controller both take this one channel, and each ignores the kinds it does
-     * not own.
-     */
-    subscribe(listener: (event: MouseEvent) => void): () => void;
-}
-export interface MouseFilter {
-    /** Hand this to Ink: `render(<App/>, { stdin: filter.stdin })`. */
-    readonly stdin: NodeJS.ReadStream;
-    readonly source: MouseSource;
-    /** Idempotent. Detaches from the real stdin and clears the flush timer (I-7). */
-    dispose(): void;
-}
-export declare function createMouseFilter(real: NodeJS.ReadStream): MouseFilter;
-/**
- * Build a filter, or `null` if construction throws.
- *
- * The `null` return is the whole point (P0-1): `enterAltScreen` derives whether
- * to enable mouse reporting from `filter !== null`, so a construction failure
- * degrades to "the wheel is inert" — a supported, tested rung of the fail-safe
- * ladder — rather than leaving reporting on with no filter in front of Ink.
- */
-export declare function tryCreateMouseFilter(real: NodeJS.ReadStream, onError?: (reason: string) => void): MouseFilter | null;

package/dist/input/stdin-mouse-filter.js

@@ -1,153 +0,0 @@
-/**
- * Stdin mouse filter (mouse-wheel-region-routing §4.2 / §5.2).
- *
- * 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, and writes the remainder into a
- * `PassThrough` that carries the surface Ink requires.
- *
- * ORDERING IS AN INVARIANT, NOT A CONVENTION (I-8). The caller must build this
- * filter BEFORE anything writes `\x1b[?1000h`. Reporting enabled while Ink
- * still holds the raw stream does not degrade the feature — it types
- * `[<0;12;5M` into the user's message on every click, which is strictly worse
- * than the bug this feature fixes. `cli.tsx::runInteractive` is the only caller
- * and passes `filter !== null` to `enterAltScreen`.
- */
-import { PassThrough } from 'node:stream';
-import { splitMouseEvents } from './mouse-events.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 `isMousePrefix` to false immediately.
- */
-const PENDING_FLUSH_MS = 12;
-/** 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 });
-}
-export function createMouseFilter(real) {
-    const wrapper = new PassThrough();
-    const listeners = new Set();
-    let pending = '';
-    let flushTimer = null;
-    let disposed = false;
-    // --- 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 clearFlushTimer = () => {
-        if (!flushTimer)
-            return;
-        clearTimeout(flushTimer);
-        flushTimer = null;
-    };
-    const flushPending = () => {
-        clearFlushTimer();
-        if (pending.length === 0 || disposed)
-            return;
-        const text = pending;
-        pending = '';
-        wrapper.write(text);
-    };
-    const onData = (chunk) => {
-        if (disposed)
-            return;
-        clearFlushTimer();
-        const decoded = typeof chunk === 'string' ? chunk : chunk.toString('utf8');
-        const split = splitMouseEvents(pending + decoded);
-        pending = split.pending;
-        if (split.text.length > 0)
-            wrapper.write(split.text);
-        for (const event of split.events)
-            emit(event);
-        if (pending.length > 0) {
-            // `.unref()` so a held tail can never keep the process alive on its own.
-            flushTimer = setTimeout(flushPending, PENDING_FLUSH_MS);
-            flushTimer.unref?.();
-        }
-    };
-    // 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 = () => {
-        flushPending();
-        if (!wrapper.writableEnded)
-            wrapper.end();
-    };
-    // `setEncoding('utf8')` on the REAL stream so Node's StringDecoder handles
-    // multi-byte boundaries for us — the parser 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);
-            },
-        },
-        dispose() {
-            if (disposed)
-                return;
-            disposed = true;
-            clearFlushTimer();
-            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): `enterAltScreen` derives whether
- * to enable mouse reporting from `filter !== null`, so a construction failure
- * degrades to "the wheel is inert" — a supported, tested rung of the fail-safe
- * ladder — rather than leaving reporting on with no filter in front of Ink.
- */
-export function tryCreateMouseFilter(real, onError) {
-    try {
-        return createMouseFilter(real);
-    }
-    catch (err) {
-        onError?.(err instanceof Error ? err.message : String(err));
-        return null;
-    }
-}