pdf.js 4.x vendorizado y pruebas del extractor de PDF

La 3.x leía mal los CMap `ToUnicode` con destinos de un byte —fuera de
especificación, pero los emiten informes de laboratorio reales generados con
Ghostscript— y devolvía cada carácter desplazado 8 bits ('H' → U+4800), con lo
que la importación fallaba entera con «No se encontraron datos reconocibles».
El desplazamiento NO se puede reparar a posteriori: el '0' desplazado cae en
U+3000 y el extractor lo normaliza a espacio, así que una ALT de 260 U/L se
leería como 26. Por eso `textoIlegible()` detecta el caso y aborta en vez de
importar números equivocados.

pdf.js 4+ se distribuye como módulo ES y ya no publica `window.pdfjsLib`, de ahí
el paso de .js a .mjs y la carga dinámica. La versión es un invariante: los
ficheros de `assets/lib/pdfjs/` se copian de la devDependency con
`npm run vendor-pdfjs` para que navegador y pruebas usen la misma.

`frontend/tests/pdf-parser.test.ts` fija todo esto con un PDF construido con esa
anomalía, y cubre la ventana de aceptación de valores: sólo en la línea de su
etiqueta o en la `RESULTADO` que sigue a su cabecera (la ventana ciega anterior
importaba el cociente A/G como albúmina).

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>

frontend/package-lock.json

@@ -13,6 +13,7 @@
         "@typescript-eslint/parser": "^8.20.0",
         "eslint": "^9.18.0",
         "jsdom": "^29.1.1",
+        "pdfjs-dist": "^6.2.108",
         "typescript": "^5.7.3",
         "vite": "^6.0.7",
         "vitest": "^3.0.2"
@@ -958,6 +959,283 @@
       "dev": true,
       "license": "MIT"
     },
+    "node_modules/@napi-rs/canvas": {
+      "version": "1.0.3",
+      "resolved": "https://registry.npmjs.org/@napi-rs/canvas/-/canvas-1.0.3.tgz",
+      "integrity": "sha512-OlI657a5XXvKGFX7kNeIzJ8rO7IXt87Mqu2H8rXE46viAuOfum/JA7ysX7+eBhxNKznT+RCZh418mndlcFX3+w==",
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "workspaces": [
+        "e2e/*"
+      ],
+      "engines": {
+        "node": ">= 10"
+      },
+      "funding": {
+        "type": "github",
+        "url": "https://github.com/sponsors/Brooooooklyn"
+      },
+      "optionalDependencies": {
+        "@napi-rs/canvas-android-arm64": "1.0.3",
+        "@napi-rs/canvas-darwin-arm64": "1.0.3",
+        "@napi-rs/canvas-darwin-x64": "1.0.3",
+        "@napi-rs/canvas-linux-arm-gnueabihf": "1.0.3",
+        "@napi-rs/canvas-linux-arm64-gnu": "1.0.3",
+        "@napi-rs/canvas-linux-arm64-musl": "1.0.3",
+        "@napi-rs/canvas-linux-riscv64-gnu": "1.0.3",
+        "@napi-rs/canvas-linux-x64-gnu": "1.0.3",
+        "@napi-rs/canvas-linux-x64-musl": "1.0.3",
+        "@napi-rs/canvas-win32-arm64-msvc": "1.0.3",
+        "@napi-rs/canvas-win32-x64-msvc": "1.0.3"
+      }
+    },
+    "node_modules/@napi-rs/canvas-android-arm64": {
+      "version": "1.0.3",
+      "resolved": "https://registry.npmjs.org/@napi-rs/canvas-android-arm64/-/canvas-android-arm64-1.0.3.tgz",
+      "integrity": "sha512-7kSCdUhoXiO+AaIMXdBGdtp6EctZNkmF62Rea/BmVQlwKaM3bBhOzyGUzxyxz9dv5vdBfpyAaxhSRSJF4kqK4A==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "android"
+      ],
+      "engines": {
+        "node": ">= 10"
+      },
+      "funding": {
+        "type": "github",
+        "url": "https://github.com/sponsors/Brooooooklyn"
+      }
+    },
+    "node_modules/@napi-rs/canvas-darwin-arm64": {
+      "version": "1.0.3",
+      "resolved": "https://registry.npmjs.org/@napi-rs/canvas-darwin-arm64/-/canvas-darwin-arm64-1.0.3.tgz",
+      "integrity": "sha512-ds14V1BPagLszQyaDTeggny5fNeTCqsUQ5QhFj9VDxSEfzrVxXtdbR0LoFyKa0Siaaw8KvqSk4t7k/WoZJwvbg==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "darwin"
+      ],
+      "engines": {
+        "node": ">= 10"
+      },
+      "funding": {
+        "type": "github",
+        "url": "https://github.com/sponsors/Brooooooklyn"
+      }
+    },
+    "node_modules/@napi-rs/canvas-darwin-x64": {
+      "version": "1.0.3",
+      "resolved": "https://registry.npmjs.org/@napi-rs/canvas-darwin-x64/-/canvas-darwin-x64-1.0.3.tgz",
+      "integrity": "sha512-qof3LRAAycmkV2I1izZo9RoSHF8kCQr5O05sFwv0jK8rSdYV6KHVwimo6Qb7RxZj40WHKbLHm5JDaUF0o5XUAA==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "darwin"
+      ],
+      "engines": {
+        "node": ">= 10"
+      },
+      "funding": {
+        "type": "github",
+        "url": "https://github.com/sponsors/Brooooooklyn"
+      }
+    },
+    "node_modules/@napi-rs/canvas-linux-arm-gnueabihf": {
+      "version": "1.0.3",
+      "resolved": "https://registry.npmjs.org/@napi-rs/canvas-linux-arm-gnueabihf/-/canvas-linux-arm-gnueabihf-1.0.3.tgz",
+      "integrity": "sha512-FU2kKZLmolHA9+KcUA+l1+xH3WTLUUTQDU/kLv9SEUr2TrRPu94aytOeizFJDHPs/QBcw4QL1mCQhetQXYBbag==",
+      "cpu": [
+        "arm"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">= 10"
+      },
+      "funding": {
+        "type": "github",
+        "url": "https://github.com/sponsors/Brooooooklyn"
+      }
+    },
+    "node_modules/@napi-rs/canvas-linux-arm64-gnu": {
+      "version": "1.0.3",
+      "resolved": "https://registry.npmjs.org/@napi-rs/canvas-linux-arm64-gnu/-/canvas-linux-arm64-gnu-1.0.3.tgz",
+      "integrity": "sha512-GVSjntxKeA+/y/ZKf1F+cmUw1WeIkE5aMRPqnZUlBTBvBcrvgWccJAWuYCKPX4QJQwZILIIwhgdAbl51yj6fpA==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "libc": [
+        "glibc"
+      ],
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">= 10"
+      },
+      "funding": {
+        "type": "github",
+        "url": "https://github.com/sponsors/Brooooooklyn"
+      }
+    },
+    "node_modules/@napi-rs/canvas-linux-arm64-musl": {
+      "version": "1.0.3",
+      "resolved": "https://registry.npmjs.org/@napi-rs/canvas-linux-arm64-musl/-/canvas-linux-arm64-musl-1.0.3.tgz",
+      "integrity": "sha512-J51oK/axyZ13kxycumSMfLiDZMdWdOVvqDFI28BpuViZHE3A0bQfr8B5vg8YnPEnqLD3BSn1hkdlh2buspEcNQ==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "libc": [
+        "musl"
+      ],
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">= 10"
+      },
+      "funding": {
+        "type": "github",
+        "url": "https://github.com/sponsors/Brooooooklyn"
+      }
+    },
+    "node_modules/@napi-rs/canvas-linux-riscv64-gnu": {
+      "version": "1.0.3",
+      "resolved": "https://registry.npmjs.org/@napi-rs/canvas-linux-riscv64-gnu/-/canvas-linux-riscv64-gnu-1.0.3.tgz",
+      "integrity": "sha512-CtQgQjoVTX67jS9XuCTtJ40Sl7wRLMguoFnnGnfDmCWf7kzKFZVwj5ynqUOIGKFMSB61ZCuQlwPvVNxYTTseaw==",
+      "cpu": [
+        "riscv64"
+      ],
+      "dev": true,
+      "libc": [
+        "glibc"
+      ],
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">= 10"
+      },
+      "funding": {
+        "type": "github",
+        "url": "https://github.com/sponsors/Brooooooklyn"
+      }
+    },
+    "node_modules/@napi-rs/canvas-linux-x64-gnu": {
+      "version": "1.0.3",
+      "resolved": "https://registry.npmjs.org/@napi-rs/canvas-linux-x64-gnu/-/canvas-linux-x64-gnu-1.0.3.tgz",
+      "integrity": "sha512-jtfzAHFp+FRaR7zGT4jyCe6wUgAG/dVb5A4Apd8FY9jKarntDfUAlJXscugiH7ZF5kKnu7/lHFk9LaDPcrGEVQ==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "libc": [
+        "glibc"
+      ],
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">= 10"
+      },
+      "funding": {
+        "type": "github",
+        "url": "https://github.com/sponsors/Brooooooklyn"
+      }
+    },
+    "node_modules/@napi-rs/canvas-linux-x64-musl": {
+      "version": "1.0.3",
+      "resolved": "https://registry.npmjs.org/@napi-rs/canvas-linux-x64-musl/-/canvas-linux-x64-musl-1.0.3.tgz",
+      "integrity": "sha512-xTzaUCKUHTY4bCGadeeRZggbRVbGUT1petg7Z8r9AJR2+D9Bqu6nQAgqBGC6D47tA70LjaaaLTrJ7wNY1T74dg==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "libc": [
+        "musl"
+      ],
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">= 10"
+      },
+      "funding": {
+        "type": "github",
+        "url": "https://github.com/sponsors/Brooooooklyn"
+      }
+    },
+    "node_modules/@napi-rs/canvas-win32-arm64-msvc": {
+      "version": "1.0.3",
+      "resolved": "https://registry.npmjs.org/@napi-rs/canvas-win32-arm64-msvc/-/canvas-win32-arm64-msvc-1.0.3.tgz",
+      "integrity": "sha512-ktVLuBkI6QVOm5BwO/WbdGwxgeetAMJa7TTmR8qBarXF0OU2NKjvjUtPJAl2y8t+zBRczJl/1VOl9gua6WcK2g==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "win32"
+      ],
+      "engines": {
+        "node": ">= 10"
+      },
+      "funding": {
+        "type": "github",
+        "url": "https://github.com/sponsors/Brooooooklyn"
+      }
+    },
+    "node_modules/@napi-rs/canvas-win32-x64-msvc": {
+      "version": "1.0.3",
+      "resolved": "https://registry.npmjs.org/@napi-rs/canvas-win32-x64-msvc/-/canvas-win32-x64-msvc-1.0.3.tgz",
+      "integrity": "sha512-SGhlQ8bDjL1Cz2KnsKMasr/5sTcwG/SZkB6WCJxLsmSm/3aS2C+3p39bA7iZ2/94+NkVDySZfbiGoaSZSFHYxA==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "win32"
+      ],
+      "engines": {
+        "node": ">= 10"
+      },
+      "funding": {
+        "type": "github",
+        "url": "https://github.com/sponsors/Brooooooklyn"
+      }
+    },
     "node_modules/@rollup/rollup-android-arm-eabi": {
       "version": "4.62.2",
       "resolved": "https://registry.npmjs.org/@rollup/rollup-android-arm-eabi/-/rollup-android-arm-eabi-4.62.2.tgz",
@@ -2898,6 +3176,19 @@
         "node": ">= 14.16"
       }
     },
+    "node_modules/pdfjs-dist": {
+      "version": "6.2.108",
+      "resolved": "https://registry.npmjs.org/pdfjs-dist/-/pdfjs-dist-6.2.108.tgz",
+      "integrity": "sha512-YxFb+SQcodN2rnX9Tn3dHYlqfb7NjlzzfONPpJd+AKoKtUjEdevTfbC07d5TcczzOK6261auRkP/M8OBHs9vFQ==",
+      "dev": true,
+      "license": "Apache-2.0",
+      "engines": {
+        "node": ">=22.13.0 || >=24"
+      },
+      "optionalDependencies": {
+        "@napi-rs/canvas": "^1.0.0"
+      }
+    },
     "node_modules/picocolors": {
       "version": "1.1.1",
       "resolved": "https://registry.npmjs.org/picocolors/-/picocolors-1.1.1.tgz",

frontend/package.json

@@ -8,6 +8,7 @@
     "dev": "vite",
     "build": "tsc --noEmit && vite build && npm run copy-assets",
     "copy-assets": "mkdir -p ../dist/assets && cp -R ../assets/. ../dist/assets/",
+    "vendor-pdfjs": "cp node_modules/pdfjs-dist/build/pdf.min.mjs node_modules/pdfjs-dist/build/pdf.worker.min.mjs ../assets/lib/pdfjs/",
     "preview": "vite preview",
     "test": "vitest run",
     "test:watch": "vitest",
@@ -20,6 +21,7 @@
     "@typescript-eslint/parser": "^8.20.0",
     "eslint": "^9.18.0",
     "jsdom": "^29.1.1",
+    "pdfjs-dist": "^6.2.108",
     "typescript": "^5.7.3",
     "vite": "^6.0.7",
     "vitest": "^3.0.2"

frontend/src/main.ts

@@ -6,6 +6,7 @@ import { analizarResultados } from './analisis.js';
 import { colapsarPatrones, inicializarSincMob, imagenesDataUrl, capturasMicroscopio } from './ui.js';
 import { llamarIA, inicializarConfigBackend } from './ia.js';
 import { inicializarParserPdf } from './pdf-parser.js';
+import { inicializarPanelesVacios } from './panel-vacio.js';
 import { inicializarImportLab } from './lab-import.js';
 import { verificarAuth, abrirModalAuth } from './auth.js';
 import { abrirModalPapers, inicializarModalPapers } from './papers.js';
@@ -33,6 +34,7 @@ if (btnTema) {
 let referencias: Referencias = {};
 let alteraciones: Alteraciones = {};
 let ultimoAnalisis: ResultadoAnalisis = { hallazgos: [], patrones: [] };
+let ultimosMedidos: string[] = [];
 
 const cargarReferencias = async (): Promise<void> => {
   try {
@@ -144,6 +146,9 @@ const evaluar = (): void => {
   const valores = obtenerValoresFormulario();
   const { hallazgos, patrones } = analizarResultados(valores, paciente, referencias, alteraciones);
   ultimoAnalisis = { hallazgos, patrones };
+  // Los medidos van aparte y NO dentro de ResultadoAnalisis: eso es la salida del motor, que
+  // sólo devuelve lo alterado. Aquí interesa el panel completo, incluidos los valores en rango.
+  ultimosMedidos = Object.keys(valores);
 
   actualizarClasesInputs(hallazgos);
   renderizarPatrones(patrones);
@@ -170,6 +175,7 @@ elId<HTMLSelectElement>('pt-sexo').addEventListener('change', evaluar);
 
 inicializarSincMob(evaluar);
 void inicializarConfigBackend();  // pide la lista de modelos al servidor; no bloquea el arranque
+inicializarPanelesVacios();
 inicializarParserPdf(evaluar);
 inicializarImportLab(evaluar);
 inicializarModalPapers();
@@ -202,7 +208,10 @@ const imagenesActuales = (): string[] =>
 const dispararIA = (): void => {
   colapsarPatrones(true);
   // Se encola desde un callback síncrono (abrirModalAuth), así que no se puede await aquí.
-  sinEsperar('Análisis IA', llamarIA(obtenerDatosPaciente, () => ultimoAnalisis, imagenesActuales));
+  sinEsperar(
+    'Análisis IA',
+    llamarIA(obtenerDatosPaciente, () => ({ ...ultimoAnalisis, medidos: ultimosMedidos }), imagenesActuales),
+  );
 };
 
 const botonAnalizar = document.querySelector<HTMLElement>('.boton-analizar');

frontend/src/pdf-parser.ts

@@ -4,7 +4,8 @@
 import { aplicarValoresAFormulario, aplicarPacienteAFormulario, mostrarToast } from './form-inject.js';
 import { manejadorAsync } from './async.js';
 
-const PDFJS_WORKER = 'assets/lib/pdfjs/pdf.worker.min.js';
+const PDFJS_MODULO = 'assets/lib/pdfjs/pdf.min.mjs';
+const PDFJS_WORKER = 'assets/lib/pdfjs/pdf.worker.min.mjs';
 
 interface AnalitoDef { campo: string; re: RegExp; claveConv?: string }
 interface ConversionRegla { re: RegExp; factor: number | ((v: number) => number) }
@@ -12,14 +13,16 @@ type Resultados = Record<string, number | string>;
 
 interface PdfjsLib {
   GlobalWorkerOptions: { workerSrc: string };
-  getDocument(opts: { data: ArrayBuffer }): { promise: Promise<PdfDoc> };
+  getDocument(opts: { data: ArrayBuffer | Uint8Array }): { promise: Promise<PdfDoc> };
 }
 interface PdfDoc { numPages: number; getPage(n: number): Promise<PdfPage> }
 interface PdfPage { getTextContent(): Promise<{ items: Array<{ str: string; hasEOL?: boolean }> }> }
 
 const DEFS_ANALITOS: AnalitoDef[] = [
   // Hematología: Serie Roja
-  { campo: 'rbc', re: /\b(?:eritrocit\w*|gl[oó]bulos?\s+rojos?|r\.?b\.?c\.?|eri)\b/i },
+  // `hematies` es como lo etiquetan los laboratorios españoles (el texto llega ya sin acentos,
+  // ver `sinAcentos`).
+  { campo: 'rbc', re: /\b(?:eritrocit\w*|hematies|gl[oó]bulos?\s+rojos?|r\.?b\.?c\.?|eri)\b/i },
   { campo: 'hgb', re: /\b(?:hemoglobin[ao]?\w*|hgb|hb)\b(?!a\d)/i },
   { campo: 'hct', re: /\b(?:hematocrit[oo]?\w*|hct|pcv)\b/i },
   { campo: 'vcm', re: /\b(?:v\.?c\.?m\.?|m\.?c\.?v\.?|vol(?:umen)?\s+corp\w*)\b/i },
@@ -34,7 +37,10 @@ const DEFS_ANALITOS: AnalitoDef[] = [
   // Hematología: Serie Blanca
   { campo: 'wbc', re: /\b(?:leucocit\w*|w\.?b\.?c\.?|white\s+blood\s+cell|leu)\b/i },
   { campo: 'neutro_abs', re: /\bgran?#/i },
-  { campo: 'neutro', re: /\b(?:neutr[oó]fil\w*|neut\b|neu\b|gran?(?!#))\b/i },
+  // «SEGMENTADOS» es como los informes españoles nombran a los neutrófilos maduros; sin él la
+  // fórmula leucocitaria de esos informes se importaba sin neutrófilos, que es el dato que más
+  // pesa en la detección de inflamación.
+  { campo: 'neutro', re: /\b(?:neutr[oó]fil\w*|segmentad\w*|neut\b|neu\b|gran?(?!#))\b/i },
   { campo: 'linfo_abs', re: /\blymp?#/i },
   { campo: 'linfo', re: /\b(?:linf[oa]cit\w*|lymph\w*|linf\b|lym(?!#))\b/i },
   { campo: 'mono_abs', re: /\bmon\w*#/i },
@@ -88,12 +94,13 @@ const DEFS_ANALITOS: AnalitoDef[] = [
 
   // Bioquímica: Enzimas
   { campo: 'lipasa', re: /\b(?:lipas[ae]\b|lipa\b)\b/i },
-  { campo: 'ck', re: /\b(?:c\.?k\.?\b|creatina?\s+kinas[ae]|creatine\s+kinas[ae])\b/i },
+  // «CREATINKINASA», en una palabra, es como la etiquetan los informes españoles.
+  { campo: 'ck', re: /\b(?:c\.?k\.?\b|creatin[ae]?\s*kinas[ae]|creatine\s+kinas[ae])\b/i },
 
   // Perfil Endocrino
   { campo: 'cortisol_bas', re: /\b(?:cortisol\s+bas[ae]?l?)\b/i },
   { campo: 'cortisol_acth', re: /\b(?:cortisol\s+(?:post[-\s]?acth|post)\b)/i },
-  { campo: 't4_total', re: /\b(?:t4\s+total|t4\s+libre|tiroxin\w*|thyroxin\w*)\b/i },
+  { campo: 't4_total', re: /\b(?:t4(?:\s+(?:total|libre))?|tiroxin\w*|thyroxin\w*)\b/i },
   { campo: 'insulina', re: /\b(?:insulin[ao]?\w*)\b/i },
 
   // Urianálisis
@@ -167,11 +174,20 @@ function aplicarConversion(campo: string, claveConv: string | undefined, value:
   return value;
 }
 
-function extraerValorYUnidad(contexto: string): { num: number | null; unit: string } {
+// Campos donde 0 es un resultado clínico legítimo y no ruido de parseo. En el resto se sigue
+// descartando: un 0 suelto suele venir de una fecha o un número de página, no de una medición.
+// «BASÓFILOS 0 %» es la lectura normal de un hemograma sano y se estaba tirando.
+const PERMITEN_CERO = new Set([
+  'neutro', 'neutro_abs', 'linfo', 'linfo_abs', 'mono', 'mono_abs',
+  'eosino', 'eosino_abs', 'baso', 'baso_abs', 'reti', 'reti_abs', 'nrbc',
+]);
+
+function extraerValorYUnidad(contexto: string, campo = ''): { num: number | null; unit: string } {
   const m = contexto.match(/[<>≤≥]?\s*(\d+(?:[.,]\d+)?)([\s\S]*)/);
   if (!m) return { num: null, unit: '' };
   const v = parseFloat(m[1].replace(',', '.'));
-  if (!isFinite(v) || v <= 0) return { num: null, unit: '' };
+  const minimo = PERMITEN_CERO.has(campo) ? 0 : Number.MIN_VALUE;
+  if (!isFinite(v) || v < minimo) return { num: null, unit: '' };
   return { num: v, unit: m[2].slice(0, 50) };
 }
 
@@ -185,17 +201,91 @@ function parsearSemiCuantitativo(text: string): string | null {
   return null;
 }
 
-function parsearTextoLab(textoCrudo: string): Resultados {
+// Los informes españoles escriben los analitos en mayúsculas Y acentuados (EOSINÓFILOS,
+// BASÓFILOS, HEMATÍES). `\w` no cubre 'Ó', así que `eosino\w*` no casa con «EOSINÓFILOS» y toda
+// la fórmula leucocitaria se perdía. Se quitan los diacríticos ANTES de buscar; las posiciones
+// se conservan porque NFD + borrado de marcas no cambia el número de caracteres base.
+function sinAcentos(texto: string): string {
+  return texto.normalize('NFD').replace(/\p{M}/gu, '');
+}
+
+// Dónde puede estar el valor de una etiqueta. Antes era una ventana ciega de 150 caracteres, que
+// se saltaba líneas y secciones enteras: medido con un informe real, «densidad urinaria» —citada
+// de pasada en el párrafo interpretativo del SDMA— capturaba el resultado de la CREATINKINASA
+// dos líneas más abajo e importaba una densidad urinaria de 90 en una analítica sin orina. Un
+// valor equivocado es peor que un valor ausente: el que falta se ve, el que sobra se interpreta.
+//
+// Las dos disposiciones reales son:
+//   1. En la misma línea:  `HEMATOCRITO....... 48,1 %`
+//   2. Bajo una cabecera:  `CREATININA / SUERO` / `Química seca - …` / `RESULTADO....... 1,73`
+// Así que se lee el resto de la línea y, si no hay número, se avanza hasta una línea RESULTADO,
+// parando en cuanto aparece otra cabecera en mayúsculas (es decir, otro analito).
+const MAX_LINEAS_BUSCADAS = 6;
+const RE_LINEA_RESULTADO = /^\s*(?:resultado|result)\b/i;
+
+function esCabecera(linea: string): boolean {
+  const letras = linea.replace(/[^A-Za-zÁÉÍÓÚÑáéíóúñ]/g, '');
+  if (letras.length < 3) return false;
+  return letras === letras.toUpperCase();
+}
+
+// Se prueban TODAS las apariciones de la etiqueta, no sólo la primera, y gana la primera que
+// venga acompañada de un número. Los informes nombran el analito antes de medirlo —«FÓRMULA
+// LEUCOCITARIA» es el título de la sección y «LEUCOCITOS....... 7.510» el dato—, así que quedarse
+// con la primera aparición perdía el valor. El orden importa: si la primera sí trae número, es la
+// que se usa, igual que antes.
+const MAX_APARICIONES = 5;
+const globales = new Map<RegExp, RegExp>();
+
+function comoGlobal(re: RegExp): RegExp {
+  let g = globales.get(re);
+  if (!g) {
+    g = new RegExp(re.source, re.flags.includes('g') ? re.flags : re.flags + 'g');
+    globales.set(re, g);
+  }
+  g.lastIndex = 0;
+  return g;
+}
+
+function primerValorDe(texto: string, def: AnalitoDef): number | null {
+  const re = comoGlobal(def.re);
+  for (let i = 0; i < MAX_APARICIONES; i++) {
+    const match = re.exec(texto);
+    if (!match) return null;
+    const contexto = contextoDeValor(texto, match.index + match[0].length);
+    const { num, unit } = extraerValorYUnidad(contexto, def.campo);
+    if (num !== null) return aplicarConversion(def.campo, def.claveConv, num, unit);
+  }
+  return null;
+}
+
+function contextoDeValor(texto: string, desde: number): string {
+  const lineas = texto.slice(desde, desde + 600).split('\n');
+  const resto = lineas[0] ?? '';
+  if (/\d/.test(resto)) return resto;
+
+  for (const linea of lineas.slice(1, MAX_LINEAS_BUSCADAS)) {
+    if (RE_LINEA_RESULTADO.test(linea)) return linea;
+    // Otra cabecera en mayúsculas o una línea que YA trae un número: en ambos casos lo que
+    // viene después pertenece a otro analito. Sin la segunda condición, «COCIENTE ALBÚMINA /
+    // GLOBULINA» se saltaba la línea `ALBUMINA... 40 g/L` y se quedaba con el RESULTADO de
+    // debajo, que es el cociente A/G (1,11) y no la albúmina.
+    if (esCabecera(linea) || /\d/.test(linea)) break;
+  }
+  return '';
+}
+
+// Exportadas para las pruebas: son puras (texto → datos) y concentran toda la lógica de
+// reconocimiento, que es donde han estado los fallos.
+export function parsearTextoLab(textoCrudo: string): Resultados {
   const resultados: Resultados = {};
+  const texto = sinAcentos(textoCrudo);
 
   for (const def of DEFS_ANALITOS) {
     if (resultados[def.campo] !== undefined) continue;
-    const match = def.re.exec(textoCrudo);
-    if (!match) continue;
-    const contexto = textoCrudo.slice(match.index + match[0].length, match.index + match[0].length + 150);
-    const { num, unit } = extraerValorYUnidad(contexto);
-    if (num === null) continue;
-    resultados[def.campo] = aplicarConversion(def.campo, def.claveConv, num, unit);
+    const encontrado = primerValorDe(texto, def);
+    if (encontrado === null) continue;
+    resultados[def.campo] = encontrado;
   }
 
   // Derivar % desde conteos absolutos si el % no se encontro directamente y se conoce el WBC
@@ -220,9 +310,9 @@ function parsearTextoLab(textoCrudo: string): Resultados {
 
   for (const def of DEFS_SEMICUANTITATIVOS) {
     if (resultados[def.campo] !== undefined) continue;
-    const match = def.re.exec(textoCrudo);
+    const match = def.re.exec(texto);
     if (!match) continue;
-    const contexto = textoCrudo.slice(match.index, match.index + 80);
+    const contexto = texto.slice(match.index, match.index + 80);
     const val = parsearSemiCuantitativo(contexto);
     if (val) resultados[def.campo] = val;
   }
@@ -266,7 +356,7 @@ function inferEspecie(raza: string): string | null {
   return null;
 }
 
-function parsearTextoPaciente(textoCrudo: string): PacientePdf {
+export function parsearTextoPaciente(textoCrudo: string): PacientePdf {
   const p: PacientePdf = {};
 
   const coincEsp = textoCrudo.match(/\b(?:especies?|species|tipo(?:\s+de)?\s+animal)\s*:?\s{0,4}([A-Za-záéíóúÁÉÍÓÚñÑ]{3,20})/i);
@@ -276,6 +366,17 @@ function parsearTextoPaciente(textoCrudo: string): PacientePdf {
     else if (/fel[io]|gat[ao]|cat/.test(v)) p.especie = 'Felino';
   }
 
+  // Muchos informes no rotulan «Especie:»: escriben el nombre científico o el común junto al
+  // nombre del animal («EDNA / Perra, Canis lupus familiaris»). Se busca sólo si la etiqueta
+  // explícita no dio nada, para que ésta siga mandando.
+  if (!p.especie) {
+    if (/\bcanis\s+(?:lupus\s+)?familiaris\b|\bperr[ao]\b/i.test(textoCrudo)) p.especie = 'Canino';
+    else if (/\bfelis\s+(?:silvestris\s+)?catus\b|\bgat[ao]\b/i.test(textoCrudo)) p.especie = 'Felino';
+  }
+
+  // Y el sexo se deduce del mismo sitio: «Perra»/«Gata» sólo existen en femenino.
+  if (/\b(?:perra|gata)\b/i.test(textoCrudo)) p.sexo = 'Hembra';
+
   const coincRaza = textoCrudo.match(/\b(?:raza|breed|race|cruce)\s*:?\s{0,4}([^\n\r;:]{2,60})/i);
   if (coincRaza) {
     const crudo = coincRaza[1];
@@ -307,23 +408,58 @@ function parsearTextoPaciente(textoCrudo: string): PacientePdf {
   return p;
 }
 
-async function cargarPdfJs(): Promise<PdfjsLib | undefined> {
-  const w = window as unknown as { pdfjsLib?: PdfjsLib };
-  if (w.pdfjsLib) return w.pdfjsLib;
-  await new Promise<void>((resolve, reject) => {
-    const script = document.createElement('script');
-    script.src = 'assets/lib/pdfjs/pdf.min.js';
-    script.onload = () => resolve();
-    script.onerror = () => reject(new Error('no se pudo cargar pdf.js'));
-    document.head.appendChild(script);
-  });
-  return w.pdfjsLib;
+class ErrorTextoIlegible extends Error {
+  constructor() {
+    super('el texto del PDF no se pudo decodificar de forma fiable');
+    this.name = 'ErrorTextoIlegible';
+  }
+}
+
+let pdfjsCargado: PdfjsLib | undefined;
+
+// pdf.js 4+ se distribuye como módulo ES y ya no publica `window.pdfjsLib`, así que se carga
+// con import() dinámico en vez de inyectar un <script>. Sigue siendo perezoso a propósito:
+// son ~1,7 MB entre módulo y worker, y sólo hacen falta si el usuario adjunta un PDF.
+//
+// La versión importa. La 3.11 leía mal los CMap `ToUnicode` con destinos de UN byte —fuera de
+// especificación, pero los emiten productores reales (informes de laboratorio generados con
+// Ghostscript)— y devolvía cada carácter desplazado 8 bits: 'H' (0x48) salía como U+4800. El
+// texto extraído no casaba con ningún analito y la importación fallaba entera. Ver
+// `frontend/tests/pdf-parser.test.ts`, que fija el caso con un PDF de ese tipo.
+async function cargarPdfJs(): Promise<PdfjsLib> {
+  if (pdfjsCargado) return pdfjsCargado;
+  // @vite-ignore: es un asset vendorizado que se resuelve en tiempo de ejecución; la build no
+  // debe intentar empaquetarlo.
+  const modulo = (await import(
+    /* @vite-ignore */ new URL(PDFJS_MODULO, document.baseURI).href
+  )) as unknown as PdfjsLib;
+  modulo.GlobalWorkerOptions.workerSrc = new URL(PDFJS_WORKER, document.baseURI).href;
+  pdfjsCargado = modulo;
+  return modulo;
+}
+
+/** Texto que salió del extractor con los bytes descolocados (ver `cargarPdfJs`).
+ *
+ * No se intenta reparar aunque la transformación sea reversible sobre el papel: el extractor
+ * normaliza a espacio los códigos que caen en un espacio Unicode, y '0' (0x30) desplazado es
+ * U+3000 (espacio ideográfico). Los ceros se pierden ANTES de que este código vea el texto, así
+ * que «reparar» convertiría una ALT de 260 U/L en 26. Vale más no importar nada que importar un
+ * número equivocado en una analítica.
+ */
+function textoIlegible(texto: string): boolean {
+  let noAscii = 0;
+  let desplazados = 0;
+  for (const ch of texto) {
+    const c = ch.codePointAt(0) as number;
+    if (c <= 0x7f) continue;
+    noAscii++;
+    if ((c & 0xff) === 0 && c >>> 8 >= 0x20) desplazados++;
+  }
+  return noAscii >= 20 && desplazados / noAscii > 0.5;
 }
 
 async function extraerTextoPdf(file: File): Promise<string> {
   const pdfjs = await cargarPdfJs();
-  if (!pdfjs) throw new Error('PDF.js no cargado');
-  pdfjs.GlobalWorkerOptions.workerSrc = PDFJS_WORKER;
 
   const buf = await file.arrayBuffer();
   const pdf = await pdfjs.getDocument({ data: buf }).promise;
@@ -333,7 +469,67 @@ async function extraerTextoPdf(file: File): Promise<string> {
     const content = await page.getTextContent();
     paginas.push(content.items.map((i) => i.str + (i.hasEOL ? '\n' : ' ')).join(''));
   }
-  return paginas.join('\n');
+  const texto = paginas.join('\n');
+  if (textoIlegible(texto)) throw new ErrorTextoIlegible();
+  return texto;
+}
+
+// Lee un PDF y vuelca lo que reconozca en el formulario. El PDF se parsea entero, sin importar
+// desde qué panel se haya adjuntado: los valores caen en el panel al que pertenece cada analito.
+async function importarPdf(file: File, evaluar: () => void): Promise<void> {
+  try {
+    const textoCrudo = await extraerTextoPdf(file);
+    const resultados = parsearTextoLab(textoCrudo);
+    const contadorLab = aplicarValoresAFormulario(resultados, evaluar);
+    const patient = parsearTextoPaciente(textoCrudo);
+    const contadorPac = aplicarPacienteAFormulario(patient);
+    const partes: string[] = [];
+    if (contadorLab > 0) partes.push(`${contadorLab} valor${contadorLab !== 1 ? 'es' : ''}`);
+    if (contadorPac > 0) partes.push('datos del paciente');
+    mostrarToast(partes.length > 0
+      ? `${partes.join(' y ')} importados del PDF.`
+      : 'No se encontraron datos reconocibles en el PDF.', partes.length === 0);
+  } catch {
+    mostrarToast('Error al leer el PDF. ¿Es un PDF con texto (no escaneado)?', true);
+  }
+}
+
+// Arrastrar y soltar sobre un panel de exámenes. Se escucha en el <section> entero y no sólo en
+// la zona vacía: una vez el panel muestra el formulario la zona desaparece, y soltar otro PDF
+// encima del panel debe seguir funcionando.
+function inicializarArrastre(evaluar: () => void): void {
+  document.querySelectorAll<HTMLElement>('.subpanel[id^="panel-"]').forEach((panel) => {
+    if (!panel.querySelector('.panel-vacio')) return;
+
+    // `dragover` con preventDefault es lo que le dice al navegador que aquí se puede soltar;
+    // sin él, el drop lo captura la ventana y navega al fichero.
+    panel.addEventListener('dragover', (e) => {
+      e.preventDefault();
+      panel.classList.add('arrastrando');
+    });
+    // `dragleave` salta también al pasar sobre un hijo; sólo cuenta salir del panel de verdad.
+    panel.addEventListener('dragleave', (e) => {
+      if (!panel.contains((e as DragEvent).relatedTarget as Node | null)) {
+        panel.classList.remove('arrastrando');
+      }
+    });
+    panel.addEventListener('drop', manejadorAsync('Importar PDF', async (e: Event) => {
+      e.preventDefault();
+      panel.classList.remove('arrastrando');
+      const file = (e as DragEvent).dataTransfer?.files?.[0];
+      if (!file) return;
+      if (file.type !== 'application/pdf' && !/\.pdf$/i.test(file.name)) {
+        mostrarToast('Sólo se pueden adjuntar archivos PDF.', true);
+        return;
+      }
+      await importarPdf(file, evaluar);
+    }));
+  });
+
+  // Soltar FUERA de un panel no debe abrir el PDF sustituyendo la aplicación (con el formulario
+  // a medio rellenar, eso es perder el trabajo por un gesto impreciso).
+  document.addEventListener('dragover', (e) => e.preventDefault());
+  document.addEventListener('drop', (e) => e.preventDefault());
 }
 
 export function inicializarParserPdf(evaluar: () => void): void {
@@ -349,21 +545,9 @@ export function inicializarParserPdf(evaluar: () => void): void {
       const file = input.files?.[0];
       if (!file) return;
       input.value = '';
-      try {
-        const textoCrudo = await extraerTextoPdf(file);
-        const resultados = parsearTextoLab(textoCrudo);
-        const contadorLab = aplicarValoresAFormulario(resultados, evaluar);
-        const patient = parsearTextoPaciente(textoCrudo);
-        const contadorPac = aplicarPacienteAFormulario(patient);
-        const partes: string[] = [];
-        if (contadorLab > 0) partes.push(`${contadorLab} valor${contadorLab !== 1 ? 'es' : ''}`);
-        if (contadorPac > 0) partes.push('datos del paciente');
-        mostrarToast(partes.length > 0
-          ? `${partes.join(' y ')} importados del PDF.`
-          : 'No se encontraron datos reconocibles en el PDF.', partes.length === 0);
-      } catch {
-        mostrarToast('Error al leer el PDF. ¿Es un PDF con texto (no escaneado)?', true);
-      }
+      await importarPdf(file, evaluar);
     }));
   });
+
+  inicializarArrastre(evaluar);
 }

frontend/tests/pdf-parser.test.ts

@@ -0,0 +1,219 @@
+// @vitest-environment jsdom
+// Regresión del importador de PDF. Cubre las dos capas donde ha fallado:
+//
+//   1. La DECODIFICACIÓN del texto (pdf.js). Un informe real de laboratorio no se pudo importar
+//      —«No se encontraron datos reconocibles en el PDF»— porque su CMap `ToUnicode` declara
+//      destinos de UN byte (fuera de especificación, pero lo emiten productores reales tipo
+//      Ghostscript) y pdf.js 3.11 los leía de dos en dos: cada carácter salía desplazado 8 bits,
+//      'H' (0x48) como U+4800. Aquí se construye un PDF con esa misma anomalía y se fija que la
+//      versión de pdf.js que vendorizamos lo decodifica bien.
+//
+//   2. El RECONOCIMIENTO sobre el texto ya decodificado (parsearTextoLab / parsearTextoPaciente).
+//
+// El texto de las pruebas de la capa 2 reproduce la MAQUETA del informe real (dot leaders,
+// cabecera de sección + línea RESULTADO, párrafos interpretativos) con datos inventados: el
+// informe original lleva nombre de propietario, clínica, dirección y nº de chip, y no tiene por
+// qué entrar en el repositorio para fijar una regresión de parseo.
+
+import { describe, it, expect } from 'vitest';
+import * as pdfjs from 'pdfjs-dist/legacy/build/pdf.mjs';
+import { parsearTextoLab, parsearTextoPaciente } from '../src/pdf-parser.js';
+
+// --- Capa 1: decodificación -----------------------------------------------------------------
+
+/** PDF mínimo cuyo `ToUnicode` usa destinos de un byte (`<48><48><48>` en vez de `<48><48><0048>`). */
+function pdfConToUnicodeDefectuoso(lineas: string[]): Uint8Array {
+  const usados = [...new Set(lineas.join('').split(''))].filter((c) => c !== ' ');
+  const bfchar = usados
+    .map((c) => {
+      const hex = c.charCodeAt(0).toString(16).padStart(2, '0');
+      return `<${hex}><${hex}>`;  // ← destino de UN byte: la anomalía que se quiere reproducir
+    })
+    .join('\n');
+  const cmap = `/CIDInit /ProcSet findresource begin
+12 dict begin
+begincmap
+/CMapType 2 def
+1 begincodespacerange
+<00><ff>
+endcodespacerange
+${usados.length} beginbfchar
+${bfchar}
+endbfchar
+endcmap
+CMapName currentdict /CMap defineresource pop
+end end`;
+
+  const escapar = (s: string) => s.replace(/[\\()]/g, (c) => `\\${c}`);
+  const contenido = `BT /F1 10 Tf 40 750 Td 14 TL\n${lineas
+    .map((l) => `(${escapar(l)}) Tj T*`)
+    .join('\n')}\nET`;
+
+  const objetos = [
+    '<< /Type /Catalog /Pages 2 0 R >>',
+    '<< /Type /Pages /Kids [3 0 R] /Count 1 >>',
+    '<< /Type /Page /Parent 2 0 R /MediaBox [0 0 612 792] '
+      + '/Resources << /Font << /F1 4 0 R >> >> /Contents 5 0 R >>',
+    '<< /Type /Font /Subtype /Type1 /BaseFont /Helvetica /ToUnicode 6 0 R >>',
+    `<< /Length ${contenido.length} >>\nstream\n${contenido}\nendstream`,
+    `<< /Length ${cmap.length} >>\nstream\n${cmap}\nendstream`,
+  ];
+
+  let pdf = '%PDF-1.4\n';
+  const offsets: number[] = [];
+  objetos.forEach((cuerpo, i) => {
+    offsets.push(pdf.length);
+    pdf += `${i + 1} 0 obj\n${cuerpo}\nendobj\n`;
+  });
+  const inicioXref = pdf.length;
+  pdf += `xref\n0 ${objetos.length + 1}\n0000000000 65535 f \n`;
+  for (const off of offsets) pdf += `${String(off).padStart(10, '0')} 00000 n \n`;
+  pdf += `trailer\n<< /Size ${objetos.length + 1} /Root 1 0 R >>\nstartxref\n${inicioXref}\n%%EOF\n`;
+
+  return Uint8Array.from(pdf, (c) => c.charCodeAt(0));
+}
+
+async function extraer(datos: Uint8Array): Promise<string> {
+  const doc = await pdfjs.getDocument({ data: datos }).promise;
+  const paginas: string[] = [];
+  for (let p = 1; p <= doc.numPages; p++) {
+    const contenido = await (await doc.getPage(p)).getTextContent();
+    // Mismo ensamblado que `extraerTextoPdf` en src/pdf-parser.ts.
+    paginas.push(
+      contenido.items
+        .map((i) => ('str' in i ? i.str + (i.hasEOL ? '\n' : ' ') : ''))
+        .join(''),
+    );
+  }
+  return paginas.join('\n');
+}
+
+describe('decodificación de PDF con ToUnicode defectuoso', () => {
+  it('lee los caracteres sin desplazarlos 8 bits', async () => {
+    const texto = await extraer(
+      pdfConToUnicodeDefectuoso(['HEMATOCRITO...... 48,1 %', 'ALT-GPT......... 260 U/L']),
+    );
+
+    expect(texto).toContain('HEMATOCRITO');
+    expect(texto).toContain('ALT-GPT');
+    // El síntoma exacto de la regresión: 'H' saliendo como U+4800 y ',' como U+2C00.
+    expect(texto).not.toContain('䠀');
+    expect(texto).not.toContain('Ⰰ');
+  });
+
+  it('conserva los ceros (el 0 desplazado caía en U+3000 y se normalizaba a espacio)', async () => {
+    const texto = await extraer(pdfConToUnicodeDefectuoso(['ALT-GPT......... 260 U/L']));
+
+    // Este es el motivo por el que el desplazamiento NO se repara a posteriori: perder los ceros
+    // convierte una ALT de 260 U/L en 26, que es un resultado normal.
+    expect(texto).toContain('260');
+    expect(parsearTextoLab(texto).alt).toBe(260);
+  });
+});
+
+// --- Capa 2: reconocimiento -----------------------------------------------------------------
+
+// Maqueta del informe: etiqueta + líderes de puntos con el valor en la misma línea (hemograma) o
+// cabecera de sección con el valor en una línea RESULTADO posterior (bioquímica).
+const INFORME = `Datos personales
+LUNA
+Perra, Canis lupus familiaris
+PRUEBA RESULTADO UNIDADES VAL.DE REFERENCIA
+HEMOGRAMA
+Contaje y Fórmula Electrónico
+HEMATOCRITO...................... 48,1 % (37,0-55,0)
+HEMOGLOBINA...................... 17,7 g/dL (12,0-20,0)
+HEMATÍES......................... 7.300.000 /µL (5.100.000-8.000.000)
+PLAQUETAS........................ 171.000 /µL (200.000-500.000)
+FÓRMULA LEUCOCITARIA
+LEUCOCITOS....................... 7.510 /µL (4.900-21.700)
+EOSINÓFILOS...................... 5 %
+BASÓFILOS........................ 0 %
+LINFOCITOS....................... 29 %
+SEGMENTADOS...................... 59 %
+UREA / SUERO
+Química seca - Espectrofotometría Ultravioleta-Visible
+RESULTADO........................ 67 mg/dL (11-53)
+CREATININA / SUERO
+Química seca - Espectrofotometría Ultravioleta-Visible
+RESULTADO........................ 1,73 mg/dL (0,50-1,60)
+PROTEÍNAS TOTALES / SUERO
+Química seca - Espectrofotometría Ultravioleta-Visible
+RESULTADO........................ 76 g/L (47-68)
+COCIENTE ALBÚMINA / GLOBULINA
+Química seca - Espectrofotometría Ultravioleta-Visible
+ALBUMINA......................... 40 g/L (24-40)
+GLOBULINAS TOTALES............... 36,00 g/L (21,00-35,00)
+RESULTADO........................ 1,11 (0,70-1,50)
+ALT-GPT
+Química seca - Espectrofotometría Ultravioleta-Visible
+RESULTADO........................ 260 U/L (21-79)
+SDMA (Dimetilarginina simétrica)
+Inmunoturbidimetría
+RESULTADO........................ 12,6 µg/dL (<15,0)
+Interpretación:
+El aumento de SDMA en suero o plasma es un indicador temprano de reducción de la
+funcionalidad renal. IRIS recomienda valorar los resultados de SDMA junto a otros
+parámetros; entre ellos UPC, Creatinina, presión arterial y densidad urinaria.
+CREATINKINASA
+Química seca - Espectrofotometría Ultravioleta-Visible
+RESULTADO........................ 90 U/L (<300)
+`;
+
+describe('parsearTextoLab sobre la maqueta de informe español', () => {
+  const r = parsearTextoLab(INFORME);
+
+  it('lee los valores de la misma línea', () => {
+    expect(r.hct).toBe(48.1);
+    expect(r.hgb).toBe(17.7);
+    expect(r.wbc).toBe(7.51);
+    expect(r.plt).toBe(171);
+  });
+
+  it('lee los valores que van en la línea RESULTADO bajo su cabecera', () => {
+    expect(r.creat).toBe(1.73);
+    expect(r.alt).toBe(260);
+    expect(r.sdma).toBe(12.6);
+    expect(r.prot).toBe(7.6);              // 76 g/L → g/dL
+    expect(r.bun).toBeCloseTo(31.29, 1);   // urea 67 mg/dL → BUN
+  });
+
+  it('reconoce los nombres acentuados en mayúsculas', () => {
+    expect(r.rbc).toBe(7.3);      // HEMATÍES
+    expect(r.eosino).toBe(5);     // EOSINÓFILOS
+    expect(r.linfo).toBe(29);
+  });
+
+  it('reconoce SEGMENTADOS como neutrófilos', () => {
+    expect(r.neutro).toBe(59);
+  });
+
+  it('conserva un 0 legítimo de la fórmula leucocitaria', () => {
+    expect(r.baso).toBe(0);
+  });
+
+  it('no confunde el analito con el cociente calculado a partir de él', () => {
+    // Bajo «COCIENTE ALBÚMINA / GLOBULINA» la línea RESULTADO es el cociente A/G (1,11); la
+    // albúmina y las globulinas están en sus propias líneas, encima.
+    expect(r.alb).toBe(4);        // 40 g/L → g/dL
+    expect(r.glob).toBe(3.6);     // 36 g/L → g/dL
+  });
+
+  it('no inventa un analito citado de pasada en un párrafo interpretativo', () => {
+    // «densidad urinaria» aparece en la interpretación del SDMA. El valor más cercano es el de
+    // la CREATINKINASA, dos líneas más abajo: importarlo daría una densidad urinaria de 90 en
+    // una analítica que no incluye orina.
+    expect(r.usg).toBeUndefined();
+  });
+});
+
+describe('parsearTextoPaciente', () => {
+  it('deduce especie y sexo del nombre científico y del género gramatical', () => {
+    expect(parsearTextoPaciente(INFORME)).toMatchObject({ especie: 'Canino', sexo: 'Hembra' });
+  });
+
+  it('la etiqueta explícita manda sobre la deducción', () => {
+    const p = parsearTextoPaciente('Especie: Felino\nSexo: Macho\nEl perro del vecino');
+    expect(p).toMatchObject({ especie: 'Felino', sexo: 'Macho' });
+  });
+});