@hoilab/ada-cli 0.84.22 → 0.85.0

package/dist/core/muestreo-restringido.js

@@ -0,0 +1,65 @@
+/**
+ * La decodificación restringida, con su propio interruptor.
+ *
+ * QUÉ ES. Cuando el proveedor lo admite, el esquema de cada herramienta se le
+ * pasa en modo estricto, de forma que el modelo **no puede** emitir una llamada
+ * que no encaje: no es que la rechacemos después, es que no llega a generarse.
+ *
+ * POR QUÉ IMPORTA AQUÍ. El fallo más caro que medimos contra un modelo
+ * gratuito fue exactamente de esa clase: mandó `edits` como cadena de JSON con
+ * tabuladores crudos dentro, y el turno entero se perdió. Con decodificación
+ * restringida ese estado no existe. La tolerancia de
+ * `parsearJsonTolerante` repara el daño; esto lo evita.
+ *
+ * POR QUÉ NO VIENE ENCENDIDA. Porque no está medida de punta a punta, y en
+ * este proyecto encender algo por lo bien que suena es como se llega a una
+ * casilla verde que no protege de nada. Lo que SÍ está medido, ejecutándolo:
+ *
+ *   - las cuatro herramientas que la declaran —`edit`, `write`, `read`,
+ *     `bash`— admiten esquema estricto, así que la palanca está conectada y
+ *     no es decorativa;
+ *   - la comparación con el modelo real no se pudo completar: el nivel
+ *     gratuito de OpenRouter contesta a un ping de cinco tokens pero no
+ *     sostiene un turno de trece mil, y dos intentos se agotaron.
+ *
+ * Así que se deja apagada y se dice por qué, en vez de encenderla a ciegas o
+ * fingir que la decisión está tomada.
+ *
+ * LO QUE SÍ CAMBIA. Antes solo se activaba con `PI_EXPERIMENTAL=1`, que
+ * enciende TODO lo experimental a la vez. Quien quiera probar solo esto tenía
+ * que aceptar lo demás, y en un equipo con control de cambios eso significa no
+ * probarlo nunca. Ahora tiene su propio interruptor.
+ */
+/** La variable dedicada. No hay ajuste en `settings.json` todavía, a propósito:
+ * un ajuste persistido para algo sin medir invita a olvidarlo encendido. */
+export const VARIABLE = "ADA_MUESTREO_RESTRINGIDO";
+function encendidaPor(valor) {
+    return valor === "1" || valor === "true" || valor === "yes";
+}
+export function estadoDelMuestreo(env = process.env) {
+    const propia = env[VARIABLE];
+    if (propia !== undefined) {
+        // Un valor explícito manda sobre `PI_EXPERIMENTAL`, incluso para APAGARLA:
+        // quien enciende todo lo experimental pero apaga esto a mano ha tomado una
+        // decisión, y respetarla es lo contrario de un defecto silencioso.
+        return encendidaPor(propia)
+            ? { activo: true, origen: "propio", motivo: `${VARIABLE}=${propia}` }
+            : { activo: false, origen: "apagada", motivo: `${VARIABLE}=${propia} la apaga explícitamente` };
+    }
+    // Se lee del `env` recibido y no de `process.env` a través de
+    // `areExperimentalFeaturesEnabled()`: esa función lee el entorno del proceso
+    // directamente, así que la rama de compatibilidad no se podía probar sin
+    // ensuciar el proceso entero. Lo cazó la propia prueba.
+    if (env.PI_EXPERIMENTAL === "1") {
+        return { activo: true, origen: "experimental", motivo: "PI_EXPERIMENTAL=1 enciende todo lo experimental" };
+    }
+    return {
+        activo: false,
+        origen: "apagada",
+        motivo: `apagada por defecto: no está medida de punta a punta. Enciéndela con ${VARIABLE}=1`,
+    };
+}
+export function muestreoRestringidoActivo(env = process.env) {
+    return estadoDelMuestreo(env).activo;
+}
+//# sourceMappingURL=muestreo-restringido.js.map

package/dist/core/muestreo-restringido.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"muestreo-restringido.js","sourceRoot":"","sources":["../../src/core/muestreo-restringido.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AAcH;4EAC4E;AAC5E,MAAM,CAAC,MAAM,QAAQ,GAAG,0BAA0B,CAAC;AAEnD,SAAS,YAAY,CAAC,KAAyB,EAAW;IACzD,OAAO,KAAK,KAAK,GAAG,IAAI,KAAK,KAAK,MAAM,IAAI,KAAK,KAAK,KAAK,CAAC;AAAA,CAC5D;AAED,MAAM,UAAU,iBAAiB,CAAC,GAAG,GAAsB,OAAO,CAAC,GAAG,EAAqB;IAC1F,MAAM,MAAM,GAAG,GAAG,CAAC,QAAQ,CAAC,CAAC;IAC7B,IAAI,MAAM,KAAK,SAAS,EAAE,CAAC;QAC1B,4EAA2E;QAC3E,2EAA2E;QAC3E,oEAAmE;QACnE,OAAO,YAAY,CAAC,MAAM,CAAC;YAC1B,CAAC,CAAC,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAE,GAAG,QAAQ,IAAI,MAAM,EAAE,EAAE;YACrE,CAAC,CAAC,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,GAAG,QAAQ,IAAI,MAAM,2BAA0B,EAAE,CAAC;IAClG,CAAC;IACD,+DAA8D;IAC9D,8EAA6E;IAC7E,2EAAyE;IACzE,yDAAwD;IACxD,IAAI,GAAG,CAAC,eAAe,KAAK,GAAG,EAAE,CAAC;QACjC,OAAO,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,cAAc,EAAE,MAAM,EAAE,iDAAiD,EAAE,CAAC;IAC5G,CAAC;IACD,OAAO;QACN,MAAM,EAAE,KAAK;QACb,MAAM,EAAE,SAAS;QACjB,MAAM,EAAE,0EAAwE,QAAQ,IAAI;KAC5F,CAAC;AAAA,CACF;AAED,MAAM,UAAU,yBAAyB,CAAC,GAAG,GAAsB,OAAO,CAAC,GAAG,EAAW;IACxF,OAAO,iBAAiB,CAAC,GAAG,CAAC,CAAC,MAAM,CAAC;AAAA,CACrC","sourcesContent":["/**\n * La decodificación restringida, con su propio interruptor.\n *\n * QUÉ ES. Cuando el proveedor lo admite, el esquema de cada herramienta se le\n * pasa en modo estricto, de forma que el modelo **no puede** emitir una llamada\n * que no encaje: no es que la rechacemos después, es que no llega a generarse.\n *\n * POR QUÉ IMPORTA AQUÍ. El fallo más caro que medimos contra un modelo\n * gratuito fue exactamente de esa clase: mandó `edits` como cadena de JSON con\n * tabuladores crudos dentro, y el turno entero se perdió. Con decodificación\n * restringida ese estado no existe. La tolerancia de\n * `parsearJsonTolerante` repara el daño; esto lo evita.\n *\n * POR QUÉ NO VIENE ENCENDIDA. Porque no está medida de punta a punta, y en\n * este proyecto encender algo por lo bien que suena es como se llega a una\n * casilla verde que no protege de nada. Lo que SÍ está medido, ejecutándolo:\n *\n *   - las cuatro herramientas que la declaran —`edit`, `write`, `read`,\n *     `bash`— admiten esquema estricto, así que la palanca está conectada y\n *     no es decorativa;\n *   - la comparación con el modelo real no se pudo completar: el nivel\n *     gratuito de OpenRouter contesta a un ping de cinco tokens pero no\n *     sostiene un turno de trece mil, y dos intentos se agotaron.\n *\n * Así que se deja apagada y se dice por qué, en vez de encenderla a ciegas o\n * fingir que la decisión está tomada.\n *\n * LO QUE SÍ CAMBIA. Antes solo se activaba con `PI_EXPERIMENTAL=1`, que\n * enciende TODO lo experimental a la vez. Quien quiera probar solo esto tenía\n * que aceptar lo demás, y en un equipo con control de cambios eso significa no\n * probarlo nunca. Ahora tiene su propio interruptor.\n */\n\n/** Cómo quedó activada, o por qué no lo está. Tres estados y no dos. */\nexport interface EstadoDelMuestreo {\n\tactivo: boolean;\n\t/**\n\t * `propio`      — encendida por su variable, sin arrastrar lo demás.\n\t * `experimental`— encendida de rebote por `PI_EXPERIMENTAL=1`.\n\t * `apagada`     — ninguna de las dos.\n\t */\n\torigen: \"propio\" | \"experimental\" | \"apagada\";\n\tmotivo: string;\n}\n\n/** La variable dedicada. No hay ajuste en `settings.json` todavía, a propósito:\n * un ajuste persistido para algo sin medir invita a olvidarlo encendido. */\nexport const VARIABLE = \"ADA_MUESTREO_RESTRINGIDO\";\n\nfunction encendidaPor(valor: string | undefined): boolean {\n\treturn valor === \"1\" || valor === \"true\" || valor === \"yes\";\n}\n\nexport function estadoDelMuestreo(env: NodeJS.ProcessEnv = process.env): EstadoDelMuestreo {\n\tconst propia = env[VARIABLE];\n\tif (propia !== undefined) {\n\t\t// Un valor explícito manda sobre `PI_EXPERIMENTAL`, incluso para APAGARLA:\n\t\t// quien enciende todo lo experimental pero apaga esto a mano ha tomado una\n\t\t// decisión, y respetarla es lo contrario de un defecto silencioso.\n\t\treturn encendidaPor(propia)\n\t\t\t? { activo: true, origen: \"propio\", motivo: `${VARIABLE}=${propia}` }\n\t\t\t: { activo: false, origen: \"apagada\", motivo: `${VARIABLE}=${propia} la apaga explícitamente` };\n\t}\n\t// Se lee del `env` recibido y no de `process.env` a través de\n\t// `areExperimentalFeaturesEnabled()`: esa función lee el entorno del proceso\n\t// directamente, así que la rama de compatibilidad no se podía probar sin\n\t// ensuciar el proceso entero. Lo cazó la propia prueba.\n\tif (env.PI_EXPERIMENTAL === \"1\") {\n\t\treturn { activo: true, origen: \"experimental\", motivo: \"PI_EXPERIMENTAL=1 enciende todo lo experimental\" };\n\t}\n\treturn {\n\t\tactivo: false,\n\t\torigen: \"apagada\",\n\t\tmotivo: `apagada por defecto: no está medida de punta a punta. Enciéndela con ${VARIABLE}=1`,\n\t};\n}\n\nexport function muestreoRestringidoActivo(env: NodeJS.ProcessEnv = process.env): boolean {\n\treturn estadoDelMuestreo(env).activo;\n}\n"]}

package/dist/core/orphan-process-journal.d.ts

@@ -0,0 +1,48 @@
+/**
+ * Journal de procesos huérfanos — no dejar dev servers colgados tras un crash.
+ *
+ * `utils/shell.ts` guarda los pids detached en un `Set` en memoria y los mata en
+ * las señales de apagado limpio. En SIGKILL, OOM o un force-quit de la app de
+ * escritorio ese Set se evapora, y el watcher, el dev server o el test runner
+ * siguen vivos ocupando puertos hasta que alguien los encuentra a mano.
+ *
+ * Esto persiste los pids a disco para poder barrerlos en el siguiente arranque.
+ *
+ * LA VERIFICACIÓN DE IDENTIDAD NO ES OPCIONAL. Los pids se reciclan: matar por
+ * pid a secas puede matar un proceso ajeno que heredó el número, que es
+ * estrictamente peor que la fuga que arreglamos. Por eso se guarda además un
+ * identificador de arranque del proceso (hora de inicio) y solo se mata si
+ * coincide.
+ */
+export interface OrphanRecord {
+    pid: number;
+    /** Identidad del arranque: distingue un pid reciclado del original. */
+    startId?: string;
+    active: boolean;
+    ts: string;
+}
+/**
+ * Identificador del arranque de un proceso. `undefined` si no existe o no se
+ * puede determinar — y en ese caso NO se mata nada.
+ */
+export declare function processStartId(pid: number): string | undefined;
+export declare class OrphanProcessJournal {
+    private path;
+    /** La ruta deriva de agentDir, NO de una variable de entorno: un subagente
+     * que hereda el entorno no debe appendear en el journal de su padre. */
+    constructor(agentDir: string);
+    track(pid: number): Promise<void>;
+    untrack(pid: number): Promise<void>;
+    private write;
+    /** Último estado conocido de cada pid; solo los que quedaron activos. */
+    pending(): Promise<Array<{
+        pid: number;
+        startId: string;
+    }>>;
+    /**
+     * Mata los huérfanos cuya identidad AÚN coincide y limpia el journal.
+     * Devuelve los pids realmente matados.
+     */
+    reap(kill: (pid: number) => void): Promise<number[]>;
+}
+//# sourceMappingURL=orphan-process-journal.d.ts.map

package/dist/core/orphan-process-journal.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"orphan-process-journal.d.ts","sourceRoot":"","sources":["../../src/core/orphan-process-journal.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAOH,MAAM,WAAW,YAAY;IAC5B,GAAG,EAAE,MAAM,CAAC;IACZ,uEAAuE;IACvE,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,MAAM,EAAE,OAAO,CAAC;IAChB,EAAE,EAAE,MAAM,CAAC;CACX;AAED;;;GAGG;AACH,wBAAgB,cAAc,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAmB9D;AAED,qBAAa,oBAAoB;IAChC,OAAO,CAAC,IAAI,CAAS;IAErB;4EACwE;IACxE,YAAY,QAAQ,EAAE,MAAM,EAE3B;IAEK,KAAK,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAEtC;IAEK,OAAO,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAExC;YAEa,KAAK;IASnB,0EAAyE;IACnE,OAAO,IAAI,OAAO,CAAC,KAAK,CAAC;QAAE,GAAG,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC,CAmBhE;IAED;;;OAGG;IACG,IAAI,CAAC,IAAI,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,IAAI,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC,CAczD;CACD","sourcesContent":["/**\n * Journal de procesos huérfanos — no dejar dev servers colgados tras un crash.\n *\n * `utils/shell.ts` guarda los pids detached en un `Set` en memoria y los mata en\n * las señales de apagado limpio. En SIGKILL, OOM o un force-quit de la app de\n * escritorio ese Set se evapora, y el watcher, el dev server o el test runner\n * siguen vivos ocupando puertos hasta que alguien los encuentra a mano.\n *\n * Esto persiste los pids a disco para poder barrerlos en el siguiente arranque.\n *\n * LA VERIFICACIÓN DE IDENTIDAD NO ES OPCIONAL. Los pids se reciclan: matar por\n * pid a secas puede matar un proceso ajeno que heredó el número, que es\n * estrictamente peor que la fuga que arreglamos. Por eso se guarda además un\n * identificador de arranque del proceso (hora de inicio) y solo se mata si\n * coincide.\n */\n\nimport { execFileSync } from \"node:child_process\";\nimport { readFileSync } from \"node:fs\";\nimport { appendFile, mkdir, readFile, rm } from \"node:fs/promises\";\nimport { dirname, join } from \"node:path\";\n\nexport interface OrphanRecord {\n\tpid: number;\n\t/** Identidad del arranque: distingue un pid reciclado del original. */\n\tstartId?: string;\n\tactive: boolean;\n\tts: string;\n}\n\n/**\n * Identificador del arranque de un proceso. `undefined` si no existe o no se\n * puede determinar — y en ese caso NO se mata nada.\n */\nexport function processStartId(pid: number): string | undefined {\n\tif (!Number.isInteger(pid) || pid <= 0) return undefined;\n\t// Linux: campo 22 de /proc/<pid>/stat es starttime en jiffies.\n\ttry {\n\t\tconst stat = readFileSync(`/proc/${pid}/stat`, \"utf8\");\n\t\tconst fields = stat.slice(stat.lastIndexOf(\")\") + 2).split(\" \");\n\t\tif (fields[19]) return `proc:${fields[19]}`;\n\t} catch {\n\t\t// macOS/BSD no tienen /proc: se usa ps.\n\t}\n\ttry {\n\t\tconst out = execFileSync(\"ps\", [\"-p\", String(pid), \"-o\", \"lstart=\"], {\n\t\t\tencoding: \"utf-8\",\n\t\t\tstdio: [\"ignore\", \"pipe\", \"ignore\"],\n\t\t}).trim();\n\t\treturn out ? `ps:${out}` : undefined;\n\t} catch {\n\t\treturn undefined;\n\t}\n}\n\nexport class OrphanProcessJournal {\n\tprivate path: string;\n\n\t/** La ruta deriva de agentDir, NO de una variable de entorno: un subagente\n\t * que hereda el entorno no debe appendear en el journal de su padre. */\n\tconstructor(agentDir: string) {\n\t\tthis.path = join(agentDir, \"orphan-processes.jsonl\");\n\t}\n\n\tasync track(pid: number): Promise<void> {\n\t\tawait this.write({ pid, startId: processStartId(pid), active: true, ts: new Date().toISOString() });\n\t}\n\n\tasync untrack(pid: number): Promise<void> {\n\t\tawait this.write({ pid, active: false, ts: new Date().toISOString() });\n\t}\n\n\tprivate async write(record: OrphanRecord): Promise<void> {\n\t\ttry {\n\t\t\tawait mkdir(dirname(this.path), { recursive: true });\n\t\t\tawait appendFile(this.path, `${JSON.stringify(record)}\\n`, \"utf-8\");\n\t\t} catch {\n\t\t\t// El journal nunca debe romper el lanzamiento de un proceso.\n\t\t}\n\t}\n\n\t/** Último estado conocido de cada pid; solo los que quedaron activos. */\n\tasync pending(): Promise<Array<{ pid: number; startId: string }>> {\n\t\tlet raw: string;\n\t\ttry {\n\t\t\traw = await readFile(this.path, \"utf-8\");\n\t\t} catch {\n\t\t\treturn [];\n\t\t}\n\t\tconst latest = new Map<number, OrphanRecord>();\n\t\tfor (const line of raw.split(\"\\n\").filter(Boolean)) {\n\t\t\ttry {\n\t\t\t\tconst record = JSON.parse(line) as OrphanRecord;\n\t\t\t\tlatest.set(record.pid, record);\n\t\t\t} catch {\n\t\t\t\t// Un crash puede truncar el último append; el resto sigue siendo válido.\n\t\t\t}\n\t\t}\n\t\treturn [...latest.values()]\n\t\t\t.filter((r): r is OrphanRecord & { startId: string } => r.active && typeof r.startId === \"string\")\n\t\t\t.map((r) => ({ pid: r.pid, startId: r.startId }));\n\t}\n\n\t/**\n\t * Mata los huérfanos cuya identidad AÚN coincide y limpia el journal.\n\t * Devuelve los pids realmente matados.\n\t */\n\tasync reap(kill: (pid: number) => void): Promise<number[]> {\n\t\tconst killed: number[] = [];\n\t\tfor (const orphan of await this.pending()) {\n\t\t\t// Si el pid se recicló, el startId ya no coincide: no es nuestro.\n\t\t\tif (processStartId(orphan.pid) !== orphan.startId) continue;\n\t\t\ttry {\n\t\t\t\tkill(orphan.pid);\n\t\t\t\tkilled.push(orphan.pid);\n\t\t\t} catch {\n\t\t\t\t// ya muerto / sin permisos\n\t\t\t}\n\t\t}\n\t\tawait rm(this.path, { force: true }).catch(() => {});\n\t\treturn killed;\n\t}\n}\n"]}

package/dist/core/orphan-process-journal.js

@@ -0,0 +1,116 @@
+/**
+ * Journal de procesos huérfanos — no dejar dev servers colgados tras un crash.
+ *
+ * `utils/shell.ts` guarda los pids detached en un `Set` en memoria y los mata en
+ * las señales de apagado limpio. En SIGKILL, OOM o un force-quit de la app de
+ * escritorio ese Set se evapora, y el watcher, el dev server o el test runner
+ * siguen vivos ocupando puertos hasta que alguien los encuentra a mano.
+ *
+ * Esto persiste los pids a disco para poder barrerlos en el siguiente arranque.
+ *
+ * LA VERIFICACIÓN DE IDENTIDAD NO ES OPCIONAL. Los pids se reciclan: matar por
+ * pid a secas puede matar un proceso ajeno que heredó el número, que es
+ * estrictamente peor que la fuga que arreglamos. Por eso se guarda además un
+ * identificador de arranque del proceso (hora de inicio) y solo se mata si
+ * coincide.
+ */
+import { execFileSync } from "node:child_process";
+import { readFileSync } from "node:fs";
+import { appendFile, mkdir, readFile, rm } from "node:fs/promises";
+import { dirname, join } from "node:path";
+/**
+ * Identificador del arranque de un proceso. `undefined` si no existe o no se
+ * puede determinar — y en ese caso NO se mata nada.
+ */
+export function processStartId(pid) {
+    if (!Number.isInteger(pid) || pid <= 0)
+        return undefined;
+    // Linux: campo 22 de /proc/<pid>/stat es starttime en jiffies.
+    try {
+        const stat = readFileSync(`/proc/${pid}/stat`, "utf8");
+        const fields = stat.slice(stat.lastIndexOf(")") + 2).split(" ");
+        if (fields[19])
+            return `proc:${fields[19]}`;
+    }
+    catch {
+        // macOS/BSD no tienen /proc: se usa ps.
+    }
+    try {
+        const out = execFileSync("ps", ["-p", String(pid), "-o", "lstart="], {
+            encoding: "utf-8",
+            stdio: ["ignore", "pipe", "ignore"],
+        }).trim();
+        return out ? `ps:${out}` : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+export class OrphanProcessJournal {
+    path;
+    /** La ruta deriva de agentDir, NO de una variable de entorno: un subagente
+     * que hereda el entorno no debe appendear en el journal de su padre. */
+    constructor(agentDir) {
+        this.path = join(agentDir, "orphan-processes.jsonl");
+    }
+    async track(pid) {
+        await this.write({ pid, startId: processStartId(pid), active: true, ts: new Date().toISOString() });
+    }
+    async untrack(pid) {
+        await this.write({ pid, active: false, ts: new Date().toISOString() });
+    }
+    async write(record) {
+        try {
+            await mkdir(dirname(this.path), { recursive: true });
+            await appendFile(this.path, `${JSON.stringify(record)}\n`, "utf-8");
+        }
+        catch {
+            // El journal nunca debe romper el lanzamiento de un proceso.
+        }
+    }
+    /** Último estado conocido de cada pid; solo los que quedaron activos. */
+    async pending() {
+        let raw;
+        try {
+            raw = await readFile(this.path, "utf-8");
+        }
+        catch {
+            return [];
+        }
+        const latest = new Map();
+        for (const line of raw.split("\n").filter(Boolean)) {
+            try {
+                const record = JSON.parse(line);
+                latest.set(record.pid, record);
+            }
+            catch {
+                // Un crash puede truncar el último append; el resto sigue siendo válido.
+            }
+        }
+        return [...latest.values()]
+            .filter((r) => r.active && typeof r.startId === "string")
+            .map((r) => ({ pid: r.pid, startId: r.startId }));
+    }
+    /**
+     * Mata los huérfanos cuya identidad AÚN coincide y limpia el journal.
+     * Devuelve los pids realmente matados.
+     */
+    async reap(kill) {
+        const killed = [];
+        for (const orphan of await this.pending()) {
+            // Si el pid se recicló, el startId ya no coincide: no es nuestro.
+            if (processStartId(orphan.pid) !== orphan.startId)
+                continue;
+            try {
+                kill(orphan.pid);
+                killed.push(orphan.pid);
+            }
+            catch {
+                // ya muerto / sin permisos
+            }
+        }
+        await rm(this.path, { force: true }).catch(() => { });
+        return killed;
+    }
+}
+//# sourceMappingURL=orphan-process-journal.js.map

package/dist/core/orphan-process-journal.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"orphan-process-journal.js","sourceRoot":"","sources":["../../src/core/orphan-process-journal.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Journal de procesos huérfanos — no dejar dev servers colgados tras un crash.\n *\n * `utils/shell.ts` guarda los pids detached en un `Set` en memoria y los mata en\n * las señales de apagado limpio. En SIGKILL, OOM o un force-quit de la app de\n * escritorio ese Set se evapora, y el watcher, el dev server o el test runner\n * siguen vivos ocupando puertos hasta que alguien los encuentra a mano.\n *\n * Esto persiste los pids a disco para poder barrerlos en el siguiente arranque.\n *\n * LA VERIFICACIÓN DE IDENTIDAD NO ES OPCIONAL. Los pids se reciclan: matar por\n * pid a secas puede matar un proceso ajeno que heredó el número, que es\n * estrictamente peor que la fuga que arreglamos. Por eso se guarda además un\n * identificador de arranque del proceso (hora de inicio) y solo se mata si\n * coincide.\n */\n\nimport { execFileSync } from \"node:child_process\";\nimport { readFileSync } from \"node:fs\";\nimport { appendFile, mkdir, readFile, rm } from \"node:fs/promises\";\nimport { dirname, join } from \"node:path\";\n\nexport interface OrphanRecord {\n\tpid: number;\n\t/** Identidad del arranque: distingue un pid reciclado del original. */\n\tstartId?: string;\n\tactive: boolean;\n\tts: string;\n}\n\n/**\n * Identificador del arranque de un proceso. `undefined` si no existe o no se\n * puede determinar — y en ese caso NO se mata nada.\n */\nexport function processStartId(pid: number): string | undefined {\n\tif (!Number.isInteger(pid) || pid <= 0) return undefined;\n\t// Linux: campo 22 de /proc/<pid>/stat es starttime en jiffies.\n\ttry {\n\t\tconst stat = readFileSync(`/proc/${pid}/stat`, \"utf8\");\n\t\tconst fields = stat.slice(stat.lastIndexOf(\")\") + 2).split(\" \");\n\t\tif (fields[19]) return `proc:${fields[19]}`;\n\t} catch {\n\t\t// macOS/BSD no tienen /proc: se usa ps.\n\t}\n\ttry {\n\t\tconst out = execFileSync(\"ps\", [\"-p\", String(pid), \"-o\", \"lstart=\"], {\n\t\t\tencoding: \"utf-8\",\n\t\t\tstdio: [\"ignore\", \"pipe\", \"ignore\"],\n\t\t}).trim();\n\t\treturn out ? `ps:${out}` : undefined;\n\t} catch {\n\t\treturn undefined;\n\t}\n}\n\nexport class OrphanProcessJournal {\n\tprivate path: string;\n\n\t/** La ruta deriva de agentDir, NO de una variable de entorno: un subagente\n\t * que hereda el entorno no debe appendear en el journal de su padre. */\n\tconstructor(agentDir: string) {\n\t\tthis.path = join(agentDir, \"orphan-processes.jsonl\");\n\t}\n\n\tasync track(pid: number): Promise<void> {\n\t\tawait this.write({ pid, startId: processStartId(pid), active: true, ts: new Date().toISOString() });\n\t}\n\n\tasync untrack(pid: number): Promise<void> {\n\t\tawait this.write({ pid, active: false, ts: new Date().toISOString() });\n\t}\n\n\tprivate async write(record: OrphanRecord): Promise<void> {\n\t\ttry {\n\t\t\tawait mkdir(dirname(this.path), { recursive: true });\n\t\t\tawait appendFile(this.path, `${JSON.stringify(record)}\\n`, \"utf-8\");\n\t\t} catch {\n\t\t\t// El journal nunca debe romper el lanzamiento de un proceso.\n\t\t}\n\t}\n\n\t/** Último estado conocido de cada pid; solo los que quedaron activos. */\n\tasync pending(): Promise<Array<{ pid: number; startId: string }>> {\n\t\tlet raw: string;\n\t\ttry {\n\t\t\traw = await readFile(this.path, \"utf-8\");\n\t\t} catch {\n\t\t\treturn [];\n\t\t}\n\t\tconst latest = new Map<number, OrphanRecord>();\n\t\tfor (const line of raw.split(\"\\n\").filter(Boolean)) {\n\t\t\ttry {\n\t\t\t\tconst record = JSON.parse(line) as OrphanRecord;\n\t\t\t\tlatest.set(record.pid, record);\n\t\t\t} catch {\n\t\t\t\t// Un crash puede truncar el último append; el resto sigue siendo válido.\n\t\t\t}\n\t\t}\n\t\treturn [...latest.values()]\n\t\t\t.filter((r): r is OrphanRecord & { startId: string } => r.active && typeof r.startId === \"string\")\n\t\t\t.map((r) => ({ pid: r.pid, startId: r.startId }));\n\t}\n\n\t/**\n\t * Mata los huérfanos cuya identidad AÚN coincide y limpia el journal.\n\t * Devuelve los pids realmente matados.\n\t */\n\tasync reap(kill: (pid: number) => void): Promise<number[]> {\n\t\tconst killed: number[] = [];\n\t\tfor (const orphan of await this.pending()) {\n\t\t\t// Si el pid se recicló, el startId ya no coincide: no es nuestro.\n\t\t\tif (processStartId(orphan.pid) !== orphan.startId) continue;\n\t\t\ttry {\n\t\t\t\tkill(orphan.pid);\n\t\t\t\tkilled.push(orphan.pid);\n\t\t\t} catch {\n\t\t\t\t// ya muerto / sin permisos\n\t\t\t}\n\t\t}\n\t\tawait rm(this.path, { force: true }).catch(() => {});\n\t\treturn killed;\n\t}\n}\n"]}

package/dist/core/privacidad/categorias-especiales.d.ts

@@ -0,0 +1,186 @@
+/**
+ * Detectar las CATEGORÍAS ESPECIALES del artículo 9 del RGPD (y las condenas
+ * del artículo 10) en un texto, sin repetir el texto en el hallazgo.
+ *
+ * POR QUÉ EXISTE, medido antes de escribir nada. El escáner de
+ * `memory-engine/security.ts` tiene cinco patrones de datos personales
+ * (correo, teléfono, DNI/NIE, IBAN, fecha de nacimiento) y CERO del artículo 9.
+ * Sobre un corpus de 24 cadenas que sí deberían saltar, en nivel `strict`
+ * fallaban 20. Entre las 20: «baja por depresión», «afiliado a CCOO»,
+ * «HIV positive», «huella dactilar registrada», «tiene antecedentes penales».
+ * Ninguna de ellas tiene hoy categoría en `SensitiveCategory`, así que
+ * `redactSensitive` las devuelve idénticas, sin un solo bloque: hoy una
+ * categoría especial se escribe EN CLARO en el libro de auditoría
+ * (`audit/libro.ts`), en la exportación y en el diario de edición.
+ *
+ * El coste no es simétrico con el de un correo. Tratar datos de salud,
+ * afiliación sindical, origen étnico, religión, opinión política, vida sexual,
+ * biometría o genética está PROHIBIDO salvo excepción tasada (art. 9.1 y 9.2),
+ * y las condenas penales sólo pueden tratarse bajo control de la autoridad
+ * (art. 10). Filtrar uno de estos no es un incidente de privacidad: es un
+ * tratamiento ilícito.
+ *
+ * LAS DOS MITADES. Un detector de vocabulario ingenuo es peor que ninguno.
+ * «diagnóstico» sale de cualquier compilador, «union» de cualquier SQL,
+ * «race» de cualquier `race condition`, y un identificador interno de ocho
+ * cifras no es un DNI. Un detector que grita sobre todo se desactiva en una
+ * semana y entonces no protege de nada. Por eso aquí hay dos mecanismos, y
+ * los dos se miden contra el corpus benigno:
+ *
+ *   1. Los IDENTIFICADORES se VALIDAN, no se reconocen por su forma. DNI y NIE
+ *      por la letra de control (módulo 23 sobre TRWAGMYFPDXBNJZSQVHLCKE), IBAN
+ *      y número de la Seguridad Social por módulo 97. Esto no es sólo rigor:
+ *      es lo que hace desaparecer el único falso positivo medido del escáner
+ *      actual —el UUID `550e8400-e29b-41d4-a716-446655440000`, cuyo fragmento
+ *      `446655440000` tiene forma de NSS pero da 56 donde debería dar 00—.
+ *
+ *   2. El VOCABULARIO ambiguo exige CO-OCURRENCIA con un marcador de persona.
+ *      «diagnóstico» solo no dispara; «su diagnóstico» sí. Ver `VENTANA`.
+ *
+ * LA VENTANA es de 60 caracteres entre los bordes más cercanos del término y
+ * del marcador. Una oración simple en español ronda las 10-12 palabras, unos
+ * 60-70 caracteres; dentro de eso el marcador y el término suelen compartir
+ * sujeto. Más allá ya son dos frases distintas y la co-ocurrencia deja de
+ * significar nada: el marcador habla de una persona y el término, de otra cosa.
+ * Medido sobre el corpus: con 60 caracteres las 12 cadenas benignas salen
+ * limpias y las 19 sensibles por vocabulario salen todas.
+ *
+ * QUÉ NO HACE, y conviene que conste:
+ *
+ *   · No entiende negación ni hipótesis. «no está de baja por depresión» y
+ *     «si estuviera de baja por depresión» disparan igual. Es deliberado: en
+ *     un detector de fugas el falso negativo se paga más caro que el falso
+ *     positivo POR CADA CASO, y la negación en texto libre no se resuelve con
+ *     una lista de palabras.
+ *   · No cubre `fingerprint` ni `huella digital` como biometría, porque en
+ *     este repositorio son la huella de un certificado o de un fichero. Sí
+ *     cubre «huella dactilar», que no tiene lectura técnica.
+ *   · La matrícula española no tiene dígito de control: es la única forma sin
+ *     validar de las cinco. Se compensa exigiendo el alfabeto real de las
+ *     placas (consonantes, sin vocales ni Ñ ni Q), que descarta casi cualquier
+ *     token accidental de cuatro cifras y tres letras.
+ *   · No sustituye a `classifySensitive`: es complementario. Aquí no hay
+ *     correos, ni teléfonos, ni tarjetas.
+ */
+/** Las diez categorías que este módulo sabe nombrar. */
+export type CategoriaEspecial = "salud" | "sindical" | "origen-etnico" | "religion" | "opinion-politica" | "vida-sexual" | "biometrico" | "genetico" | "condenas" | "identificador-nacional";
+export interface HallazgoEspecial {
+    categoria: CategoriaEspecial;
+    /**
+     * El artículo del RGPD que hace especial al dato. Es lo que el DPO necesita
+     * en su informe: el 9 exige una de las excepciones del 9.2, el 10 exige
+     * control de la autoridad pública.
+     *
+     * `identificador-nacional` se marca como "9" porque la API sólo admite dos
+     * valores, pero su base real es el art. 87 (número de identificación
+     * nacional, condiciones específicas de cada Estado miembro). Quien redacte
+     * el informe debe leerlo así.
+     */
+    articulo: "9" | "10";
+    /** Posición inicial en el texto, para poder redactar sólo ese trozo. */
+    desde: number;
+    /** Posición final (exclusiva). */
+    hasta: number;
+    /**
+     * La FORMA que lo disparó. NUNCA el texto detectado: un informe de fuga que
+     * cita la fuga es otra fuga, y estos hallazgos van a un libro de auditoría
+     * que se exporta.
+     */
+    porque: string;
+}
+/**
+ * El tercer estado: «no he podido mirar».
+ *
+ * Una lista vacía significa «he mirado el texto entero y no hay nada». Si el
+ * módulo no puede analizar, devolver `[]` convertiría un fallo en un permiso:
+ * quien llama guardaría la nota creyendo que está limpia. Por eso se LANZA.
+ *
+ * Se lanza en dos casos, y sólo en dos:
+ *   · `no-es-cadena`: llega algo que no es `string` (un `null` de una API, un
+ *     objeto que alguien esperaba serializado).
+ *   · `demasiado-largo`: por encima de `LIMITE_CARACTERES`. El barrido es
+ *     lineal por patrón, pero son ~80 patrones y la búsqueda de marcadores es
+ *     cuadrática en el número de coincidencias; con un volcado de megabytes el
+ *     detector deja de responder y quien llama se queda colgado sin saber por
+ *     qué. Falla rápido y explícito.
+ */
+export declare class TextoNoAnalizable extends Error {
+    readonly motivo: "no-es-cadena" | "demasiado-largo";
+    constructor(motivo: "no-es-cadena" | "demasiado-largo", detalle: string);
+}
+/** 200.000 caracteres ≈ 200 KB. Una nota de memoria razonable no llega a 10 KB. */
+export declare const LIMITE_CARACTERES = 200000;
+/** Caracteres de distancia máxima entre el término y su marcador de persona. */
+export declare const VENTANA = 60;
+/**
+ * Devuelve el texto en minúsculas, sin acentos y con TODO espacio en blanco
+ * convertido en un espacio simple, con la MISMA longitud.
+ *
+ * Lo del salto de línea no es cosmético y se midió: con el salto intacto,
+ * «perfil\ngenético» y «trade\nunion» salían LIMPIOS —los patrones de varias
+ * palabras llevan un espacio literal— y un dato de categoría especial partido
+ * por un ajuste de línea es exactamente lo que produce cualquier editor, todo
+ * correo citado y todo comentario de código. Se arregla aquí, en el plegado,
+ * y no patrón a patrón: son ~30 patrones de varias palabras y arreglar sólo
+ * los que uno recuerda deja el resto igual de ciegos.
+ */
+export declare function plegar(texto: string): string;
+/**
+ * Letra de control del DNI: módulo 23 sobre la tabla oficial.
+ *
+ * Acepta los puntos de millar («12.345.678»), que es como se imprime en la
+ * tarjeta y como lo teclea la mitad de la gente.
+ */
+export declare function dniValido(numero: string, letra: string): boolean;
+/** NIE: la inicial X/Y/Z vale 0/1/2 y luego es el mismo módulo 23. */
+export declare function nieValido(inicial: string, numero: string, letra: string): boolean;
+/** IBAN: mover los cuatro primeros al final, letra → número, y módulo 97 = 1. */
+export declare function ibanValido(iban: string): boolean;
+/**
+ * Número de la Seguridad Social: provincia (2) + número (8) + control (2),
+ * donde el control es el módulo 97 de los diez primeros dígitos.
+ *
+ * La excepción documentada: cuando el número de afiliación es menor que
+ * 10.000.000 —es decir, empieza por cero— el código de provincia se coloca
+ * DETRÁS. Se prueban las dos lecturas y basta con que una cuadre; probar sólo
+ * la principal perdería a todos los afiliados antiguos.
+ */
+export declare function nssValido(provincia: string, numero: string, control: string): boolean;
+/**
+ * Busca categorías especiales del art. 9 y condenas del art. 10.
+ *
+ * TRES ESTADOS, no dos:
+ *   · lista con hallazgos → hay datos de categoría especial;
+ *   · lista vacía → he mirado el texto entero y no hay;
+ *   · `TextoNoAnalizable` → no he podido mirar. Nunca se confunde con la vacía.
+ *
+ * Ningún campo del hallazgo lleva el texto detectado; sólo su posición y la
+ * forma que lo disparó.
+ */
+export declare function categoriasEspeciales(texto: string): HallazgoEspecial[];
+/**
+ * Devuelve el texto con los tramos hallados —y SÓLO ésos— sustituidos por
+ * bloques.
+ *
+ * Es lo que le falta hoy a `redactSensitive`: medido,
+ * `redactSensitive("baja por depresión, afiliado a CCOO, HIV positive",
+ * "strict")` devuelve la cadena idéntica, y esa función alimenta el libro de
+ * auditoría y el diario de edición.
+ *
+ * DOS DECISIONES, las dos deliberadas:
+ *
+ *   · El bloque tiene la MISMA longitud que el tramo. Un texto tapado que
+ *     encoge delata dónde estaba el dato al comparar con el original, y además
+ *     rompe cualquier índice que alguien haya guardado sobre el texto.
+ *   · No se escribe la categoría en el hueco. Poner «[salud]» taparía el dato y
+ *     publicaría el diagnóstico: que hay información de salud sobre esta
+ *     persona ya es, por sí solo, una categoría especial. La categoría va en el
+ *     hallazgo, que es para el DPO; el texto tapado es para todos los demás.
+ *
+ * Un texto sin hallazgos sale idéntico byte a byte —se devuelve el mismo
+ * objeto—, y `TextoNoAnalizable` sube igual que en `categoriasEspeciales`:
+ * devolver aquí el texto sin tocar sería devolver el original en claro
+ * creyendo haberlo tapado.
+ */
+export declare function taparCategoriasEspeciales(texto: string): string;
+//# sourceMappingURL=categorias-especiales.d.ts.map

package/dist/core/privacidad/categorias-especiales.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"categorias-especiales.d.ts","sourceRoot":"","sources":["../../../src/core/privacidad/categorias-especiales.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+DG;AAEH,0DAAwD;AACxD,MAAM,MAAM,iBAAiB,GAC1B,OAAO,GACP,UAAU,GACV,eAAe,GACf,UAAU,GACV,kBAAkB,GAClB,aAAa,GACb,YAAY,GACZ,UAAU,GACV,UAAU,GACV,wBAAwB,CAAC;AAE5B,MAAM,WAAW,gBAAgB;IAChC,SAAS,EAAE,iBAAiB,CAAC;IAC7B;;;;;;;;;OASG;IACH,QAAQ,EAAE,GAAG,GAAG,IAAI,CAAC;IACrB,0EAAwE;IACxE,KAAK,EAAE,MAAM,CAAC;IACd,mCAAkC;IAClC,KAAK,EAAE,MAAM,CAAC;IACd;;;;OAIG;IACH,MAAM,EAAE,MAAM,CAAC;CACf;AAED;;;;;;;;;;;;;;;GAeG;AACH,qBAAa,iBAAkB,SAAQ,KAAK;IAC3C,QAAQ,CAAC,MAAM,EAAE,cAAc,GAAG,iBAAiB,CAAC;IACpD,YAAY,MAAM,EAAE,cAAc,GAAG,iBAAiB,EAAE,OAAO,EAAE,MAAM,EAItE;CACD;AAED,qFAAmF;AACnF,eAAO,MAAM,iBAAiB,SAAU,CAAC;AAEzC,kFAAgF;AAChF,eAAO,MAAM,OAAO,KAAK,CAAC;AA2D1B;;;;;;;;;;;GAWG;AACH,wBAAgB,MAAM,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAmB5C;AAQD;;;;;GAKG;AACH,wBAAgB,SAAS,CAAC,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,OAAO,CAIhE;AAED,uEAAsE;AACtE,wBAAgB,SAAS,CAAC,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,OAAO,CAIjF;AASD,qFAAiF;AACjF,wBAAgB,UAAU,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAShD;AAED;;;;;;;;GAQG;AACH,wBAAgB,SAAS,CAAC,SAAS,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,OAAO,CAKrF;AA8aD;;;;;;;;;;GAUG;AACH,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,MAAM,GAAG,gBAAgB,EAAE,CAkFtE;AAKD;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,wBAAgB,yBAAyB,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAiB/D","sourcesContent":["/**\n * Detectar las CATEGORÍAS ESPECIALES del artículo 9 del RGPD (y las condenas\n * del artículo 10) en un texto, sin repetir el texto en el hallazgo.\n *\n * POR QUÉ EXISTE, medido antes de escribir nada. El escáner de\n * `memory-engine/security.ts` tiene cinco patrones de datos personales\n * (correo, teléfono, DNI/NIE, IBAN, fecha de nacimiento) y CERO del artículo 9.\n * Sobre un corpus de 24 cadenas que sí deberían saltar, en nivel `strict`\n * fallaban 20. Entre las 20: «baja por depresión», «afiliado a CCOO»,\n * «HIV positive», «huella dactilar registrada», «tiene antecedentes penales».\n * Ninguna de ellas tiene hoy categoría en `SensitiveCategory`, así que\n * `redactSensitive` las devuelve idénticas, sin un solo bloque: hoy una\n * categoría especial se escribe EN CLARO en el libro de auditoría\n * (`audit/libro.ts`), en la exportación y en el diario de edición.\n *\n * El coste no es simétrico con el de un correo. Tratar datos de salud,\n * afiliación sindical, origen étnico, religión, opinión política, vida sexual,\n * biometría o genética está PROHIBIDO salvo excepción tasada (art. 9.1 y 9.2),\n * y las condenas penales sólo pueden tratarse bajo control de la autoridad\n * (art. 10). Filtrar uno de estos no es un incidente de privacidad: es un\n * tratamiento ilícito.\n *\n * LAS DOS MITADES. Un detector de vocabulario ingenuo es peor que ninguno.\n * «diagnóstico» sale de cualquier compilador, «union» de cualquier SQL,\n * «race» de cualquier `race condition`, y un identificador interno de ocho\n * cifras no es un DNI. Un detector que grita sobre todo se desactiva en una\n * semana y entonces no protege de nada. Por eso aquí hay dos mecanismos, y\n * los dos se miden contra el corpus benigno:\n *\n *   1. Los IDENTIFICADORES se VALIDAN, no se reconocen por su forma. DNI y NIE\n *      por la letra de control (módulo 23 sobre TRWAGMYFPDXBNJZSQVHLCKE), IBAN\n *      y número de la Seguridad Social por módulo 97. Esto no es sólo rigor:\n *      es lo que hace desaparecer el único falso positivo medido del escáner\n *      actual —el UUID `550e8400-e29b-41d4-a716-446655440000`, cuyo fragmento\n *      `446655440000` tiene forma de NSS pero da 56 donde debería dar 00—.\n *\n *   2. El VOCABULARIO ambiguo exige CO-OCURRENCIA con un marcador de persona.\n *      «diagnóstico» solo no dispara; «su diagnóstico» sí. Ver `VENTANA`.\n *\n * LA VENTANA es de 60 caracteres entre los bordes más cercanos del término y\n * del marcador. Una oración simple en español ronda las 10-12 palabras, unos\n * 60-70 caracteres; dentro de eso el marcador y el término suelen compartir\n * sujeto. Más allá ya son dos frases distintas y la co-ocurrencia deja de\n * significar nada: el marcador habla de una persona y el término, de otra cosa.\n * Medido sobre el corpus: con 60 caracteres las 12 cadenas benignas salen\n * limpias y las 19 sensibles por vocabulario salen todas.\n *\n * QUÉ NO HACE, y conviene que conste:\n *\n *   · No entiende negación ni hipótesis. «no está de baja por depresión» y\n *     «si estuviera de baja por depresión» disparan igual. Es deliberado: en\n *     un detector de fugas el falso negativo se paga más caro que el falso\n *     positivo POR CADA CASO, y la negación en texto libre no se resuelve con\n *     una lista de palabras.\n *   · No cubre `fingerprint` ni `huella digital` como biometría, porque en\n *     este repositorio son la huella de un certificado o de un fichero. Sí\n *     cubre «huella dactilar», que no tiene lectura técnica.\n *   · La matrícula española no tiene dígito de control: es la única forma sin\n *     validar de las cinco. Se compensa exigiendo el alfabeto real de las\n *     placas (consonantes, sin vocales ni Ñ ni Q), que descarta casi cualquier\n *     token accidental de cuatro cifras y tres letras.\n *   · No sustituye a `classifySensitive`: es complementario. Aquí no hay\n *     correos, ni teléfonos, ni tarjetas.\n */\n\n/** Las diez categorías que este módulo sabe nombrar. */\nexport type CategoriaEspecial =\n\t| \"salud\"\n\t| \"sindical\"\n\t| \"origen-etnico\"\n\t| \"religion\"\n\t| \"opinion-politica\"\n\t| \"vida-sexual\"\n\t| \"biometrico\"\n\t| \"genetico\"\n\t| \"condenas\"\n\t| \"identificador-nacional\";\n\nexport interface HallazgoEspecial {\n\tcategoria: CategoriaEspecial;\n\t/**\n\t * El artículo del RGPD que hace especial al dato. Es lo que el DPO necesita\n\t * en su informe: el 9 exige una de las excepciones del 9.2, el 10 exige\n\t * control de la autoridad pública.\n\t *\n\t * `identificador-nacional` se marca como \"9\" porque la API sólo admite dos\n\t * valores, pero su base real es el art. 87 (número de identificación\n\t * nacional, condiciones específicas de cada Estado miembro). Quien redacte\n\t * el informe debe leerlo así.\n\t */\n\tarticulo: \"9\" | \"10\";\n\t/** Posición inicial en el texto, para poder redactar sólo ese trozo. */\n\tdesde: number;\n\t/** Posición final (exclusiva). */\n\thasta: number;\n\t/**\n\t * La FORMA que lo disparó. NUNCA el texto detectado: un informe de fuga que\n\t * cita la fuga es otra fuga, y estos hallazgos van a un libro de auditoría\n\t * que se exporta.\n\t */\n\tporque: string;\n}\n\n/**\n * El tercer estado: «no he podido mirar».\n *\n * Una lista vacía significa «he mirado el texto entero y no hay nada». Si el\n * módulo no puede analizar, devolver `[]` convertiría un fallo en un permiso:\n * quien llama guardaría la nota creyendo que está limpia. Por eso se LANZA.\n *\n * Se lanza en dos casos, y sólo en dos:\n *   · `no-es-cadena`: llega algo que no es `string` (un `null` de una API, un\n *     objeto que alguien esperaba serializado).\n *   · `demasiado-largo`: por encima de `LIMITE_CARACTERES`. El barrido es\n *     lineal por patrón, pero son ~80 patrones y la búsqueda de marcadores es\n *     cuadrática en el número de coincidencias; con un volcado de megabytes el\n *     detector deja de responder y quien llama se queda colgado sin saber por\n *     qué. Falla rápido y explícito.\n */\nexport class TextoNoAnalizable extends Error {\n\treadonly motivo: \"no-es-cadena\" | \"demasiado-largo\";\n\tconstructor(motivo: \"no-es-cadena\" | \"demasiado-largo\", detalle: string) {\n\t\tsuper(`No se pudo analizar el texto (${motivo}): ${detalle}`);\n\t\tthis.name = \"TextoNoAnalizable\";\n\t\tthis.motivo = motivo;\n\t}\n}\n\n/** 200.000 caracteres ≈ 200 KB. Una nota de memoria razonable no llega a 10 KB. */\nexport const LIMITE_CARACTERES = 200_000;\n\n/** Caracteres de distancia máxima entre el término y su marcador de persona. */\nexport const VENTANA = 60;\n\n// ─────────────────────────────────────────────────────────────────────────────\n// Plegado: quitar acentos y mayúsculas SIN mover ni un índice\n// ─────────────────────────────────────────────────────────────────────────────\n\n/**\n * `NFD` + quitar diacríticos cambiaría la longitud y con ella `desde`/`hasta`,\n * que dejarían de servir para redactar el original. Aquí se mapea carácter a\n * carácter, uno a uno, para que el texto plegado y el original compartan\n * índices exactamente.\n */\nconst EQUIVALENTES: Record<string, string> = {\n\tá: \"a\",\n\tà: \"a\",\n\tä: \"a\",\n\tâ: \"a\",\n\té: \"e\",\n\tè: \"e\",\n\të: \"e\",\n\tê: \"e\",\n\tí: \"i\",\n\tì: \"i\",\n\tï: \"i\",\n\tî: \"i\",\n\tó: \"o\",\n\tò: \"o\",\n\tö: \"o\",\n\tô: \"o\",\n\tú: \"u\",\n\tù: \"u\",\n\tü: \"u\",\n\tû: \"u\",\n\tñ: \"n\",\n\tç: \"c\",\n\tÁ: \"a\",\n\tÀ: \"a\",\n\tÄ: \"a\",\n\tÂ: \"a\",\n\tÉ: \"e\",\n\tÈ: \"e\",\n\tË: \"e\",\n\tÊ: \"e\",\n\tÍ: \"i\",\n\tÌ: \"i\",\n\tÏ: \"i\",\n\tÎ: \"i\",\n\tÓ: \"o\",\n\tÒ: \"o\",\n\tÖ: \"o\",\n\tÔ: \"o\",\n\tÚ: \"u\",\n\tÙ: \"u\",\n\tÜ: \"u\",\n\tÛ: \"u\",\n\tÑ: \"n\",\n\tÇ: \"c\",\n};\n\n/**\n * Devuelve el texto en minúsculas, sin acentos y con TODO espacio en blanco\n * convertido en un espacio simple, con la MISMA longitud.\n *\n * Lo del salto de línea no es cosmético y se midió: con el salto intacto,\n * «perfil\\ngenético» y «trade\\nunion» salían LIMPIOS —los patrones de varias\n * palabras llevan un espacio literal— y un dato de categoría especial partido\n * por un ajuste de línea es exactamente lo que produce cualquier editor, todo\n * correo citado y todo comentario de código. Se arregla aquí, en el plegado,\n * y no patrón a patrón: son ~30 patrones de varias palabras y arreglar sólo\n * los que uno recuerda deja el resto igual de ciegos.\n */\nexport function plegar(texto: string): string {\n\tlet salida = \"\";\n\tfor (let i = 0; i < texto.length; i++) {\n\t\tconst c = texto[i] as string;\n\t\tif (c === \"\\n\" || c === \"\\r\" || c === \"\\t\" || c === \"\\f\" || c === \"\\v\") {\n\t\t\tsalida += \" \";\n\t\t\tcontinue;\n\t\t}\n\t\tconst equivalente = EQUIVALENTES[c];\n\t\tif (equivalente !== undefined) {\n\t\t\tsalida += equivalente;\n\t\t\tcontinue;\n\t\t}\n\t\tconst minuscula = c.toLowerCase();\n\t\t// Hay caracteres cuya minúscula ocupa dos unidades ('İ' → 'i̇'). Ésos se\n\t\t// dejan como están: mover un índice cuesta más que perder una coincidencia.\n\t\tsalida += minuscula.length === 1 ? minuscula : c;\n\t}\n\treturn salida;\n}\n\n// ─────────────────────────────────────────────────────────────────────────────\n// Validación de identificadores\n// ─────────────────────────────────────────────────────────────────────────────\n\nconst LETRAS_DNI = \"TRWAGMYFPDXBNJZSQVHLCKE\";\n\n/**\n * Letra de control del DNI: módulo 23 sobre la tabla oficial.\n *\n * Acepta los puntos de millar («12.345.678»), que es como se imprime en la\n * tarjeta y como lo teclea la mitad de la gente.\n */\nexport function dniValido(numero: string, letra: string): boolean {\n\tconst digitos = numero.replace(/\\./g, \"\");\n\tif (!/^\\d{8}$/.test(digitos)) return false;\n\treturn LETRAS_DNI[Number(digitos) % 23] === letra.toUpperCase();\n}\n\n/** NIE: la inicial X/Y/Z vale 0/1/2 y luego es el mismo módulo 23. */\nexport function nieValido(inicial: string, numero: string, letra: string): boolean {\n\tconst prefijo = { X: \"0\", Y: \"1\", Z: \"2\" }[inicial.toUpperCase()];\n\tif (prefijo === undefined) return false;\n\treturn dniValido(prefijo + numero, letra);\n}\n\n/** Resto módulo 97 de una cadena de dígitos, sin desbordar el entero. */\nfunction modulo97(digitos: string): number {\n\tlet resto = 0;\n\tfor (const d of digitos) resto = (resto * 10 + Number(d)) % 97;\n\treturn resto;\n}\n\n/** IBAN: mover los cuatro primeros al final, letra → número, y módulo 97 = 1. */\nexport function ibanValido(iban: string): boolean {\n\tconst limpio = iban.replace(/\\s/g, \"\").toUpperCase();\n\tif (!/^[A-Z]{2}\\d{2}[A-Z0-9]{10,30}$/.test(limpio)) return false;\n\tconst rotado = limpio.slice(4) + limpio.slice(0, 4);\n\tlet digitos = \"\";\n\tfor (const c of rotado) {\n\t\tdigitos += c >= \"A\" && c <= \"Z\" ? String(c.charCodeAt(0) - 55) : c;\n\t}\n\treturn modulo97(digitos) === 1;\n}\n\n/**\n * Número de la Seguridad Social: provincia (2) + número (8) + control (2),\n * donde el control es el módulo 97 de los diez primeros dígitos.\n *\n * La excepción documentada: cuando el número de afiliación es menor que\n * 10.000.000 —es decir, empieza por cero— el código de provincia se coloca\n * DETRÁS. Se prueban las dos lecturas y basta con que una cuadre; probar sólo\n * la principal perdería a todos los afiliados antiguos.\n */\nexport function nssValido(provincia: string, numero: string, control: string): boolean {\n\tconst esperado = Number(control);\n\tif (modulo97(provincia + numero) === esperado) return true;\n\tif (numero.startsWith(\"0\")) return modulo97(numero + provincia) === esperado;\n\treturn false;\n}\n\n// ─────────────────────────────────────────────────────────────────────────────\n// Marcadores de persona\n// ─────────────────────────────────────────────────────────────────────────────\n\n/**\n * Lo que sitúa un dato EN UNA PERSONA. Sin uno de éstos cerca, el vocabulario\n * ambiguo no dispara.\n *\n * No están los artículos («el», «la», «los»): son tan frecuentes que\n * convertirían la co-ocurrencia en un adorno —todo texto en español tiene un\n * artículo a menos de 60 caracteres de cualquier cosa—. Sí están los posesivos\n * y los pronombres, que es lo que atribuye el dato a alguien.\n *\n * «de baja» / «baja por» entran porque una baja es siempre de una persona; es\n * el marcador que sostiene «baja por depresión», donde no hay ningún pronombre.\n */\nconst MARCADORES: RegExp[] = [\n\t/\\b(?:yo|tu|ella|ellos|ellas|nosotros|nosotras|vosotros|usted|ustedes)\\b/g,\n\t// SIN `su` ni `sus`, y es una corrección medida. En español el posesivo de\n\t// tercera persona vale para CUALQUIER antecedente, animado o no: «agrega sus\n\t// diagnósticos» habla de un comprobador, no de un paciente. Con `su`/`sus`\n\t// dentro, 7 de los 10 falsos positivos que quedaban sobre `src` venían de\n\t// ahí. Los de primera y segunda persona sí implican a alguien.\n\t/\\b(?:mi|mis|tus|nuestro|nuestra|nuestros|nuestras)\\b/g,\n\t// SIN `i`: es la variable de bucle de todo el código escrito jamás, y sobre\n\t// el plegado no hay forma de distinguirla del pronombre inglés.\n\t/\\b(?:he|she|they|we|my|his|her|their|our|your|him|them)\\b/g,\n\t/\\b(?:paciente|pacientes|enfermo|enferma|empleado|empleada|empleados|empleadas)\\b/g,\n\t/\\b(?:trabajador|trabajadora|trabajadores|usuario|usuaria|usuarios|cliente|clientes)\\b/g,\n\t/\\b(?:candidato|candidata|afiliado|afiliada|socio|socia|miembro|companero|companera|colega)\\b/g,\n\t/\\b(?:patient|employee|employees|worker|workers|user|users|customer|member|colleague)\\b/g,\n\t/\\b(?:don|dona|sr|sra|senor|senora|mr|mrs|ms)\\b/g,\n\t/\\bde baja\\b|\\bbaja por\\b|\\bsick leave\\b|\\bon leave\\b/g,\n];\n\n/**\n * Nombre y apellido SEGUIDOS: dos palabras capitalizadas pegadas, ni al\n * principio del texto ni tras un punto.\n *\n * MEDIDO, y es la corrección más cara de este módulo. Antes bastaba UNA palabra\n * capitalizada. Sobre los 469 ficheros `.ts` reales de `src` eso daba 20.272\n * marcadores: en un repositorio documentado en español toda palabra que abre\n * frase dentro de un bloque de documentación y todo nombre de tipo\n * (`Comprobador`, `Deteccion`, `Diagnostico`) valía por «una persona». El\n * resultado era que la co-ocurrencia no filtraba nada y el detector marcaba 51\n * veces palabras como `diagnóstico` y `positivo` —la segunda dentro de la\n * expresión «falso positivo», que es justo lo que este módulo intenta evitar—.\n * Exigiendo las dos palabras seguidas quedan 351 candidatos sobre el mismo\n * corpus, y ninguno acaba produciendo un hallazgo.\n *\n * Lo que se paga: «Ana padece esclerosis» ya no tiene marcador por el nombre.\n * Se acepta a sabiendas —un nombre de pila suelto es indistinguible de un\n * identificador de código— y se compensa con el vocabulario sin marcador.\n */\nconst NOMBRE_COMPLETO = /\\b[A-ZÁÉÍÓÚÑ][a-záéíóúñ]{2,} [A-ZÁÉÍÓÚÑ][a-záéíóúñ]{2,}\\b/g;\n\ninterface Tramo {\n\tdesde: number;\n\thasta: number;\n}\n\nfunction marcadoresDe(plegado: string, original: string): Tramo[] {\n\tconst tramos: Tramo[] = [];\n\tfor (const patron of MARCADORES) {\n\t\tfor (const m of plegado.matchAll(patron)) {\n\t\t\ttramos.push({ desde: m.index, hasta: m.index + m[0].length });\n\t\t}\n\t}\n\tfor (const m of original.matchAll(NOMBRE_COMPLETO)) {\n\t\tconst antes = original.slice(0, m.index).trimEnd();\n\t\tif (antes.length === 0) continue; // primera palabra del texto\n\t\tif (/[.!?¿¡:]$/.test(antes)) continue; // primera palabra de la oración\n\t\ttramos.push({ desde: m.index, hasta: m.index + m[0].length });\n\t}\n\treturn tramos;\n}\n\n/** ¿Hay algún marcador a menos de `VENTANA` del término, sin solaparlo? */\nfunction tieneMarcadorCerca(termino: Tramo, marcadores: Tramo[]): boolean {\n\tfor (const m of marcadores) {\n\t\tif (m.desde < termino.hasta && termino.desde < m.hasta) continue; // se solapan: es el propio término\n\t\tconst distancia = m.desde >= termino.hasta ? m.desde - termino.hasta : termino.desde - m.hasta;\n\t\tif (distancia <= VENTANA) return true;\n\t}\n\treturn false;\n}\n\n// ─────────────────────────────────────────────────────────────────────────────\n// Vocabulario\n// ─────────────────────────────────────────────────────────────────────────────\n\ninterface Termino {\n\tcategoria: CategoriaEspecial;\n\tpatron: RegExp;\n\t/** `true` = ambiguo fuera de contexto, exige marcador de persona cerca. */\n\texigeMarcador: boolean;\n\t/**\n\t * `true` = el patrón corre sobre el texto ORIGINAL, no sobre el plegado.\n\t *\n\t * Es para las siglas: un sindicato se escribe SIEMPRE en mayúsculas, y sobre\n\t * el plegado `USO` es indistinguible de «uso» y `LAB` de «lab». Medido: la\n\t * lista de siglas sobre el plegado producía 64 hallazgos sobre los ficheros\n\t * reales de `src` —todos «uso» y «usó»—; la misma lista en mayúsculas sobre\n\t * el original produce CERO, sin perder «afiliado a CCOO».\n\t */\n\tsobreOriginal?: boolean;\n}\n\n/**\n * Español e inglés en la misma tabla. Lo que entra sin marcador es lo que no\n * tiene otra lectura en un repositorio de software: `diabetes` no sale de un\n * compilador. Lo que exige marcador es lo que sí sale: `diagnostico`,\n * `depresion`, `positivo`.\n *\n * Ausencias deliberadas, cada una por un falso positivo concreto:\n *   · `union` a secas → `union type`, `UNION ALL`. Sólo entra en locuciones\n *     («union member», «trade union»).\n *   · `race` a secas → `race condition`. Sólo entra «racial origin».\n *   · `podemos` como partido → es la primera persona del plural de «poder».\n *     Se cubre por la locución «votante de», que revela la opinión política\n *     sea cual sea el partido.\n *   · `master`, `slave`, `blacklist` → vocabulario técnico, no étnico.\n */\nconst TERMINOS: Termino[] = [\n\t// ── Salud (art. 9) ──\n\t{ categoria: \"salud\", patron: /\\bdiabetes\\b|\\bdiabetic(?:o|a|os|as)?\\b/g, exigeMarcador: false },\n\t{\n\t\tcategoria: \"salud\",\n\t\tpatron: /\\balergi(?:a|as)\\b|\\balergic(?:o|a)\\b|\\ballerg(?:y|ic|ies)\\b/g,\n\t\texigeMarcador: false,\n\t},\n\t{ categoria: \"salud\", patron: /\\b(?:vih|hiv|sida|aids|hepatitis|tuberculosis)\\b/g, exigeMarcador: false },\n\t{ categoria: \"salud\", patron: /\\bcancer\\b|\\bleucemia\\b|\\bleukemia\\b|\\btumor(?:es)?\\b/g, exigeMarcador: false },\n\t{ categoria: \"salud\", patron: /\\bgrupo sanguineo\\b|\\bblood (?:type|group)\\b/g, exigeMarcador: false },\n\t{\n\t\tcategoria: \"salud\",\n\t\tpatron: /\\ben tratamiento (?:con|por|de)\\b|\\bunder treatment for\\b|\\bon medication\\b/g,\n\t\texigeMarcador: false,\n\t},\n\t{\n\t\tcategoria: \"salud\",\n\t\tpatron:\n\t\t\t/\\b(?:sertralina|fluoxetina|paroxetina|litio|insulina|metformina|antidepresiv(?:o|os)|antirretroviral(?:es)?|quimioterapia|chemotherapy)\\b/g,\n\t\texigeMarcador: false,\n\t},\n\t{\n\t\tcategoria: \"salud\",\n\t\tpatron: /\\bhistoria clinica\\b|\\bhistorial medico\\b|\\bmedical (?:record|history)\\b|\\binforme medico\\b/g,\n\t\texigeMarcador: false,\n\t},\n\t{\n\t\tcategoria: \"salud\",\n\t\tpatron: /\\bembarazad(?:a|as)\\b|\\bpregnan(?:t|cy)\\b|\\bdiscapacidad\\b|\\bminusvalia\\b/g,\n\t\texigeMarcador: false,\n\t},\n\t// `diagnostico` PARTIDO EN DOS, y es la lección más cara del módulo. En un\n\t// agente de programación «diagnóstico» es lo que escupe el compilador: sobre\n\t// `src` aparece 46 veces y ninguna habla de la salud de nadie. La forma que\n\t// sí es art. 9 no es la palabra suelta, es la CONSTRUCCIÓN: a alguien se le\n\t// diagnostica ALGO. Ésa no exige marcador porque ya lo lleva dentro.\n\t{\n\t\tcategoria: \"salud\",\n\t\tpatron:\n\t\t\t/\\bdiagnosticad(?:o|a|os|as) (?:de|con)\\b|\\bdiagnos(?:ed with|is of)\\b|\\bdiagnostico (?:medico|clinico|psiquiatrico|psicologico|de cancer)\\b|\\bmedical diagnosis\\b/g,\n\t\texigeMarcador: false,\n\t},\n\t{\n\t\tcategoria: \"salud\",\n\t\tpatron: /\\bdiagnostic(?:o|os|ado|ada|ados|adas)\\b|\\bdiagnos(?:is|ed)\\b/g,\n\t\texigeMarcador: true,\n\t},\n\t{\n\t\tcategoria: \"salud\",\n\t\tpatron: /\\bdepresion\\b|\\bansiedad\\b|\\bdepression\\b|\\banxiety\\b|\\bburnout\\b/g,\n\t\texigeMarcador: true,\n\t},\n\t{\n\t\tcategoria: \"salud\",\n\t\tpatron: /\\benfermedad(?:es)?\\b|\\bdolencia\\b|\\billness\\b|\\bdisease\\b|\\bsintomas\\b/g,\n\t\texigeMarcador: true,\n\t},\n\t// `positivo` va sin «falso» ni «false» delante: «falso positivo» es la\n\t// expresión de oficio de este repositorio —medido, 5 hallazgos en `src`, uno\n\t// de ellos en un comentario que explica cómo evitar falsos positivos— y no\n\t// habla de la serología de nadie.\n\t{\n\t\tcategoria: \"salud\",\n\t\tpatron: /(?<!\\bfals[oa]s? )(?<!\\bfalse )(?:\\bpositiv(?:o|a)\\b|\\bpositive\\b|\\bseropositiv(?:o|a)\\b)/g,\n\t\texigeMarcador: true,\n\t},\n\t// Patologías sin lectura técnica: no salen de un compilador, así que no\n\t// exigen marcador. Coste medido sobre los 469 ficheros de `src` y sobre 200\n\t// commits: CERO hallazgos.\n\t{\n\t\tcategoria: \"salud\",\n\t\tpatron:\n\t\t\t/\\besquizofrenia\\b|\\bbipolar\\b|\\bepilep(?:sia|tic(?:o|a))\\b|\\balzheimer\\b|\\bparkinson\\b|\\bdialisis\\b|\\besclerosis\\b|\\bfibromialgia\\b|\\bcelia(?:co|ca)\\b|\\basma\\b|\\bictus\\b|\\binfarto\\b/g,\n\t\texigeMarcador: false,\n\t},\n\t{\n\t\tcategoria: \"salud\",\n\t\tpatron:\n\t\t\t/\\bsuicidi(?:o|os|arse)\\b|\\bautolesion(?:es)?\\b|\\bsalud mental\\b|\\bmental health\\b|\\bingreso psiquiatric(?:o|a)\\b|\\bpsiquiatric(?:o|a)\\b/g,\n\t\texigeMarcador: false,\n\t},\n\t{\n\t\tcategoria: \"salud\",\n\t\tpatron:\n\t\t\t/\\badict(?:o|a) a\\b|\\balcoholi(?:co|ca|smo)\\b|\\bdrogodependien\\w*\\b|\\bdesintoxicacion\\b|\\brehabilitacion\\b|\\btoxicoman\\w*\\b/g,\n\t\texigeMarcador: false,\n\t},\n\t{\n\t\tcategoria: \"salud\",\n\t\tpatron:\n\t\t\t/\\bbaja medica\\b|\\bbaja laboral\\b|\\bincapacidad (?:temporal|permanente|laboral)\\b|\\bsick leave\\b|\\bmedical leave\\b/g,\n\t\texigeMarcador: false,\n\t},\n\t{\n\t\tcategoria: \"salud\",\n\t\tpatron:\n\t\t\t/\\babortion\\b|\\binterrupcion (?:voluntaria )?del embarazo\\b|\\btratamiento de fertilidad\\b|\\bmiscarriage\\b/g,\n\t\texigeMarcador: false,\n\t},\n\t// Siglas clínicas, en mayúsculas y sobre el original. Sólo las que no\n\t// colisionan con vocabulario técnico: fuera `IAM` (AWS), `ACV`, `TOC` (tabla\n\t// de contenidos) y `SNS`, que en un repositorio son otra cosa.\n\t{\n\t\tcategoria: \"salud\",\n\t\tpatron: /\\b(?:TDAH|TEPT|EPOC|VHC|VHB)\\b/g,\n\t\texigeMarcador: false,\n\t\tsobreOriginal: true,\n\t},\n\n\t// ── Afiliación sindical (art. 9) ──\n\t// EN MAYÚSCULAS y sobre el original: ver `sobreOriginal`. `uso`, `lab`, `cnt`\n\t// y `ela` en minúsculas son palabras corrientes, no sindicatos.\n\t{\n\t\tcategoria: \"sindical\",\n\t\tpatron: /\\b(?:CCOO|UGT|CGT|CNT|USO|ELA|LAB|CIG|SATSE|CSIF)\\b/g,\n\t\texigeMarcador: false,\n\t\tsobreOriginal: true,\n\t},\n\t// `liberado sindical` y `seccion sindical` llevan la palabra dentro: no hay\n\t// otra lectura. `huelga` sí la tiene —«huelga decir»— y además una huelga\n\t// convocada no es un dato de nadie; lo que revela afiliación es que una\n\t// PERSONA aparezca al lado. De ahí el marcador sólo en la segunda.\n\t{\n\t\tcategoria: \"sindical\",\n\t\tpatron: /\\bliberad(?:o|a) sindical\\b|\\bseccion sindical\\b/g,\n\t\texigeMarcador: false,\n\t},\n\t{ categoria: \"sindical\", patron: /\\bhuelga\\b|\\bpiquete\\b/g, exigeMarcador: true },\n\t{\n\t\tcategoria: \"sindical\",\n\t\tpatron:\n\t\t\t/\\bsindicat(?:o|os)\\b|\\bsindicalista\\b|\\bafiliacion sindical\\b|\\bdelegad(?:o|a) sindical\\b|\\bcomite de empresa\\b/g,\n\t\texigeMarcador: false,\n\t},\n\t{\n\t\tcategoria: \"sindical\",\n\t\tpatron: /\\bunion member(?:ship)?\\b|\\btrade union\\b|\\blabou?r union\\b|\\bunioni[sz]ed\\b|\\bshop steward\\b/g,\n\t\texigeMarcador: false,\n\t},\n\n\t// ── Origen étnico o racial (art. 9) ──\n\t{\n\t\tcategoria: \"origen-etnico\",\n\t\tpatron:\n\t\t\t/\\bde origen (?:marroqui|gitan(?:o|a)|magrebi|subsaharian(?:o|a)|arabe|bereber|judi(?:o|a)|latin(?:o|a)|rumen(?:o|a)|rumano|rumana|chin(?:o|a)|african(?:o|a)|asiatic(?:o|a)|indi(?:o|a)|turc(?:o|a)|paquistani|senegales|ecuatorian(?:o|a)|bolivian(?:o|a)|etnic(?:o|a))\\b/g,\n\t\texigeMarcador: false,\n\t},\n\t{\n\t\tcategoria: \"origen-etnico\",\n\t\tpatron:\n\t\t\t/\\betnia\\b|\\bgitan(?:o|a|os|as)\\b|\\bracial origin\\b|\\bethnic (?:origin|group|background|minority)\\b|\\bethnicity\\b|\\borigen racial\\b|\\bminoria etnica\\b/g,\n\t\texigeMarcador: false,\n\t},\n\n\t// ── Religión o creencias (art. 9) ──\n\t{\n\t\tcategoria: \"religion\",\n\t\tpatron:\n\t\t\t/\\bmusulman(?:a|es|as)?\\b|\\bmuslim\\b|\\bislamic(?:o|a)?\\b|\\bcatolic(?:o|a|os|as)\\b|\\bcatholic\\b|\\bevangelic(?:o|a)\\b|\\bprotestante\\b|\\bjudi(?:o|a)\\b|\\bjewish\\b|\\bhindu\\b|\\bbudista\\b|\\bbuddhist\\b|\\btestigo de jehova\\b|\\bate(?:o|a)\\b/g,\n\t\texigeMarcador: false,\n\t},\n\t// `agnostico` sale de la lista: medido, en `src` aparece una vez y es\n\t// «agnóstico de proveedor». La creencia religiosa que hay que cazar es la\n\t// que se declara, no la que se niega con una palabra que además es jerga.\n\t{\n\t\tcategoria: \"religion\",\n\t\tpatron:\n\t\t\t/\\bcreencias religiosas\\b|\\breligious belief(?:s)?\\b|\\bconviccion religiosa\\b|\\bpractica religiosa\\b|\\bmotivos religiosos\\b|\\bramadan\\b|\\bkosher\\b|\\bhalal\\b|\\bva a misa\\b|\\bbautizad(?:o|a)\\b/g,\n\t\texigeMarcador: false,\n\t},\n\n\t// ── Opiniones políticas (art. 9) ──\n\t{\n\t\tcategoria: \"opinion-politica\",\n\t\tpatron:\n\t\t\t/\\bvotante de\\b|\\bvot(?:a|o|e) a\\b|\\bvoted for\\b|\\bmilitante de\\b|\\bsimpatizante de\\b|\\bafiliad(?:o|a) al partido\\b/g,\n\t\texigeMarcador: false,\n\t},\n\t{\n\t\tcategoria: \"opinion-politica\",\n\t\tpatron:\n\t\t\t/\\bpartido popular\\b|\\bpsoe\\b|\\bizquierda unida\\b|\\bpartido comunista\\b|\\bideologia politica\\b|\\bpolitical (?:opinion|affiliation|party)\\b/g,\n\t\texigeMarcador: false,\n\t},\n\n\t// ── Vida sexual u orientación sexual (art. 9) ──\n\t{\n\t\tcategoria: \"vida-sexual\",\n\t\tpatron:\n\t\t\t/\\bgay\\b|\\blesbian(?:a|as)?\\b|\\bbisexual\\b|\\bhomosexual\\b|\\bheterosexual\\b|\\btransexual\\b|\\btransgener(?:o|a)\\b|\\btransgender\\b|\\bqueer\\b/g,\n\t\texigeMarcador: false,\n\t},\n\t{\n\t\tcategoria: \"vida-sexual\",\n\t\tpatron:\n\t\t\t/\\borientacion sexual\\b|\\bsexual orientation\\b|\\bidentidad de genero\\b|\\bgender identity\\b|\\bpareja de hecho\\b|\\bcivil partnership\\b/g,\n\t\texigeMarcador: false,\n\t},\n\n\t// ── Datos biométricos (art. 9) ──\n\t{\n\t\tcategoria: \"biometrico\",\n\t\tpatron:\n\t\t\t/\\bhuella(?:s)? dactilar(?:es)?\\b|\\breconocimiento facial\\b|\\bfacial recognition\\b|\\bfingerprint scan(?:ner)?\\b|\\biris scan\\b|\\bescaneo de iris\\b|\\bvoiceprint\\b|\\bhuella de voz\\b/g,\n\t\texigeMarcador: false,\n\t},\n\t{\n\t\tcategoria: \"biometrico\",\n\t\tpatron: /\\bdatos biometricos\\b|\\bbiometric data\\b|\\bplantilla biometrica\\b|\\bbiometric template\\b/g,\n\t\texigeMarcador: false,\n\t},\n\n\t// ── Datos genéticos (art. 9) ──\n\t{\n\t\tcategoria: \"genetico\",\n\t\tpatron:\n\t\t\t/\\bperfil genetic(?:o|a)\\b|\\bgenetic (?:profile|test|testing|data|marker)\\b|\\btest genetico\\b|\\bsecuenciacion (?:genetica|del genoma)\\b|\\bgenoma\\b|\\bcariotipo\\b|\\bbrca[12]\\b/g,\n\t\texigeMarcador: false,\n\t},\n\n\t// ── Condenas e infracciones penales (art. 10) ──\n\t{\n\t\tcategoria: \"condenas\",\n\t\tpatron: /\\bantecedentes penales\\b|\\bcriminal record\\b|\\bcertificado de penales\\b|\\bregistro de delincuentes\\b/g,\n\t\texigeMarcador: false,\n\t},\n\t{\n\t\tcategoria: \"condenas\",\n\t\tpatron:\n\t\t\t/\\bcondenad(?:o|a) por\\b|\\bconvicted of\\b|\\bsentenciad(?:o|a) a\\b|\\bsentenced to\\b|\\bimputad(?:o|a) por\\b|\\bproceso penal\\b|\\ben prision por\\b/g,\n\t\texigeMarcador: false,\n\t},\n\t// Las formas que faltaban, medidas: «cumplió condena por robo», «detenido\n\t// por», «orden de alejamiento» y «violencia de género» salían LIMPIAS. Coste\n\t// sobre los 469 ficheros de `src` y 200 commits: CERO.\n\t{\n\t\tcategoria: \"condenas\",\n\t\tpatron:\n\t\t\t/\\bcondena por\\b|\\bcumplio condena\\b|\\bdetenid(?:o|a) por\\b|\\borden de alejamiento\\b|\\bdelito de\\b|\\bviolencia de genero\\b|\\bjuicio penal\\b|\\barrested for\\b|\\bon probation\\b|\\bparole\\b/g,\n\t\texigeMarcador: false,\n\t},\n];\n\n// ─────────────────────────────────────────────────────────────────────────────\n// Identificadores\n// ─────────────────────────────────────────────────────────────────────────────\n\n/**\n * Van sobre el texto ORIGINAL, no sobre el plegado —el plegado ya no distingue\n * `X` de `x`— pero SÍ aceptan minúsculas y los puntos de millar.\n *\n * MEDIDO, y era un agujero de los grandes: `dni 12345678z`, `nie z1234567r`,\n * `es9121000418450200051332` y `DNI 12.345.678-Z` salían LIMPIOS. Las cuatro\n * son formas que produce cualquiera: el punto de millar es como se imprime un\n * DNI en España, y la minúscula es lo que sale de un `toLowerCase()` en\n * cualquier campo de formulario, de un `JSON` normalizado o de una URL.\n *\n * El coste se midió, y no salió gratis: `/Users/31017423z/...` —un directorio\n * de trabajo real, citado en dos ficheros de `src`— tiene ocho cifras y una\n * letra, y PASA el módulo 23. De ahí el `(?<![/\\\\])` y el `(?![/\\\\])`: un token\n * pegado a una barra es un segmento de ruta, no un documento. Con ese guardián\n * la forma insensible a mayúsculas produce CERO hallazgos sobre los 469\n * ficheros `.ts` de `src` y sobre 200 commits.\n */\nconst DNI = /(?<![/\\\\])\\b(\\d{2}\\.?\\d{3}\\.?\\d{3})[ .-]?([A-Za-z])\\b(?![/\\\\])/g;\nconst NIE = /(?<![/\\\\])\\b([XYZxyz])[ .-]?(\\d{7})[ .-]?([A-Za-z])\\b(?![/\\\\])/g;\nconst IBAN = /\\b([A-Za-z]{2}\\d{2}(?:[ ]?[A-Za-z0-9]{4}){3,7}[ ]?[A-Za-z0-9]{0,4})\\b/g;\nconst NSS = /\\b(\\d{2})[ -]?(\\d{8})[ -]?(\\d{2})\\b/g;\n/** Matrícula española desde 2000: cuatro cifras y tres consonantes, sin Ñ ni Q. */\nconst MATRICULA = /\\b\\d{4}[ -]?[BCDFGHJKLMNPRSTVWXYZ]{3}\\b/g;\n\nconst PORQUE_MODULO_23 = \"identificador nacional con letra de control correcta (comprobada, modulo 23)\";\nconst PORQUE_MODULO_97 = \"identificador nacional con digito de control correcto (comprobado, modulo 97)\";\nconst PORQUE_FORMA_PLACA =\n\t\"identificador nacional con la forma exacta de una placa (cuatro cifras y tres consonantes; sin control que comprobar)\";\nconst PORQUE_VOCABULARIO = \"vocabulario de categoria especial sin otra lectura tecnica\";\nconst PORQUE_CON_MARCADOR = `vocabulario ambiguo con un marcador de persona a menos de ${VENTANA} caracteres`;\n\nfunction articuloDe(categoria: CategoriaEspecial): \"9\" | \"10\" {\n\treturn categoria === \"condenas\" ? \"10\" : \"9\";\n}\n\n/**\n * Funde los hallazgos de la MISMA categoría que se solapan.\n *\n * «afiliado al partido popular» dispara dos patrones políticos sobre tramos\n * que se pisan; dos hallazgos para un solo dato inflan el informe del DPO y\n * hacen que redactar sea redactar dos veces lo mismo.\n */\nfunction fundir(hallazgos: HallazgoEspecial[]): HallazgoEspecial[] {\n\tconst ordenados = [...hallazgos].sort((a, b) => a.desde - b.desde || a.hasta - b.hasta);\n\tconst salida: HallazgoEspecial[] = [];\n\tfor (const h of ordenados) {\n\t\tconst previo = salida.find((p) => p.categoria === h.categoria && h.desde < p.hasta && p.desde < h.hasta);\n\t\tif (previo) {\n\t\t\tprevio.desde = Math.min(previo.desde, h.desde);\n\t\t\tprevio.hasta = Math.max(previo.hasta, h.hasta);\n\t\t\tcontinue;\n\t\t}\n\t\tsalida.push({ ...h });\n\t}\n\treturn salida.sort((a, b) => a.desde - b.desde);\n}\n\n/**\n * Busca categorías especiales del art. 9 y condenas del art. 10.\n *\n * TRES ESTADOS, no dos:\n *   · lista con hallazgos → hay datos de categoría especial;\n *   · lista vacía → he mirado el texto entero y no hay;\n *   · `TextoNoAnalizable` → no he podido mirar. Nunca se confunde con la vacía.\n *\n * Ningún campo del hallazgo lleva el texto detectado; sólo su posición y la\n * forma que lo disparó.\n */\nexport function categoriasEspeciales(texto: string): HallazgoEspecial[] {\n\tif (typeof texto !== \"string\") {\n\t\tthrow new TextoNoAnalizable(\"no-es-cadena\", `llego un ${texto === null ? \"null\" : typeof texto}`);\n\t}\n\tif (texto.length > LIMITE_CARACTERES) {\n\t\tthrow new TextoNoAnalizable(\"demasiado-largo\", `${texto.length} caracteres, el limite es ${LIMITE_CARACTERES}`);\n\t}\n\n\tconst hallazgos: HallazgoEspecial[] = [];\n\tconst plegado = plegar(texto);\n\tconst marcadores = marcadoresDe(plegado, texto);\n\n\tfor (const termino of TERMINOS) {\n\t\t// Plegado y original tienen la MISMA longitud, así que los índices de uno\n\t\t// sirven para el otro y para el cálculo de distancia al marcador.\n\t\tconst donde = termino.sobreOriginal ? texto : plegado;\n\t\tfor (const m of donde.matchAll(termino.patron)) {\n\t\t\tconst tramo = { desde: m.index, hasta: m.index + m[0].length };\n\t\t\tif (termino.exigeMarcador && !tieneMarcadorCerca(tramo, marcadores)) continue;\n\t\t\thallazgos.push({\n\t\t\t\tcategoria: termino.categoria,\n\t\t\t\tarticulo: articuloDe(termino.categoria),\n\t\t\t\tdesde: tramo.desde,\n\t\t\t\thasta: tramo.hasta,\n\t\t\t\tporque: termino.exigeMarcador ? PORQUE_CON_MARCADOR : PORQUE_VOCABULARIO,\n\t\t\t});\n\t\t}\n\t}\n\n\t// Identificadores: la forma sólo abre la puerta; entra el que valida.\n\tfor (const m of texto.matchAll(DNI)) {\n\t\tif (!dniValido(m[1] as string, m[2] as string)) continue;\n\t\thallazgos.push({\n\t\t\tcategoria: \"identificador-nacional\",\n\t\t\tarticulo: \"9\",\n\t\t\tdesde: m.index,\n\t\t\thasta: m.index + m[0].length,\n\t\t\tporque: PORQUE_MODULO_23,\n\t\t});\n\t}\n\tfor (const m of texto.matchAll(NIE)) {\n\t\tif (!nieValido(m[1] as string, m[2] as string, m[3] as string)) continue;\n\t\thallazgos.push({\n\t\t\tcategoria: \"identificador-nacional\",\n\t\t\tarticulo: \"9\",\n\t\t\tdesde: m.index,\n\t\t\thasta: m.index + m[0].length,\n\t\t\tporque: PORQUE_MODULO_23,\n\t\t});\n\t}\n\tfor (const m of texto.matchAll(IBAN)) {\n\t\tconst candidato = (m[1] as string).trimEnd();\n\t\tif (!ibanValido(candidato)) continue;\n\t\thallazgos.push({\n\t\t\tcategoria: \"identificador-nacional\",\n\t\t\tarticulo: \"9\",\n\t\t\tdesde: m.index,\n\t\t\thasta: m.index + candidato.length,\n\t\t\tporque: PORQUE_MODULO_97,\n\t\t});\n\t}\n\tfor (const m of texto.matchAll(NSS)) {\n\t\tif (!nssValido(m[1] as string, m[2] as string, m[3] as string)) continue;\n\t\thallazgos.push({\n\t\t\tcategoria: \"identificador-nacional\",\n\t\t\tarticulo: \"9\",\n\t\t\tdesde: m.index,\n\t\t\thasta: m.index + m[0].length,\n\t\t\tporque: PORQUE_MODULO_97,\n\t\t});\n\t}\n\tfor (const m of texto.matchAll(MATRICULA)) {\n\t\thallazgos.push({\n\t\t\tcategoria: \"identificador-nacional\",\n\t\t\tarticulo: \"9\",\n\t\t\tdesde: m.index,\n\t\t\thasta: m.index + m[0].length,\n\t\t\tporque: PORQUE_FORMA_PLACA,\n\t\t});\n\t}\n\n\treturn fundir(hallazgos);\n}\n\n/** Con lo que se sustituye cada tramo. El mismo bloque que usa `redactSensitive`. */\nconst BLOQUE = \"█\";\n\n/**\n * Devuelve el texto con los tramos hallados —y SÓLO ésos— sustituidos por\n * bloques.\n *\n * Es lo que le falta hoy a `redactSensitive`: medido,\n * `redactSensitive(\"baja por depresión, afiliado a CCOO, HIV positive\",\n * \"strict\")` devuelve la cadena idéntica, y esa función alimenta el libro de\n * auditoría y el diario de edición.\n *\n * DOS DECISIONES, las dos deliberadas:\n *\n *   · El bloque tiene la MISMA longitud que el tramo. Un texto tapado que\n *     encoge delata dónde estaba el dato al comparar con el original, y además\n *     rompe cualquier índice que alguien haya guardado sobre el texto.\n *   · No se escribe la categoría en el hueco. Poner «[salud]» taparía el dato y\n *     publicaría el diagnóstico: que hay información de salud sobre esta\n *     persona ya es, por sí solo, una categoría especial. La categoría va en el\n *     hallazgo, que es para el DPO; el texto tapado es para todos los demás.\n *\n * Un texto sin hallazgos sale idéntico byte a byte —se devuelve el mismo\n * objeto—, y `TextoNoAnalizable` sube igual que en `categoriasEspeciales`:\n * devolver aquí el texto sin tocar sería devolver el original en claro\n * creyendo haberlo tapado.\n */\nexport function taparCategoriasEspeciales(texto: string): string {\n\tconst hallazgos = categoriasEspeciales(texto);\n\tif (hallazgos.length === 0) return texto;\n\n\t// Los hallazgos vienen ordenados por `desde`, pero `fundir` sólo une los de\n\t// la MISMA categoría: dos categorías distintas pueden pisarse («judío» es\n\t// origen étnico y religión a la vez). El cursor evita tapar dos veces el\n\t// mismo trozo, que duplicaría bloques y alargaría el texto.\n\tlet salida = \"\";\n\tlet cursor = 0;\n\tfor (const h of hallazgos) {\n\t\tif (h.hasta <= cursor) continue;\n\t\tconst desde = Math.max(h.desde, cursor);\n\t\tsalida += texto.slice(cursor, desde) + BLOQUE.repeat(h.hasta - desde);\n\t\tcursor = h.hasta;\n\t}\n\treturn salida + texto.slice(cursor);\n}\n"]}