@johpaz/hive-sdk 0.4.3 → 0.4.5

package/docs/plans/2026-09-05-office-dependency-hardening-design.md

@@ -0,0 +1,28 @@
+# Office dependency hardening
+
+## Scope
+
+Remediate the five high-severity advisories reported for the Office tools without
+changing their public names or successful result shapes. The XLSX reader is the
+highest-priority path because it parses user-selected files synchronously. The
+PDF reader only extracts text and does not render the viewer or annotation layer,
+but its vulnerable dependency is still upgraded. The `image-size` findings are
+documented rather than forcing a PPTX replacement because the dependency is not
+loaded by the published `pptxgenjs` path used by Hive.
+
+## Design
+
+Use the current safe PDF.js major and the official SheetJS CE tarball, updating
+both manifests so workspace and published metadata remain aligned. Before loading
+PDF or XLSX data into memory, inspect the regular file and reject inputs above a
+fixed byte limit. PDF processing explicitly disables scripting/eval, bounds the
+number of pages returned per call, and checks a processing deadline between
+pages. XLSX processing bounds workbook sheet count, rows returned per sheet, and
+checks a deadline between sheets. These controls are defense in depth; dependency
+updates remain the remediation for the reported CVEs.
+
+Tests exercise rejection before parsing, page-range validation, XLSX row limits,
+and normal PDF/XLSX behavior. A repository security note records the exact
+`image-size` dependency chain, why it is currently unreachable, the evidence
+required before suppressing it in scanners, and the conditions that invalidate
+the exception (adding image input or an upstream package change).

package/docs/plans/2026-09-06-dependency-audit-remediation-design.md

@@ -0,0 +1,25 @@
+# Dependency audit remediation
+
+## Scope
+
+Remove the critical Baileys advisory and every remaining audit finding that can
+be fixed inside the dependency ranges already accepted by the SDK. Preserve the
+public API and avoid package overrides unless a direct dependency cannot express
+the safe version. The unpatched and unreachable `image-size` findings retain the
+documented exception in `SECURITY.md`.
+
+## Design
+
+Pin `@whiskeysockets/baileys` to the latest official release candidate in both
+published manifests. This moves beyond the security fix in rc12 and includes the
+follow-up protocol-message regression fix. Refresh transitive packages only
+within their parents' declared semver ranges so patched `ws`, `protobufjs`,
+`nanoid`, `fast-uri`, `hono`, `undici`, and related HTTP packages can resolve
+without changing Hive application code.
+
+Use `bun audit` as the failing security regression check: the baseline must show
+the critical advisory before the change and no critical finding afterward. Run
+the channel tests, typecheck, and complete suite to detect API or runtime drift.
+Inspect the final lockfile and audit output before committing. Any advisory that
+cannot be removed by a compatible update is reported separately rather than
+hidden with a broad suppression.

package/docs/plans/2026-09-06-pptx-image-size-remediation-design.md

@@ -0,0 +1,54 @@
+# Remediación de `image-size` en la generación PPTX
+
+## Contexto y decisión
+
+`pptxgenjs@4.0.1` declara `image-size@^1.2.1`, afectado por
+GHSA-w3rx-r6r6-pgpr y GHSA-5p2g-fcmc-qvqq. No existe una versión corregida de
+`image-size`, y el repositorio oficial de PptxGenJS todavía conserva la
+dependencia. Sin embargo, el artefacto ESM publicado de PptxGenJS no importa
+`image-size`: sólo usa `jszip`. Hive tampoco expone imágenes en
+`office_escribir_pptx`; el flujo acepta texto, viñetas y notas del presentador.
+
+Se conservará una copia vendorizada del artefacto ESM oficial de
+PptxGenJS 4.0.1, junto con su licencia MIT y un archivo de procedencia. El
+wrapper de Hive importará ese artefacto local y mantendrá deliberadamente una
+API limitada a texto y notas. Se eliminará `pptxgenjs` de los manifiestos y del
+lockfile, lo que también elimina `image-size` y `queue` del grafo instalable.
+
+Se descartan dos alternativas. Mantener la excepción conserva funcionalidad,
+pero deja el auditor en rojo. Reimplementar directamente el paquete OOXML
+evitaría código vendorizado, pero introduce un riesgo mayor de incompatibilidad
+con PowerPoint, Keynote y LibreOffice, especialmente para notas y relaciones
+internas.
+
+## Integración, errores y mantenimiento
+
+El código vendorizado vivirá bajo `packages/core/src/vendor/pptxgenjs/` y no
+tendrá un `package.json` con dependencias. Un módulo TypeScript local expondrá
+únicamente los métodos que usa la herramienta (`addSlide`, `addText`,
+`addNotes`, `writeFile`), evitando que el resto del SDK dependa de la API amplia
+de PptxGenJS. La herramienta conservará su manejo actual de directorios,
+errores y forma de respuesta.
+
+El archivo de procedencia fijará versión, URL oficial y licencia. Las futuras
+actualizaciones deben reemplazar el artefacto desde una versión oficial,
+verificar su hash y volver a ejecutar las pruebas y el audit. No se añadirá
+soporte para imágenes mediante esta copia: cualquier ampliación de esa API
+requiere una revisión de seguridad nueva.
+
+## Verificación
+
+Una prueba funcional generará una presentación temporal con portada, texto,
+viñetas y notas. Después abrirá el resultado como ZIP y comprobará las partes
+OOXML principales, el número de diapositivas y la presencia del contenido y de
+las notas. Esto protege el comportamiento que Hive usa realmente, sin probar
+detalles internos del proveedor.
+
+La aceptación requiere:
+
+1. La prueba PPTX nueva y la suite de Office pasan.
+2. El typecheck del workspace pasa.
+3. `bun audit` reporta cero vulnerabilidades.
+4. `rg` no encuentra `image-size` ni `pptxgenjs` como dependencias en los
+   manifiestos o el lockfile.
+

package/docs/plans/2026-09-06-typescript7-bun142-documentation-design.md

@@ -0,0 +1,48 @@
+# Cierre de migración a TypeScript 7 y Bun 1.4.2
+
+## Objetivo y decisión
+
+Hive adoptará TypeScript 7.0.2 para su desarrollo y mantendrá Bun 1.4.2 como
+runtime mínimo y versión de referencia en CI. La migración debe terminar con el
+typecheck limpio; no se conservarán `@ts-ignore` ni conversiones a `any` para
+ocultar incompatibilidades. Los puntos donde los tipos DOM y Bun describen de
+forma distinta una misma API tendrán adaptadores locales y estrechos que
+expresen sólo el contrato usado por Hive.
+
+La documentación se dividirá en dos referencias. `UPGRADING.md` explicará los
+requisitos de Bun y TypeScript, los pasos de actualización, los cambios de tipos
+y la validación. `SECURITY-GUARDRAILS.md` inventariará los controles que ya
+existen en dependencias, documentos Office, transporte y CI. README, el índice,
+la API de cron y el changelog enlazarán estas referencias.
+
+Se descartan dos alternativas: documentar únicamente en el changelog dificulta
+encontrar instrucciones operativas; mezclar migración y seguridad en una sola
+página confunde requisitos de plataforma con controles de entrada.
+
+## Compatibilidad y correcciones de tipos
+
+El lector SSE consumirá un contrato estructural mínimo (`read`) en vez de exigir
+la extensión `readMany` que Bun añade al lector global. El cliente WebSocket
+usará un constructor tipado localmente con `Bun.WebSocketOptions`, porque al
+incluir `DOM` TypeScript selecciona el constructor estándar y omite la
+sobrecarga de opciones de Bun. Audio convertirá toda entrada a bytes propios
+respaldados por `ArrayBuffer` antes de crear un `Blob`; esto satisface el modelo
+genérico de typed arrays de TypeScript 7 y evita compartir memoria mutable.
+
+Los demás cambios de migración se conservarán sólo si el typecheck y las pruebas
+demuestran que son compatibles con Bun 1.4.2. Los casts se limitarán a fronteras
+con APIs externas y tendrán comentarios que expliquen la divergencia.
+
+## Guardrails y validación
+
+La referencia de guardrails documentará límites exactos y el comportamiento al
+rechazar entradas: PDF de 25 MiB, máximo 200 páginas, scripting/eval apagados y
+deadline; XLSX de 15 MiB, máximo 25 hojas y 10.000 filas por hoja; PPTX sólo de
+texto con artefacto vendorizado; dependencias auditadas y distribuciones
+oficiales fijadas. También cubrirá el mínimo de Bun, CI con lockfile congelado y
+typecheck de TypeScript 7.
+
+La aceptación requiere `bun --version` 1.4.2, `bun run typecheck` limpio, pruebas
+de los componentes modificados, suite completa, `bun audit` sin hallazgos y
+`git diff --check` limpio. Cualquier prueba intermitente se repetirá aislada y
+se informará explícitamente.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@johpaz/hive-sdk",
-  "version": "0.4.3",
+  "version": "0.4.5",
   "private": false,
   "description": "Hive SDK — The Agent Harness SDK. Build, deploy, and scale AI agent applications with multi-channel support, context engineering, and swarm orchestration.",
   "license": "MIT",
@@ -77,10 +77,12 @@
     "!packages/**/*.test.ts",
     "README.md",
     "CHANGELOG.md",
+    "SECURITY.md",
+    "docs",
     "LICENSE"
   ],
   "engines": {
-    "bun": ">=1.4.0"
+    "bun": ">=1.4.2"
   },
   "workspaces": [
     "packages/core",
@@ -103,7 +105,7 @@
     "@modelcontextprotocol/sdk": "^1.26.0",
     "@sapphire/snowflake": "^3.5.5",
     "@slack/bolt": "^4.7.2",
-    "@whiskeysockets/baileys": "7.0.0-rc11",
+    "@whiskeysockets/baileys": "7.0.0-rc14",
     "async-mutex": "^0.5.0",
     "discord.js": "^14.26.4",
     "docx": "^9.6.1",
@@ -115,16 +117,15 @@
     "mammoth": "^1.12.0",
     "ollama": "^0.6.3",
     "openai": "^6.18.0",
-    "pdfjs-dist": "^5.6.205",
-    "pptxgenjs": "^4.0.1",
+    "pdfjs-dist": "^6.3.289",
     "qrcode-terminal": "^0.12.0",
     "toon-format-parser": "^1.1.0",
-    "xlsx": "^0.18.5",
+    "xlsx": "https://cdn.sheetjs.com/xlsx-0.20.3/xlsx-0.20.3.tgz",
     "zod": "^4.4.3"
   },
   "devDependencies": {
-    "@types/bun": "^1.3.13",
+    "@types/bun": "^1.4.1",
     "@types/jsonwebtoken": "^9.0.10",
-    "typescript": "6.0.2"
+    "typescript": "7.0.2"
   }
 }

package/packages/cli/templates/hive-app/package.json

@@ -12,5 +12,8 @@
   },
   "devDependencies": {
     "@types/bun": "latest"
+  },
+  "engines": {
+    "bun": ">=1.4.2"
   }
 }

package/packages/core/src/agent/llm-providers/hiveagents.ts

@@ -135,8 +135,8 @@ export class HiveAgentsProvider extends OpenAICompatBase {
     return new OpenAI({
       apiKey,
       baseURL,
-      fetch: async (url: RequestInfo | URL, init?: RequestInit) => {
-        const headers = new Headers(init?.headers as HeadersInit | undefined)
+      fetch: async (url: string | URL | Request, init?: RequestInit) => {
+        const headers = new Headers(init?.headers)
         for (const h of BLOCKED_HEADERS) headers.delete(h)
 
         // Debug: log exact request so we can replicate with curl

package/packages/core/src/agent/providers/index.ts

@@ -13,6 +13,19 @@ import type { ContentPart } from "../../multimodal/types.ts"
 import type { TurnSource } from "../../storage/collections.ts"
 import type { MCPClientManager } from "../../mcp/index.ts"
 
+/**
+ * Bloque de contenido de un mensaje del loop.
+ *
+ * El mensaje llega con `content` laxo (`string` o arreglo), y acá sólo se
+ * consumen los bloques de texto. Declarar la forma quita el `any` implícito
+ * del filtro y, de paso, el `as any` que hacía falta para leer `.text`.
+ * Bajo el `strict: false` de este repo el `any` era invisible; en un
+ * consumidor que compile en estricto es un error, y el SDK se publica en
+ * fuente, así que lo compilan con SU configuración.
+ */
+interface ContentBlock { type?: string }
+interface TextBlock extends ContentBlock { type: "text"; text: string }
+
 export type Provider = "openai" | "anthropic" | "gemini" | "mistral" | "kimi" | "ollama" | "openrouter" | "deepseek" | "nvidia" | "hiveagents" | "z-ai" | "modelscope" | "minimax" | "qwen" | "groq" | "opencode-go"
 
 export interface StepEvent {
@@ -164,7 +177,10 @@ export class AgentRunner {
             const content = typeof lastMsg.content === "string" 
               ? lastMsg.content 
               : Array.isArray(lastMsg.content)
-                ? lastMsg.content.filter(p => p.type === "text").map(p => (p as any).text).join("\n")
+                ? (lastMsg.content as ContentBlock[])
+                    .filter((p): p is TextBlock => p.type === "text")
+                    .map((p) => p.text)
+                    .join("\n")
                 : ""
             lastAgentContent = content
             // Accumulate non-empty content that's not just whitespace

package/packages/core/src/api/createAgent.ts

@@ -285,7 +285,7 @@ export async function createAgent(config: AgentConfig): Promise<Agent> {
 
 	const { runAgent } = await import("../agent/agent-loop.ts");
 
-	return {
+	const agente: Agent = {
 		name: config.name,
 		id: agentId,
 		config,
@@ -340,13 +340,15 @@ export async function createAgent(config: AgentConfig): Promise<Agent> {
 			// El loop emite el texto acumulado del turno, no deltas: quedarse con el
 			// último evento evita duplicar la respuesta al concatenar.
 			let response = "";
-			for await (const event of this.chat(task, opts)) {
+			for await (const event of agente.chat(task, opts)) {
 				if (event.type === "text") response = event.content;
 				if (event.type === "done" && event.response) response = event.response;
 			}
 			return response;
 		},
 	};
+
+	return agente;
 }
 
 function safeParse(raw: string): Record<string, unknown> {

package/packages/core/src/config/loader.ts

@@ -1,3 +1,4 @@
+import { resolvePort } from "../utils/port.ts";
 import * as z from "zod";
 import { mkdirSync, existsSync, readFileSync } from "node:fs";
 import * as path from "node:path";
@@ -407,7 +408,7 @@ function buildDefaultConfig(): Config {
   return {
     gateway: {
       host: process.env.HIVE_HOST || "127.0.0.1",
-      port: parseInt(process.env.HIVE_PORT || "18790", 10),
+      port: resolvePort(process.env.HIVE_PORT, 18790),
       pidFile: path.join(hiveDir, "gateway.pid"),
       authToken: process.env.HIVE_AUTH_TOKEN || undefined,
       tools: {

package/packages/core/src/gateway/server.ts

@@ -98,7 +98,7 @@ async function handleChat(
   mcpManager?: MCPClientManager | null
 ): Promise<Response> {
   try {
-    const body = await req.json();
+    const body = (await req.json()) as { message?: string; threadId?: string };
     const message = body.message ?? "";
     const threadId = body.threadId ?? crypto.randomUUID();
 

package/packages/core/src/mcp/transports/sse.ts

@@ -6,6 +6,14 @@ export interface SSETransportConfig {
   headers?: Record<string, string>;
 }
 
+interface ByteStreamReader {
+  read(): Promise<{ done: boolean; value?: Uint8Array }>;
+}
+
+interface ByteStream {
+  getReader(): ByteStreamReader;
+}
+
 export class SSETransport implements Transport {
   private baseUrl: string;
   private messagesUrl: string | null = null; // Endpoint recibido del servidor
@@ -96,16 +104,22 @@ export class SSETransport implements Transport {
       this.sessionId = sessionId;
     }
 
-    // Track cookies for session affinity (important for n8n/proxies)
-    const setCookie = response.headers.get("set-cookie");
-    if (setCookie) {
-      // Simple cookie extraction: just keep the keys and values
-      const newCookies = setCookie.split(',').map(c => c.split(';')[0].trim());
+    // Track cookies for session affinity (important for n8n/proxies).
+    //
+    // `getSetCookie()` y no `get("set-cookie")`: Set-Cookie es la única cabecera
+    // que puede repetirse sin combinarse, y `get()` devuelve las repeticiones
+    // unidas con ", " (Bun 1.4 lo alineó con la spec de Fetch). Partir eso por
+    // coma rompe cualquier cookie cuyo valor lleve una —`Expires=Wed, 09 Jun
+    // 2027 10:18:14 GMT` es el caso de todos los días— y dejaba fragmentos como
+    // "09 Jun 2027 10:18:14 GMT" haciéndose pasar por cookies.
+    const setCookies = response.headers.getSetCookie();
+    if (setCookies.length > 0) {
+      const newCookies = setCookies.map(c => c.split(";")[0].trim());
       this.cookies = [...new Set([...this.cookies, ...newCookies])];
     }
   }
 
-  private startReading(stream: ReadableStream<Uint8Array>) {
+  private startReading(stream: ByteStream) {
     const reader = stream.getReader();
     const decoder = new TextDecoder();
     let buffer = "";
@@ -118,7 +132,7 @@ export class SSETransport implements Transport {
   }
 
   private async processStream(
-    reader: ReadableStreamDefaultReader<Uint8Array>,
+    reader: ByteStreamReader,
     decoder: TextDecoder,
     buffer: string
   ): Promise<void> {
@@ -238,4 +252,4 @@ export class SSETransport implements Transport {
 
 export function createSSETransport(config: SSETransportConfig): Transport {
   return new SSETransport(config) as unknown as Transport;
-}
+}

package/packages/core/src/mcp/transports/websocket.ts

@@ -8,6 +8,11 @@ export interface WebSocketTransportConfig {
   reconnectMaxAttempts?: number; // máximo de intentos (default: 10)
 }
 
+type BunWebSocketConstructor = new (
+  url: string | URL,
+  options?: Bun.WebSocketOptions,
+) => WebSocket;
+
 export class WebSocketTransport implements Transport {
   private url: string;
   private ws: WebSocket | null = null;
@@ -40,15 +45,12 @@ export class WebSocketTransport implements Transport {
     return new Promise((resolve, reject) => {
 
       // CORRECCIÓN 1 — headers en Bun WebSocket
-      // Bun acepta las opciones como segundo argumento cuando no hay subprotocols,
-      // o como objeto con `headers` dentro de un array de subprotocols vacío.
-      // La forma más segura y compatible:
+      // Con la lib DOM activa, TypeScript expone sólo la sobrecarga estándar
+      // (subprotocols). El runtime de Bun acepta Bun.WebSocketOptions.
+      const BunWebSocket = WebSocket as unknown as BunWebSocketConstructor;
       const ws = this.headers && Object.keys(this.headers).length > 0
-        ? new WebSocket(this.url, {
-          // @ts-expect-error — Bun extiende la API estándar de WebSocket
-          headers: this.headers,
-        })
-        : new WebSocket(this.url);
+        ? new BunWebSocket(this.url, { headers: this.headers })
+        : new BunWebSocket(this.url);
 
       this.ws = ws;
       let resolved = false;
@@ -156,4 +158,4 @@ export function createWebSocketTransport(
   config: WebSocketTransportConfig
 ): Transport {
   return new WebSocketTransport(config) as unknown as Transport;
-}
+}

package/packages/core/src/scheduler/CronScheduler.ts

@@ -7,9 +7,11 @@
  * El motor de cron es propio (`./cron`), sin dependencias: sólo `setTimeout` e
  * `Intl` del runtime. Antes era `croner`.
  *
- * `Bun.cron()` no sirve como reemplazo —se evaluó contra el runtime 1.4.0—:
+ * `Bun.cron()` no sirve como reemplazo —reevaluado contra el runtime 1.4.2—:
  * acepta sólo 5 campos y rechaza el sexto, no admite una fecha ISO como patrón
- * (que es como se agendan los jobs `one_shot`), ignora la zona horaria, y su
+ * (que es como se agendan los jobs `one_shot`), no toma una zona por job (usa la
+ * local del proceso desde 1.4; antes era UTC, y ese cambio silencioso es
+ * justamente por qué no conviene delegarle la conversión), y su
  * handle no expone la próxima corrida, que es de donde sale `next_run_at` y con
  * lo que se detectan las corridas perdidas al arrancar. Tampoco tiene
  * equivalente de `protect`, `maxRuns`, `interval`, `startAt`/`stopAt` ni

package/packages/core/src/scheduler/cron/job.ts

@@ -8,7 +8,8 @@
  * habría sido migrar la base para no ganar nada.
  *
  * No usa `Bun.cron()`: ese sólo acepta 5 campos, no admite una fecha ISO como
- * patrón —que es como se agendan los jobs `one_shot`—, ignora la zona horaria y
+ * patrón —que es como se agendan los jobs `one_shot`—, no toma una zona por job
+ * (usa la local del proceso desde Bun 1.4; antes era UTC) y
  * su handle no expone la próxima corrida, que es de donde sale `next_run_at` y
  * con lo que el scheduler detecta las corridas perdidas al arrancar. Lo que sí
  * se usa de Bun es el runtime pelado: `setTimeout` e `Intl`.

package/packages/core/src/scheduler/cron/zoned-time.ts

@@ -2,7 +2,8 @@
  * Reloj de pared ↔ instante, en una zona horaria IANA.
  *
  * Es la parte difícil de un cron con zona horaria y la razón por la que no
- * alcanza con `Bun.cron.parse()`, que sólo trabaja en UTC. "Todos los días a
+ * alcanza con `Bun.cron.parse()`, que resuelve en una sola zona —UTC hasta Bun
+ * 1.3, la local del proceso desde 1.4— y nunca en la del job. "Todos los días a
  * las 9" significa las 9 **del reloj de la pared en Bogotá**, y ese instante se
  * corre una hora dos veces al año en las zonas con horario de verano. Calcular
  * el offset una sola vez y sumarlo produce un cron que se desfasa un día al año

package/packages/core/src/tool-runtime/tool-worker.ts

@@ -100,7 +100,9 @@ async function runTool(message: WorkerRunMessage): Promise<void> {
   }
 }
 
-onmessage = (event: MessageEvent<WorkerRunMessage | WorkerRpcResponse>) => {
+declare const self: Worker
+
+self.onmessage = (event: MessageEvent<WorkerRunMessage | WorkerRpcResponse>) => {
   const message = event.data
 
   if (message.type === "rpc_result") {

package/packages/core/src/tools/office/office-escribir-pptx.ts

@@ -60,7 +60,9 @@ export const officeEscribirPptxTool: Tool = {
     log.debug(`Generando PPTX: ${ruta}`);
 
     try {
-      const pptxgen = (await import("pptxgenjs")).default;
+      // PptxGenJS 4.0.1 ESM is vendored without its unused image parser.
+      // Keep this tool text-only; image support requires a new security review.
+      const pptxgen = (await import("../../vendor/pptxgenjs/pptxgen.es.js")).default;
       const pres = new pptxgen();
 
       // Configuración básica

package/packages/core/src/tools/office/office-leer-pdf.ts

@@ -10,6 +10,14 @@ import type { Tool } from "../types.ts";
 import { logger } from "../../utils/logger.ts";
 import * as fs from "node:fs";
 import * as path from "node:path";
+import { fileURLToPath } from "node:url";
+import {
+  assertBeforeDeadline,
+  MAX_PDF_INPUT_BYTES,
+  MAX_PDF_PAGES_PER_REQUEST,
+  OFFICE_PROCESSING_TIMEOUT_MS,
+  validateOfficeInput,
+} from "./security-limits.ts";
 
 const log = logger.child("office-leer-pdf");
 
@@ -48,61 +56,102 @@ export const officeLeerPdfTool: Tool = {
         return { ok: false, error: `Archivo no encontrado: ${rutaAbsoluta}` };
       }
 
+      const inputError = validateOfficeInput(
+        rutaAbsoluta,
+        MAX_PDF_INPUT_BYTES,
+        "El PDF",
+      );
+      if (inputError) return { ok: false, error: inputError };
+
       const buffer = fs.readFileSync(rutaAbsoluta);
       const uint8Array = new Uint8Array(buffer);
 
-      // Importar pdfjs-dist (compatible con Bun, sin worker)
+      // La build legacy conserva compatibilidad con Bun. PDF.js configura su
+      // propio fake worker en Node/Bun; borrar workerSrc rompe PDF.js 6+.
       const pdfjsLib = await import("pdfjs-dist/legacy/build/pdf.mjs" as any).catch(
         () => import("pdfjs-dist" as any)
       );
 
-      // Desactivar worker para entorno Node/Bun
       const lib = pdfjsLib.default ?? pdfjsLib;
-      if (lib.GlobalWorkerOptions) {
-        lib.GlobalWorkerOptions.workerSrc = "";
-      }
-
-      const doc = await lib.getDocument({ data: uint8Array, disableWorker: true }).promise;
-      const totalPaginas = doc.numPages;
+      const pdfjsPackageUrl = import.meta.resolve("pdfjs-dist/package.json");
+      const loadingTask = lib.getDocument({
+        data: uint8Array,
+        enableScripting: false,
+        isEvalSupported: false,
+        // Bun's process.getBuiltinModule("fs/promises") expects a filesystem
+        // path here; a file:// URL string is not accepted.
+        standardFontDataUrl: fileURLToPath(
+          new URL("./standard_fonts/", pdfjsPackageUrl),
+        ),
+      });
 
-      // Metadata
-      let titulo: string | undefined;
       try {
-        const meta = await doc.getMetadata();
-        titulo = (meta?.info as any)?.Title ?? undefined;
-      } catch {
-        // metadata opcional
+        const deadline = Date.now() + OFFICE_PROCESSING_TIMEOUT_MS;
+        const doc = await loadingTask.promise;
+        const totalPaginas = doc.numPages;
+
+        // Metadata
+        let titulo: string | undefined;
+        try {
+          const meta = await doc.getMetadata();
+          titulo = (meta?.info as any)?.Title ?? undefined;
+        } catch {
+          // metadata opcional
+        }
+
+        const inicio = paginaInicio;
+        if (!Number.isInteger(inicio) || inicio > totalPaginas) {
+          return {
+            ok: false,
+            error: `La página inicial debe estar entre 1 y ${totalPaginas}`,
+          };
+        }
+        if (paginaFin !== undefined && (!Number.isInteger(paginaFin) || paginaFin < inicio)) {
+          return {
+            ok: false,
+            error: "La página final debe ser un entero mayor o igual a la página inicial",
+          };
+        }
+
+        const fin = paginaFin ? Math.min(paginaFin, totalPaginas) : totalPaginas;
+        const paginasSolicitadas = fin - inicio + 1;
+        if (paginasSolicitadas > MAX_PDF_PAGES_PER_REQUEST) {
+          return {
+            ok: false,
+            error: `Se pueden leer como máximo ${MAX_PDF_PAGES_PER_REQUEST} páginas por solicitud`,
+          };
+        }
+
+        const textosPorPagina: Array<{ pagina: number; texto: string }> = [];
+
+        for (let i = inicio; i <= fin; i++) {
+          assertBeforeDeadline(deadline, "La lectura del PDF");
+          const pagina = await doc.getPage(i);
+          const contenido = await pagina.getTextContent();
+          const texto = (contenido.items as any[])
+            .map((item: any) => item.str ?? "")
+            .join(" ")
+            .replace(/\s+/g, " ")
+            .trim();
+          textosPorPagina.push({ pagina: i, texto });
+        }
+
+        const textoCompleto = textosPorPagina.map((p) => p.texto).join("\n\n");
+
+        log.info(`PDF leído: ${totalPaginas} páginas, ${textoCompleto.length} caracteres`);
+
+        return {
+          ok: true,
+          ruta: rutaAbsoluta,
+          totalPaginas,
+          paginasLeidas: paginasSolicitadas,
+          titulo,
+          texto: textoCompleto,
+          paginas: textosPorPagina,
+        };
+      } finally {
+        await loadingTask.destroy();
       }
-
-      const inicio = paginaInicio;
-      const fin = paginaFin ? Math.min(paginaFin, totalPaginas) : totalPaginas;
-
-      const textosPorPagina: Array<{ pagina: number; texto: string }> = [];
-
-      for (let i = inicio; i <= fin; i++) {
-        const pagina = await doc.getPage(i);
-        const contenido = await pagina.getTextContent();
-        const texto = (contenido.items as any[])
-          .map((item: any) => item.str ?? "")
-          .join(" ")
-          .replace(/\s+/g, " ")
-          .trim();
-        textosPorPagina.push({ pagina: i, texto });
-      }
-
-      const textoCompleto = textosPorPagina.map((p) => p.texto).join("\n\n");
-
-      log.info(`PDF leído: ${totalPaginas} páginas, ${textoCompleto.length} caracteres`);
-
-      return {
-        ok: true,
-        ruta: rutaAbsoluta,
-        totalPaginas,
-        paginasLeidas: fin - inicio + 1,
-        titulo,
-        texto: textoCompleto,
-        paginas: textosPorPagina,
-      };
     } catch (error) {
       log.error(`Error leyendo PDF: ${(error as Error).message}`);
       return {