chocolatito-code 1.6.6 → 1.6.7

package/dist/ui/ink/montarApp.js

@@ -2,6 +2,8 @@ import { jsx as _jsx } from "react/jsx-runtime";
 import process from "node:process";
 import { render } from "ink";
 import { App } from "./App.js";
+import { darPorPintado, vaciarTranscripcion } from "./transcripcion.js";
+import { devolverTecladoDelPrompt, tomarTecladoParaPrompt } from "../interrupt.js";
 /**
  * MONTA EL ÁRBOL Y LO DEJA VIVO TODA LA SESIÓN
  *
@@ -12,23 +14,113 @@ import { App } from "./App.js";
  * parece a su causa. Con el montaje aparte, `index.ts` llama a los dos y no hay
  * ciclo.
  *
+ * LAS OPCIONES, UNA POR UNA
+ *
  * `exitOnCtrlC: false` porque Ctrl+C ya lo trata el prompt: dejar que Ink cierre
  * el proceso por su cuenta se salta el guardado de la sesión.
+ *
+ * `patchConsole: false` y esto necesita explicación, porque el de serie de Ink
+ * es bueno y aun así no se usa. Quedan cerca de cien `console.log` y
+ * `console.error` repartidos por el programa —los comandos de barra, los avisos
+ * de los hooks, la licencia— y escribir directo con un marco de Ink puesto lo
+ * descuadra. El parche de Ink resuelve eso: borra su marco, escribe y repinta.
+ *
+ * Pero los manda por un camino distinto que el texto del agente, y con otro
+ * tiempo: el del agente espera al dibujado de React, el del parche sale en el
+ * acto. Dos colas para la misma conversación acaban ordenándola mal. Aquí los dos
+ * van por la transcripción, que es una sola cola. Ver ui/pantalla.ts.
+ *
+ * `alternateScreen: false` es lo de serie y se pone a la vista a propósito: es
+ * justo lo que se quitó, y dejarlo escrito ahorra que alguien —yo, dentro de
+ * tres semanas— vuelva a probarlo.
  */
 let arbol = null;
 export function montarArbol() {
     if (arbol)
         return;
-    arbol = render(_jsx(App, {}), { exitOnCtrlC: false });
+    // EL TECLADO ES DE INK MIENTRAS EL ÁRBOL VIVA
+    //
+    // El vigilante de Esc guarda cómo estaba el modo del teclado al empezar el
+    // turno y lo restaura al pararse. Cuando se para tarde —y se para tarde a
+    // menudo: es un `keypress` que se desengancha en el siguiente tick— restaura
+    // "no crudo" con el árbol delante. El terminal vuelve a hacer eco por su
+    // cuenta, las teclas dejan de llegar a Ink, y Enter suelta la línea de golpe.
+    //
+    // Visto desde fuera: "con darle enter se va la traba". Es el teclado que se
+    // queda pillado después de un /effort.
+    //
+    // Esta marca ya existía para el prompt clásico, que la ponía al abrirse y la
+    // quitaba al cerrarse. Con el árbol único el prompt no se cierra nunca, así
+    // que se pone aquí y no se quita hasta desmontar.
+    tomarTecladoParaPrompt();
+    arbol = render(_jsx(App, {}), {
+        exitOnCtrlC: false,
+        patchConsole: false,
+        alternateScreen: false,
+    });
 }
+/**
+ * Suelta el árbol.
+ *
+ * `darPorPintado()` ANTES de desmontar, y el orden importa: si el árbol se
+ * vuelve a montar —un diálogo que necesita el teclado para él solo—, el
+ * `<Static>` nuevo empieza su cuenta de cero y reimprimiría la conversación
+ * entera. En la pantalla normal esas líneas siguen ahí, en el terminal; la marca
+ * dice por dónde iba para que el montaje nuevo solo escriba lo que falta.
+ *
+ * `clear()` borra el marco de abajo antes de irse. Sin eso queda una copia
+ * muerta de la barra en mitad del historial, y en la próxima sesión de scroll el
+ * usuario se encuentra dos.
+ */
 export function desmontarArbol() {
     if (!arbol)
         return;
+    darPorPintado();
+    try {
+        arbol.clear();
+    }
+    catch { }
     try {
         arbol.unmount();
     }
     catch { }
     arbol = null;
+    devolverTecladoDelPrompt();
+}
+export function hayArbol() {
+    return arbol !== null;
+}
+/**
+ * Borra la pantalla de verdad. Es lo que hacen /clear, /cd y Ctrl+L.
+ *
+ * POR QUE NO VALE UN `console.clear()`
+ *
+ * `console.clear()` escribe la secuencia de borrado directa al terminal, y no
+ * pasa por la interceptación de consola: ahí solo van `log`, `error`, `warn` e
+ * `info`. Con el árbol montado eso borra filas que Ink cree suyas, y a partir de
+ * ahí Ink borra y repinta sobre un sitio que ya no existe. Lo que se ve es
+ * basura, o nada.
+ *
+ * Aquí se hace en el orden que no rompe nada: se borra el marco con la cuenta
+ * todavía buena, se suelta el árbol, se limpia la pantalla —y el historial del
+ * terminal con `3J`, que es lo que el usuario espera de un /clear— y se vuelve a
+ * montar de cero.
+ *
+ * Y se vacía la transcripción: si no, el <Static> nuevo tendría por delante toda
+ * la conversación que se acaba de borrar.
+ */
+export function limpiarLaPantalla() {
+    const habia = arbol !== null;
+    if (habia)
+        desmontarArbol();
+    vaciarTranscripcion();
+    try {
+        // 2J la pantalla, 3J el historial de desplazamiento, H el cursor arriba.
+        process.stdout.write("\x1b[2J\x1b[3J\x1b[H");
+    }
+    catch { }
+    if (habia)
+        montarArbol();
 }
 // Si el proceso muere sin pasar por la salida ordenada, el árbol tiene que
 // soltarse igual: un árbol vivo en un proceso que se cierra deja el terminal a

package/dist/ui/ink/prestamo.d.ts

@@ -0,0 +1,63 @@
+/**
+ * PRESTARLE EL TERMINAL A OTRO UN MOMENTO
+ *
+ * EL PROBLEMA
+ *
+ * Con el árbol de Ink montado, el terminal tiene un dueño: Ink pide el modo
+ * crudo, lleva la cuenta de las filas que ha pintado y repinta por diferencias.
+ *
+ * Pero hay tres sitios del programa que necesitan el teclado para ellos solos, y
+ * los tres se abren EN MITAD DE UN TURNO, con el árbol vivo:
+ *
+ *   - el diálogo de permisos (ui/permissionPrompt.ts), que sube el cursor con
+ *     `\x1b[nA` y repinta su caja a mano;
+ *   - el aviso de bucle (ui/loopPrompt.ts), que abre `readline`;
+ *   - el menú de /effort (ui/selector.ts), que repinta su lista.
+ *
+ * Los tres escriben directo a `process.stdout` y abren `readline` sobre el mismo
+ * `process.stdin` que Ink está leyendo. Dos dueños a la vez: el marco de Ink se
+ * descuadra desde la primera herramienta que pida permiso, y a partir de ahí
+ * repinta sobre filas que ya no son suyas.
+ *
+ * LA SOLUCIÓN, QUE YA VENÍA EN INK
+ *
+ * `suspendTerminal` existe para esto —está pensado para abrir `$EDITOR` o `less`
+ * desde una aplicación de Ink— y hace exactamente lo que hace falta: vacía lo
+ * pendiente, borra su marco, devuelve el cursor, suelta el modo crudo, y al
+ * volver reclama la entrada y fuerza un redibujado completo. Si la tarea revienta
+ * lo restaura igual.
+ *
+ * POR QUE HAY UN ARCHIVO SOLO PARA ESTO
+ *
+ * `suspendTerminal` solo se coge con `useApp()`, o sea desde dentro de un
+ * componente. Quien lo necesita —el diálogo de permisos, llamado desde el bucle
+ * del agente— está a diez capas de React. Aquí App lo deja apuntado al montarse
+ * y el resto del programa lo usa sin saber que Ink existe.
+ *
+ * SIN ÁRBOL NO PASA NADA
+ *
+ * En el modo clásico no hay nadie registrado y la tarea se ejecuta tal cual. Por
+ * eso se puede envolver a los tres sin condicionales en el sitio de la llamada.
+ */
+type Prestamo = (tarea: () => void | Promise<void>) => Promise<void>;
+export declare function registrarPrestamo(fn: Prestamo | null): void;
+export declare function hayPrestamo(): boolean;
+/**
+ * ¿Está el terminal ahora mismo en manos de otro?
+ *
+ * Lo pregunta el vigilante del teclado del árbol: mientras un diálogo tiene el
+ * terminal, el modo crudo es SUYO y reafirmarlo por detrás le quitaría las
+ * teclas justo cuando está esperando una respuesta.
+ */
+export declare function terminalPrestado(): boolean;
+/**
+ * Corre `tarea` con el terminal en manos de quien lo pide.
+ *
+ * El guardián de anidamiento no es hipotético: un subagente puede pedir permiso
+ * mientras el principal ya tiene un diálogo abierto. Suspender dos veces lanza
+ * una excepción dentro de Ink, y el árbol se quedaría suspendido para siempre —
+ * pantalla muerta. Si ya está prestado, la tarea corre y ya está: el terminal ya
+ * es de quien lo pidió primero.
+ */
+export declare function conElTerminalPrestado<T>(tarea: () => Promise<T>): Promise<T>;
+export {};

package/dist/ui/ink/prestamo.js

@@ -0,0 +1,92 @@
+/**
+ * PRESTARLE EL TERMINAL A OTRO UN MOMENTO
+ *
+ * EL PROBLEMA
+ *
+ * Con el árbol de Ink montado, el terminal tiene un dueño: Ink pide el modo
+ * crudo, lleva la cuenta de las filas que ha pintado y repinta por diferencias.
+ *
+ * Pero hay tres sitios del programa que necesitan el teclado para ellos solos, y
+ * los tres se abren EN MITAD DE UN TURNO, con el árbol vivo:
+ *
+ *   - el diálogo de permisos (ui/permissionPrompt.ts), que sube el cursor con
+ *     `\x1b[nA` y repinta su caja a mano;
+ *   - el aviso de bucle (ui/loopPrompt.ts), que abre `readline`;
+ *   - el menú de /effort (ui/selector.ts), que repinta su lista.
+ *
+ * Los tres escriben directo a `process.stdout` y abren `readline` sobre el mismo
+ * `process.stdin` que Ink está leyendo. Dos dueños a la vez: el marco de Ink se
+ * descuadra desde la primera herramienta que pida permiso, y a partir de ahí
+ * repinta sobre filas que ya no son suyas.
+ *
+ * LA SOLUCIÓN, QUE YA VENÍA EN INK
+ *
+ * `suspendTerminal` existe para esto —está pensado para abrir `$EDITOR` o `less`
+ * desde una aplicación de Ink— y hace exactamente lo que hace falta: vacía lo
+ * pendiente, borra su marco, devuelve el cursor, suelta el modo crudo, y al
+ * volver reclama la entrada y fuerza un redibujado completo. Si la tarea revienta
+ * lo restaura igual.
+ *
+ * POR QUE HAY UN ARCHIVO SOLO PARA ESTO
+ *
+ * `suspendTerminal` solo se coge con `useApp()`, o sea desde dentro de un
+ * componente. Quien lo necesita —el diálogo de permisos, llamado desde el bucle
+ * del agente— está a diez capas de React. Aquí App lo deja apuntado al montarse
+ * y el resto del programa lo usa sin saber que Ink existe.
+ *
+ * SIN ÁRBOL NO PASA NADA
+ *
+ * En el modo clásico no hay nadie registrado y la tarea se ejecuta tal cual. Por
+ * eso se puede envolver a los tres sin condicionales en el sitio de la llamada.
+ */
+let prestar = null;
+/** Ink revienta si se suspende dos veces. Ver ink.js:873-875. */
+let yaPrestado = false;
+export function registrarPrestamo(fn) {
+    prestar = fn;
+}
+export function hayPrestamo() {
+    return prestar !== null;
+}
+/**
+ * ¿Está el terminal ahora mismo en manos de otro?
+ *
+ * Lo pregunta el vigilante del teclado del árbol: mientras un diálogo tiene el
+ * terminal, el modo crudo es SUYO y reafirmarlo por detrás le quitaría las
+ * teclas justo cuando está esperando una respuesta.
+ */
+export function terminalPrestado() {
+    return yaPrestado;
+}
+/**
+ * Corre `tarea` con el terminal en manos de quien lo pide.
+ *
+ * El guardián de anidamiento no es hipotético: un subagente puede pedir permiso
+ * mientras el principal ya tiene un diálogo abierto. Suspender dos veces lanza
+ * una excepción dentro de Ink, y el árbol se quedaría suspendido para siempre —
+ * pantalla muerta. Si ya está prestado, la tarea corre y ya está: el terminal ya
+ * es de quien lo pidió primero.
+ */
+export async function conElTerminalPrestado(tarea) {
+    if (!prestar || yaPrestado)
+        return tarea();
+    let resultado;
+    let fallo = null;
+    yaPrestado = true;
+    try {
+        await prestar(async () => {
+            try {
+                resultado = await tarea();
+            }
+            catch (e) {
+                fallo = e;
+            }
+        });
+    }
+    finally {
+        yaPrestado = false;
+    }
+    if (fallo)
+        throw fallo;
+    return resultado;
+}

package/dist/ui/ink/teclado.d.ts

@@ -0,0 +1,48 @@
+/**
+ * EL TECLADO SIGUE SIENDO NUESTRO, SE COMPRUEBE CUANDO SE COMPRUEBE
+ *
+ * EL FALLO, CON SUS PALABRAS
+ *
+ * "al poner un / y poner algo luego se queda trabado y ya no se puede escribir a
+ * menos que pongas enter". Y antes: "al cambiar de potencia se queda pegado y no
+ * deja escribir, tengo que presionar enter". Y antes: "escribí 2 prompts y al
+ * siguiente ya no me deja escribir nada, teclee lo que teclee".
+ *
+ * Es siempre el mismo, y el "se arregla con Enter" es la firma que lo delata: en
+ * modo cocido la consola guarda lo que tecleas y no lo suelta hasta el Enter. O
+ * sea que el teclado no está muerto — está en manos del terminal, y quien hace
+ * el eco es PowerShell, no la caja.
+ *
+ * POR QUE VUELVE UNA Y OTRA VEZ
+ *
+ * Porque hay muchos sitios que apagan el modo crudo, y todos con razón: un
+ * `InterruptWatcher` que se para tarde y restaura el estado anterior, un
+ * `readline` que al cerrarse hace `pause()` y `setRawMode(false)`, un proceso
+ * hijo que hereda la consola y la devuelve en cocido. Basta con que UNA de las
+ * veinte salidas se escape.
+ *
+ * Y HAY UNA FORMA QUE NODE NI SIQUIERA VE
+ *
+ * Cuando el que la cambia es un proceso hijo, `process.stdin.isRaw` se queda
+ * diciendo `true`. Por debajo, libuv guarda el modo que cree tener y empieza con
+ * `if (tty->mode == mode) return 0;`: a partir de ahí todos los `setRawMode(true)`
+ * son un no-op. Node cree que manda y no manda. Por eso hay una reafirmación
+ * —pasar por `false` y volver— que sí rompe esa caché.
+ *
+ * POR QUE ESTE ARCHIVO ES NUEVO
+ *
+ * El vigilante existía y funcionaba, pero vivía DENTRO del prompt clásico
+ * (ui/prompt.ts), que se abría y se cerraba en cada vuelta. Al mudarse a Ink y
+ * después al árbol único, el prompt dejó de abrirse y cerrarse... y el vigilante
+ * se quedó atrás. El fallo volvió, y volvió idéntico.
+ *
+ * Aquí vive mientras viva el árbol, que es toda la sesión.
+ */
+/**
+ * @param esperando ¿está la caja abierta esperando una orden?
+ *
+ * Se usa para reafirmar en el momento exacto en que se abre. Ese instante es el
+ * que sigue a un comando de barra, a un menú o a un proceso hijo: justo cuando
+ * la consola puede acabar de volver en cocido sin que Node se entere.
+ */
+export declare function useTecladoSiempreNuestro(esperando: boolean): void;

package/dist/ui/ink/teclado.js

@@ -0,0 +1,96 @@
+import { useEffect } from "react";
+import process from "node:process";
+import { MS_ENTRE_COMPROBACIONES, reafirmarModoCrudo, repararTeclado, } from "../keyboardGuard.js";
+import { terminalPrestado } from "./prestamo.js";
+/**
+ * EL TECLADO SIGUE SIENDO NUESTRO, SE COMPRUEBE CUANDO SE COMPRUEBE
+ *
+ * EL FALLO, CON SUS PALABRAS
+ *
+ * "al poner un / y poner algo luego se queda trabado y ya no se puede escribir a
+ * menos que pongas enter". Y antes: "al cambiar de potencia se queda pegado y no
+ * deja escribir, tengo que presionar enter". Y antes: "escribí 2 prompts y al
+ * siguiente ya no me deja escribir nada, teclee lo que teclee".
+ *
+ * Es siempre el mismo, y el "se arregla con Enter" es la firma que lo delata: en
+ * modo cocido la consola guarda lo que tecleas y no lo suelta hasta el Enter. O
+ * sea que el teclado no está muerto — está en manos del terminal, y quien hace
+ * el eco es PowerShell, no la caja.
+ *
+ * POR QUE VUELVE UNA Y OTRA VEZ
+ *
+ * Porque hay muchos sitios que apagan el modo crudo, y todos con razón: un
+ * `InterruptWatcher` que se para tarde y restaura el estado anterior, un
+ * `readline` que al cerrarse hace `pause()` y `setRawMode(false)`, un proceso
+ * hijo que hereda la consola y la devuelve en cocido. Basta con que UNA de las
+ * veinte salidas se escape.
+ *
+ * Y HAY UNA FORMA QUE NODE NI SIQUIERA VE
+ *
+ * Cuando el que la cambia es un proceso hijo, `process.stdin.isRaw` se queda
+ * diciendo `true`. Por debajo, libuv guarda el modo que cree tener y empieza con
+ * `if (tty->mode == mode) return 0;`: a partir de ahí todos los `setRawMode(true)`
+ * son un no-op. Node cree que manda y no manda. Por eso hay una reafirmación
+ * —pasar por `false` y volver— que sí rompe esa caché.
+ *
+ * POR QUE ESTE ARCHIVO ES NUEVO
+ *
+ * El vigilante existía y funcionaba, pero vivía DENTRO del prompt clásico
+ * (ui/prompt.ts), que se abría y se cerraba en cada vuelta. Al mudarse a Ink y
+ * después al árbol único, el prompt dejó de abrirse y cerrarse... y el vigilante
+ * se quedó atrás. El fallo volvió, y volvió idéntico.
+ *
+ * Aquí vive mientras viva el árbol, que es toda la sesión.
+ */
+/**
+ * @param esperando ¿está la caja abierta esperando una orden?
+ *
+ * Se usa para reafirmar en el momento exacto en que se abre. Ese instante es el
+ * que sigue a un comando de barra, a un menú o a un proceso hijo: justo cuando
+ * la consola puede acabar de volver en cocido sin que Node se entere.
+ */
+export function useTecladoSiempreNuestro(esperando) {
+    // Al abrir la caja se reafirma SIEMPRE, sin preguntar. `repararTeclado` solo
+    // actúa cuando SABE que se perdió el modo crudo, y este es justo el caso en el
+    // que no lo sabe.
+    useEffect(() => {
+        if (!esperando)
+            return;
+        if (terminalPrestado())
+            return;
+        reafirmarModoCrudo(process.stdin);
+        avisar(`reafirmado al abrir la caja (isRaw decia ${process.stdin.isRaw})`);
+    }, [esperando]);
+    // Y cuatro veces por segundo, mientras el árbol viva, se comprueba que sigue
+    // siendo nuestro. No se reafirma en cada vuelta a propósito: pasar por `false`
+    // y volver cuatro veces por segundo es pedirle problemas a la consola por un
+    // caso raro. Aquí solo se repara lo que se ve roto.
+    useEffect(() => {
+        const vigilante = setInterval(() => {
+            // Mientras un diálogo tiene el terminal, el modo crudo es SUYO: tocarlo
+            // por detrás le quitaría las teclas justo cuando espera una respuesta.
+            if (terminalPrestado())
+                return;
+            const reparado = repararTeclado(process.stdin);
+            if (reparado.length > 0)
+                avisar(`recuperado: ${reparado.join(" y ")}`);
+        }, MS_ENTRE_COMPROBACIONES);
+        // Un temporizador de vigilancia no es motivo para que el proceso siga vivo.
+        vigilante.unref?.();
+        return () => clearInterval(vigilante);
+    }, []);
+}
+/**
+ * Se calla salvo que se pida verlo.
+ *
+ * Si esto llega a decir algo es que hay un fallo de verdad en quien soltó el
+ * teclado, y saber cuál de las veinte salidas fue vale más que el mensaje.
+ */
+function avisar(texto) {
+    if (process.env.CHOCOLATITO_TECLADO !== "debug")
+        return;
+    try {
+        process.stderr.write(`\n[teclado] ${texto}\n`);
+    }
+    catch { }
+}

package/dist/ui/ink/transcripcion.d.ts

@@ -0,0 +1,114 @@
+/**
+ * LA CONVERSACIÓN, EN CAMINO AL HISTORIAL DEL TERMINAL
+ *
+ * QUÉ SUSTITUYE, Y POR QUÉ
+ *
+ * Antes esto era `historial.ts`: un buffer en memoria con las últimas 5000
+ * líneas, que hacía falta porque la pantalla alternativa deja al terminal sin
+ * historial propio. Aquí no hay pantalla alternativa. Lo que se escribe entra en
+ * el historial DEL TERMINAL —el de verdad, el de la rueda del ratón— a través de
+ * `<Static>` de Ink, y esto es solo la cinta transportadora que lo lleva hasta
+ * allí.
+ *
+ * POR QUÉ HAY QUE PARTIR EN LÍNEAS
+ *
+ * `<Static>` emite un elemento y lo da por escrito para siempre: una vez fuera,
+ * ni Ink ni nadie puede volver a tocarlo, porque ya es texto del terminal. Así
+ * que solo puede entrar lo que está terminado. El modelo, en cambio, escribe a
+ * chorros que cortan a mitad de palabra.
+ *
+ * Aquí se separan las dos cosas: lo que ya tiene su salto de línea pasa a
+ * `<Static>` y se vuelve permanente; el trozo que cuelga se queda en `resto` y
+ * lo pinta la zona de abajo, que sí se repinta. Cuando llega el salto, el resto
+ * entero cruza al otro lado. Visto desde fuera es una línea que se va
+ * escribiendo, sin saltos ni parpadeos.
+ *
+ * LAS DOS REGLAS DE <STATIC>, QUE NO SON NEGOCIABLES
+ *
+ * Están medidas en `node_modules/ink/build/components/Static.js:11-20`, que es
+ * todo el mecanismo: guarda un índice, renderiza `items.slice(indice)` y en el
+ * commit siguiente adelanta el índice a `items.length`. No compara nada.
+ *
+ *   1. La lista SOLO crece. Un `splice`, un `filter` o un vaciado hacen retroceder
+ *      el índice, y todo lo que se añada por encima se REIMPRIME: la conversación
+ *      sale duplicada en el historial del terminal y ya no hay forma de borrarla.
+ *   2. Cada elemento necesita `key` propia y estable. React reutiliza nodos por
+ *      posición, y la lista que ve cambia de longitud en cada commit; sin `key`
+ *      acabas emitiendo el texto de otro. Por eso cada línea lleva su `id`.
+ *
+ * Y POR QUÉ EXISTE `base`
+ *
+ * Cuando el árbol se desmonta y se vuelve a montar —un diálogo de permisos que
+ * necesita el teclado para él solo— el `<Static>` nuevo empieza de cero y
+ * volvería a escribir la conversación entera. Pero en la pantalla normal esas
+ * líneas siguen ahí, en el terminal, que no se ha borrado. `base` marca por
+ * dónde iba, y el montaje nuevo solo recibe lo que aún no se ha pintado.
+ */
+export interface LineaPermanente {
+    /** Estable y única. Es la `key` que <Static> necesita. */
+    id: number;
+    texto: string;
+}
+/**
+ * Entra texto del agente. Acepta trozos a media línea, que es lo normal.
+ *
+ * El `\r` suelto se descarta con su línea: en un flujo de markdown no es un
+ * retorno de carro de verdad, viene de un `\r\n` partido por la mitad entre dos
+ * trozos, y dejarlo pasar mete una línea vacía por cada salto.
+ */
+export declare function anotar(texto: string): void;
+/**
+ * Las líneas que <Static> todavía no ha escrito.
+ *
+ * DEVUELVE UN ARRAY NUEVO CADA VEZ QUE HAY ALGO NUEVO, Y NO ES UN CAPRICHO
+ *
+ * Este fue el fallo que dejó la conversación entera sin escribirse, y costó
+ * encontrarlo porque no parecía un fallo: la primera versión devolvía el array
+ * interno tal cual, al que `anotar` le hace `push`.
+ *
+ * <Static> memoriza lo que va a emitir con `useMemo(() => items.slice(index),
+ * [items, index])` (Static.js:12-14). Con la MISMA referencia de array y el
+ * mismo índice, React da por buena la memoria y devuelve lo de antes: el `[]`
+ * del primer dibujado. El array crecía, la pantalla no. Nada de emitir de más
+ * ni de menos: sencillamente no se emitía NUNCA.
+ *
+ * Así que la referencia tiene que cambiar cuando cambia el contenido. Se
+ * reconstruye solo cuando ha crecido de verdad —una vez por línea terminada, no
+ * una por dibujado—, que a treinta fotogramas por segundo es la diferencia entre
+ * reconstruirlo treinta veces por segundo o ninguna mientras nadie escribe.
+ */
+export declare function pendientes(): LineaPermanente[];
+/** El trozo que cuelga, el que pinta la zona de abajo. */
+export declare function colgando(): string;
+/**
+ * "Lo de hasta aquí ya está en el terminal."
+ *
+ * Se llama SOLO justo antes de desmontar el árbol. Llamarlo con el árbol vivo
+ * encogería la lista que ve <Static>, que es la regla 1 de arriba.
+ */
+export declare function darPorPintado(): void;
+export declare function alCambiar(cb: () => void): () => void;
+/** Para las pruebas. En producción la conversación no se tira nunca. */
+export declare function vaciarTranscripcion(): void;
+/** Cuántas líneas terminadas van. Para las pruebas y para medir. */
+export declare function cuantasLineas(): number;
+/**
+ * Recorta el trozo que cuelga para que quepa en las filas que le tocan.
+ *
+ * NO ES COSMÉTICO, ES LA RED DE SEGURIDAD DEL RENDIMIENTO
+ *
+ * En Windows, si el bloque de abajo llega a medir lo que la ventana, Ink deja de
+ * repintar por diferencias y pasa a `clearTerminal` + reimprimir la conversación
+ * ENTERA en cada fotograma (ink.js:100-102 y 769). Con el spinner a 30 por
+ * segundo eso es parpadeo, historial perdido y coste creciente con la sesión.
+ *
+ * El caso que lo dispara: un párrafo largo sin un solo salto de línea. Mientras
+ * no lo termine, ese párrafo entero es "lo que cuelga".
+ *
+ * Cuando hay que recortar se quitan también los colores: cortar una cadena por
+ * el medio parte los códigos de escape y lo que sale es basura de colores
+ * enganchada al resto de la sesión. Es un trozo que en cuanto llegue su salto de
+ * línea se reemplaza por la línea entera y bien pintada, así que el recorte no
+ * dura ni un parpadeo.
+ */
+export declare function recortarCola(texto: string, cols: number, filas: number): string[];