@hoilab/ada-cli 0.84.22 → 0.85.0

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

@@ -0,0 +1,71 @@
+/**
+ * Hashline — formato de edición anclado por hash de línea.
+ *
+ * Nuestro único formato de edición hoy (`edit`, en `core/tools/edit.ts`) casa
+ * `oldText` contra el contenido actual del fichero: si el texto no está
+ * literal, la edición falla con un error de "no encontrado". No hay forma de
+ * decir "quiero cambiar las líneas 10-12 tal como las vi", así que un hunk
+ * calculado sobre una versión del fichero que ya cambió por debajo (otro
+ * proceso, otra pestaña del agente, el usuario a mano) se puede colar sobre
+ * líneas que ya no son las que el hunk cree que son, con la única defensa de
+ * que `oldText` deje de encontrarse — y si el nuevo contenido de esas líneas
+ * es distinto pero de la misma LONGITUD y forma que el viejo `oldText`
+ * (variable renombrada, número cambiado), ni eso lo detiene.
+ *
+ * Hashline cierra ese hueco por construcción: el hunk lleva un hash del
+ * contenido exacto del rango que dice tocar, calculado sobre lo que el
+ * llamante VIO. `aplicarHashline` recalcula ese mismo hash sobre el fichero
+ * tal como está AHORA y rechaza el hunk si no coincide — sin tocar el
+ * fichero — en vez de intentar adivinar dónde se movió el texto. La idea es
+ * la de `@oh-my-pi/hashline` (paquete de referencia en
+ * `/Users/31017423z/auditoria-omp/oh-my-pi/packages/hashline`): anclar cada
+ * hunk a un hash de contenido y rechazar el que ya no cuadra. Lo que cambia
+ * aquí es el alcance: ellos anclan el FICHERO ENTERO con una gramática de
+ * varias operaciones (PUT/CUT/MV…) pensada para sustituir su tool de edición
+ * completa; esto ancla cada RANGO de líneas por separado, como una quinta
+ * opción de formato de edición, no un reemplazo del `edit` que ya existe.
+ */
+/** Etiqueta de 8 hex del contenido exacto de las líneas `desde..hasta` (1-indexado, inclusive). */
+export declare function etiquetaDeRango(lineas: readonly string[], desde: number, hasta: number): string;
+/** Construye la cabecera `[ruta#tag]` para el rango `desde..hasta` del contenido actual. */
+export declare function construirCabecera(ruta: string, contenido: string, desde: number, hasta: number): string;
+export interface HunkHashline {
+    ruta: string;
+    tag: string;
+    /** 1-indexado, inclusive. */
+    desde: number;
+    hasta: number;
+    /** Líneas de sustitución, ya sin el `+` de cabecera. */
+    cuerpo: string[];
+}
+/** `{hunk}` si parseó, `{error}` si no — dos formas distintas, nunca un `null` que mezcle los dos motivos. */
+export type ResultadoParseo = {
+    hunk: HunkHashline;
+} | {
+    error: string;
+};
+/**
+ * Parsea un hunk hashline de tres partes: cabecera `[ruta#tag]`, línea de
+ * rango `A` o `A-B`, y cuerpo con cada línea de sustitución prefijada por
+ * `+` (una línea `+` sola es una línea en blanco).
+ */
+export declare function parsearHunk(texto: string): ResultadoParseo;
+export type ResultadoAplicar = {
+    ok: true;
+    contenido: string;
+}
+/** El hunk parseó pero su tag no corresponde a las líneas actuales, o el rango cae fuera del fichero: nada se toca. */
+ | {
+    ok: false;
+    motivo: string;
+};
+/**
+ * Aplica un hunk ya parseado sobre `contenidoActual`. Rechaza sin tocar nada
+ * si el tag no coincide con lo que hay AHORA en ese rango — esa es toda la
+ * garantía del formato: un hunk calculado sobre una versión vieja del
+ * fichero nunca se aplica en silencio sobre líneas que ya cambiaron.
+ */
+export declare function aplicarHunk(contenidoActual: string, hunk: HunkHashline): ResultadoAplicar;
+/** Atajo: parsea y aplica en un paso, contra el contenido actual del fichero que nombra el hunk. */
+export declare function aplicarHashline(contenidoActual: string, textoHunk: string): ResultadoAplicar;
+//# sourceMappingURL=hashline.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"hashline.d.ts","sourceRoot":"","sources":["../../../src/core/edicion/hashline.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AAIH,oGAAmG;AACnG,wBAAgB,eAAe,CAAC,MAAM,EAAE,SAAS,MAAM,EAAE,EAAE,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,MAAM,CAG/F;AAED,4FAA4F;AAC5F,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,MAAM,CAEvG;AAED,MAAM,WAAW,YAAY;IAC5B,IAAI,EAAE,MAAM,CAAC;IACb,GAAG,EAAE,MAAM,CAAC;IACZ,6BAA6B;IAC7B,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,EAAE,MAAM,CAAC;IACd,0DAAwD;IACxD,MAAM,EAAE,MAAM,EAAE,CAAC;CACjB;AAED,iHAA8G;AAC9G,MAAM,MAAM,eAAe,GAAG;IAAE,IAAI,EAAE,YAAY,CAAA;CAAE,GAAG;IAAE,KAAK,EAAE,MAAM,CAAA;CAAE,CAAC;AAKzE;;;;GAIG;AACH,wBAAgB,WAAW,CAAC,KAAK,EAAE,MAAM,GAAG,eAAe,CAgC1D;AAED,MAAM,MAAM,gBAAgB,GACzB;IAAE,EAAE,EAAE,IAAI,CAAC;IAAC,SAAS,EAAE,MAAM,CAAA;CAAE;AACjC,yHAAuH;GACrH;IAAE,EAAE,EAAE,KAAK,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,CAAC;AAEjC;;;;;GAKG;AACH,wBAAgB,WAAW,CAAC,eAAe,EAAE,MAAM,EAAE,IAAI,EAAE,YAAY,GAAG,gBAAgB,CAqBzF;AAED,oGAAoG;AACpG,wBAAgB,eAAe,CAAC,eAAe,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,gBAAgB,CAI5F","sourcesContent":["/**\n * Hashline — formato de edición anclado por hash de línea.\n *\n * Nuestro único formato de edición hoy (`edit`, en `core/tools/edit.ts`) casa\n * `oldText` contra el contenido actual del fichero: si el texto no está\n * literal, la edición falla con un error de \"no encontrado\". No hay forma de\n * decir \"quiero cambiar las líneas 10-12 tal como las vi\", así que un hunk\n * calculado sobre una versión del fichero que ya cambió por debajo (otro\n * proceso, otra pestaña del agente, el usuario a mano) se puede colar sobre\n * líneas que ya no son las que el hunk cree que son, con la única defensa de\n * que `oldText` deje de encontrarse — y si el nuevo contenido de esas líneas\n * es distinto pero de la misma LONGITUD y forma que el viejo `oldText`\n * (variable renombrada, número cambiado), ni eso lo detiene.\n *\n * Hashline cierra ese hueco por construcción: el hunk lleva un hash del\n * contenido exacto del rango que dice tocar, calculado sobre lo que el\n * llamante VIO. `aplicarHashline` recalcula ese mismo hash sobre el fichero\n * tal como está AHORA y rechaza el hunk si no coincide — sin tocar el\n * fichero — en vez de intentar adivinar dónde se movió el texto. La idea es\n * la de `@oh-my-pi/hashline` (paquete de referencia en\n * `/Users/31017423z/auditoria-omp/oh-my-pi/packages/hashline`): anclar cada\n * hunk a un hash de contenido y rechazar el que ya no cuadra. Lo que cambia\n * aquí es el alcance: ellos anclan el FICHERO ENTERO con una gramática de\n * varias operaciones (PUT/CUT/MV…) pensada para sustituir su tool de edición\n * completa; esto ancla cada RANGO de líneas por separado, como una quinta\n * opción de formato de edición, no un reemplazo del `edit` que ya existe.\n */\n\nimport { createHash } from \"node:crypto\";\n\n/** Etiqueta de 8 hex del contenido exacto de las líneas `desde..hasta` (1-indexado, inclusive). */\nexport function etiquetaDeRango(lineas: readonly string[], desde: number, hasta: number): string {\n\tconst texto = lineas.slice(desde - 1, hasta).join(\"\\n\");\n\treturn createHash(\"sha256\").update(texto).digest(\"hex\").slice(0, 8);\n}\n\n/** Construye la cabecera `[ruta#tag]` para el rango `desde..hasta` del contenido actual. */\nexport function construirCabecera(ruta: string, contenido: string, desde: number, hasta: number): string {\n\treturn `[${ruta}#${etiquetaDeRango(contenido.split(\"\\n\"), desde, hasta)}]`;\n}\n\nexport interface HunkHashline {\n\truta: string;\n\ttag: string;\n\t/** 1-indexado, inclusive. */\n\tdesde: number;\n\thasta: number;\n\t/** Líneas de sustitución, ya sin el `+` de cabecera. */\n\tcuerpo: string[];\n}\n\n/** `{hunk}` si parseó, `{error}` si no — dos formas distintas, nunca un `null` que mezcle los dos motivos. */\nexport type ResultadoParseo = { hunk: HunkHashline } | { error: string };\n\nconst RE_CABECERA = /^\\[(.+)#([0-9a-f]{8})\\]\\s*$/;\nconst RE_RANGO = /^(\\d+)(?:-(\\d+))?\\s*$/;\n\n/**\n * Parsea un hunk hashline de tres partes: cabecera `[ruta#tag]`, línea de\n * rango `A` o `A-B`, y cuerpo con cada línea de sustitución prefijada por\n * `+` (una línea `+` sola es una línea en blanco).\n */\nexport function parsearHunk(texto: string): ResultadoParseo {\n\tconst lineas = texto.replace(/\\r\\n/g, \"\\n\").split(\"\\n\");\n\t// Ignora líneas en blanco iniciales/finales: son ruido de quien compone el\n\t// hunk a mano, no parte del formato.\n\twhile (lineas.length > 0 && lineas[0].trim() === \"\") lineas.shift();\n\twhile (lineas.length > 0 && lineas.at(-1)?.trim() === \"\") lineas.pop();\n\n\tif (lineas.length < 2) return { error: \"hunk vacío: hace falta cabecera y línea de rango\" };\n\n\tconst cabecera = lineas[0].match(RE_CABECERA);\n\tif (!cabecera) return { error: `cabecera inválida: \"${lineas[0]}\" (se esperaba \"[ruta#8hex]\")` };\n\n\tconst rango = lineas[1].match(RE_RANGO);\n\tif (!rango) return { error: `rango inválido: \"${lineas[1]}\" (se esperaba \"A\" o \"A-B\")` };\n\tconst desde = Number(rango[1]);\n\tconst hasta = rango[2] !== undefined ? Number(rango[2]) : desde;\n\tif (desde < 1 || hasta < desde) return { error: `rango sin sentido: ${desde}-${hasta}` };\n\n\tconst cuerpo: string[] = [];\n\tfor (let i = 2; i < lineas.length; i++) {\n\t\tconst linea = lineas[i];\n\t\tif (linea === \"+\") {\n\t\t\tcuerpo.push(\"\");\n\t\t\tcontinue;\n\t\t}\n\t\tif (!linea.startsWith(\"+\")) {\n\t\t\treturn { error: `línea de cuerpo sin \"+\": \"${linea}\"` };\n\t\t}\n\t\tcuerpo.push(linea.slice(1));\n\t}\n\n\treturn { hunk: { ruta: cabecera[1], tag: cabecera[2], desde, hasta, cuerpo } };\n}\n\nexport type ResultadoAplicar =\n\t| { ok: true; contenido: string }\n\t/** El hunk parseó pero su tag no corresponde a las líneas actuales, o el rango cae fuera del fichero: nada se toca. */\n\t| { ok: false; motivo: string };\n\n/**\n * Aplica un hunk ya parseado sobre `contenidoActual`. Rechaza sin tocar nada\n * si el tag no coincide con lo que hay AHORA en ese rango — esa es toda la\n * garantía del formato: un hunk calculado sobre una versión vieja del\n * fichero nunca se aplica en silencio sobre líneas que ya cambiaron.\n */\nexport function aplicarHunk(contenidoActual: string, hunk: HunkHashline): ResultadoAplicar {\n\tconst lineas = contenidoActual.split(\"\\n\");\n\tif (hunk.hasta > lineas.length) {\n\t\treturn {\n\t\t\tok: false,\n\t\t\tmotivo: `el rango ${hunk.desde}-${hunk.hasta} cae fuera del fichero (tiene ${lineas.length} líneas)`,\n\t\t};\n\t}\n\n\tconst tagActual = etiquetaDeRango(lineas, hunk.desde, hunk.hasta);\n\tif (tagActual !== hunk.tag) {\n\t\treturn {\n\t\t\tok: false,\n\t\t\tmotivo:\n\t\t\t\t`tag obsoleto: el hunk trae #${hunk.tag} para las líneas ${hunk.desde}-${hunk.hasta} pero ahora mismo ` +\n\t\t\t\t`esas líneas etiquetan #${tagActual} — el fichero cambió por debajo desde que se calculó este hunk`,\n\t\t};\n\t}\n\n\tconst resultado = [...lineas.slice(0, hunk.desde - 1), ...hunk.cuerpo, ...lineas.slice(hunk.hasta)].join(\"\\n\");\n\treturn { ok: true, contenido: resultado };\n}\n\n/** Atajo: parsea y aplica en un paso, contra el contenido actual del fichero que nombra el hunk. */\nexport function aplicarHashline(contenidoActual: string, textoHunk: string): ResultadoAplicar {\n\tconst parseado = parsearHunk(textoHunk);\n\tif (\"error\" in parseado) return { ok: false, motivo: parseado.error };\n\treturn aplicarHunk(contenidoActual, parseado.hunk);\n}\n"]}

package/dist/core/edicion/hashline.js

@@ -0,0 +1,111 @@
+/**
+ * Hashline — formato de edición anclado por hash de línea.
+ *
+ * Nuestro único formato de edición hoy (`edit`, en `core/tools/edit.ts`) casa
+ * `oldText` contra el contenido actual del fichero: si el texto no está
+ * literal, la edición falla con un error de "no encontrado". No hay forma de
+ * decir "quiero cambiar las líneas 10-12 tal como las vi", así que un hunk
+ * calculado sobre una versión del fichero que ya cambió por debajo (otro
+ * proceso, otra pestaña del agente, el usuario a mano) se puede colar sobre
+ * líneas que ya no son las que el hunk cree que son, con la única defensa de
+ * que `oldText` deje de encontrarse — y si el nuevo contenido de esas líneas
+ * es distinto pero de la misma LONGITUD y forma que el viejo `oldText`
+ * (variable renombrada, número cambiado), ni eso lo detiene.
+ *
+ * Hashline cierra ese hueco por construcción: el hunk lleva un hash del
+ * contenido exacto del rango que dice tocar, calculado sobre lo que el
+ * llamante VIO. `aplicarHashline` recalcula ese mismo hash sobre el fichero
+ * tal como está AHORA y rechaza el hunk si no coincide — sin tocar el
+ * fichero — en vez de intentar adivinar dónde se movió el texto. La idea es
+ * la de `@oh-my-pi/hashline` (paquete de referencia en
+ * `/Users/31017423z/auditoria-omp/oh-my-pi/packages/hashline`): anclar cada
+ * hunk a un hash de contenido y rechazar el que ya no cuadra. Lo que cambia
+ * aquí es el alcance: ellos anclan el FICHERO ENTERO con una gramática de
+ * varias operaciones (PUT/CUT/MV…) pensada para sustituir su tool de edición
+ * completa; esto ancla cada RANGO de líneas por separado, como una quinta
+ * opción de formato de edición, no un reemplazo del `edit` que ya existe.
+ */
+import { createHash } from "node:crypto";
+/** Etiqueta de 8 hex del contenido exacto de las líneas `desde..hasta` (1-indexado, inclusive). */
+export function etiquetaDeRango(lineas, desde, hasta) {
+    const texto = lineas.slice(desde - 1, hasta).join("\n");
+    return createHash("sha256").update(texto).digest("hex").slice(0, 8);
+}
+/** Construye la cabecera `[ruta#tag]` para el rango `desde..hasta` del contenido actual. */
+export function construirCabecera(ruta, contenido, desde, hasta) {
+    return `[${ruta}#${etiquetaDeRango(contenido.split("\n"), desde, hasta)}]`;
+}
+const RE_CABECERA = /^\[(.+)#([0-9a-f]{8})\]\s*$/;
+const RE_RANGO = /^(\d+)(?:-(\d+))?\s*$/;
+/**
+ * Parsea un hunk hashline de tres partes: cabecera `[ruta#tag]`, línea de
+ * rango `A` o `A-B`, y cuerpo con cada línea de sustitución prefijada por
+ * `+` (una línea `+` sola es una línea en blanco).
+ */
+export function parsearHunk(texto) {
+    const lineas = texto.replace(/\r\n/g, "\n").split("\n");
+    // Ignora líneas en blanco iniciales/finales: son ruido de quien compone el
+    // hunk a mano, no parte del formato.
+    while (lineas.length > 0 && lineas[0].trim() === "")
+        lineas.shift();
+    while (lineas.length > 0 && lineas.at(-1)?.trim() === "")
+        lineas.pop();
+    if (lineas.length < 2)
+        return { error: "hunk vacío: hace falta cabecera y línea de rango" };
+    const cabecera = lineas[0].match(RE_CABECERA);
+    if (!cabecera)
+        return { error: `cabecera inválida: "${lineas[0]}" (se esperaba "[ruta#8hex]")` };
+    const rango = lineas[1].match(RE_RANGO);
+    if (!rango)
+        return { error: `rango inválido: "${lineas[1]}" (se esperaba "A" o "A-B")` };
+    const desde = Number(rango[1]);
+    const hasta = rango[2] !== undefined ? Number(rango[2]) : desde;
+    if (desde < 1 || hasta < desde)
+        return { error: `rango sin sentido: ${desde}-${hasta}` };
+    const cuerpo = [];
+    for (let i = 2; i < lineas.length; i++) {
+        const linea = lineas[i];
+        if (linea === "+") {
+            cuerpo.push("");
+            continue;
+        }
+        if (!linea.startsWith("+")) {
+            return { error: `línea de cuerpo sin "+": "${linea}"` };
+        }
+        cuerpo.push(linea.slice(1));
+    }
+    return { hunk: { ruta: cabecera[1], tag: cabecera[2], desde, hasta, cuerpo } };
+}
+/**
+ * Aplica un hunk ya parseado sobre `contenidoActual`. Rechaza sin tocar nada
+ * si el tag no coincide con lo que hay AHORA en ese rango — esa es toda la
+ * garantía del formato: un hunk calculado sobre una versión vieja del
+ * fichero nunca se aplica en silencio sobre líneas que ya cambiaron.
+ */
+export function aplicarHunk(contenidoActual, hunk) {
+    const lineas = contenidoActual.split("\n");
+    if (hunk.hasta > lineas.length) {
+        return {
+            ok: false,
+            motivo: `el rango ${hunk.desde}-${hunk.hasta} cae fuera del fichero (tiene ${lineas.length} líneas)`,
+        };
+    }
+    const tagActual = etiquetaDeRango(lineas, hunk.desde, hunk.hasta);
+    if (tagActual !== hunk.tag) {
+        return {
+            ok: false,
+            motivo: `tag obsoleto: el hunk trae #${hunk.tag} para las líneas ${hunk.desde}-${hunk.hasta} pero ahora mismo ` +
+                `esas líneas etiquetan #${tagActual} — el fichero cambió por debajo desde que se calculó este hunk`,
+        };
+    }
+    const resultado = [...lineas.slice(0, hunk.desde - 1), ...hunk.cuerpo, ...lineas.slice(hunk.hasta)].join("\n");
+    return { ok: true, contenido: resultado };
+}
+/** Atajo: parsea y aplica en un paso, contra el contenido actual del fichero que nombra el hunk. */
+export function aplicarHashline(contenidoActual, textoHunk) {
+    const parseado = parsearHunk(textoHunk);
+    if ("error" in parseado)
+        return { ok: false, motivo: parseado.error };
+    return aplicarHunk(contenidoActual, parseado.hunk);
+}
+//# sourceMappingURL=hashline.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"hashline.js","sourceRoot":"","sources":["../../../src/core/edicion/hashline.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AAEH,OAAO,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAEzC,oGAAmG;AACnG,MAAM,UAAU,eAAe,CAAC,MAAyB,EAAE,KAAa,EAAE,KAAa,EAAU;IAChG,MAAM,KAAK,GAAG,MAAM,CAAC,KAAK,CAAC,KAAK,GAAG,CAAC,EAAE,KAAK,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;IACxD,OAAO,UAAU,CAAC,QAAQ,CAAC,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;AAAA,CACpE;AAED,4FAA4F;AAC5F,MAAM,UAAU,iBAAiB,CAAC,IAAY,EAAE,SAAiB,EAAE,KAAa,EAAE,KAAa,EAAU;IACxG,OAAO,IAAI,IAAI,IAAI,eAAe,CAAC,SAAS,CAAC,KAAK,CAAC,IAAI,CAAC,EAAE,KAAK,EAAE,KAAK,CAAC,GAAG,CAAC;AAAA,CAC3E;AAeD,MAAM,WAAW,GAAG,6BAA6B,CAAC;AAClD,MAAM,QAAQ,GAAG,uBAAuB,CAAC;AAEzC;;;;GAIG;AACH,MAAM,UAAU,WAAW,CAAC,KAAa,EAAmB;IAC3D,MAAM,MAAM,GAAG,KAAK,CAAC,OAAO,CAAC,OAAO,EAAE,IAAI,CAAC,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC;IACxD,4EAA2E;IAC3E,qCAAqC;IACrC,OAAO,MAAM,CAAC,MAAM,GAAG,CAAC,IAAI,MAAM,CAAC,CAAC,CAAC,CAAC,IAAI,EAAE,KAAK,EAAE;QAAE,MAAM,CAAC,KAAK,EAAE,CAAC;IACpE,OAAO,MAAM,CAAC,MAAM,GAAG,CAAC,IAAI,MAAM,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,EAAE,IAAI,EAAE,KAAK,EAAE;QAAE,MAAM,CAAC,GAAG,EAAE,CAAC;IAEvE,IAAI,MAAM,CAAC,MAAM,GAAG,CAAC;QAAE,OAAO,EAAE,KAAK,EAAE,oDAAkD,EAAE,CAAC;IAE5F,MAAM,QAAQ,GAAG,MAAM,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,WAAW,CAAC,CAAC;IAC9C,IAAI,CAAC,QAAQ;QAAE,OAAO,EAAE,KAAK,EAAE,wBAAuB,MAAM,CAAC,CAAC,CAAC,+BAA+B,EAAE,CAAC;IAEjG,MAAM,KAAK,GAAG,MAAM,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,QAAQ,CAAC,CAAC;IACxC,IAAI,CAAC,KAAK;QAAE,OAAO,EAAE,KAAK,EAAE,qBAAoB,MAAM,CAAC,CAAC,CAAC,6BAA6B,EAAE,CAAC;IACzF,MAAM,KAAK,GAAG,MAAM,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC;IAC/B,MAAM,KAAK,GAAG,KAAK,CAAC,CAAC,CAAC,KAAK,SAAS,CAAC,CAAC,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC;IAChE,IAAI,KAAK,GAAG,CAAC,IAAI,KAAK,GAAG,KAAK;QAAE,OAAO,EAAE,KAAK,EAAE,sBAAsB,KAAK,IAAI,KAAK,EAAE,EAAE,CAAC;IAEzF,MAAM,MAAM,GAAa,EAAE,CAAC;IAC5B,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE,CAAC;QACxC,MAAM,KAAK,GAAG,MAAM,CAAC,CAAC,CAAC,CAAC;QACxB,IAAI,KAAK,KAAK,GAAG,EAAE,CAAC;YACnB,MAAM,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC;YAChB,SAAS;QACV,CAAC;QACD,IAAI,CAAC,KAAK,CAAC,UAAU,CAAC,GAAG,CAAC,EAAE,CAAC;YAC5B,OAAO,EAAE,KAAK,EAAE,8BAA6B,KAAK,GAAG,EAAE,CAAC;QACzD,CAAC;QACD,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC;IAC7B,CAAC;IAED,OAAO,EAAE,IAAI,EAAE,EAAE,IAAI,EAAE,QAAQ,CAAC,CAAC,CAAC,EAAE,GAAG,EAAE,QAAQ,CAAC,CAAC,CAAC,EAAE,KAAK,EAAE,KAAK,EAAE,MAAM,EAAE,EAAE,CAAC;AAAA,CAC/E;AAOD;;;;;GAKG;AACH,MAAM,UAAU,WAAW,CAAC,eAAuB,EAAE,IAAkB,EAAoB;IAC1F,MAAM,MAAM,GAAG,eAAe,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC;IAC3C,IAAI,IAAI,CAAC,KAAK,GAAG,MAAM,CAAC,MAAM,EAAE,CAAC;QAChC,OAAO;YACN,EAAE,EAAE,KAAK;YACT,MAAM,EAAE,YAAY,IAAI,CAAC,KAAK,IAAI,IAAI,CAAC,KAAK,iCAAiC,MAAM,CAAC,MAAM,WAAU;SACpG,CAAC;IACH,CAAC;IAED,MAAM,SAAS,GAAG,eAAe,CAAC,MAAM,EAAE,IAAI,CAAC,KAAK,EAAE,IAAI,CAAC,KAAK,CAAC,CAAC;IAClE,IAAI,SAAS,KAAK,IAAI,CAAC,GAAG,EAAE,CAAC;QAC5B,OAAO;YACN,EAAE,EAAE,KAAK;YACT,MAAM,EACL,+BAA+B,IAAI,CAAC,GAAG,qBAAoB,IAAI,CAAC,KAAK,IAAI,IAAI,CAAC,KAAK,oBAAoB;gBACvG,2BAA0B,SAAS,oEAAgE;SACpG,CAAC;IACH,CAAC;IAED,MAAM,SAAS,GAAG,CAAC,GAAG,MAAM,CAAC,KAAK,CAAC,CAAC,EAAE,IAAI,CAAC,KAAK,GAAG,CAAC,CAAC,EAAE,GAAG,IAAI,CAAC,MAAM,EAAE,GAAG,MAAM,CAAC,KAAK,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;IAC/G,OAAO,EAAE,EAAE,EAAE,IAAI,EAAE,SAAS,EAAE,SAAS,EAAE,CAAC;AAAA,CAC1C;AAED,oGAAoG;AACpG,MAAM,UAAU,eAAe,CAAC,eAAuB,EAAE,SAAiB,EAAoB;IAC7F,MAAM,QAAQ,GAAG,WAAW,CAAC,SAAS,CAAC,CAAC;IACxC,IAAI,OAAO,IAAI,QAAQ;QAAE,OAAO,EAAE,EAAE,EAAE,KAAK,EAAE,MAAM,EAAE,QAAQ,CAAC,KAAK,EAAE,CAAC;IACtE,OAAO,WAAW,CAAC,eAAe,EAAE,QAAQ,CAAC,IAAI,CAAC,CAAC;AAAA,CACnD","sourcesContent":["/**\n * Hashline — formato de edición anclado por hash de línea.\n *\n * Nuestro único formato de edición hoy (`edit`, en `core/tools/edit.ts`) casa\n * `oldText` contra el contenido actual del fichero: si el texto no está\n * literal, la edición falla con un error de \"no encontrado\". No hay forma de\n * decir \"quiero cambiar las líneas 10-12 tal como las vi\", así que un hunk\n * calculado sobre una versión del fichero que ya cambió por debajo (otro\n * proceso, otra pestaña del agente, el usuario a mano) se puede colar sobre\n * líneas que ya no son las que el hunk cree que son, con la única defensa de\n * que `oldText` deje de encontrarse — y si el nuevo contenido de esas líneas\n * es distinto pero de la misma LONGITUD y forma que el viejo `oldText`\n * (variable renombrada, número cambiado), ni eso lo detiene.\n *\n * Hashline cierra ese hueco por construcción: el hunk lleva un hash del\n * contenido exacto del rango que dice tocar, calculado sobre lo que el\n * llamante VIO. `aplicarHashline` recalcula ese mismo hash sobre el fichero\n * tal como está AHORA y rechaza el hunk si no coincide — sin tocar el\n * fichero — en vez de intentar adivinar dónde se movió el texto. La idea es\n * la de `@oh-my-pi/hashline` (paquete de referencia en\n * `/Users/31017423z/auditoria-omp/oh-my-pi/packages/hashline`): anclar cada\n * hunk a un hash de contenido y rechazar el que ya no cuadra. Lo que cambia\n * aquí es el alcance: ellos anclan el FICHERO ENTERO con una gramática de\n * varias operaciones (PUT/CUT/MV…) pensada para sustituir su tool de edición\n * completa; esto ancla cada RANGO de líneas por separado, como una quinta\n * opción de formato de edición, no un reemplazo del `edit` que ya existe.\n */\n\nimport { createHash } from \"node:crypto\";\n\n/** Etiqueta de 8 hex del contenido exacto de las líneas `desde..hasta` (1-indexado, inclusive). */\nexport function etiquetaDeRango(lineas: readonly string[], desde: number, hasta: number): string {\n\tconst texto = lineas.slice(desde - 1, hasta).join(\"\\n\");\n\treturn createHash(\"sha256\").update(texto).digest(\"hex\").slice(0, 8);\n}\n\n/** Construye la cabecera `[ruta#tag]` para el rango `desde..hasta` del contenido actual. */\nexport function construirCabecera(ruta: string, contenido: string, desde: number, hasta: number): string {\n\treturn `[${ruta}#${etiquetaDeRango(contenido.split(\"\\n\"), desde, hasta)}]`;\n}\n\nexport interface HunkHashline {\n\truta: string;\n\ttag: string;\n\t/** 1-indexado, inclusive. */\n\tdesde: number;\n\thasta: number;\n\t/** Líneas de sustitución, ya sin el `+` de cabecera. */\n\tcuerpo: string[];\n}\n\n/** `{hunk}` si parseó, `{error}` si no — dos formas distintas, nunca un `null` que mezcle los dos motivos. */\nexport type ResultadoParseo = { hunk: HunkHashline } | { error: string };\n\nconst RE_CABECERA = /^\\[(.+)#([0-9a-f]{8})\\]\\s*$/;\nconst RE_RANGO = /^(\\d+)(?:-(\\d+))?\\s*$/;\n\n/**\n * Parsea un hunk hashline de tres partes: cabecera `[ruta#tag]`, línea de\n * rango `A` o `A-B`, y cuerpo con cada línea de sustitución prefijada por\n * `+` (una línea `+` sola es una línea en blanco).\n */\nexport function parsearHunk(texto: string): ResultadoParseo {\n\tconst lineas = texto.replace(/\\r\\n/g, \"\\n\").split(\"\\n\");\n\t// Ignora líneas en blanco iniciales/finales: son ruido de quien compone el\n\t// hunk a mano, no parte del formato.\n\twhile (lineas.length > 0 && lineas[0].trim() === \"\") lineas.shift();\n\twhile (lineas.length > 0 && lineas.at(-1)?.trim() === \"\") lineas.pop();\n\n\tif (lineas.length < 2) return { error: \"hunk vacío: hace falta cabecera y línea de rango\" };\n\n\tconst cabecera = lineas[0].match(RE_CABECERA);\n\tif (!cabecera) return { error: `cabecera inválida: \"${lineas[0]}\" (se esperaba \"[ruta#8hex]\")` };\n\n\tconst rango = lineas[1].match(RE_RANGO);\n\tif (!rango) return { error: `rango inválido: \"${lineas[1]}\" (se esperaba \"A\" o \"A-B\")` };\n\tconst desde = Number(rango[1]);\n\tconst hasta = rango[2] !== undefined ? Number(rango[2]) : desde;\n\tif (desde < 1 || hasta < desde) return { error: `rango sin sentido: ${desde}-${hasta}` };\n\n\tconst cuerpo: string[] = [];\n\tfor (let i = 2; i < lineas.length; i++) {\n\t\tconst linea = lineas[i];\n\t\tif (linea === \"+\") {\n\t\t\tcuerpo.push(\"\");\n\t\t\tcontinue;\n\t\t}\n\t\tif (!linea.startsWith(\"+\")) {\n\t\t\treturn { error: `línea de cuerpo sin \"+\": \"${linea}\"` };\n\t\t}\n\t\tcuerpo.push(linea.slice(1));\n\t}\n\n\treturn { hunk: { ruta: cabecera[1], tag: cabecera[2], desde, hasta, cuerpo } };\n}\n\nexport type ResultadoAplicar =\n\t| { ok: true; contenido: string }\n\t/** El hunk parseó pero su tag no corresponde a las líneas actuales, o el rango cae fuera del fichero: nada se toca. */\n\t| { ok: false; motivo: string };\n\n/**\n * Aplica un hunk ya parseado sobre `contenidoActual`. Rechaza sin tocar nada\n * si el tag no coincide con lo que hay AHORA en ese rango — esa es toda la\n * garantía del formato: un hunk calculado sobre una versión vieja del\n * fichero nunca se aplica en silencio sobre líneas que ya cambiaron.\n */\nexport function aplicarHunk(contenidoActual: string, hunk: HunkHashline): ResultadoAplicar {\n\tconst lineas = contenidoActual.split(\"\\n\");\n\tif (hunk.hasta > lineas.length) {\n\t\treturn {\n\t\t\tok: false,\n\t\t\tmotivo: `el rango ${hunk.desde}-${hunk.hasta} cae fuera del fichero (tiene ${lineas.length} líneas)`,\n\t\t};\n\t}\n\n\tconst tagActual = etiquetaDeRango(lineas, hunk.desde, hunk.hasta);\n\tif (tagActual !== hunk.tag) {\n\t\treturn {\n\t\t\tok: false,\n\t\t\tmotivo:\n\t\t\t\t`tag obsoleto: el hunk trae #${hunk.tag} para las líneas ${hunk.desde}-${hunk.hasta} pero ahora mismo ` +\n\t\t\t\t`esas líneas etiquetan #${tagActual} — el fichero cambió por debajo desde que se calculó este hunk`,\n\t\t};\n\t}\n\n\tconst resultado = [...lineas.slice(0, hunk.desde - 1), ...hunk.cuerpo, ...lineas.slice(hunk.hasta)].join(\"\\n\");\n\treturn { ok: true, contenido: resultado };\n}\n\n/** Atajo: parsea y aplica en un paso, contra el contenido actual del fichero que nombra el hunk. */\nexport function aplicarHashline(contenidoActual: string, textoHunk: string): ResultadoAplicar {\n\tconst parseado = parsearHunk(textoHunk);\n\tif (\"error\" in parseado) return { ok: false, motivo: parseado.error };\n\treturn aplicarHunk(contenidoActual, parseado.hunk);\n}\n"]}

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

@@ -0,0 +1,64 @@
+/**
+ * Casar una edición cuando el modelo ELIDE el medio con `...`.
+ *
+ * EL CASO. El modelo quiere reescribir una función de treinta líneas y cambia
+ * dos. Retipear las otras veintiocho es caro y, sobre todo, es donde se
+ * equivoca: cada línea retecleada es una oportunidad de meter un espacio de
+ * más. Así que hace lo natural y nombra los extremos:
+ *
+ *     function total(items: Item[]) {
+ *     ...
+ *     }
+ *
+ * Hasta ahora eso era un rechazo seguro —«el texto no coincide exactamente»— y
+ * costaba un turno entero releyendo el fichero para volver a escribir a ciegas
+ * lo que ya estaba bien.
+ *
+ * POR QUÉ ESTO ES MÁS PELIGROSO QUE LOS DEMÁS CAMINOS, y por qué las anclas se
+ * comparan con IGUALDAD EXACTA de línea. Este camino se traga líneas que el
+ * modelo NO ha nombrado: todo lo que hay entre las dos anclas desaparece. Un
+ * fallo aquí no deja un espacio mal, borra código. Con esa apuesta encima de la
+ * mesa, la comparación laxa no se paga: `casarIgnorandoSangria` puede permitirse
+ * recortar la sangría porque el bloque que sustituye está enteramente escrito
+ * por el modelo; aquí no.
+ *
+ * Y hay una razón medida, no estética. Sobre el fichero de siete líneas del
+ * banco, el ancla de cierre es `}` y aparece DOS veces si se comparan las líneas
+ * recortadas: la del `for` interior (`    }`) y la de la función (`}`). Con
+ * igualdad exacta hay una sola, y es la correcta. La comparación laxa habría
+ * convertido este caso en una moneda al aire — o en un rechazo, si se es
+ * honesto con la ambigüedad.
+ *
+ * ALCANCE MEDIDO, para que nadie se lleve una sorpresa. Con la regla de ancla
+ * única, sobre las 1173 funciones de nivel superior de `src/core/` y el patrón
+ * `cabecera` + `...` + `}`, casan 164 (14%): en la práctica solo la ÚLTIMA
+ * función de cada fichero, porque el `}` de la columna cero de cualquier función
+ * posterior vuelve ambigua el ancla de cierre. Es el lado seguro de la moneda
+ * —rechazar cuesta un turno y tragarse líneas que nadie nombró cuesta código—,
+ * pero conviene no confundir «recuperado» con «recuperado siempre»: el resto
+ * sigue costando el turno. La carga `hueco-cierre-no-unico` lo mide, para que
+ * quien lo cambie tenga que cambiar una cifra y no una intuición.
+ *
+ * TRES INVARIANTES:
+ *
+ * 1. **Anclas a los dos lados.** Un `...` al principio deja el hueco sin fondo:
+ *    el reemplazo se comería el fichero desde su inicio. Cae por el invariante 2
+ *    y no por una guarda propia — la guarda propia estaba escrita y no se podía
+ *    poner roja, así que se quitó; el detalle está en el cuerpo.
+ * 2. **Cada ancla en un solo sitio.** La primera, única en todo el fichero; las
+ *    siguientes, únicas en lo que queda por detrás de la anterior. Dos
+ *    posiciones es una moneda al aire y se rechaza.
+ * 3. **El `newText` no puede llevar elisión.** Si el modelo elide también en el
+ *    reemplazo, escribirlo dejaría un `...` literal dentro del código. Ese es el
+ *    fallo que se lee como éxito: la edición «entra» y el fichero no compila.
+ */
+import { type CasadoPorSangria } from "./sangria.ts";
+/**
+ * Casa `oldText` contra `contenido` cuando el patrón elide el medio con `...`.
+ *
+ * Devuelve `null` cuando no hay elisión, cuando alguna ancla falta, cuando
+ * alguna casa en más de un sitio, o cuando el reemplazo también elide. `null`
+ * significa «no puedo», nunca «no hay»: quien llama sigue con su propio error.
+ */
+export declare function casarHuecoElidido(contenido: string, oldText: string, newText: string): CasadoPorSangria | null;
+//# sourceMappingURL=hueco.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"hueco.d.ts","sourceRoot":"","sources":["../../../src/core/edicion/hueco.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqDG;AAEH,OAAO,EAAE,KAAK,gBAAgB,EAAmC,MAAM,cAAc,CAAC;AAiBtF;;;;;;GAMG;AACH,wBAAgB,iBAAiB,CAAC,SAAS,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,gBAAgB,GAAG,IAAI,CAiF9G","sourcesContent":["/**\n * Casar una edición cuando el modelo ELIDE el medio con `...`.\n *\n * EL CASO. El modelo quiere reescribir una función de treinta líneas y cambia\n * dos. Retipear las otras veintiocho es caro y, sobre todo, es donde se\n * equivoca: cada línea retecleada es una oportunidad de meter un espacio de\n * más. Así que hace lo natural y nombra los extremos:\n *\n *     function total(items: Item[]) {\n *     ...\n *     }\n *\n * Hasta ahora eso era un rechazo seguro —«el texto no coincide exactamente»— y\n * costaba un turno entero releyendo el fichero para volver a escribir a ciegas\n * lo que ya estaba bien.\n *\n * POR QUÉ ESTO ES MÁS PELIGROSO QUE LOS DEMÁS CAMINOS, y por qué las anclas se\n * comparan con IGUALDAD EXACTA de línea. Este camino se traga líneas que el\n * modelo NO ha nombrado: todo lo que hay entre las dos anclas desaparece. Un\n * fallo aquí no deja un espacio mal, borra código. Con esa apuesta encima de la\n * mesa, la comparación laxa no se paga: `casarIgnorandoSangria` puede permitirse\n * recortar la sangría porque el bloque que sustituye está enteramente escrito\n * por el modelo; aquí no.\n *\n * Y hay una razón medida, no estética. Sobre el fichero de siete líneas del\n * banco, el ancla de cierre es `}` y aparece DOS veces si se comparan las líneas\n * recortadas: la del `for` interior (`    }`) y la de la función (`}`). Con\n * igualdad exacta hay una sola, y es la correcta. La comparación laxa habría\n * convertido este caso en una moneda al aire — o en un rechazo, si se es\n * honesto con la ambigüedad.\n *\n * ALCANCE MEDIDO, para que nadie se lleve una sorpresa. Con la regla de ancla\n * única, sobre las 1173 funciones de nivel superior de `src/core/` y el patrón\n * `cabecera` + `...` + `}`, casan 164 (14%): en la práctica solo la ÚLTIMA\n * función de cada fichero, porque el `}` de la columna cero de cualquier función\n * posterior vuelve ambigua el ancla de cierre. Es el lado seguro de la moneda\n * —rechazar cuesta un turno y tragarse líneas que nadie nombró cuesta código—,\n * pero conviene no confundir «recuperado» con «recuperado siempre»: el resto\n * sigue costando el turno. La carga `hueco-cierre-no-unico` lo mide, para que\n * quien lo cambie tenga que cambiar una cifra y no una intuición.\n *\n * TRES INVARIANTES:\n *\n * 1. **Anclas a los dos lados.** Un `...` al principio deja el hueco sin fondo:\n *    el reemplazo se comería el fichero desde su inicio. Cae por el invariante 2\n *    y no por una guarda propia — la guarda propia estaba escrita y no se podía\n *    poner roja, así que se quitó; el detalle está en el cuerpo.\n * 2. **Cada ancla en un solo sitio.** La primera, única en todo el fichero; las\n *    siguientes, únicas en lo que queda por detrás de la anterior. Dos\n *    posiciones es una moneda al aire y se rechaza.\n * 3. **El `newText` no puede llevar elisión.** Si el modelo elide también en el\n *    reemplazo, escribirlo dejaría un `...` literal dentro del código. Ese es el\n *    fallo que se lee como éxito: la edición «entra» y el fichero no compila.\n */\n\nimport { type CasadoPorSangria, reSangrarComoElBloque, unidadDe } from \"./sangria.ts\";\n\n/**\n * Una línea que es SOLO una elisión, con el comentario que los modelos le\n * cuelgan delante (`// ...`, `# ...`, `-- ...`, o abierto y cerrado de bloque) o\n * sin él.\n *\n * Tiene que ser la línea entera. `...props,` es código real y no casa, que es\n * justo lo que se quiere: la elisión es un gesto deliberado del modelo y ocupa\n * su propia línea.\n */\nconst ELISION = /^\\s*(?:\\/\\/|#|--|\\/\\*)?\\s*(?:\\.{3}|…)\\s*(?:\\*\\/)?\\s*$/;\n\nfunction esLineaDeElision(linea: string): boolean {\n\treturn ELISION.test(linea);\n}\n\n/**\n * Casa `oldText` contra `contenido` cuando el patrón elide el medio con `...`.\n *\n * Devuelve `null` cuando no hay elisión, cuando alguna ancla falta, cuando\n * alguna casa en más de un sitio, o cuando el reemplazo también elide. `null`\n * significa «no puedo», nunca «no hay»: quien llama sigue con su propio error.\n */\nexport function casarHuecoElidido(contenido: string, oldText: string, newText: string): CasadoPorSangria | null {\n\tconst patron = oldText.split(\"\\n\");\n\t// Líneas vacías de los extremos: ruido de copiado, igual que en la sangría.\n\twhile (patron.length > 0 && patron[0].trim() === \"\") patron.shift();\n\twhile (patron.length > 0 && patron[patron.length - 1].trim() === \"\") patron.pop();\n\tif (!patron.some(esLineaDeElision)) return null;\n\n\t// Invariante 3: si el reemplazo elide, no hay nada que escribir sin inventar.\n\tif (newText.split(\"\\n\").some(esLineaDeElision)) return null;\n\n\t// El patrón partido por sus elisiones. Un trozo vacío significa una elisión\n\t// pegada a un extremo o a otra elisión — el hueco sin fondo del invariante 1.\n\t//\n\t// Aquí había una guarda explícita contra los trozos vacíos y la QUITÉ, porque\n\t// no se podía poner roja: la rompí a propósito y la puerta siguió en verde.\n\t// La razón es que el invariante 2 ya la cubre, y se demuestra: un ancla vacía\n\t// casa en TODAS las posiciones desde `desde`, o sea `lineas.length - desde + 1`\n\t// de ellas. Para una elisión delantera `desde` es 0 y eso son al menos dos\n\t// posiciones en cualquier fichero, luego «una sola posición» la rechaza\n\t// siempre. Una guarda que no se puede poner roja es una invariante declarada y\n\t// no comprobada, que es peor que no declararla.\n\tconst anclas: string[][] = [[]];\n\tfor (const linea of patron) {\n\t\tif (esLineaDeElision(linea)) anclas.push([]);\n\t\telse anclas[anclas.length - 1].push(linea);\n\t}\n\n\tconst lineas = contenido.split(\"\\n\");\n\n\t// Invariante 2: cada ancla en un solo sitio, y por detrás de la anterior.\n\tlet desde = 0;\n\tlet primeraLinea = -1;\n\tlet ultimaLinea = -1;\n\tfor (const ancla of anclas) {\n\t\tconst posiciones: number[] = [];\n\t\tfor (let i = desde; i + ancla.length <= lineas.length; i++) {\n\t\t\tlet casa = true;\n\t\t\tfor (let j = 0; j < ancla.length; j++) {\n\t\t\t\tif (lineas[i + j] !== ancla[j]) {\n\t\t\t\t\tcasa = false;\n\t\t\t\t\tbreak;\n\t\t\t\t}\n\t\t\t}\n\t\t\tif (casa) posiciones.push(i);\n\t\t}\n\t\tif (posiciones.length !== 1) return null;\n\t\tif (primeraLinea === -1) primeraLinea = posiciones[0];\n\t\tultimaLinea = posiciones[0] + ancla.length - 1;\n\t\tdesde = ultimaLinea + 1;\n\t}\n\n\t// Desplazamientos en el contenido original: hay que contar los saltos.\n\tlet indice = 0;\n\tfor (let i = 0; i < primeraLinea; i++) indice += lineas[i].length + 1;\n\tlet longitud = 0;\n\tfor (let i = primeraLinea; i <= ultimaLinea; i++) longitud += lineas[i].length + 1;\n\tlongitud -= 1;\n\n\t// El CARÁCTER de sangría sale del fichero, igual que en `casarIgnorandoSangria`.\n\t//\n\t// Aquí se escribía el `newText` tal cual, y eso rompía en este camino el\n\t// invariante 2 del módulo de al lado. Medido con la carga `hueco-elidido`: el\n\t// fichero se sangra con cuatro espacios, el modelo elide y manda\n\t// `\\treturn 0;`, y entraba un TABULADOR en un fichero de espacios. Es una de\n\t// las dos formas exactas en las que corrompe oh-my-pi —«aplica y deja la\n\t// sangría mal»—, y el banco la daba por correcta. En TypeScript es cosmético;\n\t// en Python es un error de sintaxis, o peor, una línea que se sale del bloque\n\t// `if` sin romper nada.\n\t//\n\t// Se re-sangra SOLO si el carácter no coincide, y por qué: cuando el modelo ya\n\t// usa el del fichero, reescribir la sangría de todas sus líneas tocaría bytes\n\t// que nadie ha pedido tocar — el interior de una plantilla multilínea es\n\t// contenido, no estructura. Con el carácter equivocado no hay elección: esas\n\t// líneas ya están mal.\n\tconst bloque = lineas.slice(primeraLinea, ultimaLinea + 1);\n\tconst nuevas = newText.split(\"\\n\");\n\tconst textoNuevo =\n\t\tunidadDe(bloque).caracter === unidadDe(nuevas).caracter\n\t\t\t? newText\n\t\t\t: reSangrarComoElBloque(nuevas, bloque).join(\"\\n\");\n\treturn { indice, longitud, textoNuevo };\n}\n"]}

package/dist/core/edicion/hueco.js

@@ -0,0 +1,162 @@
+/**
+ * Casar una edición cuando el modelo ELIDE el medio con `...`.
+ *
+ * EL CASO. El modelo quiere reescribir una función de treinta líneas y cambia
+ * dos. Retipear las otras veintiocho es caro y, sobre todo, es donde se
+ * equivoca: cada línea retecleada es una oportunidad de meter un espacio de
+ * más. Así que hace lo natural y nombra los extremos:
+ *
+ *     function total(items: Item[]) {
+ *     ...
+ *     }
+ *
+ * Hasta ahora eso era un rechazo seguro —«el texto no coincide exactamente»— y
+ * costaba un turno entero releyendo el fichero para volver a escribir a ciegas
+ * lo que ya estaba bien.
+ *
+ * POR QUÉ ESTO ES MÁS PELIGROSO QUE LOS DEMÁS CAMINOS, y por qué las anclas se
+ * comparan con IGUALDAD EXACTA de línea. Este camino se traga líneas que el
+ * modelo NO ha nombrado: todo lo que hay entre las dos anclas desaparece. Un
+ * fallo aquí no deja un espacio mal, borra código. Con esa apuesta encima de la
+ * mesa, la comparación laxa no se paga: `casarIgnorandoSangria` puede permitirse
+ * recortar la sangría porque el bloque que sustituye está enteramente escrito
+ * por el modelo; aquí no.
+ *
+ * Y hay una razón medida, no estética. Sobre el fichero de siete líneas del
+ * banco, el ancla de cierre es `}` y aparece DOS veces si se comparan las líneas
+ * recortadas: la del `for` interior (`    }`) y la de la función (`}`). Con
+ * igualdad exacta hay una sola, y es la correcta. La comparación laxa habría
+ * convertido este caso en una moneda al aire — o en un rechazo, si se es
+ * honesto con la ambigüedad.
+ *
+ * ALCANCE MEDIDO, para que nadie se lleve una sorpresa. Con la regla de ancla
+ * única, sobre las 1173 funciones de nivel superior de `src/core/` y el patrón
+ * `cabecera` + `...` + `}`, casan 164 (14%): en la práctica solo la ÚLTIMA
+ * función de cada fichero, porque el `}` de la columna cero de cualquier función
+ * posterior vuelve ambigua el ancla de cierre. Es el lado seguro de la moneda
+ * —rechazar cuesta un turno y tragarse líneas que nadie nombró cuesta código—,
+ * pero conviene no confundir «recuperado» con «recuperado siempre»: el resto
+ * sigue costando el turno. La carga `hueco-cierre-no-unico` lo mide, para que
+ * quien lo cambie tenga que cambiar una cifra y no una intuición.
+ *
+ * TRES INVARIANTES:
+ *
+ * 1. **Anclas a los dos lados.** Un `...` al principio deja el hueco sin fondo:
+ *    el reemplazo se comería el fichero desde su inicio. Cae por el invariante 2
+ *    y no por una guarda propia — la guarda propia estaba escrita y no se podía
+ *    poner roja, así que se quitó; el detalle está en el cuerpo.
+ * 2. **Cada ancla en un solo sitio.** La primera, única en todo el fichero; las
+ *    siguientes, únicas en lo que queda por detrás de la anterior. Dos
+ *    posiciones es una moneda al aire y se rechaza.
+ * 3. **El `newText` no puede llevar elisión.** Si el modelo elide también en el
+ *    reemplazo, escribirlo dejaría un `...` literal dentro del código. Ese es el
+ *    fallo que se lee como éxito: la edición «entra» y el fichero no compila.
+ */
+import { reSangrarComoElBloque, unidadDe } from "./sangria.js";
+/**
+ * Una línea que es SOLO una elisión, con el comentario que los modelos le
+ * cuelgan delante (`// ...`, `# ...`, `-- ...`, o abierto y cerrado de bloque) o
+ * sin él.
+ *
+ * Tiene que ser la línea entera. `...props,` es código real y no casa, que es
+ * justo lo que se quiere: la elisión es un gesto deliberado del modelo y ocupa
+ * su propia línea.
+ */
+const ELISION = /^\s*(?:\/\/|#|--|\/\*)?\s*(?:\.{3}|…)\s*(?:\*\/)?\s*$/;
+function esLineaDeElision(linea) {
+    return ELISION.test(linea);
+}
+/**
+ * Casa `oldText` contra `contenido` cuando el patrón elide el medio con `...`.
+ *
+ * Devuelve `null` cuando no hay elisión, cuando alguna ancla falta, cuando
+ * alguna casa en más de un sitio, o cuando el reemplazo también elide. `null`
+ * significa «no puedo», nunca «no hay»: quien llama sigue con su propio error.
+ */
+export function casarHuecoElidido(contenido, oldText, newText) {
+    const patron = oldText.split("\n");
+    // Líneas vacías de los extremos: ruido de copiado, igual que en la sangría.
+    while (patron.length > 0 && patron[0].trim() === "")
+        patron.shift();
+    while (patron.length > 0 && patron[patron.length - 1].trim() === "")
+        patron.pop();
+    if (!patron.some(esLineaDeElision))
+        return null;
+    // Invariante 3: si el reemplazo elide, no hay nada que escribir sin inventar.
+    if (newText.split("\n").some(esLineaDeElision))
+        return null;
+    // El patrón partido por sus elisiones. Un trozo vacío significa una elisión
+    // pegada a un extremo o a otra elisión — el hueco sin fondo del invariante 1.
+    //
+    // Aquí había una guarda explícita contra los trozos vacíos y la QUITÉ, porque
+    // no se podía poner roja: la rompí a propósito y la puerta siguió en verde.
+    // La razón es que el invariante 2 ya la cubre, y se demuestra: un ancla vacía
+    // casa en TODAS las posiciones desde `desde`, o sea `lineas.length - desde + 1`
+    // de ellas. Para una elisión delantera `desde` es 0 y eso son al menos dos
+    // posiciones en cualquier fichero, luego «una sola posición» la rechaza
+    // siempre. Una guarda que no se puede poner roja es una invariante declarada y
+    // no comprobada, que es peor que no declararla.
+    const anclas = [[]];
+    for (const linea of patron) {
+        if (esLineaDeElision(linea))
+            anclas.push([]);
+        else
+            anclas[anclas.length - 1].push(linea);
+    }
+    const lineas = contenido.split("\n");
+    // Invariante 2: cada ancla en un solo sitio, y por detrás de la anterior.
+    let desde = 0;
+    let primeraLinea = -1;
+    let ultimaLinea = -1;
+    for (const ancla of anclas) {
+        const posiciones = [];
+        for (let i = desde; i + ancla.length <= lineas.length; i++) {
+            let casa = true;
+            for (let j = 0; j < ancla.length; j++) {
+                if (lineas[i + j] !== ancla[j]) {
+                    casa = false;
+                    break;
+                }
+            }
+            if (casa)
+                posiciones.push(i);
+        }
+        if (posiciones.length !== 1)
+            return null;
+        if (primeraLinea === -1)
+            primeraLinea = posiciones[0];
+        ultimaLinea = posiciones[0] + ancla.length - 1;
+        desde = ultimaLinea + 1;
+    }
+    // Desplazamientos en el contenido original: hay que contar los saltos.
+    let indice = 0;
+    for (let i = 0; i < primeraLinea; i++)
+        indice += lineas[i].length + 1;
+    let longitud = 0;
+    for (let i = primeraLinea; i <= ultimaLinea; i++)
+        longitud += lineas[i].length + 1;
+    longitud -= 1;
+    // El CARÁCTER de sangría sale del fichero, igual que en `casarIgnorandoSangria`.
+    //
+    // Aquí se escribía el `newText` tal cual, y eso rompía en este camino el
+    // invariante 2 del módulo de al lado. Medido con la carga `hueco-elidido`: el
+    // fichero se sangra con cuatro espacios, el modelo elide y manda
+    // `\treturn 0;`, y entraba un TABULADOR en un fichero de espacios. Es una de
+    // las dos formas exactas en las que corrompe oh-my-pi —«aplica y deja la
+    // sangría mal»—, y el banco la daba por correcta. En TypeScript es cosmético;
+    // en Python es un error de sintaxis, o peor, una línea que se sale del bloque
+    // `if` sin romper nada.
+    //
+    // Se re-sangra SOLO si el carácter no coincide, y por qué: cuando el modelo ya
+    // usa el del fichero, reescribir la sangría de todas sus líneas tocaría bytes
+    // que nadie ha pedido tocar — el interior de una plantilla multilínea es
+    // contenido, no estructura. Con el carácter equivocado no hay elección: esas
+    // líneas ya están mal.
+    const bloque = lineas.slice(primeraLinea, ultimaLinea + 1);
+    const nuevas = newText.split("\n");
+    const textoNuevo = unidadDe(bloque).caracter === unidadDe(nuevas).caracter
+        ? newText
+        : reSangrarComoElBloque(nuevas, bloque).join("\n");
+    return { indice, longitud, textoNuevo };
+}
+//# sourceMappingURL=hueco.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"hueco.js","sourceRoot":"","sources":["../../../src/core/edicion/hueco.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Casar una edición cuando el modelo ELIDE el medio con `...`.\n *\n * EL CASO. El modelo quiere reescribir una función de treinta líneas y cambia\n * dos. Retipear las otras veintiocho es caro y, sobre todo, es donde se\n * equivoca: cada línea retecleada es una oportunidad de meter un espacio de\n * más. Así que hace lo natural y nombra los extremos:\n *\n *     function total(items: Item[]) {\n *     ...\n *     }\n *\n * Hasta ahora eso era un rechazo seguro —«el texto no coincide exactamente»— y\n * costaba un turno entero releyendo el fichero para volver a escribir a ciegas\n * lo que ya estaba bien.\n *\n * POR QUÉ ESTO ES MÁS PELIGROSO QUE LOS DEMÁS CAMINOS, y por qué las anclas se\n * comparan con IGUALDAD EXACTA de línea. Este camino se traga líneas que el\n * modelo NO ha nombrado: todo lo que hay entre las dos anclas desaparece. Un\n * fallo aquí no deja un espacio mal, borra código. Con esa apuesta encima de la\n * mesa, la comparación laxa no se paga: `casarIgnorandoSangria` puede permitirse\n * recortar la sangría porque el bloque que sustituye está enteramente escrito\n * por el modelo; aquí no.\n *\n * Y hay una razón medida, no estética. Sobre el fichero de siete líneas del\n * banco, el ancla de cierre es `}` y aparece DOS veces si se comparan las líneas\n * recortadas: la del `for` interior (`    }`) y la de la función (`}`). Con\n * igualdad exacta hay una sola, y es la correcta. La comparación laxa habría\n * convertido este caso en una moneda al aire — o en un rechazo, si se es\n * honesto con la ambigüedad.\n *\n * ALCANCE MEDIDO, para que nadie se lleve una sorpresa. Con la regla de ancla\n * única, sobre las 1173 funciones de nivel superior de `src/core/` y el patrón\n * `cabecera` + `...` + `}`, casan 164 (14%): en la práctica solo la ÚLTIMA\n * función de cada fichero, porque el `}` de la columna cero de cualquier función\n * posterior vuelve ambigua el ancla de cierre. Es el lado seguro de la moneda\n * —rechazar cuesta un turno y tragarse líneas que nadie nombró cuesta código—,\n * pero conviene no confundir «recuperado» con «recuperado siempre»: el resto\n * sigue costando el turno. La carga `hueco-cierre-no-unico` lo mide, para que\n * quien lo cambie tenga que cambiar una cifra y no una intuición.\n *\n * TRES INVARIANTES:\n *\n * 1. **Anclas a los dos lados.** Un `...` al principio deja el hueco sin fondo:\n *    el reemplazo se comería el fichero desde su inicio. Cae por el invariante 2\n *    y no por una guarda propia — la guarda propia estaba escrita y no se podía\n *    poner roja, así que se quitó; el detalle está en el cuerpo.\n * 2. **Cada ancla en un solo sitio.** La primera, única en todo el fichero; las\n *    siguientes, únicas en lo que queda por detrás de la anterior. Dos\n *    posiciones es una moneda al aire y se rechaza.\n * 3. **El `newText` no puede llevar elisión.** Si el modelo elide también en el\n *    reemplazo, escribirlo dejaría un `...` literal dentro del código. Ese es el\n *    fallo que se lee como éxito: la edición «entra» y el fichero no compila.\n */\n\nimport { type CasadoPorSangria, reSangrarComoElBloque, unidadDe } from \"./sangria.ts\";\n\n/**\n * Una línea que es SOLO una elisión, con el comentario que los modelos le\n * cuelgan delante (`// ...`, `# ...`, `-- ...`, o abierto y cerrado de bloque) o\n * sin él.\n *\n * Tiene que ser la línea entera. `...props,` es código real y no casa, que es\n * justo lo que se quiere: la elisión es un gesto deliberado del modelo y ocupa\n * su propia línea.\n */\nconst ELISION = /^\\s*(?:\\/\\/|#|--|\\/\\*)?\\s*(?:\\.{3}|…)\\s*(?:\\*\\/)?\\s*$/;\n\nfunction esLineaDeElision(linea: string): boolean {\n\treturn ELISION.test(linea);\n}\n\n/**\n * Casa `oldText` contra `contenido` cuando el patrón elide el medio con `...`.\n *\n * Devuelve `null` cuando no hay elisión, cuando alguna ancla falta, cuando\n * alguna casa en más de un sitio, o cuando el reemplazo también elide. `null`\n * significa «no puedo», nunca «no hay»: quien llama sigue con su propio error.\n */\nexport function casarHuecoElidido(contenido: string, oldText: string, newText: string): CasadoPorSangria | null {\n\tconst patron = oldText.split(\"\\n\");\n\t// Líneas vacías de los extremos: ruido de copiado, igual que en la sangría.\n\twhile (patron.length > 0 && patron[0].trim() === \"\") patron.shift();\n\twhile (patron.length > 0 && patron[patron.length - 1].trim() === \"\") patron.pop();\n\tif (!patron.some(esLineaDeElision)) return null;\n\n\t// Invariante 3: si el reemplazo elide, no hay nada que escribir sin inventar.\n\tif (newText.split(\"\\n\").some(esLineaDeElision)) return null;\n\n\t// El patrón partido por sus elisiones. Un trozo vacío significa una elisión\n\t// pegada a un extremo o a otra elisión — el hueco sin fondo del invariante 1.\n\t//\n\t// Aquí había una guarda explícita contra los trozos vacíos y la QUITÉ, porque\n\t// no se podía poner roja: la rompí a propósito y la puerta siguió en verde.\n\t// La razón es que el invariante 2 ya la cubre, y se demuestra: un ancla vacía\n\t// casa en TODAS las posiciones desde `desde`, o sea `lineas.length - desde + 1`\n\t// de ellas. Para una elisión delantera `desde` es 0 y eso son al menos dos\n\t// posiciones en cualquier fichero, luego «una sola posición» la rechaza\n\t// siempre. Una guarda que no se puede poner roja es una invariante declarada y\n\t// no comprobada, que es peor que no declararla.\n\tconst anclas: string[][] = [[]];\n\tfor (const linea of patron) {\n\t\tif (esLineaDeElision(linea)) anclas.push([]);\n\t\telse anclas[anclas.length - 1].push(linea);\n\t}\n\n\tconst lineas = contenido.split(\"\\n\");\n\n\t// Invariante 2: cada ancla en un solo sitio, y por detrás de la anterior.\n\tlet desde = 0;\n\tlet primeraLinea = -1;\n\tlet ultimaLinea = -1;\n\tfor (const ancla of anclas) {\n\t\tconst posiciones: number[] = [];\n\t\tfor (let i = desde; i + ancla.length <= lineas.length; i++) {\n\t\t\tlet casa = true;\n\t\t\tfor (let j = 0; j < ancla.length; j++) {\n\t\t\t\tif (lineas[i + j] !== ancla[j]) {\n\t\t\t\t\tcasa = false;\n\t\t\t\t\tbreak;\n\t\t\t\t}\n\t\t\t}\n\t\t\tif (casa) posiciones.push(i);\n\t\t}\n\t\tif (posiciones.length !== 1) return null;\n\t\tif (primeraLinea === -1) primeraLinea = posiciones[0];\n\t\tultimaLinea = posiciones[0] + ancla.length - 1;\n\t\tdesde = ultimaLinea + 1;\n\t}\n\n\t// Desplazamientos en el contenido original: hay que contar los saltos.\n\tlet indice = 0;\n\tfor (let i = 0; i < primeraLinea; i++) indice += lineas[i].length + 1;\n\tlet longitud = 0;\n\tfor (let i = primeraLinea; i <= ultimaLinea; i++) longitud += lineas[i].length + 1;\n\tlongitud -= 1;\n\n\t// El CARÁCTER de sangría sale del fichero, igual que en `casarIgnorandoSangria`.\n\t//\n\t// Aquí se escribía el `newText` tal cual, y eso rompía en este camino el\n\t// invariante 2 del módulo de al lado. Medido con la carga `hueco-elidido`: el\n\t// fichero se sangra con cuatro espacios, el modelo elide y manda\n\t// `\\treturn 0;`, y entraba un TABULADOR en un fichero de espacios. Es una de\n\t// las dos formas exactas en las que corrompe oh-my-pi —«aplica y deja la\n\t// sangría mal»—, y el banco la daba por correcta. En TypeScript es cosmético;\n\t// en Python es un error de sintaxis, o peor, una línea que se sale del bloque\n\t// `if` sin romper nada.\n\t//\n\t// Se re-sangra SOLO si el carácter no coincide, y por qué: cuando el modelo ya\n\t// usa el del fichero, reescribir la sangría de todas sus líneas tocaría bytes\n\t// que nadie ha pedido tocar — el interior de una plantilla multilínea es\n\t// contenido, no estructura. Con el carácter equivocado no hay elección: esas\n\t// líneas ya están mal.\n\tconst bloque = lineas.slice(primeraLinea, ultimaLinea + 1);\n\tconst nuevas = newText.split(\"\\n\");\n\tconst textoNuevo =\n\t\tunidadDe(bloque).caracter === unidadDe(nuevas).caracter\n\t\t\t? newText\n\t\t\t: reSangrarComoElBloque(nuevas, bloque).join(\"\\n\");\n\treturn { indice, longitud, textoNuevo };\n}\n"]}

package/dist/core/edicion/limpiar-carga.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Quitarle a un `oldText` el ruido que no es código.
+ *
+ * EL CASO MÁS VERGONZOSO ES EL NUESTRO. Nuestro propio `read` añade al final de
+ * lo que devuelve una línea como:
+ *
+ *     [Showing lines 1-5 of 5. Use offset=6 to continue.]
+ *
+ * El modelo lee un fichero, copia el bloque que quiere cambiar —cabecera
+ * incluida, porque venía pegada— y nosotros rechazamos la edición porque «el
+ * texto no coincide exactamente». Generamos la contaminación y luego la
+ * castigamos.
+ *
+ * Los otros tres son ruido que los modelos añaden solos y que ninguna de las
+ * dos partes discute que sea ruido: vallas de markdown, sentinelas de sobre de
+ * parche, y los números de línea de un `grep`.
+ *
+ * LA REGLA QUE EVITA HACER DAÑO: solo se quita lo que es INEQUÍVOCO. Un `3:` al
+ * principio de una línea podría ser una etiqueta de código real, así que solo se
+ * trata como número de línea cuando TODAS las líneas lo llevan y además los
+ * números van en orden. Preferimos dejar ruido que borrar código: quitar de más
+ * cambia el patrón y lo casa en el sitio equivocado, y eso es corrupción
+ * silenciosa — la clase de fallo que más cara nos ha salido.
+ */
+/** Lo que se quitó, para poder explicarlo en un error. */
+export interface CargaLimpia {
+    texto: string;
+    /** Qué se retiró, en orden. Vacío = no había ruido. */
+    quitado: readonly string[];
+}
+/**
+ * Limpia `oldText`. Devuelve el texto y qué se quitó.
+ *
+ * Si no había nada que quitar, `quitado` viene vacío y `texto` es idéntico al
+ * de entrada — quien llama puede así distinguir «lo he limpiado» de «no había
+ * nada», sin comparar cadenas.
+ */
+export declare function limpiarCarga(oldText: string): CargaLimpia;
+//# sourceMappingURL=limpiar-carga.d.ts.map

package/dist/core/edicion/limpiar-carga.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"limpiar-carga.d.ts","sourceRoot":"","sources":["../../../src/core/edicion/limpiar-carga.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AAEH,2DAA0D;AAC1D,MAAM,WAAW,WAAW;IAC3B,KAAK,EAAE,MAAM,CAAC;IACd,2DAAuD;IACvD,OAAO,EAAE,SAAS,MAAM,EAAE,CAAC;CAC3B;AAgFD;;;;;;GAMG;AACH,wBAAgB,YAAY,CAAC,OAAO,EAAE,MAAM,GAAG,WAAW,CAUzD","sourcesContent":["/**\n * Quitarle a un `oldText` el ruido que no es código.\n *\n * EL CASO MÁS VERGONZOSO ES EL NUESTRO. Nuestro propio `read` añade al final de\n * lo que devuelve una línea como:\n *\n *     [Showing lines 1-5 of 5. Use offset=6 to continue.]\n *\n * El modelo lee un fichero, copia el bloque que quiere cambiar —cabecera\n * incluida, porque venía pegada— y nosotros rechazamos la edición porque «el\n * texto no coincide exactamente». Generamos la contaminación y luego la\n * castigamos.\n *\n * Los otros tres son ruido que los modelos añaden solos y que ninguna de las\n * dos partes discute que sea ruido: vallas de markdown, sentinelas de sobre de\n * parche, y los números de línea de un `grep`.\n *\n * LA REGLA QUE EVITA HACER DAÑO: solo se quita lo que es INEQUÍVOCO. Un `3:` al\n * principio de una línea podría ser una etiqueta de código real, así que solo se\n * trata como número de línea cuando TODAS las líneas lo llevan y además los\n * números van en orden. Preferimos dejar ruido que borrar código: quitar de más\n * cambia el patrón y lo casa en el sitio equivocado, y eso es corrupción\n * silenciosa — la clase de fallo que más cara nos ha salido.\n */\n\n/** Lo que se quitó, para poder explicarlo en un error. */\nexport interface CargaLimpia {\n\ttexto: string;\n\t/** Qué se retiró, en orden. Vacío = no había ruido. */\n\tquitado: readonly string[];\n}\n\n/** ```ts … ``` envolviendo el bloque entero. */\nfunction quitarValla(lineas: string[]): string | undefined {\n\tif (lineas.length < 2) return undefined;\n\tconst primera = lineas[0].trim();\n\tconst ultima = lineas[lineas.length - 1].trim();\n\tif (!primera.startsWith(\"```\") || ultima !== \"```\") return undefined;\n\t// La apertura puede llevar el lenguaje (```ts); el cierre nunca lleva nada.\n\tlineas.splice(lineas.length - 1, 1);\n\tlineas.splice(0, 1);\n\treturn \"valla de markdown\";\n}\n\n/** `*** Begin Patch` / `*** End Patch` y sus variantes. */\nconst SOBRE = /^\\*{3}\\s*(begin|end)\\b|^(begin|end)(\\s+of)?\\s+(patch|edits?|file)\\b/i;\n\nfunction quitarSobre(lineas: string[]): string | undefined {\n\tlet quitadas = 0;\n\twhile (lineas.length > 0 && SOBRE.test(lineas[0].trim())) {\n\t\tlineas.shift();\n\t\tquitadas++;\n\t}\n\twhile (lineas.length > 0 && SOBRE.test(lineas[lineas.length - 1].trim())) {\n\t\tlineas.pop();\n\t\tquitadas++;\n\t}\n\treturn quitadas > 0 ? \"sentinelas de sobre de parche\" : undefined;\n}\n\n/**\n * La cabecera que añade NUESTRO `read`.\n *\n * Se reconoce por su forma exacta y solo al principio o al final, nunca en\n * medio: en medio sería contenido del fichero.\n */\nconst CABECERA_READ = /^\\[Showing lines \\d+-\\d+ of \\d+\\.( Use offset=\\d+ to continue\\.)?\\]$/;\n/** Y la de un fichero truncado, del mismo sitio. */\nconst CABECERA_TRUNCADO = /^\\[(File truncated|Truncated|Showing first) .*\\]$/i;\n\nfunction quitarCabeceraPropia(lineas: string[]): string | undefined {\n\tconst es = (l: string) => CABECERA_READ.test(l.trim()) || CABECERA_TRUNCADO.test(l.trim());\n\tlet quitadas = 0;\n\twhile (lineas.length > 0 && es(lineas[0])) {\n\t\tlineas.shift();\n\t\tquitadas++;\n\t}\n\twhile (lineas.length > 0 && es(lineas[lineas.length - 1])) {\n\t\tlineas.pop();\n\t\tquitadas++;\n\t}\n\treturn quitadas > 0 ? \"la cabecera que añade nuestro propio read\" : undefined;\n}\n\n/**\n * Números de línea de un `grep` o un `read` numerado: `12:` o `12-`.\n *\n * Solo si TODAS las líneas no vacías lo llevan Y los números son consecutivos.\n * Con una sola de las dos condiciones se dejaría de tocar código real: un\n * `case 3:` o un fragmento de YAML con `80:` cumplirían la primera.\n */\nfunction quitarNumerosDeLinea(lineas: string[]): string | undefined {\n\tconst noVacias = lineas.filter((l) => l.trim() !== \"\");\n\tif (noVacias.length === 0) return undefined;\n\tconst numeros: number[] = [];\n\tfor (const linea of noVacias) {\n\t\tconst m = linea.match(/^\\s*(\\d+)[:\\-\\t]/);\n\t\tif (!m) return undefined;\n\t\tnumeros.push(Number(m[1]));\n\t}\n\t// Consecutivos, y por tanto números de línea y no datos.\n\tfor (let i = 1; i < numeros.length; i++) {\n\t\tif (numeros[i] !== numeros[i - 1] + 1) return undefined;\n\t}\n\tfor (let i = 0; i < lineas.length; i++) {\n\t\tlineas[i] = lineas[i].replace(/^\\s*\\d+[:\\-\\t]/, \"\");\n\t}\n\treturn \"números de línea\";\n}\n\n/**\n * Limpia `oldText`. Devuelve el texto y qué se quitó.\n *\n * Si no había nada que quitar, `quitado` viene vacío y `texto` es idéntico al\n * de entrada — quien llama puede así distinguir «lo he limpiado» de «no había\n * nada», sin comparar cadenas.\n */\nexport function limpiarCarga(oldText: string): CargaLimpia {\n\tconst lineas = oldText.split(\"\\n\");\n\tconst quitado: string[] = [];\n\t// Orden: primero los envoltorios de fuera adentro, y los números al final\n\t// porque una valla o un sobre romperían la comprobación de consecutivos.\n\tfor (const paso of [quitarValla, quitarSobre, quitarCabeceraPropia, quitarNumerosDeLinea]) {\n\t\tconst que = paso(lineas);\n\t\tif (que) quitado.push(que);\n\t}\n\treturn { texto: lineas.join(\"\\n\"), quitado };\n}\n"]}