@hoilab/ada-cli 0.84.22 → 0.85.1

package/dist/core/edicion/rutas-difusas.js

@@ -0,0 +1,93 @@
+/**
+ * Rutas difusas: el modelo dijo `edit.ts`, quiso decir `src/core/tools/edit.ts`.
+ *
+ * EL CASO. El modelo escribe la cola de la ruta que vio en un grep, no la
+ * completa. Hoy la tool de edición rechaza «no existe» y se pierde un turno en
+ * algo que en el workspace solo puede ser un fichero.
+ *
+ * LO QUE COPIAMOS DE oh-my-pi (index.ts resolveEditPath/findUniqueWorkspaceSuffix)
+ * Y LO QUE NO: la resolución por sufijo único del workspace es suya y es
+ * correcta. Las dos puertas también, porque sin ellas esto convierte un error
+ * claro en una escritura al fichero equivocado:
+ *
+ *   1. **La ruta exacta gana siempre** y no pasa por la búsqueda.
+ *   2. **Solo 1 coincidencia resuelve.** 0 o 2+ son error con candidatos —
+ *      elegir por el modelo es peor que rechazar (misma regla de dominancia
+ *      que `parecido.ts` usa para líneas).
+ *
+ * La búsqueda es por SUFIJO exacto de ruta, no por parecido de nombre: `edit.tss`
+ * no resuelve a `edit.ts`. Eso ya lo cubre la recuperación de erratas de
+ * `reparacion.ts`, en otro plano.
+ */
+import { existsSync, readdirSync } from "node:fs";
+import { join, relative, resolve, sep } from "node:path";
+import { resolveToCwd } from "../tools/path-utils.js";
+/** Directorios que nunca entran en la búsqueda difusa: ruido infinito, cero intención. */
+const EXCLUIDAS = new Set(["node_modules", ".git", ".hg", ".jj", "dist", "build", ".venv", "__pycache__"]);
+/** La entrada es ambigua: estas son las coincidencias para que el modelo elija con información. */
+export class ErrorRutaAmbigua extends Error {
+    candidatos;
+    constructor(entrada, candidatos) {
+        const visibles = candidatos.slice(0, 10);
+        const resto = candidatos.length - visibles.length;
+        super(`«${entrada}» es ambiguo: ${candidatos.length} ficheros coinciden.\n${visibles.map((c) => `  - ${c}`).join("\n")}${resto > 0 ? `\n  …y ${resto} más.` : ""}`);
+        this.name = "ErrorRutaAmbigua";
+        this.candidatos = candidatos;
+    }
+}
+/** Nadie termina en lo que pidió la entrada. */
+export class ErrorRutaInexistente extends Error {
+    constructor(entrada, raices) {
+        super(`Ningún fichero bajo ${raices.join(", ")} coincide con «${entrada}». Revisa la ruta o créala primero.`);
+        this.name = "ErrorRutaInexistente";
+    }
+}
+function recorrerFicheros(dir) {
+    const ficheros = [];
+    let entradas;
+    try {
+        entradas = readdirSync(dir, { withFileTypes: true });
+    }
+    catch {
+        // Raíz ilegible o desaparecida: contribuye con cero candidatos, no tumba la búsqueda.
+        return ficheros;
+    }
+    for (const entrada of entradas) {
+        if (entrada.isDirectory()) {
+            if (!EXCLUIDAS.has(entrada.name))
+                ficheros.push(...recorrerFicheros(join(dir, entrada.name)));
+        }
+        else {
+            ficheros.push(join(dir, entrada.name));
+        }
+    }
+    return ficheros;
+}
+/**
+ * Resuelve `entrada` contra `cwd`; si no existe tal cual, busca la única ruta
+ * bajo alguna de `raices` (por defecto `[cwd]`) que termine exactamente en ese
+ * sufijo. Exacta → `{exacta: true}`. Única por sufijo → `{exacta: false}`.
+ * Cero o varias → `ErrorRutaInexistente`/`ErrorRutaAmbigua` con candidatos.
+ */
+export async function resolverRutaDifusa(entrada, cwd, raices) {
+    const limpia = entrada.replace(/\\/g, "/").replace(/^\.\//, "");
+    const absoluta = resolveToCwd(limpia, cwd);
+    if (existsSync(absoluta))
+        return { ruta: absoluta, exacta: true };
+    const bases = (raices ?? [cwd]).map((r) => resolve(r));
+    const sufijo = limpia.replace(/^\//, "");
+    const candidatos = [];
+    for (const base of bases) {
+        for (const fichero of recorrerFicheros(base)) {
+            const rel = relative(base, fichero).split(sep).join("/");
+            if (rel === sufijo || rel.endsWith(`/${sufijo}`))
+                candidatos.push(fichero);
+        }
+    }
+    if (candidatos.length === 1)
+        return { ruta: candidatos[0], exacta: false };
+    if (candidatos.length === 0)
+        throw new ErrorRutaInexistente(sufijo, bases);
+    throw new ErrorRutaAmbigua(sufijo, candidatos);
+}
+//# sourceMappingURL=rutas-difusas.js.map

package/dist/core/edicion/rutas-difusas.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"rutas-difusas.js","sourceRoot":"","sources":["../../../src/core/edicion/rutas-difusas.ts"],"names":[],"mappings":"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"}

package/dist/core/edicion/sangria.d.ts

@@ -0,0 +1,121 @@
+/**
+ * Casar una edición cuando el modelo se equivoca con la SANGRÍA.
+ *
+ * EL CASO. Ada se indenta con tabuladores y los modelos emiten espacios sin
+ * parar. Medido sobre el banco de cargas mal formadas: de once cargas
+ * recuperables, el motor entraba en tres, y varias de las que rechazaba eran de
+ * sangría — el error más frecuente que existe.
+ *
+ * Un rechazo cuesta un turno entero: el modelo tiene que releer el fichero y
+ * volver a escribir el bloque a ciegas, y muchas veces repite el mismo error.
+ *
+ * LO QUE ESTE MÓDULO NO HACE, y es la parte importante. No basta con encontrar
+ * el sitio: hay que escribir el reemplazo con la sangría DEL FICHERO. oh-my-pi
+ * casa más cargas que nosotros pero de las diez que aplica, tres corrompen — dos
+ * de ellas dejando la sangría mal. Aplicar no es aplicar bien:
+ *
+ *     antes:  →app.listen(puerto);
+ *     mal:        app.listen(PUERTO);     ← entró, y dejó espacios en un
+ *                                            fichero de tabuladores
+ *
+ * En TypeScript eso es cosmético. En Python es un error de sintaxis, o peor: una
+ * línea que se sale del bloque `if` y cambia la semántica sin romper nada.
+ *
+ * DOS INVARIANTES QUE LO HACEN SEGURO:
+ *
+ * 1. **Una sola posición.** Si el patrón sin sangría casa en dos sitios, se
+ *    devuelve `null`. Quitar la sangría hace el patrón MENOS específico, así que
+ *    puede volver ambiguo algo que no lo era — y elegir por el modelo cuál de
+ *    los dos editar es peor que rechazar.
+ * 2. **La sangría sale del fichero, nunca del patrón.** Se mide la del bloque
+ *    casado y se reconstruye el reemplazo con su carácter y su unidad,
+ *    conservando la profundidad RELATIVA que el modelo expresó.
+ *
+ * EL ESPACIADO INTERNO, que es el mismo error una columna más adentro. El
+ * fichero tiene `let suma = 0;` y el modelo manda `let suma  = 0;`. No es un
+ * problema de sangría —la sangría está bien— y sin embargo cuesta un turno
+ * entero igual. Se recupera con una SEGUNDA pasada de comparación que colapsa
+ * los espacios y tabuladores interiores.
+ *
+ * Y aquí está la trampa que hay que ver antes de tocar esto. Colapsar espacios
+ * en `normalizeForFuzzyMatch` (en `core/tools/edit-diff.ts`) sería mucho más
+ * corto y estaría MAL: esa forma normalizada se convierte en la base de
+ * escritura cuando alguna edición del lote es difusa, y su traducción de
+ * posiciones exige que cada sustitución sea de un carácter por otro. `[ \t]+` a
+ * un espacio no lo es. Ya nos costó una corrupción silenciosa por el mismo
+ * camino: `“`→`"` en una línea que nadie pidió tocar, dejando ficheros que ni
+ * compilan. Aquí el colapso vive SOLO en la comparación —una función que se
+ * llama para decidir si dos líneas son la misma— y nunca en el texto que se
+ * escribe: el reemplazo se construye desde el `newText` del modelo y desde los
+ * bytes del bloque original, jamás desde la forma colapsada.
+ */
+/** Un bloque casado, con lo que hace falta para empalmarlo. */
+export interface CasadoPorSangria {
+    /** Desplazamiento del inicio del bloque en el contenido original. */
+    indice: number;
+    /** Cuántos caracteres ocupa el bloque casado. */
+    longitud: number;
+    /** El reemplazo, ya re-sangrado a la sangría del fichero. */
+    textoNuevo: string;
+}
+/**
+ * Qué unidad de sangría usa un bloque: el carácter y cuántos por nivel.
+ *
+ * Se deduce del propio bloque casado y no de todo el fichero, porque un fichero
+ * mixto —los hay— daría una respuesta que no vale para la región que se toca.
+ */
+export declare function unidadDe(lineas: readonly string[]): {
+    caracter: string;
+    ancho: number;
+};
+/**
+ * Re-emite `nuevas` con la sangría del BLOQUE destino, conservando la
+ * profundidad relativa que expresó el modelo.
+ *
+ * Vive aquí y se exporta porque el camino del hueco elidido (`./hueco.ts`)
+ * necesita exactamente esto: escribía el `newText` tal cual y metía un
+ * tabulador en un fichero de cuatro espacios, que es el invariante 2 de este
+ * módulo roto en el camino de al lado.
+ */
+export declare function reSangrarComoElBloque(nuevas: readonly string[], bloque: readonly string[]): string[];
+/**
+ * Casa `oldText` contra `contenido` ignorando la sangría, y re-sangra `newText`.
+ *
+ * Devuelve `null` cuando no casa, cuando casa en más de un sitio, o cuando el
+ * patrón está vacío. `null` significa «no puedo», nunca «no hay»: quien llama
+ * debe seguir con su propio error, no dar la edición por aplicada.
+ */
+export declare function casarIgnorandoSangria(contenido: string, oldText: string, newText: string): CasadoPorSangria | null;
+/**
+ * ¿El texto nuevo mete un carácter de sangría que el fichero no usa?
+ *
+ * EL CASO, encontrado auditando y reproducido ejecutando. Cuando el `oldText`
+ * casa EXACTO, el motor escribe el `newText` tal cual y se salta toda la lógica
+ * de sangría de arriba. Si el modelo teclea el bloque nuevo con tabuladores en
+ * un fichero de espacios —cosa que hace constantemente— la mezcla entra sin que
+ * nadie la mire:
+ *
+ *     class Carro:
+ *         def total(self, items):     ← 4 espacios, del fichero
+ *     →→→→s = 0                       ← tabuladores, del modelo
+ *
+ * En Python eso es un `TabError` y el fichero no arranca. Y no lo caza nadie:
+ * `core/edicion/parseo.ts` solo cubre TypeScript y JSON, así que para `.py`
+ * devuelve `null` y la red de reparación ni se despierta.
+ *
+ * En TypeScript no rompe la sintaxis, pero deja un fichero con dos estilos que
+ * el siguiente `edit` va a casar peor. Es la misma familia que perseguimos:
+ * la edición ENTRA, así que se lee como éxito.
+ *
+ * POR QUÉ AQUÍ Y NO EN UN COMPROBADOR POR LENGUAJE. Esto no necesita gramática
+ * de nada: se compara el carácter de sangría del bloque que se sustituye con el
+ * del texto que entra. Un comprobador de Python arreglaría Python; esto arregla
+ * cualquier lenguaje sensible a la sangría, presentes y futuros.
+ *
+ * QUÉ NO HACE: no toca el texto cuando el bloque original ya mezcla —ahí no hay
+ * un estilo del fichero que respetar, y elegir uno sería inventárselo—. omp, en
+ * ese caso, abandona y escribe el texto crudo (`normalize.ts:325`); nosotros
+ * hacemos lo mismo, pero solo en ese caso.
+ */
+export declare function coherenteConElBloque(bloqueOriginal: string, textoNuevo: string): string;
+//# sourceMappingURL=sangria.d.ts.map

package/dist/core/edicion/sangria.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sangria.d.ts","sourceRoot":"","sources":["../../../src/core/edicion/sangria.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkDG;AAEH,+DAA+D;AAC/D,MAAM,WAAW,gBAAgB;IAChC,qEAAqE;IACrE,MAAM,EAAE,MAAM,CAAC;IACf,iDAAiD;IACjD,QAAQ,EAAE,MAAM,CAAC;IACjB,6DAA6D;IAC7D,UAAU,EAAE,MAAM,CAAC;CACnB;AAOD;;;;;GAKG;AACH,wBAAgB,QAAQ,CAAC,MAAM,EAAE,SAAS,MAAM,EAAE,GAAG;IAAE,QAAQ,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,CAQvF;AAuCD;;;;;;;;GAQG;AACH,wBAAgB,qBAAqB,CAAC,MAAM,EAAE,SAAS,MAAM,EAAE,EAAE,MAAM,EAAE,SAAS,MAAM,EAAE,GAAG,MAAM,EAAE,CAWpG;AAuBD;;;;;;GAMG;AACH,wBAAgB,qBAAqB,CAAC,SAAS,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,gBAAgB,GAAG,IAAI,CAuHlH;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,wBAAgB,oBAAoB,CAAC,cAAc,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,GAAG,MAAM,CAwCvF"}

package/dist/core/edicion/sangria.js

@@ -0,0 +1,341 @@
+/**
+ * Casar una edición cuando el modelo se equivoca con la SANGRÍA.
+ *
+ * EL CASO. Ada se indenta con tabuladores y los modelos emiten espacios sin
+ * parar. Medido sobre el banco de cargas mal formadas: de once cargas
+ * recuperables, el motor entraba en tres, y varias de las que rechazaba eran de
+ * sangría — el error más frecuente que existe.
+ *
+ * Un rechazo cuesta un turno entero: el modelo tiene que releer el fichero y
+ * volver a escribir el bloque a ciegas, y muchas veces repite el mismo error.
+ *
+ * LO QUE ESTE MÓDULO NO HACE, y es la parte importante. No basta con encontrar
+ * el sitio: hay que escribir el reemplazo con la sangría DEL FICHERO. oh-my-pi
+ * casa más cargas que nosotros pero de las diez que aplica, tres corrompen — dos
+ * de ellas dejando la sangría mal. Aplicar no es aplicar bien:
+ *
+ *     antes:  →app.listen(puerto);
+ *     mal:        app.listen(PUERTO);     ← entró, y dejó espacios en un
+ *                                            fichero de tabuladores
+ *
+ * En TypeScript eso es cosmético. En Python es un error de sintaxis, o peor: una
+ * línea que se sale del bloque `if` y cambia la semántica sin romper nada.
+ *
+ * DOS INVARIANTES QUE LO HACEN SEGURO:
+ *
+ * 1. **Una sola posición.** Si el patrón sin sangría casa en dos sitios, se
+ *    devuelve `null`. Quitar la sangría hace el patrón MENOS específico, así que
+ *    puede volver ambiguo algo que no lo era — y elegir por el modelo cuál de
+ *    los dos editar es peor que rechazar.
+ * 2. **La sangría sale del fichero, nunca del patrón.** Se mide la del bloque
+ *    casado y se reconstruye el reemplazo con su carácter y su unidad,
+ *    conservando la profundidad RELATIVA que el modelo expresó.
+ *
+ * EL ESPACIADO INTERNO, que es el mismo error una columna más adentro. El
+ * fichero tiene `let suma = 0;` y el modelo manda `let suma  = 0;`. No es un
+ * problema de sangría —la sangría está bien— y sin embargo cuesta un turno
+ * entero igual. Se recupera con una SEGUNDA pasada de comparación que colapsa
+ * los espacios y tabuladores interiores.
+ *
+ * Y aquí está la trampa que hay que ver antes de tocar esto. Colapsar espacios
+ * en `normalizeForFuzzyMatch` (en `core/tools/edit-diff.ts`) sería mucho más
+ * corto y estaría MAL: esa forma normalizada se convierte en la base de
+ * escritura cuando alguna edición del lote es difusa, y su traducción de
+ * posiciones exige que cada sustitución sea de un carácter por otro. `[ \t]+` a
+ * un espacio no lo es. Ya nos costó una corrupción silenciosa por el mismo
+ * camino: `“`→`"` en una línea que nadie pidió tocar, dejando ficheros que ni
+ * compilan. Aquí el colapso vive SOLO en la comparación —una función que se
+ * llama para decidir si dos líneas son la misma— y nunca en el texto que se
+ * escribe: el reemplazo se construye desde el `newText` del modelo y desde los
+ * bytes del bloque original, jamás desde la forma colapsada.
+ */
+/** La sangría de una línea: su texto literal. `""` si empieza en la columna 0. */
+function sangriaDe(linea) {
+    return linea.match(/^[ \t]*/)?.[0] ?? "";
+}
+/**
+ * Qué unidad de sangría usa un bloque: el carácter y cuántos por nivel.
+ *
+ * Se deduce del propio bloque casado y no de todo el fichero, porque un fichero
+ * mixto —los hay— daría una respuesta que no vale para la región que se toca.
+ */
+export function unidadDe(lineas) {
+    const sangrias = lineas.filter((l) => l.trim() !== "").map(sangriaDe);
+    if (sangrias.some((s) => s.includes("\t")))
+        return { caracter: "\t", ancho: 1 };
+    const anchos = sangrias.map((s) => s.length).filter((n) => n > 0);
+    if (anchos.length === 0)
+        return { caracter: " ", ancho: 4 };
+    // El menor salto no nulo es la unidad. Con una sola línea sangrada no hay
+    // salto que medir, así que su propia sangría hace de unidad.
+    return { caracter: " ", ancho: Math.min(...anchos) };
+}
+/**
+ * Profundidad de una línea contando LOS DOS caracteres.
+ *
+ * `profundidad()` decide por una unidad única del bloque, y eso falla cuando es
+ * el TEXTO DEL MODELO el que mezcla: si una línea lleva 4 espacios y la
+ * siguiente 2 tabuladores, mirar solo los tabuladores da 0 y 2, cuando lo que
+ * el modelo quiso decir es 1 y 2.
+ *
+ * Medido: con eso, el cuerpo de un método Python salía a 12 espacios en vez de
+ * 8. Contando cada línea por su propio carácter sale la profundidad que el
+ * modelo quiso expresar, que es la única información suya aprovechable.
+ */
+function profundidadMixta(linea, anchoEspacios) {
+    const s = sangriaDe(linea);
+    const tabs = (s.match(/\t/g) ?? []).length;
+    const espacios = s.length - tabs;
+    return tabs + Math.floor(espacios / Math.max(1, anchoEspacios));
+}
+/** Profundidad de una línea en unidades, redondeando hacia abajo. */
+function profundidad(linea, unidad) {
+    const s = sangriaDe(linea);
+    if (unidad.caracter === "\t")
+        return (s.match(/\t/g) ?? []).length;
+    return Math.floor(s.length / Math.max(1, unidad.ancho));
+}
+/**
+ * La forma de una línea para COMPARAR: sin sangría y con el espaciado interior
+ * colapsado.
+ *
+ * Nunca se escribe. Es la mitad permisiva de la comparación y solo entra en
+ * juego cuando la estricta no ha encontrado nada.
+ */
+function colapsado(linea) {
+    return linea.trim().replace(/[ \t]+/g, " ");
+}
+/**
+ * Re-emite `nuevas` con la sangría del BLOQUE destino, conservando la
+ * profundidad relativa que expresó el modelo.
+ *
+ * Vive aquí y se exporta porque el camino del hueco elidido (`./hueco.ts`)
+ * necesita exactamente esto: escribía el `newText` tal cual y metía un
+ * tabulador en un fichero de cuatro espacios, que es el invariante 2 de este
+ * módulo roto en el camino de al lado.
+ */
+export function reSangrarComoElBloque(nuevas, bloque) {
+    const unidad = unidadDe(bloque);
+    const base = sangriaDe(bloque[0]);
+    const unidadDelModelo = unidadDe(nuevas);
+    const primeraNoVacia = nuevas.find((l) => l.trim() !== "");
+    const baseDelModelo = primeraNoVacia === undefined ? 0 : profundidad(primeraNoVacia, unidadDelModelo);
+    return nuevas.map((linea) => {
+        if (linea.trim() === "")
+            return "";
+        const relativa = profundidad(linea, unidadDelModelo) - baseDelModelo;
+        return base + unidad.caracter.repeat(Math.max(0, relativa) * unidad.ancho) + linea.trim();
+    });
+}
+/** Índices de las ventanas donde el patrón casa línea a línea bajo `forma`. */
+function ventanasQueCasan(lineas, patron, forma) {
+    const buscado = patron.map(forma);
+    const posiciones = [];
+    for (let i = 0; i + buscado.length <= lineas.length; i++) {
+        let casa = true;
+        for (let j = 0; j < buscado.length; j++) {
+            if (forma(lineas[i + j]) !== buscado[j]) {
+                casa = false;
+                break;
+            }
+        }
+        if (casa)
+            posiciones.push(i);
+    }
+    return posiciones;
+}
+/**
+ * Casa `oldText` contra `contenido` ignorando la sangría, y re-sangra `newText`.
+ *
+ * Devuelve `null` cuando no casa, cuando casa en más de un sitio, o cuando el
+ * patrón está vacío. `null` significa «no puedo», nunca «no hay»: quien llama
+ * debe seguir con su propio error, no dar la edición por aplicada.
+ */
+export function casarIgnorandoSangria(contenido, oldText, newText) {
+    const patron = oldText.split("\n");
+    // Líneas vacías al principio o al final son ruido de copiado.
+    while (patron.length > 0 && patron[0].trim() === "")
+        patron.shift();
+    while (patron.length > 0 && patron[patron.length - 1].trim() === "")
+        patron.pop();
+    if (patron.length === 0)
+        return null;
+    const lineas = contenido.split("\n");
+    // Dos pasadas, de la estricta a la permisiva. La segunda SOLO se intenta si
+    // la primera no encontró nada: colapsar espacios no puede desambiguar —
+    // cualquier par de líneas iguales al recortarlas lo sigue siendo al
+    // colapsarlas—, así que si la estricta ya casaba en dos sitios, la permisiva
+    // casaría en dos o más y el resultado es el mismo `null`. Intentarla solo
+    // desde cero deja escrito que esto añade alcance y no permisividad.
+    let posiciones = ventanasQueCasan(lineas, patron, (l) => l.trim());
+    // Si la estricta casó, el modelo reprodujo el espaciado interior TAL CUAL
+    // está en el fichero. Hace falta saberlo para el invariante 3.
+    let caseColapsando = false;
+    if (posiciones.length === 0) {
+        posiciones = ventanasQueCasan(lineas, patron, colapsado);
+        caseColapsando = true;
+    }
+    // Invariante 1: una sola posición, o nada.
+    if (posiciones.length !== 1)
+        return null;
+    const inicio = posiciones[0];
+    const bloque = lineas.slice(inicio, inicio + patron.length);
+    // Invariante 2: la sangría sale del FICHERO.
+    const unidad = unidadDe(bloque);
+    const nuevas = newText.split("\n");
+    const unidadDelModelo = unidadDe(nuevas);
+    const primeraNoVacia = nuevas.find((l) => l.trim() !== "");
+    const baseDelModelo = primeraNoVacia === undefined ? 0 : profundidad(primeraNoVacia, unidadDelModelo);
+    // ¿El modelo aportó ALGUNA información de estructura?
+    //
+    // Si mandó todas las líneas pegadas al margen, su profundidad relativa es
+    // cero en todas y no dice nada sobre el anidamiento. Re-emitirlas todas al
+    // mismo nivel es INVENTARSE la estructura, y eso es exactamente lo que
+    // corrompe. Medido: con el bloque
+    //
+    //     for (const it of items) {
+    //     suma += it.precio;        ← el modelo la manda pegada al margen
+    //     }
+    //
+    // la primera versión de esta función dejaba `suma += …` al nivel del `for`
+    // en vez de dentro, y el banco lo marcó como CORRUPTO. Un rechazo cuesta un
+    // turno; esto costaba un fichero mal indentado sin avisar.
+    const modeloAportaEstructura = nuevas.some((l) => l.trim() !== "" && profundidad(l, unidadDelModelo) - baseDelModelo !== 0);
+    const bloqueTieneEstructura = bloque.some((l) => l.trim() !== "" && profundidad(l, unidad) !== profundidad(bloque[0], unidad));
+    let reSangradas;
+    if (modeloAportaEstructura || !bloqueTieneEstructura) {
+        // El modelo dijo la profundidad, o el bloque es plano y no hay nada que
+        // preservar. En los dos casos su información basta.
+        reSangradas = reSangrarComoElBloque(nuevas, bloque);
+    }
+    else if (nuevas.length === bloque.length) {
+        // El modelo no aportó estructura pero el bloque sí la tiene, y hay el
+        // mismo número de líneas: la plantilla es el BLOQUE ORIGINAL. El modelo
+        // cambió el contenido, no la forma, así que cada línea hereda la sangría
+        // literal de la que sustituye.
+        reSangradas = nuevas.map((linea, i) => (linea.trim() === "" ? "" : sangriaDe(bloque[i]) + linea.trim()));
+    }
+    else {
+        // Ni el modelo dice la estructura, ni se puede heredar línea a línea.
+        // Cualquier sangría que pusiéramos sería adivinada, así que se rechaza:
+        // «no puedo» dicho a tiempo vale más que un fichero mal indentado.
+        return null;
+    }
+    // Invariante 3: una línea que el modelo RETECLEÓ sin cambiarla conserva sus
+    // bytes originales.
+    //
+    // Es la misma lección que el `“`→`"` de `normalizeForFuzzyMatch`, aplicada
+    // línea a línea. Al casar por espaciado colapsado, el fichero puede tener
+    // `const s = "a  b";` y el modelo mandar `const s = "a b";` dentro de un
+    // bloque cuya única intención era cambiar OTRA línea. Escribir la versión del
+    // modelo colapsaría un espacio dentro de una cadena que nadie pidió tocar.
+    // Si al colapsar las dos líneas son la misma, la que gana es la del fichero.
+    //
+    // Y SOLO cuando el casado ha necesitado colapsar. Este invariante existe para
+    // neutralizar la igualdad FALSA que introduce el colapso; si casó la pasada
+    // estricta, el modelo reprodujo el espaciado interior tal cual, así que una
+    // diferencia en el `newText` es un cambio DELIBERADO y hay que escribirlo.
+    // Medido, con el fichero `\tlet suma  = 0;` y el modelo pidiendo
+    // `let suma = 0;` con la sangría en espacios (el error de sangría más
+    // frecuente que existe, el que este módulo entero viene a arreglar):
+    //
+    //   sin la puerta:  la edición se descarta y sale «No changes made … the text
+    //                   not existing as expected» — un «no puedo» disfrazado de
+    //                   «no existe», y el texto SÍ existía y SÍ había casado
+    //   con la puerta:  entra, y queda `\tlet suma = 0;`
+    //
+    // Sin esto, ningún arreglo cuyo único cambio sea «N espacios → uno» puede
+    // entrar nunca por este camino: alinear un `=`, quitar un espacio doble o
+    // convertir un tabulador interior en espacio.
+    //
+    // Y hasta dónde llega, que no es hasta donde parece: «bytes originales» son
+    // los del `contenido` que nos han pasado, y cuando alguna OTRA edición del
+    // mismo lote es difusa, ese contenido es la forma normalizada. Comprobado:
+    // con un fichero `const s = “a  b”;` y un lote así, en disco queda
+    // `const s = "a  b";` — el doble espacio se salva y las comillas
+    // tipográficas no. No es peor que escribir la línea del modelo (que también
+    // las trae rectas), pero la promesa es más pequeña de lo que suena.
+    if (caseColapsando && nuevas.length === bloque.length) {
+        reSangradas = reSangradas.map((linea, i) => (colapsado(linea) === colapsado(bloque[i]) ? bloque[i] : linea));
+    }
+    // Desplazamientos en el contenido original: hay que contar los saltos.
+    let indice = 0;
+    for (let i = 0; i < inicio; i++)
+        indice += lineas[i].length + 1;
+    const longitud = bloque.reduce((n, l) => n + l.length + 1, 0) - 1;
+    return { indice, longitud, textoNuevo: reSangradas.join("\n") };
+}
+/**
+ * ¿El texto nuevo mete un carácter de sangría que el fichero no usa?
+ *
+ * EL CASO, encontrado auditando y reproducido ejecutando. Cuando el `oldText`
+ * casa EXACTO, el motor escribe el `newText` tal cual y se salta toda la lógica
+ * de sangría de arriba. Si el modelo teclea el bloque nuevo con tabuladores en
+ * un fichero de espacios —cosa que hace constantemente— la mezcla entra sin que
+ * nadie la mire:
+ *
+ *     class Carro:
+ *         def total(self, items):     ← 4 espacios, del fichero
+ *     →→→→s = 0                       ← tabuladores, del modelo
+ *
+ * En Python eso es un `TabError` y el fichero no arranca. Y no lo caza nadie:
+ * `core/edicion/parseo.ts` solo cubre TypeScript y JSON, así que para `.py`
+ * devuelve `null` y la red de reparación ni se despierta.
+ *
+ * En TypeScript no rompe la sintaxis, pero deja un fichero con dos estilos que
+ * el siguiente `edit` va a casar peor. Es la misma familia que perseguimos:
+ * la edición ENTRA, así que se lee como éxito.
+ *
+ * POR QUÉ AQUÍ Y NO EN UN COMPROBADOR POR LENGUAJE. Esto no necesita gramática
+ * de nada: se compara el carácter de sangría del bloque que se sustituye con el
+ * del texto que entra. Un comprobador de Python arreglaría Python; esto arregla
+ * cualquier lenguaje sensible a la sangría, presentes y futuros.
+ *
+ * QUÉ NO HACE: no toca el texto cuando el bloque original ya mezcla —ahí no hay
+ * un estilo del fichero que respetar, y elegir uno sería inventárselo—. omp, en
+ * ese caso, abandona y escribe el texto crudo (`normalize.ts:325`); nosotros
+ * hacemos lo mismo, pero solo en ese caso.
+ */
+export function coherenteConElBloque(bloqueOriginal, textoNuevo) {
+    const lineasOrig = bloqueOriginal.split("\n").filter((l) => l.trim() !== "");
+    const lineasNuevas = textoNuevo.split("\n");
+    if (lineasOrig.length === 0)
+        return textoNuevo;
+    const sangriasOrig = lineasOrig.map(sangriaDe).filter((s) => s.length > 0);
+    if (sangriasOrig.length === 0)
+        return textoNuevo;
+    const origConTab = sangriasOrig.some((s) => s.includes("\t"));
+    const origConEspacio = sangriasOrig.some((s) => s.includes(" "));
+    // El bloque original ya mezcla: no hay estilo que respetar.
+    if (origConTab && origConEspacio)
+        return textoNuevo;
+    const sangriasNuevas = lineasNuevas.filter((l) => l.trim() !== "").map(sangriaDe);
+    const nuevoConTab = sangriasNuevas.some((s) => s.includes("\t"));
+    const nuevoConEspacio = sangriasNuevas.some((s) => s.includes(" "));
+    // Coincide con el fichero, o no sangra nada: no hay nada que arreglar.
+    if (origConTab && !nuevoConEspacio)
+        return textoNuevo;
+    if (origConEspacio && !nuevoConTab)
+        return textoNuevo;
+    // Hay conflicto. Se reescribe la sangría del texto nuevo al estilo del
+    // bloque, conservando la profundidad RELATIVA que el modelo expresó — que es
+    // la única información suya que vale.
+    const unidad = unidadDe(lineasOrig);
+    // El ancho del bloque original es el que convierte espacios en niveles: si el
+    // fichero sangra de 4 en 4, ocho espacios del modelo son dos niveles.
+    const ancho = unidad.caracter === "\t"
+        ? (unidadDe(lineasOrig.filter((l) => !sangriaDe(l).includes("\t"))).ancho ?? 4)
+        : unidad.ancho;
+    const primera = lineasNuevas.find((l) => l.trim() !== "");
+    const base = primera === undefined ? 0 : profundidadMixta(primera, ancho);
+    return lineasNuevas
+        .map((linea) => {
+        if (linea.trim() === "")
+            return "";
+        const relativa = Math.max(0, profundidadMixta(linea, ancho) - base);
+        const baseDelBloque = sangriaDe(lineasOrig[0]);
+        return baseDelBloque + unidad.caracter.repeat(relativa * unidad.ancho) + linea.trim();
+    })
+        .join("\n");
+}
+//# sourceMappingURL=sangria.js.map

package/dist/core/edicion/sangria.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sangria.js","sourceRoot":"","sources":["../../../src/core/edicion/sangria.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkDG;AAYH,kFAAkF;AAClF,SAAS,SAAS,CAAC,KAAa;IAC/B,OAAO,KAAK,CAAC,KAAK,CAAC,SAAS,CAAC,EAAE,CAAC,CAAC,CAAC,IAAI,EAAE,CAAC;AAC1C,CAAC;AAED;;;;;GAKG;AACH,MAAM,UAAU,QAAQ,CAAC,MAAyB;IACjD,MAAM,QAAQ,GAAG,MAAM,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,IAAI,EAAE,KAAK,EAAE,CAAC,CAAC,GAAG,CAAC,SAAS,CAAC,CAAC;IACtE,IAAI,QAAQ,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC;QAAE,OAAO,EAAE,QAAQ,EAAE,IAAI,EAAE,KAAK,EAAE,CAAC,EAAE,CAAC;IAChF,MAAM,MAAM,GAAG,QAAQ,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC;IAClE,IAAI,MAAM,CAAC,MAAM,KAAK,CAAC;QAAE,OAAO,EAAE,QAAQ,EAAE,GAAG,EAAE,KAAK,EAAE,CAAC,EAAE,CAAC;IAC5D,0EAA0E;IAC1E,6DAA6D;IAC7D,OAAO,EAAE,QAAQ,EAAE,GAAG,EAAE,KAAK,EAAE,IAAI,CAAC,GAAG,CAAC,GAAG,MAAM,CAAC,EAAE,CAAC;AACtD,CAAC;AAED;;;;;;;;;;;GAWG;AACH,SAAS,gBAAgB,CAAC,KAAa,EAAE,aAAqB;IAC7D,MAAM,CAAC,GAAG,SAAS,CAAC,KAAK,CAAC,CAAC;IAC3B,MAAM,IAAI,GAAG,CAAC,CAAC,CAAC,KAAK,CAAC,KAAK,CAAC,IAAI,EAAE,CAAC,CAAC,MAAM,CAAC;IAC3C,MAAM,QAAQ,GAAG,CAAC,CAAC,MAAM,GAAG,IAAI,CAAC;IACjC,OAAO,IAAI,GAAG,IAAI,CAAC,KAAK,CAAC,QAAQ,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,aAAa,CAAC,CAAC,CAAC;AACjE,CAAC;AAED,qEAAqE;AACrE,SAAS,WAAW,CAAC,KAAa,EAAE,MAA2C;IAC9E,MAAM,CAAC,GAAG,SAAS,CAAC,KAAK,CAAC,CAAC;IAC3B,IAAI,MAAM,CAAC,QAAQ,KAAK,IAAI;QAAE,OAAO,CAAC,CAAC,CAAC,KAAK,CAAC,KAAK,CAAC,IAAI,EAAE,CAAC,CAAC,MAAM,CAAC;IACnE,OAAO,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,MAAM,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,MAAM,CAAC,KAAK,CAAC,CAAC,CAAC;AACzD,CAAC;AAED;;;;;;GAMG;AACH,SAAS,SAAS,CAAC,KAAa;IAC/B,OAAO,KAAK,CAAC,IAAI,EAAE,CAAC,OAAO,CAAC,SAAS,EAAE,GAAG,CAAC,CAAC;AAC7C,CAAC;AAED;;;;;;;;GAQG;AACH,MAAM,UAAU,qBAAqB,CAAC,MAAyB,EAAE,MAAyB;IACzF,MAAM,MAAM,GAAG,QAAQ,CAAC,MAAM,CAAC,CAAC;IAChC,MAAM,IAAI,GAAG,SAAS,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,CAAC;IAClC,MAAM,eAAe,GAAG,QAAQ,CAAC,MAAM,CAAC,CAAC;IACzC,MAAM,cAAc,GAAG,MAAM,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,IAAI,EAAE,KAAK,EAAE,CAAC,CAAC;IAC3D,MAAM,aAAa,GAAG,cAAc,KAAK,SAAS,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,WAAW,CAAC,cAAc,EAAE,eAAe,CAAC,CAAC;IACtG,OAAO,MAAM,CAAC,GAAG,CAAC,CAAC,KAAK,EAAE,EAAE;QAC3B,IAAI,KAAK,CAAC,IAAI,EAAE,KAAK,EAAE;YAAE,OAAO,EAAE,CAAC;QACnC,MAAM,QAAQ,GAAG,WAAW,CAAC,KAAK,EAAE,eAAe,CAAC,GAAG,aAAa,CAAC;QACrE,OAAO,IAAI,GAAG,MAAM,CAAC,QAAQ,CAAC,MAAM,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,QAAQ,CAAC,GAAG,MAAM,CAAC,KAAK,CAAC,GAAG,KAAK,CAAC,IAAI,EAAE,CAAC;IAC3F,CAAC,CAAC,CAAC;AACJ,CAAC;AAED,+EAA+E;AAC/E,SAAS,gBAAgB,CACxB,MAAyB,EACzB,MAAyB,EACzB,KAA4B;IAE5B,MAAM,OAAO,GAAG,MAAM,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC;IAClC,MAAM,UAAU,GAAa,EAAE,CAAC;IAChC,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,OAAO,CAAC,MAAM,IAAI,MAAM,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE,CAAC;QAC1D,IAAI,IAAI,GAAG,IAAI,CAAC;QAChB,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE,CAAC;YACzC,IAAI,KAAK,CAAC,MAAM,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,KAAK,OAAO,CAAC,CAAC,CAAC,EAAE,CAAC;gBACzC,IAAI,GAAG,KAAK,CAAC;gBACb,MAAM;YACP,CAAC;QACF,CAAC;QACD,IAAI,IAAI;YAAE,UAAU,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;IAC9B,CAAC;IACD,OAAO,UAAU,CAAC;AACnB,CAAC;AAED;;;;;;GAMG;AACH,MAAM,UAAU,qBAAqB,CAAC,SAAiB,EAAE,OAAe,EAAE,OAAe;IACxF,MAAM,MAAM,GAAG,OAAO,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC;IACnC,8DAA8D;IAC9D,OAAO,MAAM,CAAC,MAAM,GAAG,CAAC,IAAI,MAAM,CAAC,CAAC,CAAC,CAAC,IAAI,EAAE,KAAK,EAAE;QAAE,MAAM,CAAC,KAAK,EAAE,CAAC;IACpE,OAAO,MAAM,CAAC,MAAM,GAAG,CAAC,IAAI,MAAM,CAAC,MAAM,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC,IAAI,EAAE,KAAK,EAAE;QAAE,MAAM,CAAC,GAAG,EAAE,CAAC;IAClF,IAAI,MAAM,CAAC,MAAM,KAAK,CAAC;QAAE,OAAO,IAAI,CAAC;IAErC,MAAM,MAAM,GAAG,SAAS,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC;IAErC,4EAA4E;IAC5E,wEAAwE;IACxE,oEAAoE;IACpE,6EAA6E;IAC7E,0EAA0E;IAC1E,oEAAoE;IACpE,IAAI,UAAU,GAAG,gBAAgB,CAAC,MAAM,EAAE,MAAM,EAAE,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,IAAI,EAAE,CAAC,CAAC;IACnE,0EAA0E;IAC1E,+DAA+D;IAC/D,IAAI,cAAc,GAAG,KAAK,CAAC;IAC3B,IAAI,UAAU,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;QAC7B,UAAU,GAAG,gBAAgB,CAAC,MAAM,EAAE,MAAM,EAAE,SAAS,CAAC,CAAC;QACzD,cAAc,GAAG,IAAI,CAAC;IACvB,CAAC;IACD,2CAA2C;IAC3C,IAAI,UAAU,CAAC,MAAM,KAAK,CAAC;QAAE,OAAO,IAAI,CAAC;IAEzC,MAAM,MAAM,GAAG,UAAU,CAAC,CAAC,CAAC,CAAC;IAC7B,MAAM,MAAM,GAAG,MAAM,CAAC,KAAK,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAAC,MAAM,CAAC,CAAC;IAE5D,6CAA6C;IAC7C,MAAM,MAAM,GAAG,QAAQ,CAAC,MAAM,CAAC,CAAC;IAChC,MAAM,MAAM,GAAG,OAAO,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC;IACnC,MAAM,eAAe,GAAG,QAAQ,CAAC,MAAM,CAAC,CAAC;IACzC,MAAM,cAAc,GAAG,MAAM,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,IAAI,EAAE,KAAK,EAAE,CAAC,CAAC;IAC3D,MAAM,aAAa,GAAG,cAAc,KAAK,SAAS,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,WAAW,CAAC,cAAc,EAAE,eAAe,CAAC,CAAC;IAEtG,sDAAsD;IACtD,EAAE;IACF,0EAA0E;IAC1E,2EAA2E;IAC3E,uEAAuE;IACvE,kCAAkC;IAClC,EAAE;IACF,gCAAgC;IAChC,sEAAsE;IACtE,QAAQ;IACR,EAAE;IACF,2EAA2E;IAC3E,4EAA4E;IAC5E,2DAA2D;IAC3D,MAAM,sBAAsB,GAAG,MAAM,CAAC,IAAI,CACzC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,IAAI,EAAE,KAAK,EAAE,IAAI,WAAW,CAAC,CAAC,EAAE,eAAe,CAAC,GAAG,aAAa,KAAK,CAAC,CAC/E,CAAC;IACF,MAAM,qBAAqB,GAAG,MAAM,CAAC,IAAI,CACxC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,IAAI,EAAE,KAAK,EAAE,IAAI,WAAW,CAAC,CAAC,EAAE,MAAM,CAAC,KAAK,WAAW,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,MAAM,CAAC,CACnF,CAAC;IAEF,IAAI,WAAqB,CAAC;IAC1B,IAAI,sBAAsB,IAAI,CAAC,qBAAqB,EAAE,CAAC;QACtD,wEAAwE;QACxE,oDAAoD;QACpD,WAAW,GAAG,qBAAqB,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACrD,CAAC;SAAM,IAAI,MAAM,CAAC,MAAM,KAAK,MAAM,CAAC,MAAM,EAAE,CAAC;QAC5C,sEAAsE;QACtE,wEAAwE;QACxE,yEAAyE;QACzE,+BAA+B;QAC/B,WAAW,GAAG,MAAM,CAAC,GAAG,CAAC,CAAC,KAAK,EAAE,CAAC,EAAE,EAAE,CAAC,CAAC,KAAK,CAAC,IAAI,EAAE,KAAK,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,SAAS,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,GAAG,KAAK,CAAC,IAAI,EAAE,CAAC,CAAC,CAAC;IAC1G,CAAC;SAAM,CAAC;QACP,sEAAsE;QACtE,wEAAwE;QACxE,mEAAmE;QACnE,OAAO,IAAI,CAAC;IACb,CAAC;IAED,4EAA4E;IAC5E,oBAAoB;IACpB,EAAE;IACF,2EAA2E;IAC3E,0EAA0E;IAC1E,yEAAyE;IACzE,8EAA8E;IAC9E,2EAA2E;IAC3E,6EAA6E;IAC7E,EAAE;IACF,8EAA8E;IAC9E,4EAA4E;IAC5E,4EAA4E;IAC5E,2EAA2E;IAC3E,iEAAiE;IACjE,sEAAsE;IACtE,qEAAqE;IACrE,EAAE;IACF,8EAA8E;IAC9E,4EAA4E;IAC5E,yEAAyE;IACzE,qDAAqD;IACrD,EAAE;IACF,0EAA0E;IAC1E,0EAA0E;IAC1E,8CAA8C;IAC9C,EAAE;IACF,4EAA4E;IAC5E,2EAA2E;IAC3E,2EAA2E;IAC3E,mEAAmE;IACnE,iEAAiE;IACjE,4EAA4E;IAC5E,oEAAoE;IACpE,IAAI,cAAc,IAAI,MAAM,CAAC,MAAM,KAAK,MAAM,CAAC,MAAM,EAAE,CAAC;QACvD,WAAW,GAAG,WAAW,CAAC,GAAG,CAAC,CAAC,KAAK,EAAE,CAAC,EAAE,EAAE,CAAC,CAAC,SAAS,CAAC,KAAK,CAAC,KAAK,SAAS,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC;IAC9G,CAAC;IAED,uEAAuE;IACvE,IAAI,MAAM,GAAG,CAAC,CAAC;IACf,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,MAAM,EAAE,CAAC,EAAE;QAAE,MAAM,IAAI,MAAM,CAAC,CAAC,CAAC,CAAC,MAAM,GAAG,CAAC,CAAC;IAChE,MAAM,QAAQ,GAAG,MAAM,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC,CAAC,GAAG,CAAC,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC,CAAC,GAAG,CAAC,CAAC;IAElE,OAAO,EAAE,MAAM,EAAE,QAAQ,EAAE,UAAU,EAAE,WAAW,CAAC,IAAI,CAAC,IAAI,CAAC,EAAE,CAAC;AACjE,CAAC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,MAAM,UAAU,oBAAoB,CAAC,cAAsB,EAAE,UAAkB;IAC9E,MAAM,UAAU,GAAG,cAAc,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,IAAI,EAAE,KAAK,EAAE,CAAC,CAAC;IAC7E,MAAM,YAAY,GAAG,UAAU,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC;IAC5C,IAAI,UAAU,CAAC,MAAM,KAAK,CAAC;QAAE,OAAO,UAAU,CAAC;IAE/C,MAAM,YAAY,GAAG,UAAU,CAAC,GAAG,CAAC,SAAS,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC;IAC3E,IAAI,YAAY,CAAC,MAAM,KAAK,CAAC;QAAE,OAAO,UAAU,CAAC;IAEjD,MAAM,UAAU,GAAG,YAAY,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC,CAAC;IAC9D,MAAM,cAAc,GAAG,YAAY,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,QAAQ,CAAC,GAAG,CAAC,CAAC,CAAC;IACjE,4DAA4D;IAC5D,IAAI,UAAU,IAAI,cAAc;QAAE,OAAO,UAAU,CAAC;IAEpD,MAAM,cAAc,GAAG,YAAY,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,IAAI,EAAE,KAAK,EAAE,CAAC,CAAC,GAAG,CAAC,SAAS,CAAC,CAAC;IAClF,MAAM,WAAW,GAAG,cAAc,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC,CAAC;IACjE,MAAM,eAAe,GAAG,cAAc,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,QAAQ,CAAC,GAAG,CAAC,CAAC,CAAC;IACpE,uEAAuE;IACvE,IAAI,UAAU,IAAI,CAAC,eAAe;QAAE,OAAO,UAAU,CAAC;IACtD,IAAI,cAAc,IAAI,CAAC,WAAW;QAAE,OAAO,UAAU,CAAC;IAEtD,uEAAuE;IACvE,6EAA6E;IAC7E,sCAAsC;IACtC,MAAM,MAAM,GAAG,QAAQ,CAAC,UAAU,CAAC,CAAC;IACpC,8EAA8E;IAC9E,sEAAsE;IACtE,MAAM,KAAK,GACV,MAAM,CAAC,QAAQ,KAAK,IAAI;QACvB,CAAC,CAAC,CAAC,QAAQ,CAAC,UAAU,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,KAAK,IAAI,CAAC,CAAC;QAC/E,CAAC,CAAC,MAAM,CAAC,KAAK,CAAC;IACjB,MAAM,OAAO,GAAG,YAAY,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,IAAI,EAAE,KAAK,EAAE,CAAC,CAAC;IAC1D,MAAM,IAAI,GAAG,OAAO,KAAK,SAAS,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,gBAAgB,CAAC,OAAO,EAAE,KAAK,CAAC,CAAC;IAC1E,OAAO,YAAY;SACjB,GAAG,CAAC,CAAC,KAAK,EAAE,EAAE;QACd,IAAI,KAAK,CAAC,IAAI,EAAE,KAAK,EAAE;YAAE,OAAO,EAAE,CAAC;QACnC,MAAM,QAAQ,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,gBAAgB,CAAC,KAAK,EAAE,KAAK,CAAC,GAAG,IAAI,CAAC,CAAC;QACpE,MAAM,aAAa,GAAG,SAAS,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC,CAAC;QAC/C,OAAO,aAAa,GAAG,MAAM,CAAC,QAAQ,CAAC,MAAM,CAAC,QAAQ,GAAG,MAAM,CAAC,KAAK,CAAC,GAAG,KAAK,CAAC,IAAI,EAAE,CAAC;IACvF,CAAC,CAAC;SACD,IAAI,CAAC,IAAI,CAAC,CAAC;AACd,CAAC"}

package/dist/core/edicion/tipos.d.ts

@@ -0,0 +1,58 @@
+/**
+ * ¿La edición ha introducido un error de TIPOS?
+ *
+ * `parseo.ts` responde si el fichero sigue siendo sintácticamente válido, que
+ * es el fallo más burdo. Este responde el siguiente: el fichero parsea, pero
+ * llamas a la función con un argumento de más, o le pasas una cadena donde
+ * esperaba un número. Hasta ahora eso solo salía al ejecutar `npm run check`,
+ * que el modelo no lanza solo.
+ *
+ * oh-my-pi lo resuelve con un cliente LSP (9.920 líneas) que necesita un
+ * servidor de lenguaje instalado. Aquí sale del compilador de TypeScript que ya
+ * está en el proyecto, con un `LanguageService` que mantiene el programa vivo
+ * entre ediciones. Medido sobre este repositorio (343 ficheros):
+ *
+ *     primera comprobación   2.500 ms   (una vez por proyecto, perezosa)
+ *     otro fichero              14 ms
+ *     tras cambiar el fichero  124-220 ms
+ *
+ * LA PRECONDICIÓN QUE LO HACE USABLE
+ *
+ * Solo se informa de lo que la edición ha INTRODUCIDO. Un repositorio a medio
+ * refactorizar tiene cientos de errores de tipos, y volcárselos al modelo en
+ * cada edición sería ruido puro: dejaría de leerlos el primer día y con ellos
+ * el que sí importaba. Se comparan los diagnósticos de antes y los de después,
+ * y solo viajan los nuevos.
+ *
+ * Y solo se paga cuando hace falta: si después de la edición no hay ningún
+ * diagnóstico, no se calcula el "antes". La mayoría de ediciones son correctas,
+ * así que el caso normal es una comprobación, no dos.
+ */
+export interface ErrorDeTipos {
+    linea: number;
+    mensaje: string;
+}
+export type MotivoSinComprobar = "extension-no-comprobable" | "sin-tsconfig" | "proyecto-demasiado-grande";
+export declare class ComprobadorDeTipos {
+    /** Un servicio por `tsconfig`. Se reutiliza entre ediciones: es lo que hace que la segunda cueste 124 ms. */
+    private readonly proyectos;
+    private readonly descartados;
+    /** Por qué no se puede comprobar este fichero, o `null` si sí se puede. */
+    porQueNo(ruta: string): MotivoSinComprobar | null;
+    private buscarConfig;
+    private proyectoDe;
+    /** Diagnósticos de un contenido concreto, sin tocar el disco. */
+    private diagnosticar;
+    /**
+     * Los errores de tipos que esta edición ha INTRODUCIDO.
+     *
+     * Devuelve lista vacía cuando no hay ninguno nuevo, y también cuando no se
+     * puede comprobar — para eso está `porQueNo()`, que quien llama debe mirar si
+     * quiere distinguir «no hay errores» de «no lo he mirado». Son cosas muy
+     * distintas y confundirlas es lo que convierte un aviso en una mentira.
+     */
+    introducidos(ruta: string, antes: string | null, despues: string): ErrorDeTipos[];
+}
+/** El aviso para el modelo, o `null` si no hay nada que decir. */
+export declare function avisoDeTipos(ruta: string, errores: ErrorDeTipos[]): string | null;
+//# sourceMappingURL=tipos.d.ts.map

package/dist/core/edicion/tipos.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tipos.d.ts","sourceRoot":"","sources":["../../../src/core/edicion/tipos.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AAKH,MAAM,WAAW,YAAY;IAC5B,KAAK,EAAE,MAAM,CAAC;IACd,OAAO,EAAE,MAAM,CAAC;CAChB;AAsBD,MAAM,MAAM,kBAAkB,GAAG,0BAA0B,GAAG,cAAc,GAAG,2BAA2B,CAAC;AAE3G,qBAAa,kBAAkB;IAC9B,6GAA6G;IAC7G,OAAO,CAAC,QAAQ,CAAC,SAAS,CAA+B;IACzD,OAAO,CAAC,QAAQ,CAAC,WAAW,CAAyC;IAErE,2EAA2E;IAC3E,QAAQ,CAAC,IAAI,EAAE,MAAM,GAAG,kBAAkB,GAAG,IAAI;IAQjD,OAAO,CAAC,YAAY;IAIpB,OAAO,CAAC,UAAU;IA6ClB,iEAAiE;IACjE,OAAO,CAAC,YAAY;IAiBpB;;;;;;;OAOG;IACH,YAAY,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,IAAI,EAAE,OAAO,EAAE,MAAM,GAAG,YAAY,EAAE;CAoBjF;AAED,kEAAkE;AAClE,wBAAgB,YAAY,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,YAAY,EAAE,GAAG,MAAM,GAAG,IAAI,CAKjF"}