@hoilab/ada-cli 0.84.21 → 0.85.0

package/dist/core/banco/cargas.js

@@ -0,0 +1,520 @@
+/**
+ * Banco de CARGAS MAL FORMADAS contra el motor de edición. Sin modelo.
+ *
+ * POR QUÉ HACE FALTA OTRO BANCO. `core/banco/` mide si el MODELO encuentra y
+ * arregla un bug: llama a un proveedor de verdad, cuesta dinero y, sobre todo,
+ * mide al modelo. Hoy quedó demostrado de la peor manera: con
+ * `opencode/x-preview-f-free` la línea base salió 37,5% de acierto y 62,5% de
+ * «fantasmas», y con `opencode/hy3-free` los MISMOS casos dieron 100% y 0%. Ese
+ * 37,5% no medía a Ada; medía un proveedor que devuelve respuestas vacías.
+ *
+ * Este banco mide LO NUESTRO: dado un `oldText` con los errores que los modelos
+ * cometen de verdad, ¿entra la edición y entra BIEN? Es determinista, no cuesta
+ * nada y sirve de puerta.
+ *
+ * LA MÉTRICA, que es la decisión de diseño importante.
+ *
+ * Lo natural sería contar «cuántas aplica», y sería un error. Medido sobre
+ * oh-my-pi: de 14 cargas aplica 10 y **tres de esas diez corrompen** —una
+ * inyecta un error de sintaxis y dos estropean la sangría—. Un motor más
+ * permisivo no es mejor: es más peligroso, porque un rechazo cuesta un turno y
+ * una corrupción silenciosa cuesta un fichero.
+ *
+ * Por eso hay TRES resultados y no dos:
+ *
+ *   correcto   la edición entra y el fichero queda como debía
+ *   corrupto   la edición entra y el fichero queda MAL  ← el peor de los tres
+ *   rechazado  la edición no entra
+ *
+ * `corrupto` cuenta como peor que `rechazado` a propósito. Es la misma
+ * distinción que aplicamos en todo el repositorio: un fallo que se lee como
+ * éxito es más caro que un fallo que se ve.
+ */
+import { applyEditsToNormalizedContent } from "../tools/edit-diff.js";
+const TABS = [
+    "export function servir(puerto: number) {",
+    "\tconst app = express();",
+    "\tapp.listen(puerto);",
+    "}",
+    "",
+].join("\n");
+const TABS_OK = [
+    "export function servir(puerto: number) {",
+    "\tconst app = express();",
+    "\tapp.listen(PUERTO);",
+    "}",
+    "",
+].join("\n");
+const ESPACIOS = [
+    "function total(items: Item[]) {",
+    "    let suma = 0;",
+    "    for (const it of items) {",
+    "        suma += it.precio;",
+    "    }",
+    "    return suma;",
+    "}",
+    "",
+].join("\n");
+const REPETIDO = ["let total = 0;", "suma(a);", "let total = 0;", "suma(b);", ""].join("\n");
+/**
+ * Dos líneas que son distintas al recortarlas y la MISMA al colapsar el
+ * espaciado interior. Existe para vigilar el camino que recupera
+ * `espaciado-interno`.
+ */
+const ESPACIADO_REPETIDO = [
+    "const paso = calcular(1);",
+    "let x = 1;",
+    "const otro = calcular(2);",
+    "let  x = 1;",
+    "",
+].join("\n");
+/**
+ * Un doble espacio DENTRO de una cadena, que es espaciado con significado.
+ *
+ * Existe porque casar colapsando espacios abre la puerta a escribirlos
+ * colapsados: el modelo retipea esta línea con un espacio solo, sin intención de
+ * tocarla, mientras cambia la de abajo.
+ */
+const CADENA_CON_DOS_ESPACIOS = ["function saludo() {", '    const s = "a  b";', "    return s;", "}", ""].join("\n");
+/**
+ * Un fichero de tabuladores con un doble espacio INTERIOR, para el caso en que
+ * colapsar ese espacio es exactamente lo que el modelo pide.
+ */
+const TABS_CON_DOS_ESPACIOS = [
+    "export function servir(puerto: number) {",
+    "\tconst app  = express();",
+    "\tapp.listen(puerto);",
+    "}",
+    "",
+].join("\n");
+/**
+ * Comillas tipográficas y espacios al final, que es lo que hace falta para
+ * ejercitar el empalme del camino DIFUSO.
+ *
+ * La línea 1 solo casa tras normalizar, así que enciende ese camino para todo el
+ * lote. La línea 2 se edita por dentro y lleva comillas tipográficas que nadie
+ * ha pedido tocar y tres espacios al final, que son los dos sitios donde el
+ * empalme se ha roto de verdad.
+ */
+const TIPOGRAFICO = [
+    "const uno = “a”;",
+    'const msg = "el “titulo” va aqui" + compute(1);   ',
+    "const fin = 1;",
+    "",
+].join("\n");
+const TIPOGRAFICO_OK = [
+    'const uno = "b";',
+    'const msg = "el “titulo” va aqui" + compute(2);   ',
+    "const fin = 1;",
+    "",
+].join("\n");
+/**
+ * Dos funciones seguidas: el `}` de la columna cero de la segunda vuelve
+ * ambigua el ancla de CIERRE de la primera. Es la forma de fichero más normal
+ * que existe y mide el alcance real de la elisión.
+ */
+const DOS_FUNCIONES = ["function a() {", "\tuno();", "}", "", "function b() {", "\tdos();", "}", ""].join("\n");
+/** Dos funciones idénticas: el ancla de apertura casa en los dos sitios. */
+const DOS_IGUALES = [
+    "function envolver() {",
+    "\tinicio();",
+    "\tfin();",
+    "}",
+    "function envolver() {",
+    "\tinicio();",
+    "\tfin();",
+    "}",
+    "",
+].join("\n");
+/**
+ * El corpus. Cada caso es un error que un modelo comete DE VERDAD.
+ *
+ * No están inventados: salen de la comparación motor contra motor de oh-my-pi y
+ * de la sonda de nueve casos que se ejecutó sobre este repositorio.
+ */
+export const CARGAS = [
+    {
+        // El modelo retipea el contexto y se equivoca en una letra. omp lo aplica
+        // y ESCRIBE la errata: su fichero acaba con `item`, que no existe, y no
+        // compila. Nosotros casamos por parecido y escribimos la versión del
+        // FICHERO en las líneas que el modelo solo estaba citando.
+        id: "errata-en-el-contexto",
+        error: "el modelo retipea una línea de contexto con una errata (items → item)",
+        fichero: [
+            "function total(items) {",
+            "    let suma = 0;",
+            "    for (const it of items) {",
+            "        suma += it.precio;",
+            "    }",
+            "    return suma;",
+            "}",
+            "",
+        ].join("\n"),
+        ediciones: [
+            {
+                oldText: "    for (const it of item) {\n        suma += it.precio;\n    }",
+                newText: "    for (const it of item) {\n        suma += it.precio * it.cantidad;\n    }",
+            },
+        ],
+        esperado: "aplica",
+        resultado: [
+            "function total(items) {",
+            "    let suma = 0;",
+            "    for (const it of items) {",
+            "        suma += it.precio;",
+            "    }",
+            "    return suma;",
+            "}",
+            "",
+        ]
+            .join("\n")
+            .replace("suma += it.precio;", "suma += it.precio * it.cantidad;"),
+    },
+    {
+        // La puerta de DOMINANCIA. Dos bloques casi idénticos: el patrón con
+        // errata se parece a los dos, así que no sabemos cuál quería. Elegir por
+        // el modelo es peor que rechazar.
+        id: "parecido-ambiguo",
+        error: "un patrón con errata que se parece igual a DOS bloques distintos",
+        fichero: [
+            "function a() {",
+            "    const valor = calcular(1);",
+            "    return valor;",
+            "}",
+            "function b() {",
+            "    const valor = calcular(1);",
+            "    return valor;",
+            "}",
+            "",
+        ].join("\n"),
+        ediciones: [
+            {
+                oldText: "    const valo = calcular(1);\n    return valor;",
+                newText: "    const valor = calcular(2);\n    return valor;",
+            },
+        ],
+        esperado: "rechaza",
+    },
+    {
+        // La puerta del UMBRAL. No es una errata: es otro sitio. Un casado por
+        // parecido sin suelo casaría cualquier cosa con cualquier cosa.
+        id: "parecido-demasiado-lejos",
+        error: "el patrón no se parece a nada del fichero",
+        fichero: [
+            "function total(items) {",
+            "    let suma = 0;",
+            "    for (const it of items) {",
+            "        suma += it.precio;",
+            "    }",
+            "    return suma;",
+            "}",
+            "",
+        ].join("\n"),
+        ediciones: [
+            {
+                oldText: "    const cliente = new Cliente();\n    cliente.enviar();",
+                newText: "    const cliente = new Cliente();\n    cliente.recibir();",
+            },
+        ],
+        esperado: "rechaza",
+    },
+    {
+        // Encontrado auditando oh-my-pi y reproducido ejecutando. El `oldText` casa
+        // EXACTO, así que el motor escribía el `newText` verbatim y se saltaba toda
+        // la lógica de sangría: el fichero acababa mezclando tabuladores y espacios.
+        // En Python eso es un `TabError` y no arranca, y `parseo.ts` no cubre `.py`,
+        // así que la red de reparación ni se despertaba.
+        id: "sangria-mixta-python",
+        error: "el modelo teclea el cuerpo con tabuladores en un fichero de 4 espacios",
+        fichero: ["class Carro:", "    def total(self, items):", "        s = 0", "        return s", ""].join("\n"),
+        ediciones: [
+            {
+                oldText: "    def total(self, items):\n        s = 0\n        return s",
+                newText: "    def total(self, items):\n\t\ts = 0\n\t\tfor i in items:\n\t\t\ts += i.p\n\t\treturn s",
+            },
+        ],
+        esperado: "aplica",
+        resultado: [
+            "class Carro:",
+            "    def total(self, items):",
+            "        s = 0",
+            "        for i in items:",
+            "            s += i.p",
+            "        return s",
+            "",
+        ].join("\n"),
+    },
+    {
+        // El mismo fallo en TypeScript. No rompe la sintaxis, pero deja el fichero
+        // con dos estilos y el siguiente `edit` casa peor: la edición ENTRA, así que
+        // se lee como éxito.
+        id: "sangria-mixta-ts",
+        error: "igual que el anterior, en TypeScript: entra y deja el fichero con dos estilos",
+        fichero: ["class C {", "    total() {", "        return 1;", "    }", "}", ""].join("\n"),
+        ediciones: [
+            { oldText: "    total() {\n        return 1;\n    }", newText: "    total() {\n\t\treturn 0;\n    }" },
+        ],
+        esperado: "aplica",
+        resultado: ["class C {", "    total() {", "        return 0;", "    }", "}", ""].join("\n"),
+    },
+    {
+        id: "exacto",
+        error: "ninguno — es el control",
+        fichero: TABS,
+        ediciones: [{ oldText: "\tapp.listen(puerto);", newText: "\tapp.listen(PUERTO);" }],
+        esperado: "aplica",
+        resultado: TABS_OK,
+    },
+    {
+        id: "espacios-por-tabulador",
+        error: "el fichero usa tabuladores y el modelo emite espacios",
+        fichero: TABS,
+        ediciones: [{ oldText: "    app.listen(puerto);", newText: "    app.listen(PUERTO);" }],
+        esperado: "aplica",
+        resultado: TABS_OK,
+    },
+    {
+        id: "sin-sangria",
+        error: "el modelo manda la línea sin su sangría",
+        fichero: TABS,
+        ediciones: [{ oldText: "app.listen(puerto);", newText: "app.listen(PUERTO);" }],
+        esperado: "aplica",
+        resultado: TABS_OK,
+    },
+    {
+        id: "espacio-final-de-mas",
+        error: "un espacio al final que el fichero no tiene",
+        fichero: TABS,
+        ediciones: [{ oldText: "\tapp.listen(puerto); ", newText: "\tapp.listen(PUERTO);" }],
+        esperado: "aplica",
+        resultado: TABS_OK,
+    },
+    {
+        id: "valla-markdown",
+        error: "el bloque viene envuelto en ```",
+        fichero: TABS,
+        ediciones: [{ oldText: "```ts\n\tapp.listen(puerto);\n```", newText: "\tapp.listen(PUERTO);" }],
+        esperado: "aplica",
+        resultado: TABS_OK,
+    },
+    {
+        id: "sobre-de-parche",
+        error: "sentinelas de sobre (*** Begin Patch)",
+        fichero: TABS,
+        ediciones: [
+            { oldText: "*** Begin Patch\n\tapp.listen(puerto);\n*** End Patch", newText: "\tapp.listen(PUERTO);" },
+        ],
+        esperado: "aplica",
+        resultado: TABS_OK,
+    },
+    {
+        id: "cabecera-de-read",
+        error: "el modelo copia la cabecera que añade NUESTRO propio read",
+        fichero: TABS,
+        ediciones: [
+            {
+                oldText: "\tapp.listen(puerto);\n[Showing lines 1-5 of 5. Use offset=6 to continue.]",
+                newText: "\tapp.listen(PUERTO);",
+            },
+        ],
+        esperado: "aplica",
+        resultado: TABS_OK,
+    },
+    {
+        id: "numeros-de-linea",
+        error: "el modelo pega los números de línea de un grep",
+        fichero: TABS,
+        ediciones: [{ oldText: "3:\tapp.listen(puerto);", newText: "\tapp.listen(PUERTO);" }],
+        esperado: "aplica",
+        resultado: TABS_OK,
+    },
+    {
+        id: "bloque-sin-sangrar",
+        error: "bloque multilínea entero sin sangrar, fichero a 4 espacios",
+        fichero: ESPACIOS,
+        ediciones: [
+            {
+                oldText: "for (const it of items) {\nsuma += it.precio;\n}",
+                newText: "for (const it of items) {\nsuma += it.precio * it.cantidad;\n}",
+            },
+        ],
+        esperado: "aplica",
+        resultado: ESPACIOS.replace("suma += it.precio;", "suma += it.precio * it.cantidad;"),
+    },
+    {
+        id: "espaciado-interno",
+        error: "dos espacios donde el fichero tiene uno",
+        fichero: ESPACIOS,
+        ediciones: [{ oldText: "    let suma  = 0;", newText: "    let suma = 1;" }],
+        esperado: "aplica",
+        resultado: ESPACIOS.replace("let suma = 0;", "let suma = 1;"),
+    },
+    {
+        id: "hueco-elidido",
+        error: "el modelo elide el medio con ...",
+        fichero: ESPACIOS,
+        ediciones: [
+            {
+                oldText: "function total(items: Item[]) {\n...\n}",
+                newText: "function total(items: Item[]) {\n\treturn 0;\n}",
+            },
+        ],
+        esperado: "aplica",
+        // Con la sangría DEL FICHERO, no la del modelo. `ESPACIOS` se sangra con
+        // cuatro espacios y el modelo manda `\treturn 0;`: este resultado declaraba
+        // el tabulador como correcto, o sea daba por bueno «entra y deja la sangría
+        // mal», que es una de las tres formas en las que corrompe oh-my-pi y la
+        // razón de existir de `core/edicion/sangria.ts`. La puerta bendecía el
+        // defecto que la puerta existe para cazar.
+        resultado: "function total(items: Item[]) {\n    return 0;\n}\n",
+    },
+    {
+        id: "espaciado-a-proposito",
+        error: "el cambio ES el espaciado interior, y la sangría viene en espacios sobre un fichero de tabuladores",
+        fichero: TABS_CON_DOS_ESPACIOS,
+        ediciones: [{ oldText: "    const app  = express();", newText: "    const app = express();" }],
+        esperado: "aplica",
+        // El doble espacio DESAPARECE. Es la otra mitad de `retecleo-inocente`: ahí
+        // el modelo colapsó una línea sin querer y gana el fichero; aquí el colapso
+        // es lo único que pide, y gana el modelo. Se distinguen por si el casado
+        // necesitó colapsar: este patrón casa con la pasada ESTRICTA (el modelo
+        // reprodujo los dos espacios), así que su `newText` es deliberado.
+        resultado: TABS_CON_DOS_ESPACIOS.replace("const app  = express();", "const app = express();"),
+    },
+    {
+        id: "lote-difuso-empalme",
+        error: "dos ediciones, una difusa por comillas tipográficas, y la otra dentro de una línea con espacios al final",
+        fichero: TIPOGRAFICO,
+        ediciones: [
+            { oldText: 'const uno = "a";', newText: 'const uno = "b";' },
+            { oldText: "compute(1)", newText: "compute(2)" },
+        ],
+        esperado: "aplica",
+        // Las DOS mitades del empalme sobre bytes originales, en una sola carga:
+        //
+        //   · las comillas tipográficas de la línea 2 siguen ahí. Nadie pidió
+        //     tocarlas; escribir esa línea desde el texto normalizado dejaba
+        //     comillas rectas anidadas dentro de una cadena y el fichero no
+        //     compilaba.
+        //   · los tres espacios finales de la línea 2 y su SALTO DE LÍNEA siguen
+        //     ahí. Traducir el final normalizado de la línea a coordenadas del
+        //     original cortaba dentro de ella y pegaba la línea 3 detrás de la 2.
+        //
+        // El corpus no tenía ninguna carga sobre el empalme difuso, que es el
+        // camino donde ya nos costó una corrupción silenciosa.
+        resultado: TIPOGRAFICO_OK,
+    },
+    {
+        id: "retecleo-inocente",
+        error: "retipea una cadena con un espacio donde hay dos, cambiando solo la línea de abajo",
+        fichero: CADENA_CON_DOS_ESPACIOS,
+        ediciones: [{ oldText: 'const s = "a b";\nreturn s;', newText: 'const s = "a b";\nreturn s.trim();' }],
+        esperado: "aplica",
+        // El doble espacio de la cadena SIGUE AHÍ. Es la mitad que no se ve del
+        // casado por espaciado: entra la edición y no se toca lo que nadie pidió.
+        resultado: CADENA_CON_DOS_ESPACIOS.replace("return s;", "return s.trim();"),
+    },
+    // ── Los que DEBEN rechazarse. Sin estos, «aplicar más» sería siempre mejor
+    //    nota, y un motor que acepta cualquier cosa ganaría el banco.
+    {
+        id: "ambiguo-dos-ocurrencias",
+        error: "el oldText aparece dos veces: cuál se edita es una moneda al aire",
+        fichero: REPETIDO,
+        ediciones: [{ oldText: "let total = 0;", newText: "let total = 1;" }],
+        esperado: "rechaza",
+    },
+    {
+        id: "no-existe",
+        error: "el oldText no está en el fichero, ni parecido",
+        fichero: TABS,
+        ediciones: [{ oldText: "\tapp.escuchar(elPuerto);", newText: "\tapp.listen(PUERTO);" }],
+        esperado: "rechaza",
+    },
+    {
+        id: "vacio",
+        error: "oldText vacío: casaría en todas partes",
+        fichero: TABS,
+        ediciones: [{ oldText: "", newText: "algo" }],
+        esperado: "rechaza",
+    },
+    // ── Los tres siguientes vigilan EXACTAMENTE lo que abren `espaciado-interno`
+    //    y `hueco-elidido`. Cada capacidad nueva de casado es una capacidad nueva
+    //    de casar en el sitio equivocado, y una carga que se recupera sin una
+    //    carga que la vigile es una permisividad sin medir.
+    {
+        id: "espaciado-ambiguo",
+        error: "el patrón solo casa si se colapsan los espacios, y entonces casa en DOS sitios",
+        fichero: ESPACIADO_REPETIDO,
+        ediciones: [{ oldText: "let  x  =  1;", newText: "let x = 2;" }],
+        esperado: "rechaza",
+    },
+    {
+        id: "hueco-ancla-ambigua",
+        error: "elide el medio, pero el ancla de apertura casa en dos funciones idénticas",
+        fichero: DOS_IGUALES,
+        ediciones: [
+            { oldText: "function envolver() {\n...\n\tfin();", newText: "function envolver() {\n\tsolo();\n\tfin();" },
+        ],
+        esperado: "rechaza",
+    },
+    {
+        id: "hueco-cierre-no-unico",
+        error: "elide la PRIMERA de dos funciones: el } de la segunda vuelve ambigua el ancla de cierre",
+        fichero: DOS_FUNCIONES,
+        ediciones: [{ oldText: "function a() {\n...\n}", newText: "function a() {\n\tuno2();\n}" }],
+        // Se rechaza, y esta carga existe para que ese rechazo sea un NÚMERO y no
+        // una sorpresa. Medido sobre `src/core/`: con la regla de ancla única, la
+        // elisión casa en 164 de 1173 funciones de nivel superior (14%), y en la
+        // práctica solo en la última de cada fichero. Elegir por el modelo entre
+        // dos cierres sería una moneda al aire que se traga código que él no ha
+        // nombrado, así que el rechazo es la respuesta correcta HOY; quien amplíe
+        // el alcance tendrá que cambiar esta línea a mano y decir con qué lo mide.
+        esperado: "rechaza",
+    },
+    {
+        id: "hueco-sin-fondo",
+        error: "el ... abre el hueco sin ancla delante: se comería el fichero desde el principio",
+        fichero: TABS,
+        ediciones: [{ oldText: "...\n}", newText: "\tapp.listen(PUERTO);\n}" }],
+        esperado: "rechaza",
+    },
+];
+/** Pasa una carga por el motor y clasifica el resultado en tres estados. */
+export function evaluarCarga(carga) {
+    const base = { id: carga.id, error: carga.error, esperado: carga.esperado };
+    let salida;
+    try {
+        salida = applyEditsToNormalizedContent(carga.fichero, [...carga.ediciones], `${carga.id}.ts`).newContent;
+    }
+    catch (error) {
+        return {
+            ...base,
+            veredicto: carga.esperado === "rechaza" ? "rechazado-bien" : "rechazado",
+            detalle: carga.esperado === "rechaza" ? undefined : error.message.slice(0, 120),
+        };
+    }
+    if (carga.esperado === "rechaza") {
+        // Aplicó algo que debía rechazar. Es corrupción por definición: el fichero
+        // cambió sin que nadie pudiera saber dónde.
+        return { ...base, veredicto: "corrupto", detalle: "aplicó una edición que debía rechazarse" };
+    }
+    if (salida === carga.resultado)
+        return { ...base, veredicto: "correcto" };
+    return {
+        ...base,
+        veredicto: "corrupto",
+        detalle: `salió ${JSON.stringify(salida.slice(0, 90))}, se esperaba ${JSON.stringify((carga.resultado ?? "").slice(0, 90))}`,
+    };
+}
+export function evaluarTodas(cargas = CARGAS) {
+    const resultados = cargas.map(evaluarCarga);
+    return {
+        correctos: resultados.filter((r) => r.veredicto === "correcto").length,
+        corruptos: resultados.filter((r) => r.veredicto === "corrupto").length,
+        rechazados: resultados.filter((r) => r.veredicto === "rechazado").length,
+        rechazadosBien: resultados.filter((r) => r.veredicto === "rechazado-bien").length,
+        total: resultados.length,
+        resultados,
+    };
+}
+//# sourceMappingURL=cargas.js.map

package/dist/core/banco/cargas.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"cargas.js","sourceRoot":"","sources":["../../../src/core/banco/cargas.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Banco de CARGAS MAL FORMADAS contra el motor de edición. Sin modelo.\n *\n * POR QUÉ HACE FALTA OTRO BANCO. `core/banco/` mide si el MODELO encuentra y\n * arregla un bug: llama a un proveedor de verdad, cuesta dinero y, sobre todo,\n * mide al modelo. Hoy quedó demostrado de la peor manera: con\n * `opencode/x-preview-f-free` la línea base salió 37,5% de acierto y 62,5% de\n * «fantasmas», y con `opencode/hy3-free` los MISMOS casos dieron 100% y 0%. Ese\n * 37,5% no medía a Ada; medía un proveedor que devuelve respuestas vacías.\n *\n * Este banco mide LO NUESTRO: dado un `oldText` con los errores que los modelos\n * cometen de verdad, ¿entra la edición y entra BIEN? Es determinista, no cuesta\n * nada y sirve de puerta.\n *\n * LA MÉTRICA, que es la decisión de diseño importante.\n *\n * Lo natural sería contar «cuántas aplica», y sería un error. Medido sobre\n * oh-my-pi: de 14 cargas aplica 10 y **tres de esas diez corrompen** —una\n * inyecta un error de sintaxis y dos estropean la sangría—. Un motor más\n * permisivo no es mejor: es más peligroso, porque un rechazo cuesta un turno y\n * una corrupción silenciosa cuesta un fichero.\n *\n * Por eso hay TRES resultados y no dos:\n *\n *   correcto   la edición entra y el fichero queda como debía\n *   corrupto   la edición entra y el fichero queda MAL  ← el peor de los tres\n *   rechazado  la edición no entra\n *\n * `corrupto` cuenta como peor que `rechazado` a propósito. Es la misma\n * distinción que aplicamos en todo el repositorio: un fallo que se lee como\n * éxito es más caro que un fallo que se ve.\n */\n\nimport { applyEditsToNormalizedContent } from \"../tools/edit-diff.ts\";\n\n/** Qué debería pasar con una carga. Lo declara el caso, no lo decide el motor. */\nexport type Esperado = \"aplica\" | \"rechaza\";\n\nexport interface CargaMalFormada {\n\tid: string;\n\t/** Qué error del modelo reproduce, en una línea. */\n\terror: string;\n\t/** El fichero tal cual está en disco. */\n\tfichero: string;\n\tediciones: ReadonlyArray<{ oldText: string; newText: string }>;\n\t/**\n\t * `aplica` = el motor DEBERÍA recuperarlo. `rechaza` = debería negarse.\n\t *\n\t * Hay casos que deben rechazarse y esos son los que impiden que este banco\n\t * premie a un motor que acepta todo. Sin ellos, «aplicar más» sería siempre\n\t * mejor puntuación, y eso es exactamente el error de medición que queremos\n\t * evitar.\n\t */\n\tesperado: Esperado;\n\t/** El fichero resultante correcto. Solo para los `aplica`. */\n\tresultado?: string;\n}\n\nconst TABS = [\n\t\"export function servir(puerto: number) {\",\n\t\"\\tconst app = express();\",\n\t\"\\tapp.listen(puerto);\",\n\t\"}\",\n\t\"\",\n].join(\"\\n\");\nconst TABS_OK = [\n\t\"export function servir(puerto: number) {\",\n\t\"\\tconst app = express();\",\n\t\"\\tapp.listen(PUERTO);\",\n\t\"}\",\n\t\"\",\n].join(\"\\n\");\n\nconst ESPACIOS = [\n\t\"function total(items: Item[]) {\",\n\t\"    let suma = 0;\",\n\t\"    for (const it of items) {\",\n\t\"        suma += it.precio;\",\n\t\"    }\",\n\t\"    return suma;\",\n\t\"}\",\n\t\"\",\n].join(\"\\n\");\n\nconst REPETIDO = [\"let total = 0;\", \"suma(a);\", \"let total = 0;\", \"suma(b);\", \"\"].join(\"\\n\");\n\n/**\n * Dos líneas que son distintas al recortarlas y la MISMA al colapsar el\n * espaciado interior. Existe para vigilar el camino que recupera\n * `espaciado-interno`.\n */\nconst ESPACIADO_REPETIDO = [\n\t\"const paso = calcular(1);\",\n\t\"let x = 1;\",\n\t\"const otro = calcular(2);\",\n\t\"let  x = 1;\",\n\t\"\",\n].join(\"\\n\");\n\n/**\n * Un doble espacio DENTRO de una cadena, que es espaciado con significado.\n *\n * Existe porque casar colapsando espacios abre la puerta a escribirlos\n * colapsados: el modelo retipea esta línea con un espacio solo, sin intención de\n * tocarla, mientras cambia la de abajo.\n */\nconst CADENA_CON_DOS_ESPACIOS = [\"function saludo() {\", '    const s = \"a  b\";', \"    return s;\", \"}\", \"\"].join(\"\\n\");\n\n/**\n * Un fichero de tabuladores con un doble espacio INTERIOR, para el caso en que\n * colapsar ese espacio es exactamente lo que el modelo pide.\n */\nconst TABS_CON_DOS_ESPACIOS = [\n\t\"export function servir(puerto: number) {\",\n\t\"\\tconst app  = express();\",\n\t\"\\tapp.listen(puerto);\",\n\t\"}\",\n\t\"\",\n].join(\"\\n\");\n\n/**\n * Comillas tipográficas y espacios al final, que es lo que hace falta para\n * ejercitar el empalme del camino DIFUSO.\n *\n * La línea 1 solo casa tras normalizar, así que enciende ese camino para todo el\n * lote. La línea 2 se edita por dentro y lleva comillas tipográficas que nadie\n * ha pedido tocar y tres espacios al final, que son los dos sitios donde el\n * empalme se ha roto de verdad.\n */\nconst TIPOGRAFICO = [\n\t\"const uno = “a”;\",\n\t'const msg = \"el “titulo” va aqui\" + compute(1);   ',\n\t\"const fin = 1;\",\n\t\"\",\n].join(\"\\n\");\nconst TIPOGRAFICO_OK = [\n\t'const uno = \"b\";',\n\t'const msg = \"el “titulo” va aqui\" + compute(2);   ',\n\t\"const fin = 1;\",\n\t\"\",\n].join(\"\\n\");\n\n/**\n * Dos funciones seguidas: el `}` de la columna cero de la segunda vuelve\n * ambigua el ancla de CIERRE de la primera. Es la forma de fichero más normal\n * que existe y mide el alcance real de la elisión.\n */\nconst DOS_FUNCIONES = [\"function a() {\", \"\\tuno();\", \"}\", \"\", \"function b() {\", \"\\tdos();\", \"}\", \"\"].join(\"\\n\");\n\n/** Dos funciones idénticas: el ancla de apertura casa en los dos sitios. */\nconst DOS_IGUALES = [\n\t\"function envolver() {\",\n\t\"\\tinicio();\",\n\t\"\\tfin();\",\n\t\"}\",\n\t\"function envolver() {\",\n\t\"\\tinicio();\",\n\t\"\\tfin();\",\n\t\"}\",\n\t\"\",\n].join(\"\\n\");\n\n/**\n * El corpus. Cada caso es un error que un modelo comete DE VERDAD.\n *\n * No están inventados: salen de la comparación motor contra motor de oh-my-pi y\n * de la sonda de nueve casos que se ejecutó sobre este repositorio.\n */\nexport const CARGAS: readonly CargaMalFormada[] = [\n\t{\n\t\t// El modelo retipea el contexto y se equivoca en una letra. omp lo aplica\n\t\t// y ESCRIBE la errata: su fichero acaba con `item`, que no existe, y no\n\t\t// compila. Nosotros casamos por parecido y escribimos la versión del\n\t\t// FICHERO en las líneas que el modelo solo estaba citando.\n\t\tid: \"errata-en-el-contexto\",\n\t\terror: \"el modelo retipea una línea de contexto con una errata (items → item)\",\n\t\tfichero: [\n\t\t\t\"function total(items) {\",\n\t\t\t\"    let suma = 0;\",\n\t\t\t\"    for (const it of items) {\",\n\t\t\t\"        suma += it.precio;\",\n\t\t\t\"    }\",\n\t\t\t\"    return suma;\",\n\t\t\t\"}\",\n\t\t\t\"\",\n\t\t].join(\"\\n\"),\n\t\tediciones: [\n\t\t\t{\n\t\t\t\toldText: \"    for (const it of item) {\\n        suma += it.precio;\\n    }\",\n\t\t\t\tnewText: \"    for (const it of item) {\\n        suma += it.precio * it.cantidad;\\n    }\",\n\t\t\t},\n\t\t],\n\t\tesperado: \"aplica\",\n\t\tresultado: [\n\t\t\t\"function total(items) {\",\n\t\t\t\"    let suma = 0;\",\n\t\t\t\"    for (const it of items) {\",\n\t\t\t\"        suma += it.precio;\",\n\t\t\t\"    }\",\n\t\t\t\"    return suma;\",\n\t\t\t\"}\",\n\t\t\t\"\",\n\t\t]\n\t\t\t.join(\"\\n\")\n\t\t\t.replace(\"suma += it.precio;\", \"suma += it.precio * it.cantidad;\"),\n\t},\n\t{\n\t\t// La puerta de DOMINANCIA. Dos bloques casi idénticos: el patrón con\n\t\t// errata se parece a los dos, así que no sabemos cuál quería. Elegir por\n\t\t// el modelo es peor que rechazar.\n\t\tid: \"parecido-ambiguo\",\n\t\terror: \"un patrón con errata que se parece igual a DOS bloques distintos\",\n\t\tfichero: [\n\t\t\t\"function a() {\",\n\t\t\t\"    const valor = calcular(1);\",\n\t\t\t\"    return valor;\",\n\t\t\t\"}\",\n\t\t\t\"function b() {\",\n\t\t\t\"    const valor = calcular(1);\",\n\t\t\t\"    return valor;\",\n\t\t\t\"}\",\n\t\t\t\"\",\n\t\t].join(\"\\n\"),\n\t\tediciones: [\n\t\t\t{\n\t\t\t\toldText: \"    const valo = calcular(1);\\n    return valor;\",\n\t\t\t\tnewText: \"    const valor = calcular(2);\\n    return valor;\",\n\t\t\t},\n\t\t],\n\t\tesperado: \"rechaza\",\n\t},\n\t{\n\t\t// La puerta del UMBRAL. No es una errata: es otro sitio. Un casado por\n\t\t// parecido sin suelo casaría cualquier cosa con cualquier cosa.\n\t\tid: \"parecido-demasiado-lejos\",\n\t\terror: \"el patrón no se parece a nada del fichero\",\n\t\tfichero: [\n\t\t\t\"function total(items) {\",\n\t\t\t\"    let suma = 0;\",\n\t\t\t\"    for (const it of items) {\",\n\t\t\t\"        suma += it.precio;\",\n\t\t\t\"    }\",\n\t\t\t\"    return suma;\",\n\t\t\t\"}\",\n\t\t\t\"\",\n\t\t].join(\"\\n\"),\n\t\tediciones: [\n\t\t\t{\n\t\t\t\toldText: \"    const cliente = new Cliente();\\n    cliente.enviar();\",\n\t\t\t\tnewText: \"    const cliente = new Cliente();\\n    cliente.recibir();\",\n\t\t\t},\n\t\t],\n\t\tesperado: \"rechaza\",\n\t},\n\t{\n\t\t// Encontrado auditando oh-my-pi y reproducido ejecutando. El `oldText` casa\n\t\t// EXACTO, así que el motor escribía el `newText` verbatim y se saltaba toda\n\t\t// la lógica de sangría: el fichero acababa mezclando tabuladores y espacios.\n\t\t// En Python eso es un `TabError` y no arranca, y `parseo.ts` no cubre `.py`,\n\t\t// así que la red de reparación ni se despertaba.\n\t\tid: \"sangria-mixta-python\",\n\t\terror: \"el modelo teclea el cuerpo con tabuladores en un fichero de 4 espacios\",\n\t\tfichero: [\"class Carro:\", \"    def total(self, items):\", \"        s = 0\", \"        return s\", \"\"].join(\"\\n\"),\n\t\tediciones: [\n\t\t\t{\n\t\t\t\toldText: \"    def total(self, items):\\n        s = 0\\n        return s\",\n\t\t\t\tnewText: \"    def total(self, items):\\n\\t\\ts = 0\\n\\t\\tfor i in items:\\n\\t\\t\\ts += i.p\\n\\t\\treturn s\",\n\t\t\t},\n\t\t],\n\t\tesperado: \"aplica\",\n\t\tresultado: [\n\t\t\t\"class Carro:\",\n\t\t\t\"    def total(self, items):\",\n\t\t\t\"        s = 0\",\n\t\t\t\"        for i in items:\",\n\t\t\t\"            s += i.p\",\n\t\t\t\"        return s\",\n\t\t\t\"\",\n\t\t].join(\"\\n\"),\n\t},\n\t{\n\t\t// El mismo fallo en TypeScript. No rompe la sintaxis, pero deja el fichero\n\t\t// con dos estilos y el siguiente `edit` casa peor: la edición ENTRA, así que\n\t\t// se lee como éxito.\n\t\tid: \"sangria-mixta-ts\",\n\t\terror: \"igual que el anterior, en TypeScript: entra y deja el fichero con dos estilos\",\n\t\tfichero: [\"class C {\", \"    total() {\", \"        return 1;\", \"    }\", \"}\", \"\"].join(\"\\n\"),\n\t\tediciones: [\n\t\t\t{ oldText: \"    total() {\\n        return 1;\\n    }\", newText: \"    total() {\\n\\t\\treturn 0;\\n    }\" },\n\t\t],\n\t\tesperado: \"aplica\",\n\t\tresultado: [\"class C {\", \"    total() {\", \"        return 0;\", \"    }\", \"}\", \"\"].join(\"\\n\"),\n\t},\n\t{\n\t\tid: \"exacto\",\n\t\terror: \"ninguno — es el control\",\n\t\tfichero: TABS,\n\t\tediciones: [{ oldText: \"\\tapp.listen(puerto);\", newText: \"\\tapp.listen(PUERTO);\" }],\n\t\tesperado: \"aplica\",\n\t\tresultado: TABS_OK,\n\t},\n\t{\n\t\tid: \"espacios-por-tabulador\",\n\t\terror: \"el fichero usa tabuladores y el modelo emite espacios\",\n\t\tfichero: TABS,\n\t\tediciones: [{ oldText: \"    app.listen(puerto);\", newText: \"    app.listen(PUERTO);\" }],\n\t\tesperado: \"aplica\",\n\t\tresultado: TABS_OK,\n\t},\n\t{\n\t\tid: \"sin-sangria\",\n\t\terror: \"el modelo manda la línea sin su sangría\",\n\t\tfichero: TABS,\n\t\tediciones: [{ oldText: \"app.listen(puerto);\", newText: \"app.listen(PUERTO);\" }],\n\t\tesperado: \"aplica\",\n\t\tresultado: TABS_OK,\n\t},\n\t{\n\t\tid: \"espacio-final-de-mas\",\n\t\terror: \"un espacio al final que el fichero no tiene\",\n\t\tfichero: TABS,\n\t\tediciones: [{ oldText: \"\\tapp.listen(puerto); \", newText: \"\\tapp.listen(PUERTO);\" }],\n\t\tesperado: \"aplica\",\n\t\tresultado: TABS_OK,\n\t},\n\t{\n\t\tid: \"valla-markdown\",\n\t\terror: \"el bloque viene envuelto en ```\",\n\t\tfichero: TABS,\n\t\tediciones: [{ oldText: \"```ts\\n\\tapp.listen(puerto);\\n```\", newText: \"\\tapp.listen(PUERTO);\" }],\n\t\tesperado: \"aplica\",\n\t\tresultado: TABS_OK,\n\t},\n\t{\n\t\tid: \"sobre-de-parche\",\n\t\terror: \"sentinelas de sobre (*** Begin Patch)\",\n\t\tfichero: TABS,\n\t\tediciones: [\n\t\t\t{ oldText: \"*** Begin Patch\\n\\tapp.listen(puerto);\\n*** End Patch\", newText: \"\\tapp.listen(PUERTO);\" },\n\t\t],\n\t\tesperado: \"aplica\",\n\t\tresultado: TABS_OK,\n\t},\n\t{\n\t\tid: \"cabecera-de-read\",\n\t\terror: \"el modelo copia la cabecera que añade NUESTRO propio read\",\n\t\tfichero: TABS,\n\t\tediciones: [\n\t\t\t{\n\t\t\t\toldText: \"\\tapp.listen(puerto);\\n[Showing lines 1-5 of 5. Use offset=6 to continue.]\",\n\t\t\t\tnewText: \"\\tapp.listen(PUERTO);\",\n\t\t\t},\n\t\t],\n\t\tesperado: \"aplica\",\n\t\tresultado: TABS_OK,\n\t},\n\t{\n\t\tid: \"numeros-de-linea\",\n\t\terror: \"el modelo pega los números de línea de un grep\",\n\t\tfichero: TABS,\n\t\tediciones: [{ oldText: \"3:\\tapp.listen(puerto);\", newText: \"\\tapp.listen(PUERTO);\" }],\n\t\tesperado: \"aplica\",\n\t\tresultado: TABS_OK,\n\t},\n\t{\n\t\tid: \"bloque-sin-sangrar\",\n\t\terror: \"bloque multilínea entero sin sangrar, fichero a 4 espacios\",\n\t\tfichero: ESPACIOS,\n\t\tediciones: [\n\t\t\t{\n\t\t\t\toldText: \"for (const it of items) {\\nsuma += it.precio;\\n}\",\n\t\t\t\tnewText: \"for (const it of items) {\\nsuma += it.precio * it.cantidad;\\n}\",\n\t\t\t},\n\t\t],\n\t\tesperado: \"aplica\",\n\t\tresultado: ESPACIOS.replace(\"suma += it.precio;\", \"suma += it.precio * it.cantidad;\"),\n\t},\n\t{\n\t\tid: \"espaciado-interno\",\n\t\terror: \"dos espacios donde el fichero tiene uno\",\n\t\tfichero: ESPACIOS,\n\t\tediciones: [{ oldText: \"    let suma  = 0;\", newText: \"    let suma = 1;\" }],\n\t\tesperado: \"aplica\",\n\t\tresultado: ESPACIOS.replace(\"let suma = 0;\", \"let suma = 1;\"),\n\t},\n\t{\n\t\tid: \"hueco-elidido\",\n\t\terror: \"el modelo elide el medio con ...\",\n\t\tfichero: ESPACIOS,\n\t\tediciones: [\n\t\t\t{\n\t\t\t\toldText: \"function total(items: Item[]) {\\n...\\n}\",\n\t\t\t\tnewText: \"function total(items: Item[]) {\\n\\treturn 0;\\n}\",\n\t\t\t},\n\t\t],\n\t\tesperado: \"aplica\",\n\t\t// Con la sangría DEL FICHERO, no la del modelo. `ESPACIOS` se sangra con\n\t\t// cuatro espacios y el modelo manda `\\treturn 0;`: este resultado declaraba\n\t\t// el tabulador como correcto, o sea daba por bueno «entra y deja la sangría\n\t\t// mal», que es una de las tres formas en las que corrompe oh-my-pi y la\n\t\t// razón de existir de `core/edicion/sangria.ts`. La puerta bendecía el\n\t\t// defecto que la puerta existe para cazar.\n\t\tresultado: \"function total(items: Item[]) {\\n    return 0;\\n}\\n\",\n\t},\n\t{\n\t\tid: \"espaciado-a-proposito\",\n\t\terror: \"el cambio ES el espaciado interior, y la sangría viene en espacios sobre un fichero de tabuladores\",\n\t\tfichero: TABS_CON_DOS_ESPACIOS,\n\t\tediciones: [{ oldText: \"    const app  = express();\", newText: \"    const app = express();\" }],\n\t\tesperado: \"aplica\",\n\t\t// El doble espacio DESAPARECE. Es la otra mitad de `retecleo-inocente`: ahí\n\t\t// el modelo colapsó una línea sin querer y gana el fichero; aquí el colapso\n\t\t// es lo único que pide, y gana el modelo. Se distinguen por si el casado\n\t\t// necesitó colapsar: este patrón casa con la pasada ESTRICTA (el modelo\n\t\t// reprodujo los dos espacios), así que su `newText` es deliberado.\n\t\tresultado: TABS_CON_DOS_ESPACIOS.replace(\"const app  = express();\", \"const app = express();\"),\n\t},\n\t{\n\t\tid: \"lote-difuso-empalme\",\n\t\terror: \"dos ediciones, una difusa por comillas tipográficas, y la otra dentro de una línea con espacios al final\",\n\t\tfichero: TIPOGRAFICO,\n\t\tediciones: [\n\t\t\t{ oldText: 'const uno = \"a\";', newText: 'const uno = \"b\";' },\n\t\t\t{ oldText: \"compute(1)\", newText: \"compute(2)\" },\n\t\t],\n\t\tesperado: \"aplica\",\n\t\t// Las DOS mitades del empalme sobre bytes originales, en una sola carga:\n\t\t//\n\t\t//   · las comillas tipográficas de la línea 2 siguen ahí. Nadie pidió\n\t\t//     tocarlas; escribir esa línea desde el texto normalizado dejaba\n\t\t//     comillas rectas anidadas dentro de una cadena y el fichero no\n\t\t//     compilaba.\n\t\t//   · los tres espacios finales de la línea 2 y su SALTO DE LÍNEA siguen\n\t\t//     ahí. Traducir el final normalizado de la línea a coordenadas del\n\t\t//     original cortaba dentro de ella y pegaba la línea 3 detrás de la 2.\n\t\t//\n\t\t// El corpus no tenía ninguna carga sobre el empalme difuso, que es el\n\t\t// camino donde ya nos costó una corrupción silenciosa.\n\t\tresultado: TIPOGRAFICO_OK,\n\t},\n\t{\n\t\tid: \"retecleo-inocente\",\n\t\terror: \"retipea una cadena con un espacio donde hay dos, cambiando solo la línea de abajo\",\n\t\tfichero: CADENA_CON_DOS_ESPACIOS,\n\t\tediciones: [{ oldText: 'const s = \"a b\";\\nreturn s;', newText: 'const s = \"a b\";\\nreturn s.trim();' }],\n\t\tesperado: \"aplica\",\n\t\t// El doble espacio de la cadena SIGUE AHÍ. Es la mitad que no se ve del\n\t\t// casado por espaciado: entra la edición y no se toca lo que nadie pidió.\n\t\tresultado: CADENA_CON_DOS_ESPACIOS.replace(\"return s;\", \"return s.trim();\"),\n\t},\n\t// ── Los que DEBEN rechazarse. Sin estos, «aplicar más» sería siempre mejor\n\t//    nota, y un motor que acepta cualquier cosa ganaría el banco.\n\t{\n\t\tid: \"ambiguo-dos-ocurrencias\",\n\t\terror: \"el oldText aparece dos veces: cuál se edita es una moneda al aire\",\n\t\tfichero: REPETIDO,\n\t\tediciones: [{ oldText: \"let total = 0;\", newText: \"let total = 1;\" }],\n\t\tesperado: \"rechaza\",\n\t},\n\t{\n\t\tid: \"no-existe\",\n\t\terror: \"el oldText no está en el fichero, ni parecido\",\n\t\tfichero: TABS,\n\t\tediciones: [{ oldText: \"\\tapp.escuchar(elPuerto);\", newText: \"\\tapp.listen(PUERTO);\" }],\n\t\tesperado: \"rechaza\",\n\t},\n\t{\n\t\tid: \"vacio\",\n\t\terror: \"oldText vacío: casaría en todas partes\",\n\t\tfichero: TABS,\n\t\tediciones: [{ oldText: \"\", newText: \"algo\" }],\n\t\tesperado: \"rechaza\",\n\t},\n\t// ── Los tres siguientes vigilan EXACTAMENTE lo que abren `espaciado-interno`\n\t//    y `hueco-elidido`. Cada capacidad nueva de casado es una capacidad nueva\n\t//    de casar en el sitio equivocado, y una carga que se recupera sin una\n\t//    carga que la vigile es una permisividad sin medir.\n\t{\n\t\tid: \"espaciado-ambiguo\",\n\t\terror: \"el patrón solo casa si se colapsan los espacios, y entonces casa en DOS sitios\",\n\t\tfichero: ESPACIADO_REPETIDO,\n\t\tediciones: [{ oldText: \"let  x  =  1;\", newText: \"let x = 2;\" }],\n\t\tesperado: \"rechaza\",\n\t},\n\t{\n\t\tid: \"hueco-ancla-ambigua\",\n\t\terror: \"elide el medio, pero el ancla de apertura casa en dos funciones idénticas\",\n\t\tfichero: DOS_IGUALES,\n\t\tediciones: [\n\t\t\t{ oldText: \"function envolver() {\\n...\\n\\tfin();\", newText: \"function envolver() {\\n\\tsolo();\\n\\tfin();\" },\n\t\t],\n\t\tesperado: \"rechaza\",\n\t},\n\t{\n\t\tid: \"hueco-cierre-no-unico\",\n\t\terror: \"elide la PRIMERA de dos funciones: el } de la segunda vuelve ambigua el ancla de cierre\",\n\t\tfichero: DOS_FUNCIONES,\n\t\tediciones: [{ oldText: \"function a() {\\n...\\n}\", newText: \"function a() {\\n\\tuno2();\\n}\" }],\n\t\t// Se rechaza, y esta carga existe para que ese rechazo sea un NÚMERO y no\n\t\t// una sorpresa. Medido sobre `src/core/`: con la regla de ancla única, la\n\t\t// elisión casa en 164 de 1173 funciones de nivel superior (14%), y en la\n\t\t// práctica solo en la última de cada fichero. Elegir por el modelo entre\n\t\t// dos cierres sería una moneda al aire que se traga código que él no ha\n\t\t// nombrado, así que el rechazo es la respuesta correcta HOY; quien amplíe\n\t\t// el alcance tendrá que cambiar esta línea a mano y decir con qué lo mide.\n\t\tesperado: \"rechaza\",\n\t},\n\t{\n\t\tid: \"hueco-sin-fondo\",\n\t\terror: \"el ... abre el hueco sin ancla delante: se comería el fichero desde el principio\",\n\t\tfichero: TABS,\n\t\tediciones: [{ oldText: \"...\\n}\", newText: \"\\tapp.listen(PUERTO);\\n}\" }],\n\t\tesperado: \"rechaza\",\n\t},\n];\n\nexport type Veredicto = \"correcto\" | \"corrupto\" | \"rechazado\" | \"rechazado-bien\";\n\nexport interface ResultadoDeCarga {\n\tid: string;\n\terror: string;\n\tesperado: Esperado;\n\tveredicto: Veredicto;\n\t/** Qué salió, cuando salió mal. Para poder leer el fallo sin reproducirlo. */\n\tdetalle?: string;\n}\n\n/** Pasa una carga por el motor y clasifica el resultado en tres estados. */\nexport function evaluarCarga(carga: CargaMalFormada): ResultadoDeCarga {\n\tconst base = { id: carga.id, error: carga.error, esperado: carga.esperado };\n\tlet salida: string;\n\ttry {\n\t\tsalida = applyEditsToNormalizedContent(carga.fichero, [...carga.ediciones], `${carga.id}.ts`).newContent;\n\t} catch (error) {\n\t\treturn {\n\t\t\t...base,\n\t\t\tveredicto: carga.esperado === \"rechaza\" ? \"rechazado-bien\" : \"rechazado\",\n\t\t\tdetalle: carga.esperado === \"rechaza\" ? undefined : (error as Error).message.slice(0, 120),\n\t\t};\n\t}\n\tif (carga.esperado === \"rechaza\") {\n\t\t// Aplicó algo que debía rechazar. Es corrupción por definición: el fichero\n\t\t// cambió sin que nadie pudiera saber dónde.\n\t\treturn { ...base, veredicto: \"corrupto\", detalle: \"aplicó una edición que debía rechazarse\" };\n\t}\n\tif (salida === carga.resultado) return { ...base, veredicto: \"correcto\" };\n\treturn {\n\t\t...base,\n\t\tveredicto: \"corrupto\",\n\t\tdetalle: `salió ${JSON.stringify(salida.slice(0, 90))}, se esperaba ${JSON.stringify((carga.resultado ?? \"\").slice(0, 90))}`,\n\t};\n}\n\nexport interface Puntuacion {\n\tcorrectos: number;\n\tcorruptos: number;\n\trechazados: number;\n\trechazadosBien: number;\n\ttotal: number;\n\tresultados: readonly ResultadoDeCarga[];\n}\n\nexport function evaluarTodas(cargas: readonly CargaMalFormada[] = CARGAS): Puntuacion {\n\tconst resultados = cargas.map(evaluarCarga);\n\treturn {\n\t\tcorrectos: resultados.filter((r) => r.veredicto === \"correcto\").length,\n\t\tcorruptos: resultados.filter((r) => r.veredicto === \"corrupto\").length,\n\t\trechazados: resultados.filter((r) => r.veredicto === \"rechazado\").length,\n\t\trechazadosBien: resultados.filter((r) => r.veredicto === \"rechazado-bien\").length,\n\t\ttotal: resultados.length,\n\t\tresultados,\n\t};\n}\n"]}

package/dist/core/banco/comparar.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Compara dos ejecuciones del banco: ¿el cambio de editor mejoró o empeoró?
+ *
+ * Sin esto, dos JSON de resultados son datos sueltos. Con esto son una
+ * respuesta a "¿esto que acabo de tocar edita mejor o peor que antes?".
+ */
+import type { ResultadosEjecucion } from "./tipos.ts";
+export interface DeltaMetrica {
+    nombre: string;
+    antes: number;
+    despues: number;
+    delta: number;
+}
+export interface ComparacionEjecuciones {
+    a: {
+        archivo: string;
+        modelo: string;
+        ejecutadoEn: string;
+    };
+    b: {
+        archivo: string;
+        modelo: string;
+        ejecutadoEn: string;
+    };
+    metricas: DeltaMetrica[];
+}
+export declare function compararEjecuciones(a: ResultadosEjecucion, b: ResultadosEjecucion, rutaA: string, rutaB: string): ComparacionEjecuciones;
+export declare function formatearComparacion(c: ComparacionEjecuciones): string;
+//# sourceMappingURL=comparar.d.ts.map

package/dist/core/banco/comparar.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"comparar.d.ts","sourceRoot":"","sources":["../../../src/core/banco/comparar.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,YAAY,CAAC;AAEtD,MAAM,WAAW,YAAY;IAC5B,MAAM,EAAE,MAAM,CAAC;IACf,KAAK,EAAE,MAAM,CAAC;IACd,OAAO,EAAE,MAAM,CAAC;IAChB,KAAK,EAAE,MAAM,CAAC;CACd;AAED,MAAM,WAAW,sBAAsB;IACtC,CAAC,EAAE;QAAE,OAAO,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAC;QAAC,WAAW,EAAE,MAAM,CAAA;KAAE,CAAC;IAC5D,CAAC,EAAE;QAAE,OAAO,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAC;QAAC,WAAW,EAAE,MAAM,CAAA;KAAE,CAAC;IAC5D,QAAQ,EAAE,YAAY,EAAE,CAAC;CACzB;AAMD,wBAAgB,mBAAmB,CAClC,CAAC,EAAE,mBAAmB,EACtB,CAAC,EAAE,mBAAmB,EACtB,KAAK,EAAE,MAAM,EACb,KAAK,EAAE,MAAM,GACX,sBAAsB,CAYxB;AAED,wBAAgB,oBAAoB,CAAC,CAAC,EAAE,sBAAsB,GAAG,MAAM,CAOtE","sourcesContent":["/**\n * Compara dos ejecuciones del banco: ¿el cambio de editor mejoró o empeoró?\n *\n * Sin esto, dos JSON de resultados son datos sueltos. Con esto son una\n * respuesta a \"¿esto que acabo de tocar edita mejor o peor que antes?\".\n */\n\nimport type { ResultadosEjecucion } from \"./tipos.ts\";\n\nexport interface DeltaMetrica {\n\tnombre: string;\n\tantes: number;\n\tdespues: number;\n\tdelta: number;\n}\n\nexport interface ComparacionEjecuciones {\n\ta: { archivo: string; modelo: string; ejecutadoEn: string };\n\tb: { archivo: string; modelo: string; ejecutadoEn: string };\n\tmetricas: DeltaMetrica[];\n}\n\nfunction delta(nombre: string, antes: number, despues: number): DeltaMetrica {\n\treturn { nombre, antes, despues, delta: Math.round((despues - antes) * 10) / 10 };\n}\n\nexport function compararEjecuciones(\n\ta: ResultadosEjecucion,\n\tb: ResultadosEjecucion,\n\trutaA: string,\n\trutaB: string,\n): ComparacionEjecuciones {\n\treturn {\n\t\ta: { archivo: rutaA, modelo: `${a.proveedor}/${a.modelo}`, ejecutadoEn: a.ejecutadoEn },\n\t\tb: { archivo: rutaB, modelo: `${b.proveedor}/${b.modelo}`, ejecutadoEn: b.ejecutadoEn },\n\t\tmetricas: [\n\t\t\tdelta(\"tarea %\", a.resumen.tareaOkPct, b.resumen.tareaOkPct),\n\t\t\tdelta(\"edición %\", a.resumen.edicionOkPct, b.resumen.edicionOkPct),\n\t\t\tdelta(\"fantasma %\", a.resumen.fantasmaPct, b.resumen.fantasmaPct),\n\t\t\tdelta(\"timeout %\", a.resumen.timeoutPct, b.resumen.timeoutPct),\n\t\t\tdelta(\"error %\", a.resumen.errorPct, b.resumen.errorPct),\n\t\t],\n\t};\n}\n\nexport function formatearComparacion(c: ComparacionEjecuciones): string {\n\tconst flecha = (d: DeltaMetrica) => (d.delta > 0 ? \"▲\" : d.delta < 0 ? \"▼\" : \"=\");\n\tconst filas = c.metricas.map(\n\t\t(m) =>\n\t\t\t`  ${m.nombre.padEnd(12)} ${m.antes.toFixed(1)}%  →  ${m.despues.toFixed(1)}%   ${flecha(m)} ${Math.abs(m.delta).toFixed(1)}`,\n\t);\n\treturn [`A: ${c.a.modelo}  (${c.a.archivo})`, `B: ${c.b.modelo}  (${c.b.archivo})`, \"\", ...filas].join(\"\\n\");\n}\n"]}