@hoilab/ada-cli 0.84.21 → 0.85.0

package/dist/core/banco/analisis.js

@@ -0,0 +1,164 @@
+/**
+ * Análisis del corpus fuente: qué ficheros hay y qué tan adversos son.
+ *
+ * Mide las mismas cuatro condiciones que pide la tarea: línea repetida,
+ * fichero largo con el bug en medio, bloques estructuralmente parecidos y
+ * código denso. La dificultad no es un adjetivo, es un filtro sobre estos
+ * números — así "pesadilla" siempre significa lo mismo entre ejecuciones.
+ */
+import { readdirSync, readFileSync } from "node:fs";
+import { extname, join, relative } from "node:path";
+const EXTENSIONES = new Set([".ts", ".tsx"]);
+const DIRS_EXCLUIDOS = new Set(["node_modules", "dist", "build", "coverage", ".git", "fixtures", "fixture"]);
+function esExcluido(ruta) {
+    const partes = ruta.split("/");
+    if (partes.some((p) => DIRS_EXCLUIDOS.has(p)))
+        return true;
+    const base = partes[partes.length - 1] ?? "";
+    return base.includes(".test.") || base.includes(".spec.") || base.endsWith(".d.ts");
+}
+/** Recorre el corpus y devuelve rutas absolutas de ficheros candidatos. */
+export function listarFicheros(raiz) {
+    const encontrados = [];
+    function recorrer(dir) {
+        let entradas;
+        try {
+            entradas = readdirSync(dir, { withFileTypes: true, encoding: "utf-8" });
+        }
+        catch {
+            return;
+        }
+        for (const entrada of entradas) {
+            const ruta = join(dir, entrada.name);
+            if (esExcluido(ruta))
+                continue;
+            if (entrada.isDirectory()) {
+                recorrer(ruta);
+            }
+            else if (entrada.isFile() && EXTENSIONES.has(extname(entrada.name))) {
+                encontrados.push(ruta);
+            }
+        }
+    }
+    recorrer(raiz);
+    return encontrados.sort();
+}
+const TRIVIALES = new Set(["{", "}", "};", ");", "],", "});", "return;", "break;", "continue;", ""]);
+function contarLineasRepetidas(lineas) {
+    const posiciones = new Map();
+    lineas.forEach((linea, i) => {
+        const t = linea.trim();
+        if (t.length < 10 || TRIVIALES.has(t))
+            return;
+        const lista = posiciones.get(t) ?? [];
+        lista.push(i + 1);
+        posiciones.set(t, lista);
+    });
+    const repetidas = new Map();
+    for (const [t, pos] of posiciones)
+        if (pos.length >= 2)
+            repetidas.set(t, pos);
+    return repetidas;
+}
+/** Cuenta declaraciones de función/arrow-function: proxy barato de "bloques con forma parecida". */
+function contarBloquesSimilares(contenido) {
+    const patron = /(?:function\s+\w+|(?:const|let)\s+\w+\s*=\s*(?:async\s*)?\([^)]*\)\s*=>)/g;
+    return (contenido.match(patron) ?? []).length;
+}
+function calcularDensidad(contenido) {
+    if (!contenido)
+        return 0;
+    const sinEspacios = contenido.replace(/\s/g, "").length;
+    return sinEspacios / contenido.length;
+}
+function calcularIndentMaxima(lineas) {
+    let max = 0;
+    for (const l of lineas) {
+        if (!l.trim())
+            continue;
+        max = Math.max(max, l.length - l.trimStart().length);
+    }
+    return max;
+}
+const MIN_LINEAS = 30;
+const MAX_LINEAS = 800;
+/** Lee y analiza el corpus completo; descarta ficheros minúsculos o gigantes. */
+export function analizarCorpus(raiz) {
+    const resultado = [];
+    for (const ruta of listarFicheros(raiz)) {
+        let contenido;
+        try {
+            contenido = readFileSync(ruta, "utf-8");
+        }
+        catch {
+            continue;
+        }
+        const lineas = contenido.split("\n");
+        if (lineas.length < MIN_LINEAS || lineas.length > MAX_LINEAS)
+            continue;
+        if (!["function ", "class ", "export ", "=>"].some((t) => contenido.includes(t)))
+            continue;
+        resultado.push({
+            ruta,
+            relativa: relative(raiz, ruta),
+            contenido,
+            lineas,
+            lineasRepetidas: contarLineasRepetidas(lineas),
+            bloquesSimilares: contarBloquesSimilares(contenido),
+            densidad: calcularDensidad(contenido),
+            indentMaxima: calcularIndentMaxima(lineas),
+        });
+    }
+    return resultado;
+}
+/**
+ * Filtro de candidatos por dificultad. Cada nivel exige un tipo de condición
+ * adversa distinta, no solo "más grande":
+ *  - facil: fichero corto, sin ambigüedad por repetición.
+ *  - medio: fichero de tamaño medio.
+ *  - dificil: fichero largo con bloques estructuralmente parecidos.
+ *  - pesadilla: fichero largo con líneas repetidas — la ambigüedad forma
+ *    parte del fichero, no solo del prompt.
+ */
+export function candidatosPara(ficheros, dificultad) {
+    switch (dificultad) {
+        case "facil":
+            return ficheros.filter((f) => f.lineas.length < 150 && f.lineasRepetidas.size < 3);
+        case "medio":
+            return ficheros.filter((f) => f.lineas.length >= 100 && f.lineas.length <= 300);
+        case "dificil":
+            return ficheros.filter((f) => f.lineas.length > 200 && f.bloquesSimilares >= 3);
+        case "pesadilla":
+            return ficheros.filter((f) => f.lineasRepetidas.size > 0 && f.lineas.length > 200);
+    }
+}
+/** Puntuación de dificultad de UN caso concreto: mayor = más adverso. Solo informativa. */
+export function puntuarDificultad(fichero, numeroLinea) {
+    let puntos = 0;
+    if (fichero.lineas.length > 300)
+        puntos += 3;
+    else if (fichero.lineas.length > 150)
+        puntos += 1;
+    const medio = fichero.lineas.length * 0.33;
+    const finMedio = fichero.lineas.length * 0.66;
+    if (numeroLinea >= medio && numeroLinea <= finMedio)
+        puntos += 2;
+    const texto = (fichero.lineas[numeroLinea - 1] ?? "").trim();
+    const repeticiones = fichero.lineasRepetidas.get(texto)?.length ?? 0;
+    puntos += Math.min(repeticiones, 5);
+    if (fichero.bloquesSimilares >= 5)
+        puntos += 3;
+    else if (fichero.bloquesSimilares >= 3)
+        puntos += 1;
+    if (fichero.densidad > 0.75)
+        puntos += 2;
+    else if (fichero.densidad > 0.65)
+        puntos += 1;
+    const indent = (fichero.lineas[numeroLinea - 1] ?? "").length - (fichero.lineas[numeroLinea - 1] ?? "").trimStart().length;
+    if (indent >= 16)
+        puntos += 2;
+    else if (indent >= 8)
+        puntos += 1;
+    return puntos;
+}
+//# sourceMappingURL=analisis.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"analisis.js","sourceRoot":"","sources":["../../../src/core/banco/analisis.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Análisis del corpus fuente: qué ficheros hay y qué tan adversos son.\n *\n * Mide las mismas cuatro condiciones que pide la tarea: línea repetida,\n * fichero largo con el bug en medio, bloques estructuralmente parecidos y\n * código denso. La dificultad no es un adjetivo, es un filtro sobre estos\n * números — así \"pesadilla\" siempre significa lo mismo entre ejecuciones.\n */\n\nimport { type Dirent, readdirSync, readFileSync } from \"node:fs\";\nimport { extname, join, relative } from \"node:path\";\nimport type { Dificultad } from \"./tipos.ts\";\n\nconst EXTENSIONES = new Set([\".ts\", \".tsx\"]);\nconst DIRS_EXCLUIDOS = new Set([\"node_modules\", \"dist\", \"build\", \"coverage\", \".git\", \"fixtures\", \"fixture\"]);\n\nfunction esExcluido(ruta: string): boolean {\n\tconst partes = ruta.split(\"/\");\n\tif (partes.some((p) => DIRS_EXCLUIDOS.has(p))) return true;\n\tconst base = partes[partes.length - 1] ?? \"\";\n\treturn base.includes(\".test.\") || base.includes(\".spec.\") || base.endsWith(\".d.ts\");\n}\n\n/** Recorre el corpus y devuelve rutas absolutas de ficheros candidatos. */\nexport function listarFicheros(raiz: string): string[] {\n\tconst encontrados: string[] = [];\n\tfunction recorrer(dir: string): void {\n\t\tlet entradas: Dirent<string>[];\n\t\ttry {\n\t\t\tentradas = readdirSync(dir, { withFileTypes: true, encoding: \"utf-8\" });\n\t\t} catch {\n\t\t\treturn;\n\t\t}\n\t\tfor (const entrada of entradas) {\n\t\t\tconst ruta = join(dir, entrada.name);\n\t\t\tif (esExcluido(ruta)) continue;\n\t\t\tif (entrada.isDirectory()) {\n\t\t\t\trecorrer(ruta);\n\t\t\t} else if (entrada.isFile() && EXTENSIONES.has(extname(entrada.name))) {\n\t\t\t\tencontrados.push(ruta);\n\t\t\t}\n\t\t}\n\t}\n\trecorrer(raiz);\n\treturn encontrados.sort();\n}\n\nconst TRIVIALES = new Set([\"{\", \"}\", \"};\", \");\", \"],\", \"});\", \"return;\", \"break;\", \"continue;\", \"\"]);\n\nexport interface FicheroAnalizado {\n\truta: string;\n\trelativa: string;\n\tcontenido: string;\n\tlineas: string[];\n\t/** Texto de línea (trim) -> números de línea (1-based) donde aparece, solo si >=2 veces. */\n\tlineasRepetidas: Map<string, number[]>;\n\tbloquesSimilares: number;\n\tdensidad: number;\n\tindentMaxima: number;\n}\n\nfunction contarLineasRepetidas(lineas: string[]): Map<string, number[]> {\n\tconst posiciones = new Map<string, number[]>();\n\tlineas.forEach((linea, i) => {\n\t\tconst t = linea.trim();\n\t\tif (t.length < 10 || TRIVIALES.has(t)) return;\n\t\tconst lista = posiciones.get(t) ?? [];\n\t\tlista.push(i + 1);\n\t\tposiciones.set(t, lista);\n\t});\n\tconst repetidas = new Map<string, number[]>();\n\tfor (const [t, pos] of posiciones) if (pos.length >= 2) repetidas.set(t, pos);\n\treturn repetidas;\n}\n\n/** Cuenta declaraciones de función/arrow-function: proxy barato de \"bloques con forma parecida\". */\nfunction contarBloquesSimilares(contenido: string): number {\n\tconst patron = /(?:function\\s+\\w+|(?:const|let)\\s+\\w+\\s*=\\s*(?:async\\s*)?\\([^)]*\\)\\s*=>)/g;\n\treturn (contenido.match(patron) ?? []).length;\n}\n\nfunction calcularDensidad(contenido: string): number {\n\tif (!contenido) return 0;\n\tconst sinEspacios = contenido.replace(/\\s/g, \"\").length;\n\treturn sinEspacios / contenido.length;\n}\n\nfunction calcularIndentMaxima(lineas: string[]): number {\n\tlet max = 0;\n\tfor (const l of lineas) {\n\t\tif (!l.trim()) continue;\n\t\tmax = Math.max(max, l.length - l.trimStart().length);\n\t}\n\treturn max;\n}\n\nconst MIN_LINEAS = 30;\nconst MAX_LINEAS = 800;\n\n/** Lee y analiza el corpus completo; descarta ficheros minúsculos o gigantes. */\nexport function analizarCorpus(raiz: string): FicheroAnalizado[] {\n\tconst resultado: FicheroAnalizado[] = [];\n\tfor (const ruta of listarFicheros(raiz)) {\n\t\tlet contenido: string;\n\t\ttry {\n\t\t\tcontenido = readFileSync(ruta, \"utf-8\");\n\t\t} catch {\n\t\t\tcontinue;\n\t\t}\n\t\tconst lineas = contenido.split(\"\\n\");\n\t\tif (lineas.length < MIN_LINEAS || lineas.length > MAX_LINEAS) continue;\n\t\tif (![\"function \", \"class \", \"export \", \"=>\"].some((t) => contenido.includes(t))) continue;\n\t\tresultado.push({\n\t\t\truta,\n\t\t\trelativa: relative(raiz, ruta),\n\t\t\tcontenido,\n\t\t\tlineas,\n\t\t\tlineasRepetidas: contarLineasRepetidas(lineas),\n\t\t\tbloquesSimilares: contarBloquesSimilares(contenido),\n\t\t\tdensidad: calcularDensidad(contenido),\n\t\t\tindentMaxima: calcularIndentMaxima(lineas),\n\t\t});\n\t}\n\treturn resultado;\n}\n\n/**\n * Filtro de candidatos por dificultad. Cada nivel exige un tipo de condición\n * adversa distinta, no solo \"más grande\":\n *  - facil: fichero corto, sin ambigüedad por repetición.\n *  - medio: fichero de tamaño medio.\n *  - dificil: fichero largo con bloques estructuralmente parecidos.\n *  - pesadilla: fichero largo con líneas repetidas — la ambigüedad forma\n *    parte del fichero, no solo del prompt.\n */\nexport function candidatosPara(ficheros: FicheroAnalizado[], dificultad: Dificultad): FicheroAnalizado[] {\n\tswitch (dificultad) {\n\t\tcase \"facil\":\n\t\t\treturn ficheros.filter((f) => f.lineas.length < 150 && f.lineasRepetidas.size < 3);\n\t\tcase \"medio\":\n\t\t\treturn ficheros.filter((f) => f.lineas.length >= 100 && f.lineas.length <= 300);\n\t\tcase \"dificil\":\n\t\t\treturn ficheros.filter((f) => f.lineas.length > 200 && f.bloquesSimilares >= 3);\n\t\tcase \"pesadilla\":\n\t\t\treturn ficheros.filter((f) => f.lineasRepetidas.size > 0 && f.lineas.length > 200);\n\t}\n}\n\n/** Puntuación de dificultad de UN caso concreto: mayor = más adverso. Solo informativa. */\nexport function puntuarDificultad(fichero: FicheroAnalizado, numeroLinea: number): number {\n\tlet puntos = 0;\n\tif (fichero.lineas.length > 300) puntos += 3;\n\telse if (fichero.lineas.length > 150) puntos += 1;\n\n\tconst medio = fichero.lineas.length * 0.33;\n\tconst finMedio = fichero.lineas.length * 0.66;\n\tif (numeroLinea >= medio && numeroLinea <= finMedio) puntos += 2;\n\n\tconst texto = (fichero.lineas[numeroLinea - 1] ?? \"\").trim();\n\tconst repeticiones = fichero.lineasRepetidas.get(texto)?.length ?? 0;\n\tpuntos += Math.min(repeticiones, 5);\n\n\tif (fichero.bloquesSimilares >= 5) puntos += 3;\n\telse if (fichero.bloquesSimilares >= 3) puntos += 1;\n\n\tif (fichero.densidad > 0.75) puntos += 2;\n\telse if (fichero.densidad > 0.65) puntos += 1;\n\n\tconst indent =\n\t\t(fichero.lineas[numeroLinea - 1] ?? \"\").length - (fichero.lineas[numeroLinea - 1] ?? \"\").trimStart().length;\n\tif (indent >= 16) puntos += 2;\n\telse if (indent >= 8) puntos += 1;\n\n\treturn puntos;\n}\n"]}

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

@@ -0,0 +1,39 @@
+/**
+ * Construye el bloque que se le enseña al modelo y demuestra que es ÚNICO.
+ *
+ * El contrato de la tool `edit` real (`core/tools/edit.ts`) es: `oldText` debe
+ * ser único en el fichero. Este módulo aplica el MISMO contrato a la
+ * generación de casos: si la línea con el bug se repite en el fichero, amplía
+ * el bloque con contexto de arriba y abajo hasta que sea único, igual que
+ * tendría que hacer el propio modelo. Si no se puede — el fichero es tan
+ * repetitivo que ni con contexto hay una única ocurrencia — el caso se
+ * descarta por AMBIGUO en vez de admitirse y medir suerte.
+ */
+/** Cuántas veces aparece `bloque` (como subsecuencia contigua) dentro de `lineas`. */
+export declare function contarOcurrencias(lineas: string[], bloque: string[]): number;
+export interface BloqueUnico {
+    /** Tal como aparece en el fichero CON el bug (lo que debe buscar `edit`). */
+    bloqueEntrada: string[];
+    /** Tal como debe quedar tras el arreglo. */
+    bloqueEsperado: string[];
+    /** Línea 1-based donde empieza el bloque en el fichero de entrada. */
+    lineaInicio: number;
+    /** false si ni ampliando al máximo se logró que `bloqueEntrada` fuera único. */
+    unico: boolean;
+}
+/**
+ * Amplía hacia arriba y abajo desde `indice` (0-based, la línea con el bug)
+ * hasta que el bloque construido sobre las líneas ORIGINALES —con la línea
+ * mutada sustituida en su sitio— sea único dentro de `lineasEntrada` (el
+ * fichero completo tal y como lo ve el modelo, con el bug ya metido).
+ */
+export declare function construirBloqueUnico(lineasOriginales: string[], lineasEntrada: string[], indice: number, maxAmpliacion?: number): BloqueUnico;
+/**
+ * Re-resuelve el caso desde cero: busca `bloque.bloqueEntrada` en el fichero
+ * de entrada y aplica el reemplazo. Si el resultado no es BYTE A BYTE
+ * idéntico al fichero esperado, el prompt no determina un arreglo único y el
+ * caso debe descartarse — esta es la comprobación que la tarea pide como
+ * puerta: "cada caso se valida resolviéndolo antes de admitirlo".
+ */
+export declare function resuelveAlEsperado(contenidoEntrada: string, contenidoEsperado: string, bloque: BloqueUnico): boolean;
+//# sourceMappingURL=bloques.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"bloques.d.ts","sourceRoot":"","sources":["../../../src/core/banco/bloques.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,uFAAsF;AACtF,wBAAgB,iBAAiB,CAAC,MAAM,EAAE,MAAM,EAAE,EAAE,MAAM,EAAE,MAAM,EAAE,GAAG,MAAM,CAU5E;AAED,MAAM,WAAW,WAAW;IAC3B,6EAA6E;IAC7E,aAAa,EAAE,MAAM,EAAE,CAAC;IACxB,4CAA4C;IAC5C,cAAc,EAAE,MAAM,EAAE,CAAC;IACzB,uEAAsE;IACtE,WAAW,EAAE,MAAM,CAAC;IACpB,mFAAgF;IAChF,KAAK,EAAE,OAAO,CAAC;CACf;AAID;;;;;GAKG;AACH,wBAAgB,oBAAoB,CACnC,gBAAgB,EAAE,MAAM,EAAE,EAC1B,aAAa,EAAE,MAAM,EAAE,EACvB,MAAM,EAAE,MAAM,EACd,aAAa,SAAiB,GAC5B,WAAW,CA4Bb;AAED;;;;;;GAMG;AACH,wBAAgB,kBAAkB,CAAC,gBAAgB,EAAE,MAAM,EAAE,iBAAiB,EAAE,MAAM,EAAE,MAAM,EAAE,WAAW,GAAG,OAAO,CAYpH","sourcesContent":["/**\n * Construye el bloque que se le enseña al modelo y demuestra que es ÚNICO.\n *\n * El contrato de la tool `edit` real (`core/tools/edit.ts`) es: `oldText` debe\n * ser único en el fichero. Este módulo aplica el MISMO contrato a la\n * generación de casos: si la línea con el bug se repite en el fichero, amplía\n * el bloque con contexto de arriba y abajo hasta que sea único, igual que\n * tendría que hacer el propio modelo. Si no se puede — el fichero es tan\n * repetitivo que ni con contexto hay una única ocurrencia — el caso se\n * descarta por AMBIGUO en vez de admitirse y medir suerte.\n */\n\n/** Cuántas veces aparece `bloque` (como subsecuencia contigua) dentro de `lineas`. */\nexport function contarOcurrencias(lineas: string[], bloque: string[]): number {\n\tif (bloque.length === 0 || bloque.length > lineas.length) return 0;\n\tlet cuenta = 0;\n\touter: for (let i = 0; i <= lineas.length - bloque.length; i++) {\n\t\tfor (let j = 0; j < bloque.length; j++) {\n\t\t\tif (lineas[i + j] !== bloque[j]) continue outer;\n\t\t}\n\t\tcuenta++;\n\t}\n\treturn cuenta;\n}\n\nexport interface BloqueUnico {\n\t/** Tal como aparece en el fichero CON el bug (lo que debe buscar `edit`). */\n\tbloqueEntrada: string[];\n\t/** Tal como debe quedar tras el arreglo. */\n\tbloqueEsperado: string[];\n\t/** Línea 1-based donde empieza el bloque en el fichero de entrada. */\n\tlineaInicio: number;\n\t/** false si ni ampliando al máximo se logró que `bloqueEntrada` fuera único. */\n\tunico: boolean;\n}\n\nconst MAX_AMPLIACION = 12;\n\n/**\n * Amplía hacia arriba y abajo desde `indice` (0-based, la línea con el bug)\n * hasta que el bloque construido sobre las líneas ORIGINALES —con la línea\n * mutada sustituida en su sitio— sea único dentro de `lineasEntrada` (el\n * fichero completo tal y como lo ve el modelo, con el bug ya metido).\n */\nexport function construirBloqueUnico(\n\tlineasOriginales: string[],\n\tlineasEntrada: string[],\n\tindice: number,\n\tmaxAmpliacion = MAX_AMPLIACION,\n): BloqueUnico {\n\tlet arriba = 0;\n\tlet abajo = 0;\n\n\tconst calcular = (): { inicio: number; bloqueEsperado: string[]; bloqueEntrada: string[] } => {\n\t\tconst inicio = indice - arriba;\n\t\tconst fin = indice + abajo;\n\t\tconst bloqueEsperado = lineasOriginales.slice(inicio, fin + 1);\n\t\tconst bloqueEntrada = lineasEntrada.slice(inicio, fin + 1);\n\t\treturn { inicio, bloqueEsperado, bloqueEntrada };\n\t};\n\n\tlet actual = calcular();\n\tlet intentos = 0;\n\twhile (contarOcurrencias(lineasEntrada, actual.bloqueEntrada) > 1 && intentos < maxAmpliacion) {\n\t\tintentos++;\n\t\tif (indice - arriba - 1 >= 0) arriba++;\n\t\telse if (indice + abajo + 1 < lineasEntrada.length) abajo++;\n\t\telse break;\n\t\tactual = calcular();\n\t}\n\n\treturn {\n\t\tbloqueEntrada: actual.bloqueEntrada,\n\t\tbloqueEsperado: actual.bloqueEsperado,\n\t\tlineaInicio: actual.inicio + 1,\n\t\tunico: contarOcurrencias(lineasEntrada, actual.bloqueEntrada) === 1,\n\t};\n}\n\n/**\n * Re-resuelve el caso desde cero: busca `bloque.bloqueEntrada` en el fichero\n * de entrada y aplica el reemplazo. Si el resultado no es BYTE A BYTE\n * idéntico al fichero esperado, el prompt no determina un arreglo único y el\n * caso debe descartarse — esta es la comprobación que la tarea pide como\n * puerta: \"cada caso se valida resolviéndolo antes de admitirlo\".\n */\nexport function resuelveAlEsperado(contenidoEntrada: string, contenidoEsperado: string, bloque: BloqueUnico): boolean {\n\tif (!bloque.unico) return false;\n\tconst lineas = contenidoEntrada.split(\"\\n\");\n\tconst ocurrencias = contarOcurrencias(lineas, bloque.bloqueEntrada);\n\tif (ocurrencias !== 1) return false;\n\tconst inicio = bloque.lineaInicio - 1;\n\tconst resultado = [\n\t\t...lineas.slice(0, inicio),\n\t\t...bloque.bloqueEsperado,\n\t\t...lineas.slice(inicio + bloque.bloqueEntrada.length),\n\t].join(\"\\n\");\n\treturn resultado === contenidoEsperado;\n}\n"]}

package/dist/core/banco/bloques.js

@@ -0,0 +1,84 @@
+/**
+ * Construye el bloque que se le enseña al modelo y demuestra que es ÚNICO.
+ *
+ * El contrato de la tool `edit` real (`core/tools/edit.ts`) es: `oldText` debe
+ * ser único en el fichero. Este módulo aplica el MISMO contrato a la
+ * generación de casos: si la línea con el bug se repite en el fichero, amplía
+ * el bloque con contexto de arriba y abajo hasta que sea único, igual que
+ * tendría que hacer el propio modelo. Si no se puede — el fichero es tan
+ * repetitivo que ni con contexto hay una única ocurrencia — el caso se
+ * descarta por AMBIGUO en vez de admitirse y medir suerte.
+ */
+/** Cuántas veces aparece `bloque` (como subsecuencia contigua) dentro de `lineas`. */
+export function contarOcurrencias(lineas, bloque) {
+    if (bloque.length === 0 || bloque.length > lineas.length)
+        return 0;
+    let cuenta = 0;
+    outer: for (let i = 0; i <= lineas.length - bloque.length; i++) {
+        for (let j = 0; j < bloque.length; j++) {
+            if (lineas[i + j] !== bloque[j])
+                continue outer;
+        }
+        cuenta++;
+    }
+    return cuenta;
+}
+const MAX_AMPLIACION = 12;
+/**
+ * Amplía hacia arriba y abajo desde `indice` (0-based, la línea con el bug)
+ * hasta que el bloque construido sobre las líneas ORIGINALES —con la línea
+ * mutada sustituida en su sitio— sea único dentro de `lineasEntrada` (el
+ * fichero completo tal y como lo ve el modelo, con el bug ya metido).
+ */
+export function construirBloqueUnico(lineasOriginales, lineasEntrada, indice, maxAmpliacion = MAX_AMPLIACION) {
+    let arriba = 0;
+    let abajo = 0;
+    const calcular = () => {
+        const inicio = indice - arriba;
+        const fin = indice + abajo;
+        const bloqueEsperado = lineasOriginales.slice(inicio, fin + 1);
+        const bloqueEntrada = lineasEntrada.slice(inicio, fin + 1);
+        return { inicio, bloqueEsperado, bloqueEntrada };
+    };
+    let actual = calcular();
+    let intentos = 0;
+    while (contarOcurrencias(lineasEntrada, actual.bloqueEntrada) > 1 && intentos < maxAmpliacion) {
+        intentos++;
+        if (indice - arriba - 1 >= 0)
+            arriba++;
+        else if (indice + abajo + 1 < lineasEntrada.length)
+            abajo++;
+        else
+            break;
+        actual = calcular();
+    }
+    return {
+        bloqueEntrada: actual.bloqueEntrada,
+        bloqueEsperado: actual.bloqueEsperado,
+        lineaInicio: actual.inicio + 1,
+        unico: contarOcurrencias(lineasEntrada, actual.bloqueEntrada) === 1,
+    };
+}
+/**
+ * Re-resuelve el caso desde cero: busca `bloque.bloqueEntrada` en el fichero
+ * de entrada y aplica el reemplazo. Si el resultado no es BYTE A BYTE
+ * idéntico al fichero esperado, el prompt no determina un arreglo único y el
+ * caso debe descartarse — esta es la comprobación que la tarea pide como
+ * puerta: "cada caso se valida resolviéndolo antes de admitirlo".
+ */
+export function resuelveAlEsperado(contenidoEntrada, contenidoEsperado, bloque) {
+    if (!bloque.unico)
+        return false;
+    const lineas = contenidoEntrada.split("\n");
+    const ocurrencias = contarOcurrencias(lineas, bloque.bloqueEntrada);
+    if (ocurrencias !== 1)
+        return false;
+    const inicio = bloque.lineaInicio - 1;
+    const resultado = [
+        ...lineas.slice(0, inicio),
+        ...bloque.bloqueEsperado,
+        ...lineas.slice(inicio + bloque.bloqueEntrada.length),
+    ].join("\n");
+    return resultado === contenidoEsperado;
+}
+//# sourceMappingURL=bloques.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"bloques.js","sourceRoot":"","sources":["../../../src/core/banco/bloques.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Construye el bloque que se le enseña al modelo y demuestra que es ÚNICO.\n *\n * El contrato de la tool `edit` real (`core/tools/edit.ts`) es: `oldText` debe\n * ser único en el fichero. Este módulo aplica el MISMO contrato a la\n * generación de casos: si la línea con el bug se repite en el fichero, amplía\n * el bloque con contexto de arriba y abajo hasta que sea único, igual que\n * tendría que hacer el propio modelo. Si no se puede — el fichero es tan\n * repetitivo que ni con contexto hay una única ocurrencia — el caso se\n * descarta por AMBIGUO en vez de admitirse y medir suerte.\n */\n\n/** Cuántas veces aparece `bloque` (como subsecuencia contigua) dentro de `lineas`. */\nexport function contarOcurrencias(lineas: string[], bloque: string[]): number {\n\tif (bloque.length === 0 || bloque.length > lineas.length) return 0;\n\tlet cuenta = 0;\n\touter: for (let i = 0; i <= lineas.length - bloque.length; i++) {\n\t\tfor (let j = 0; j < bloque.length; j++) {\n\t\t\tif (lineas[i + j] !== bloque[j]) continue outer;\n\t\t}\n\t\tcuenta++;\n\t}\n\treturn cuenta;\n}\n\nexport interface BloqueUnico {\n\t/** Tal como aparece en el fichero CON el bug (lo que debe buscar `edit`). */\n\tbloqueEntrada: string[];\n\t/** Tal como debe quedar tras el arreglo. */\n\tbloqueEsperado: string[];\n\t/** Línea 1-based donde empieza el bloque en el fichero de entrada. */\n\tlineaInicio: number;\n\t/** false si ni ampliando al máximo se logró que `bloqueEntrada` fuera único. */\n\tunico: boolean;\n}\n\nconst MAX_AMPLIACION = 12;\n\n/**\n * Amplía hacia arriba y abajo desde `indice` (0-based, la línea con el bug)\n * hasta que el bloque construido sobre las líneas ORIGINALES —con la línea\n * mutada sustituida en su sitio— sea único dentro de `lineasEntrada` (el\n * fichero completo tal y como lo ve el modelo, con el bug ya metido).\n */\nexport function construirBloqueUnico(\n\tlineasOriginales: string[],\n\tlineasEntrada: string[],\n\tindice: number,\n\tmaxAmpliacion = MAX_AMPLIACION,\n): BloqueUnico {\n\tlet arriba = 0;\n\tlet abajo = 0;\n\n\tconst calcular = (): { inicio: number; bloqueEsperado: string[]; bloqueEntrada: string[] } => {\n\t\tconst inicio = indice - arriba;\n\t\tconst fin = indice + abajo;\n\t\tconst bloqueEsperado = lineasOriginales.slice(inicio, fin + 1);\n\t\tconst bloqueEntrada = lineasEntrada.slice(inicio, fin + 1);\n\t\treturn { inicio, bloqueEsperado, bloqueEntrada };\n\t};\n\n\tlet actual = calcular();\n\tlet intentos = 0;\n\twhile (contarOcurrencias(lineasEntrada, actual.bloqueEntrada) > 1 && intentos < maxAmpliacion) {\n\t\tintentos++;\n\t\tif (indice - arriba - 1 >= 0) arriba++;\n\t\telse if (indice + abajo + 1 < lineasEntrada.length) abajo++;\n\t\telse break;\n\t\tactual = calcular();\n\t}\n\n\treturn {\n\t\tbloqueEntrada: actual.bloqueEntrada,\n\t\tbloqueEsperado: actual.bloqueEsperado,\n\t\tlineaInicio: actual.inicio + 1,\n\t\tunico: contarOcurrencias(lineasEntrada, actual.bloqueEntrada) === 1,\n\t};\n}\n\n/**\n * Re-resuelve el caso desde cero: busca `bloque.bloqueEntrada` en el fichero\n * de entrada y aplica el reemplazo. Si el resultado no es BYTE A BYTE\n * idéntico al fichero esperado, el prompt no determina un arreglo único y el\n * caso debe descartarse — esta es la comprobación que la tarea pide como\n * puerta: \"cada caso se valida resolviéndolo antes de admitirlo\".\n */\nexport function resuelveAlEsperado(contenidoEntrada: string, contenidoEsperado: string, bloque: BloqueUnico): boolean {\n\tif (!bloque.unico) return false;\n\tconst lineas = contenidoEntrada.split(\"\\n\");\n\tconst ocurrencias = contarOcurrencias(lineas, bloque.bloqueEntrada);\n\tif (ocurrencias !== 1) return false;\n\tconst inicio = bloque.lineaInicio - 1;\n\tconst resultado = [\n\t\t...lineas.slice(0, inicio),\n\t\t...bloque.bloqueEsperado,\n\t\t...lineas.slice(inicio + bloque.bloqueEntrada.length),\n\t].join(\"\\n\");\n\treturn resultado === contenidoEsperado;\n}\n"]}

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

@@ -0,0 +1,84 @@
+/**
+ * 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.
+ */
+/** Qué debería pasar con una carga. Lo declara el caso, no lo decide el motor. */
+export type Esperado = "aplica" | "rechaza";
+export interface CargaMalFormada {
+    id: string;
+    /** Qué error del modelo reproduce, en una línea. */
+    error: string;
+    /** El fichero tal cual está en disco. */
+    fichero: string;
+    ediciones: ReadonlyArray<{
+        oldText: string;
+        newText: string;
+    }>;
+    /**
+     * `aplica` = el motor DEBERÍA recuperarlo. `rechaza` = debería negarse.
+     *
+     * Hay casos que deben rechazarse y esos son los que impiden que este banco
+     * premie a un motor que acepta todo. Sin ellos, «aplicar más» sería siempre
+     * mejor puntuación, y eso es exactamente el error de medición que queremos
+     * evitar.
+     */
+    esperado: Esperado;
+    /** El fichero resultante correcto. Solo para los `aplica`. */
+    resultado?: string;
+}
+/**
+ * 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 declare const CARGAS: readonly CargaMalFormada[];
+export type Veredicto = "correcto" | "corrupto" | "rechazado" | "rechazado-bien";
+export interface ResultadoDeCarga {
+    id: string;
+    error: string;
+    esperado: Esperado;
+    veredicto: Veredicto;
+    /** Qué salió, cuando salió mal. Para poder leer el fallo sin reproducirlo. */
+    detalle?: string;
+}
+/** Pasa una carga por el motor y clasifica el resultado en tres estados. */
+export declare function evaluarCarga(carga: CargaMalFormada): ResultadoDeCarga;
+export interface Puntuacion {
+    correctos: number;
+    corruptos: number;
+    rechazados: number;
+    rechazadosBien: number;
+    total: number;
+    resultados: readonly ResultadoDeCarga[];
+}
+export declare function evaluarTodas(cargas?: readonly CargaMalFormada[]): Puntuacion;
+//# sourceMappingURL=cargas.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"cargas.d.ts","sourceRoot":"","sources":["../../../src/core/banco/cargas.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AAIH,oFAAkF;AAClF,MAAM,MAAM,QAAQ,GAAG,QAAQ,GAAG,SAAS,CAAC;AAE5C,MAAM,WAAW,eAAe;IAC/B,EAAE,EAAE,MAAM,CAAC;IACX,sDAAoD;IACpD,KAAK,EAAE,MAAM,CAAC;IACd,0CAAyC;IACzC,OAAO,EAAE,MAAM,CAAC;IAChB,SAAS,EAAE,aAAa,CAAC;QAAE,OAAO,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;IAC/D;;;;;;;OAOG;IACH,QAAQ,EAAE,QAAQ,CAAC;IACnB,8DAA8D;IAC9D,SAAS,CAAC,EAAE,MAAM,CAAC;CACnB;AA0GD;;;;;GAKG;AACH,eAAO,MAAM,MAAM,EAAE,SAAS,eAAe,EA0V5C,CAAC;AAEF,MAAM,MAAM,SAAS,GAAG,UAAU,GAAG,UAAU,GAAG,WAAW,GAAG,gBAAgB,CAAC;AAEjF,MAAM,WAAW,gBAAgB;IAChC,EAAE,EAAE,MAAM,CAAC;IACX,KAAK,EAAE,MAAM,CAAC;IACd,QAAQ,EAAE,QAAQ,CAAC;IACnB,SAAS,EAAE,SAAS,CAAC;IACrB,iFAA8E;IAC9E,OAAO,CAAC,EAAE,MAAM,CAAC;CACjB;AAED,4EAA4E;AAC5E,wBAAgB,YAAY,CAAC,KAAK,EAAE,eAAe,GAAG,gBAAgB,CAuBrE;AAED,MAAM,WAAW,UAAU;IAC1B,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,EAAE,MAAM,CAAC;IAClB,UAAU,EAAE,MAAM,CAAC;IACnB,cAAc,EAAE,MAAM,CAAC;IACvB,KAAK,EAAE,MAAM,CAAC;IACd,UAAU,EAAE,SAAS,gBAAgB,EAAE,CAAC;CACxC;AAED,wBAAgB,YAAY,CAAC,MAAM,GAAE,SAAS,eAAe,EAAW,GAAG,UAAU,CAUpF","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"]}