pdf-oxide-fips 0.3.47

package/lib/types/native-bindings.js

@@ -0,0 +1,7 @@
+/**
+ * Type definitions for PDF Oxide native bindings (C++ module via NAPI)
+ *
+ * These interfaces describe the structure of objects returned from the native module.
+ * They are used for type checking and IDE auto-completion when working with the binding layer.
+ */
+export {};

package/lib/workers/index.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Worker Threads Module
+ * Exports worker pool and types for parallel PDF processing
+ */
+export type { WorkerResult, WorkerTask } from './pool.js';
+export { WorkerPool, workerPool } from './pool.js';

package/lib/workers/index.js

@@ -0,0 +1,5 @@
+/**
+ * Worker Threads Module
+ * Exports worker pool and types for parallel PDF processing
+ */
+export { WorkerPool, workerPool } from './pool.js';

package/lib/workers/pool.d.ts

@@ -0,0 +1,64 @@
+/**
+ * Worker Thread Pool Manager
+ * Enables non-blocking parallel PDF processing
+ */
+/**
+ * Represents a task to be processed by a worker
+ */
+export interface WorkerTask<T = any> {
+    operation: 'extract' | 'search' | 'render' | 'analyze';
+    documentPath: string;
+    params: Record<string, any>;
+}
+/**
+ * Result returned from a worker
+ */
+export interface WorkerResult<T = any> {
+    success: boolean;
+    data?: T;
+    error?: Error | string;
+    duration: number;
+}
+/**
+ * Thread pool for parallel PDF processing
+ */
+export declare class WorkerPool {
+    private poolSize;
+    private workers;
+    private queue;
+    private activeCount;
+    private terminated;
+    private readonly defaultTimeout;
+    /**
+     * Initialize the worker pool
+     * @param poolSize - Number of worker threads to create
+     */
+    constructor(poolSize?: number);
+    private validatePoolSize;
+    private initializeWorkers;
+    /**
+     * Run a task in the worker pool
+     * @param task - The task to run
+     * @param timeout - Optional timeout in milliseconds
+     * @returns Promise that resolves with the result
+     */
+    runTask<T = any>(task: WorkerTask<T>, timeout?: number): Promise<WorkerResult<T>>;
+    private processQueue;
+    private handleWorkerError;
+    /**
+     * Terminate all workers
+     * @returns Promise that resolves when all workers are terminated
+     */
+    terminate(): Promise<void>;
+    private cleanup;
+    /**
+     * Get current pool statistics
+     */
+    getStats(): {
+        poolSize: number;
+        activeWorkers: number;
+        queuedTasks: number;
+        terminated: boolean;
+    };
+}
+export declare const workerPool: WorkerPool;

package/lib/workers/pool.js

@@ -0,0 +1,192 @@
+/**
+ * Worker Thread Pool Manager
+ * Enables non-blocking parallel PDF processing
+ */
+import os from 'os';
+import path from 'path';
+import { fileURLToPath } from 'url';
+import { Worker } from 'worker_threads';
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+/**
+ * Thread pool for parallel PDF processing
+ */
+export class WorkerPool {
+    /**
+     * Initialize the worker pool
+     * @param poolSize - Number of worker threads to create
+     */
+    constructor(poolSize = 4) {
+        this.poolSize = poolSize;
+        this.workers = [];
+        this.queue = [];
+        this.activeCount = 0;
+        this.terminated = false;
+        this.defaultTimeout = 30000; // 30 seconds
+        this.validatePoolSize();
+        this.initializeWorkers();
+    }
+    validatePoolSize() {
+        if (this.poolSize < 1 || this.poolSize > 32) {
+            throw new Error(`Pool size must be between 1 and 32, got ${this.poolSize}`);
+        }
+    }
+    initializeWorkers() {
+        try {
+            for (let i = 0; i < this.poolSize; i++) {
+                const worker = new Worker(path.join(__dirname, 'worker.js'));
+                worker.on('error', (error) => {
+                    console.error(`Worker ${i} error:`, error);
+                    this.handleWorkerError(error instanceof Error ? error : new Error(String(error)));
+                });
+                worker.on('exit', (code) => {
+                    if (code !== 0 && !this.terminated) {
+                        console.warn(`Worker ${i} exited with code ${code}`);
+                    }
+                });
+                this.workers.push(worker);
+            }
+        }
+        catch (error) {
+            this.cleanup();
+            throw new Error(`Failed to initialize worker pool: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+    /**
+     * Run a task in the worker pool
+     * @param task - The task to run
+     * @param timeout - Optional timeout in milliseconds
+     * @returns Promise that resolves with the result
+     */
+    async runTask(task, timeout = this.defaultTimeout) {
+        if (this.terminated) {
+            throw new Error('Worker pool has been terminated');
+        }
+        if (timeout < 1000 || timeout > 300000) {
+            throw new Error('Timeout must be between 1 and 300 seconds');
+        }
+        return new Promise((resolve, reject) => {
+            const timeoutHandle = setTimeout(() => {
+                this.queue = this.queue.filter((q) => q.task !== task);
+                reject(new Error(`Worker task timeout after ${timeout}ms: ${task.operation} on ${task.documentPath}`));
+            }, timeout);
+            this.queue.push({
+                task,
+                resolve,
+                reject,
+                timeout: timeoutHandle,
+            });
+            this.processQueue();
+        });
+    }
+    processQueue() {
+        if (this.queue.length === 0 || this.activeCount >= this.poolSize) {
+            return;
+        }
+        const queuedTask = this.queue.shift();
+        if (!queuedTask)
+            return;
+        const { task, resolve, reject, timeout } = queuedTask;
+        // Find an available worker
+        const workerIndex = this.activeCount % this.poolSize;
+        const worker = this.workers[workerIndex];
+        if (!worker) {
+            reject(new Error('No available worker'));
+            clearTimeout(timeout);
+            return;
+        }
+        this.activeCount++;
+        const messageHandler = (result) => {
+            clearTimeout(timeout);
+            resolve(result);
+            this.activeCount--;
+            worker.off('message', messageHandler);
+            worker.off('error', errorHandler);
+            this.processQueue();
+        };
+        const errorHandler = (error) => {
+            clearTimeout(timeout);
+            reject(error);
+            this.activeCount--;
+            worker.off('message', messageHandler);
+            worker.off('error', errorHandler);
+            this.processQueue();
+        };
+        worker.on('message', messageHandler);
+        worker.once('error', errorHandler);
+        try {
+            worker.postMessage(task);
+        }
+        catch (error) {
+            clearTimeout(timeout);
+            reject(error instanceof Error ? error : new Error(String(error)));
+            this.activeCount--;
+            worker.off('message', messageHandler);
+            worker.off('error', errorHandler);
+            this.processQueue();
+        }
+    }
+    handleWorkerError(error) {
+        if (this.queue.length > 0) {
+            const queuedTask = this.queue.shift();
+            if (queuedTask) {
+                clearTimeout(queuedTask.timeout);
+                queuedTask.reject(error);
+                this.activeCount--;
+                this.processQueue();
+            }
+        }
+    }
+    /**
+     * Terminate all workers
+     * @returns Promise that resolves when all workers are terminated
+     */
+    async terminate() {
+        this.terminated = true;
+        // Reject all queued tasks
+        while (this.queue.length > 0) {
+            const queuedTask = this.queue.shift();
+            if (queuedTask) {
+                clearTimeout(queuedTask.timeout);
+                queuedTask.reject(new Error('Worker pool terminated'));
+            }
+        }
+        // Terminate all workers
+        await Promise.all(this.workers.map((worker) => worker.terminate().catch((error) => console.warn('Error terminating worker:', error))));
+        this.cleanup();
+    }
+    cleanup() {
+        this.workers = [];
+        this.queue = [];
+        this.activeCount = 0;
+    }
+    /**
+     * Get current pool statistics
+     */
+    getStats() {
+        return {
+            poolSize: this.poolSize,
+            activeWorkers: this.activeCount,
+            queuedTasks: this.queue.length,
+            terminated: this.terminated,
+        };
+    }
+}
+/**
+ * Global worker pool instance (singleton)
+ * Auto-configured based on CPU count
+ */
+const hardwareConcurrency = Math.max(1, os.cpus().length);
+export const workerPool = new WorkerPool(Math.min(hardwareConcurrency, 8));
+/**
+ * Graceful shutdown
+ */
+process.on('exit', async () => {
+    if (!workerPool || workerPool.terminated)
+        return;
+    try {
+        await workerPool.terminate();
+    }
+    catch (error) {
+        console.error('Error during worker pool shutdown:', error);
+    }
+});

package/lib/workers/worker.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Worker Thread Script
+ * Handles off-main-thread PDF processing tasks
+ */
+export {};

package/lib/workers/worker.js

@@ -0,0 +1,99 @@
+/**
+ * Worker Thread Script
+ * Handles off-main-thread PDF processing tasks
+ */
+import { parentPort } from 'worker_threads';
+/**
+ * Process a worker task
+ */
+async function handleTask(task) {
+    const startTime = Date.now();
+    try {
+        // Dynamically import PdfDocument since we can't use top-level imports
+        // in a worker context reliably across all environments
+        const { PdfDocument } = await import('../index.js');
+        if (!PdfDocument) {
+            throw new Error('PdfDocument not available in worker');
+        }
+        let result;
+        switch (task.operation) {
+            case 'extract': {
+                const doc = PdfDocument.open(task.documentPath);
+                const extMgr = doc.extraction;
+                if (task.params.type === 'markdown') {
+                    result = extMgr.extractMarkdown(task.params.pageIndex, task.params.options);
+                }
+                else if (task.params.type === 'html') {
+                    result = extMgr.extractHtml(task.params.pageIndex, task.params.options);
+                }
+                else {
+                    result = extMgr.extractText(task.params.pageIndex, task.params.options);
+                }
+                break;
+            }
+            case 'search': {
+                const doc = PdfDocument.open(task.documentPath);
+                const searchMgr = doc.search;
+                result = searchMgr.searchAll(task.params.query, task.params.options || {});
+                break;
+            }
+            case 'render': {
+                const doc = PdfDocument.open(task.documentPath);
+                const renderMgr = doc.rendering;
+                result = renderMgr.renderPage(task.params.pageIndex, task.params.options || {});
+                break;
+            }
+            case 'analyze': {
+                const doc = PdfDocument.open(task.documentPath);
+                result = {
+                    pageCount: doc.pageCount,
+                    metadata: doc.metadata?.getMetadata?.() || null,
+                    outline: {
+                        count: doc.outline?.getOutlineCount?.() || 0,
+                        isFlat: doc.outline?.isFlat?.() || false,
+                    },
+                    layers: {
+                        count: doc.layers?.getLayerCount?.() || 0,
+                        visible: doc.layers?.getVisibleLayerCount?.() || 0,
+                    },
+                };
+                break;
+            }
+            default:
+                throw new Error(`Unknown operation: ${task.operation}`);
+        }
+        const duration = Date.now() - startTime;
+        return {
+            success: true,
+            data: result,
+            duration,
+        };
+    }
+    catch (error) {
+        const duration = Date.now() - startTime;
+        return {
+            success: false,
+            error: error instanceof Error
+                ? {
+                    name: error.name,
+                    message: error.message,
+                    stack: error.stack,
+                }
+                : String(error),
+            duration,
+        };
+    }
+}
+/**
+ * Main worker message handler
+ */
+if (parentPort) {
+    parentPort.on('message', async (task) => {
+        const result = await handleTask(task);
+        parentPort?.postMessage(result);
+    });
+}
+else {
+    console.error('Worker script must be run as a Worker thread');
+    process.exit(1);
+}

package/package.json

@@ -0,0 +1,79 @@
+{
+  "name": "pdf-oxide-fips",
+  "version": "0.3.47",
+  "type": "module",
+  "description": "[FIPS 140-3 validated build] High-performance PDF parsing and text extraction library — prebuilt native bindings, no build toolchain required",
+  "main": "lib/index.js",
+  "types": "lib/index.d.ts",
+  "scripts": {
+    "compile:ts": "tsc",
+    "build:ts": "npm run compile:ts && node scripts/fix-esm-imports.js",
+    "build:native": "node-gyp rebuild",
+    "build": "npm run build:ts && npm run build:native",
+    "typecheck": "tsc --noEmit",
+    "clean:ts": "rimraf lib/",
+    "clean": "npm run clean:ts && node-gyp clean",
+    "prepack": "npm run build:ts",
+    "lint": "biome check .",
+    "lint:fix": "biome check --write .",
+    "format": "biome format --write .",
+    "check:publint": "publint",
+    "check:types": "attw --pack . --ignore-rules=cjs-resolves-to-esm",
+    "audit:prod": "npm audit --omit=dev --audit-level=high",
+    "test": "node --test tests/smoke.test.mjs tests/feature-guard.test.mjs tests/api-coverage.test.mjs tests/html-css.test.mjs tests/document-builder.test.mjs tests/document-editor.test.mjs tests/render-options.test.mjs tests/tables.test.mjs tests/worker-threads-safety.test.mjs"
+  },
+  "files": [
+    "lib/",
+    "prebuilds/",
+    "README.md",
+    "LICENSE-APACHE",
+    "LICENSE-MIT"
+  ],
+  "keywords": [
+    "pdf",
+    "text-extraction",
+    "pdf-parsing",
+    "rust-ffi",
+    "native-binding",
+    "prebuilt"
+  ],
+  "author": "PDF Oxide Contributors",
+  "license": "MIT OR Apache-2.0",
+  "homepage": "https://github.com/yfedoseev/pdf_oxide",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/yfedoseev/pdf_oxide.git",
+    "directory": "js"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "exports": {
+    ".": {
+      "types": "./lib/index.d.ts",
+      "import": "./lib/index.js"
+    },
+    "./builders": {
+      "types": "./lib/builders/index.d.ts",
+      "import": "./lib/builders/index.js"
+    },
+    "./managers": {
+      "types": "./lib/managers/index.d.ts",
+      "import": "./lib/managers/index.js"
+    },
+    "./errors": {
+      "types": "./lib/errors.d.ts",
+      "import": "./lib/errors.js"
+    }
+  },
+  "dependencies": {
+    "async-mutex": "^0.5.0"
+  },
+  "devDependencies": {
+    "@types/node": "^25.6.0",
+    "node-addon-api": "^8.7.0",
+    "rimraf": "^6.1.3",
+    "typescript": "^6.0.3"
+  },
+  "gypfile": false
+}