officeparser 7.0.3 → 7.2.0

package/dist/utils/astUtils.js

@@ -16,13 +16,14 @@ const OfficeGenerator_js_1 = require("../OfficeGenerator.js");
  * @param toTextSync - Synchronous text extraction logic (for backward compatibility)
  * @returns An object conforming to OfficeParserAST
  */
-function createAST(type, metadata, content, attachments, config, toTextSync) {
+function createAST(type, metadata, content, attachments, config, auxiliary, toTextSync) {
     return {
         config,
         type,
         metadata,
         content,
         attachments,
+        auxiliary,
         warnings: [],
         toText: toTextSync,
         async to(destination, genConfig) {

package/dist/utils/configUtils.d.ts

@@ -24,3 +24,8 @@ export declare function resolveParserConfig(userConfig?: OfficeParserConfig | Fu
  * @returns A fully populated configuration object
  */
 export declare function resolveGeneratorConfig<D extends string>(destination: D, astConfig?: OfficeParserConfig, userConfig?: GeneratorConfig<D> | FullGeneratorConfig): FullGeneratorConfig;
+/**
+ * Validates the containerWidth option for HTML generation.
+ * Can be 'auto', a positive number, or a positive CSS length/percentage string.
+ */
+export declare function isValidContainerWidth(width: any): boolean;

package/dist/utils/configUtils.js

@@ -4,7 +4,10 @@ exports.isFullGeneratorConfig = isFullGeneratorConfig;
 exports.isFullParserConfig = isFullParserConfig;
 exports.resolveParserConfig = resolveParserConfig;
 exports.resolveGeneratorConfig = resolveGeneratorConfig;
+exports.isValidContainerWidth = isValidContainerWidth;
 const defaults_js_1 = require("../defaults.js");
+const types_js_1 = require("../types.js");
+const errorUtils_js_1 = require("./errorUtils.js");
 /**
  * Deep clones an object, specifically handling arrays and plain objects.
  */
@@ -66,12 +69,25 @@ function resolveParserConfig(userConfig) {
     const { ocrConfig, ...rest } = userConfig;
     Object.assign(config, rest);
     if (ocrConfig) {
-        config.ocrConfig = { ...config.ocrConfig, ...ocrConfig };
+        const { timeout, ...ocrRest } = ocrConfig;
+        config.ocrConfig = {
+            ...config.ocrConfig,
+            ...ocrRest,
+            timeout: {
+                autoTerminate: timeout?.autoTerminate !== undefined ? timeout.autoTerminate : config.ocrConfig.timeout.autoTerminate,
+                workerLoad: timeout?.workerLoad !== undefined ? timeout.workerLoad : config.ocrConfig.timeout.workerLoad,
+                recognition: timeout?.recognition !== undefined ? timeout.recognition : config.ocrConfig.timeout.recognition,
+            }
+        };
     }
     // 3. Handle legacy ocrLanguage mapping if not explicitly set in ocrConfig
     if (userConfig.ocrLanguage && !userConfig.ocrConfig?.language) {
         config.ocrConfig.language = userConfig.ocrLanguage;
     }
+    // 4. Propagate the top-level abortSignal to ocrConfig so the OCR subsystem is aware of it
+    if (config.abortSignal) {
+        config.ocrConfig.abortSignal = config.abortSignal;
+    }
     return config;
 }
 /**
@@ -87,6 +103,7 @@ function resolveGeneratorConfig(destination, astConfig, userConfig) {
     // If it's already a full config and we don't need to merge AST config, return it as is.
     // We assume FullGeneratorConfig is already "safe" (references resolved).
     if (isFullGeneratorConfig(userConfig) && !astConfig) {
+        validateHtmlConfigWidth(userConfig.htmlConfig, userConfig);
         return userConfig;
     }
     // 1. Start with full defaults (deep cloned to avoid reference sharing)
@@ -102,7 +119,22 @@ function resolveGeneratorConfig(destination, astConfig, userConfig) {
                 return;
             for (const key in source) {
                 if (source[key] !== undefined) {
-                    target[key] = source[key];
+                    // Deep merge plain objects (like injections or margin)
+                    if (typeof source[key] === 'object' &&
+                        source[key] !== null &&
+                        !Array.isArray(source[key]) &&
+                        !(source[key] instanceof Function) &&
+                        !(source[key] instanceof Date) &&
+                        !(source[key] instanceof RegExp) &&
+                        !(source[key] instanceof Buffer)) {
+                        if (!target[key] || typeof target[key] !== 'object') {
+                            target[key] = {};
+                        }
+                        mergeSubConfig(target[key], source[key]);
+                    }
+                    else {
+                        target[key] = source[key];
+                    }
                 }
             }
         };
@@ -136,5 +168,40 @@ function resolveGeneratorConfig(destination, astConfig, userConfig) {
             // Since FullGeneratorConfig doesn't have an 'mdConfig', we rely on the generator implementation.
         }
     }
+    validateHtmlConfigWidth(config.htmlConfig, config);
     return config;
 }
+/**
+ * Validates the containerWidth option for HTML generation.
+ * Can be 'auto', a positive number, or a positive CSS length/percentage string.
+ */
+function isValidContainerWidth(width) {
+    if (width === 'auto')
+        return true;
+    if (typeof width === 'number') {
+        return Number.isFinite(width) && width > 0;
+    }
+    if (typeof width === 'string') {
+        const val = width.trim().toLowerCase();
+        if (val === 'auto')
+            return true;
+        const match = val.match(/^((?:\d*\.)?\d+)(px|%|em|rem|vw|vh|vmin|vmax|ch|in|cm|mm|pt|pc)?$/);
+        if (!match)
+            return false;
+        const numericValue = parseFloat(match[1]);
+        return numericValue > 0;
+    }
+    return false;
+}
+/**
+ * Emits a warning and falls back to 'auto' if the HTML containerWidth is invalid.
+ */
+function validateHtmlConfigWidth(htmlConfig, config) {
+    if (htmlConfig?.containerWidth !== undefined) {
+        const width = htmlConfig.containerWidth;
+        if (!isValidContainerWidth(width)) {
+            (0, errorUtils_js_1.logWarning)(types_js_1.OfficeWarningType.INVALID_CONTAINER_WIDTH, config, width);
+            htmlConfig.containerWidth = 'auto';
+        }
+    }
+}

package/dist/utils/errorUtils.d.ts

@@ -27,6 +27,11 @@ export declare const getOfficeError: (type: OfficeErrorType, config?: OfficePars
  * Wraps an existing error with OfficeParser context and performs corruption detection.
  * Optionally logs the error to console.
  *
+ * **Important**: Do NOT pass AbortErrors to this function. AbortErrors (err.name === 'AbortError')
+ * represent deliberate user cancellation and must be re-thrown as-is from the catch block so that
+ * callers can reliably detect them via `err.name === 'AbortError'` or `err instanceof DOMException`.
+ * This function always returns a plain `new Error(...)`, which would strip the AbortError identity.
+ *
  * @param error - The original error object
  * @param config - Parser configuration
  * @param filePath - Optional file path for context
@@ -44,3 +49,18 @@ export declare const getWrappedError: (error: any, config: OfficeParserConfig, f
  * @param error - Optional original error object
  */
 export declare const logWarning: (type: OfficeWarningType, config?: OfficeParserConfig, info?: any, error?: any) => void;
+/**
+ * Creates and returns a standard AbortError (DOMException if available).
+ * Used when the user signals cancellation of the parser operation.
+ *
+ * @returns Error object representing the abort action
+ */
+export declare const getAbortError: () => Error;
+/**
+ * Checks the provided AbortSignal and throws an AbortError if it was aborted.
+ * Helps cleanly interrupt loops and asynchronous phases of parsing.
+ *
+ * @param signal - Optional AbortSignal to inspect
+ * @throws {DOMException} If the signal has been aborted
+ */
+export declare const checkAbortSignal: (signal?: AbortSignal | null) => void;

package/dist/utils/errorUtils.js

@@ -7,7 +7,7 @@
  * consistent error reporting across all parsers and the main entry point.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.logWarning = exports.getWrappedError = exports.getOfficeError = exports.getWarningMessage = void 0;
+exports.checkAbortSignal = exports.getAbortError = exports.logWarning = exports.getWrappedError = exports.getOfficeError = exports.getWarningMessage = void 0;
 const types_js_1 = require("../types.js");
 /** Error header prefix for all error messages */
 const ERRORHEADER = "[OfficeParser]: ";
@@ -28,7 +28,8 @@ const ERROR_MESSAGES = {
     [types_js_1.OfficeErrorType.INVALID_STYLE_MAPPING]: (mapping) => `Invalid style mapping string: ${mapping}`,
     [types_js_1.OfficeErrorType.INVALID_SELECTOR]: (selector) => `Invalid selector: ${selector}`,
     [types_js_1.OfficeErrorType.INVALID_OUTPUT_MAPPING]: (output) => `Invalid output mapping: ${output}`,
-    [types_js_1.OfficeErrorType.MISSING_EMBEDDING_FUNCTION]: `Semantic chunking requires an "embeddingFunction" to be provided in chunksConfig. This function must accept a string and return a Promise resolving to a number array (vector).`
+    [types_js_1.OfficeErrorType.MISSING_EMBEDDING_FUNCTION]: `Semantic chunking requires an "embeddingFunction" to be provided in chunksConfig. This function must accept a string and return a Promise resolving to a number array (vector).`,
+    [types_js_1.OfficeErrorType.OPERATION_ABORTED]: `The operation was aborted.`
 };
 /**
  * Lookup table for warning messages.
@@ -49,7 +50,8 @@ const WARNING_MESSAGES = {
     [types_js_1.OfficeWarningType.BUFFER_TYPE_MISMATCH]: (info) => `File content type mismatch: Detected '${info.detected}' but expected/provided '${info.expected}'. Parsing will proceed with '${info.expected}' as requested.`,
     [types_js_1.OfficeWarningType.FILE_TYPE_DETECTION_FAILED]: `Auto-detection of file type failed. This can happen on older Node.js versions with modern file-type versions. Please provide the 'fileType' hint in the configuration if parsing fails.`,
     [types_js_1.OfficeWarningType.EMPTY_CHUNK_GENERATED]: (strategy) => `No chunks generated for document. Check if the document content is compatible with the '${strategy}' strategy.`,
-    [types_js_1.OfficeWarningType.WHITESPACE_NODE_SKIPPED]: (nodeType) => `Skipped whitespace-only node of type: ${nodeType}`
+    [types_js_1.OfficeWarningType.WHITESPACE_NODE_SKIPPED]: (nodeType) => `Skipped whitespace-only node of type: ${nodeType}`,
+    [types_js_1.OfficeWarningType.INVALID_CONTAINER_WIDTH]: (val) => `Invalid HTML containerWidth: ${JSON.stringify(val)}. Falling back to "auto". Width must be a positive number, a valid CSS length string (e.g., "900px", "100%", "50vw"), or "auto".`
 };
 /**
  * Creates a formatted warning message for a specific warning type.
@@ -118,6 +120,11 @@ exports.getOfficeError = getOfficeError;
  * Wraps an existing error with OfficeParser context and performs corruption detection.
  * Optionally logs the error to console.
  *
+ * **Important**: Do NOT pass AbortErrors to this function. AbortErrors (err.name === 'AbortError')
+ * represent deliberate user cancellation and must be re-thrown as-is from the catch block so that
+ * callers can reliably detect them via `err.name === 'AbortError'` or `err instanceof DOMException`.
+ * This function always returns a plain `new Error(...)`, which would strip the AbortError identity.
+ *
  * @param error - The original error object
  * @param config - Parser configuration
  * @param filePath - Optional file path for context
@@ -176,3 +183,32 @@ const logWarning = (type, config, info, error) => {
     reportIssue(issue, config);
 };
 exports.logWarning = logWarning;
+/**
+ * Creates and returns a standard AbortError (DOMException if available).
+ * Used when the user signals cancellation of the parser operation.
+ *
+ * @returns Error object representing the abort action
+ */
+const getAbortError = () => {
+    const message = ERROR_MESSAGES[types_js_1.OfficeErrorType.OPERATION_ABORTED];
+    if (typeof DOMException !== 'undefined') {
+        return new DOMException(message, 'AbortError');
+    }
+    const err = new Error(message);
+    err.name = 'AbortError';
+    return err;
+};
+exports.getAbortError = getAbortError;
+/**
+ * Checks the provided AbortSignal and throws an AbortError if it was aborted.
+ * Helps cleanly interrupt loops and asynchronous phases of parsing.
+ *
+ * @param signal - Optional AbortSignal to inspect
+ * @throws {DOMException} If the signal has been aborted
+ */
+const checkAbortSignal = (signal) => {
+    if (signal?.aborted) {
+        throw (0, exports.getAbortError)();
+    }
+};
+exports.checkAbortSignal = checkAbortSignal;

package/dist/utils/moduleLoader.js

@@ -14,7 +14,7 @@ exports.loadPdfJs = loadPdfJs;
 const envUtils_js_1 = require("./envUtils.js");
 async function loadNodeEsmModule(specifier) {
     // In Node.js, we resolve the specifier to an absolute file URL.
-    // This ensures that the dynamic import() call (executed via new Function)
+    // This ensures that the dynamic import() call
     // always finds the correct module regardless of the caller's context.
     // This is especially important in Node 18 for sub-paths of packages.
     try {
@@ -22,11 +22,11 @@ async function loadNodeEsmModule(specifier) {
         // @ts-ignore - require.resolve is available in Node.js
         const absolutePath = require.resolve(specifier);
         const fileUrl = pathToFileURL(absolutePath).href;
-        return new Function('s', 'return import(s)')(fileUrl);
+        return import(fileUrl);
     }
     catch (e) {
         // Fallback for cases where require.resolve might fail (e.g. non-file specifiers)
-        return new Function('s', 'return import(s)')(specifier);
+        return import(specifier);
     }
 }
 /**

package/dist/utils/ocrUtils.js

@@ -13,6 +13,24 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.terminateOcr = exports.performOcr = void 0;
 const envUtils_js_1 = require("./envUtils.js");
+const errorUtils_js_1 = require("./errorUtils.js");
+/**
+ * Wraps a promise in a timeout.
+ *
+ * @param promise - The promise to wrap
+ * @param ms - Timeout duration in milliseconds
+ * @param errMsg - Error message to throw if timeout occurs
+ * @returns The wrapped promise
+ */
+function withTimeout(promise, ms, errMsg) {
+    let id;
+    const timeout = new Promise((_, reject) => {
+        id = setTimeout(() => {
+            reject(new Error(errMsg));
+        }, ms);
+    });
+    return Promise.race([promise, timeout]).then((res) => { clearTimeout(id); return res; }, (err) => { clearTimeout(id); throw err; });
+}
 /**
  * Manages a pool of Tesseract workers with "Smart Affinity".
  *
@@ -31,6 +49,7 @@ class OcrSchedulerManager {
     MAX_WORKERS = 4;
     idleTimeout = 10000; // 10s default
     timeoutId = null;
+    isProcessing = false;
     constructor() { }
     /**
      * Returns the singleton instance of the manager.
@@ -65,103 +84,289 @@ class OcrSchedulerManager {
      * Performs OCR on an image using the smart worker pool.
      *
      * @param image - Image data (Buffer, string path, or Blob)
-     * @param config - OCR configuration (language, custom paths)
+     * @param config - OCR configuration (language, custom paths, timeouts, signal)
      * @returns Recognized text
      */
     async recognize(image, config) {
+        const signal = config?.abortSignal;
+        if (signal?.aborted) {
+            return Promise.reject((0, errorUtils_js_1.getAbortError)());
+        }
         return new Promise((resolve, reject) => {
-            // Update idle timeout if provided
-            if (config?.autoTerminateTimeout !== undefined) {
-                this.idleTimeout = config.autoTerminateTimeout;
+            // Update idle timeout if provided.
+            // Priority: timeout.autoTerminate (new) > autoTerminateTimeout (deprecated) > built-in default.
+            const effectiveAutoTerminate = config?.timeout?.autoTerminate ?? config?.autoTerminateTimeout;
+            if (effectiveAutoTerminate !== undefined) {
+                this.idleTimeout = effectiveAutoTerminate;
             }
             // Reset the inactivity timer every time a new job is requested
             this.resetIdleTimer();
+            let abortListener = null;
+            let finished = false;
+            let job;
+            const cleanResolve = (val) => {
+                if (finished)
+                    return;
+                finished = true;
+                if (job)
+                    job.isFinished = true;
+                if (abortListener && signal) {
+                    signal.removeEventListener('abort', abortListener);
+                }
+                resolve(val);
+            };
+            const cleanReject = (err) => {
+                if (finished)
+                    return;
+                finished = true;
+                if (job)
+                    job.isFinished = true;
+                if (abortListener && signal) {
+                    signal.removeEventListener('abort', abortListener);
+                }
+                reject(err);
+            };
+            // Priority: timeout.recognition (new) > 30 s default.
+            const recogTimeout = config?.timeout?.recognition ?? 30000;
+            // Create job
+            job = {
+                image,
+                config: config || {},
+                resolve: cleanResolve,
+                reject: cleanReject,
+                startTime: Date.now(),
+                timeoutMs: recogTimeout
+            };
+            if (signal) {
+                abortListener = () => {
+                    if (finished)
+                        return;
+                    const err = (0, errorUtils_js_1.getAbortError)();
+                    cleanReject(err);
+                    // 1. Remove job from queue if it hasn't run yet
+                    const idx = this.queue.indexOf(job);
+                    if (idx !== -1) {
+                        this.queue.splice(idx, 1);
+                    }
+                    // 2. Find if any worker is currently running this job and terminate/remove it
+                    const workerIndex = this.pool.findIndex(mw => mw.activeJob === job);
+                    if (workerIndex !== -1) {
+                        const managedWorker = this.pool[workerIndex];
+                        // Remove from pool immediately to prevent reuse
+                        this.pool.splice(workerIndex, 1);
+                        // Terminate the worker process
+                        try {
+                            managedWorker.worker.terminate();
+                        }
+                        catch (e) { }
+                        // Trigger queue processing for subsequent tasks
+                        this.processQueue();
+                    }
+                };
+                signal.addEventListener('abort', abortListener);
+            }
             // Add job to queue and trigger processing
-            this.queue.push({ image, config: config || {}, resolve, reject });
+            this.queue.push(job);
             this.processQueue();
         });
     }
     /**
      * Attempts to process the next job in the queue using an available worker.
+     * Designed to be race-free and support concurrent/parallel job execution.
      */
     async processQueue() {
-        if (this.queue.length === 0)
+        if (this.isProcessing)
             return;
-        const nextJob = this.queue[0];
-        const requestedLanguage = nextJob.config.language || 'eng';
-        // 1. Find an idle worker with the EXACT language affinity
-        let managed = this.pool.find(mw => !mw.isBusy && mw.language === requestedLanguage);
-        // 2. If not found and we have room, create a new worker
-        if (!managed && this.pool.length < this.MAX_WORKERS) {
-            try {
-                const { createWorker } = await import('tesseract.js');
-                const options = { logger: () => { } };
-                if (nextJob.config.workerPath)
-                    options.workerPath = nextJob.config.workerPath;
-                if (nextJob.config.corePath)
-                    options.corePath = nextJob.config.corePath;
-                if (nextJob.config.langPath)
-                    options.langPath = nextJob.config.langPath;
-                const worker = await createWorker(requestedLanguage, 1, options);
-                managed = {
-                    worker,
-                    language: requestedLanguage,
-                    lastUsed: Date.now(),
-                    isBusy: false
-                };
-                this.pool.push(managed);
+        this.isProcessing = true;
+        try {
+            while (this.queue.length > 0) {
+                const nextJob = this.queue[0];
+                if (nextJob.isFinished) {
+                    this.queue.shift();
+                    continue;
+                }
+                const requestedLanguage = nextJob.config.language || 'eng';
+                // 1. Find an idle worker with the EXACT language affinity
+                let managed = this.pool.find(mw => !mw.isBusy && mw.language === requestedLanguage);
+                // 2. If not found and we have room, create a new worker
+                if (!managed && this.pool.length < this.MAX_WORKERS) {
+                    const job = this.queue.shift();
+                    if (!job)
+                        continue;
+                    this.createAndRunWorker(job, requestedLanguage);
+                    continue;
+                }
+                // 3. If still not found and we are at capacity, find the LRU idle worker and re-initialize it
+                if (!managed) {
+                    const idleWorkers = this.pool.filter(mw => !mw.isBusy);
+                    if (idleWorkers.length > 0) {
+                        const job = this.queue.shift();
+                        if (!job)
+                            continue;
+                        managed = idleWorkers.reduce((prev, curr) => (prev.lastUsed < curr.lastUsed ? prev : curr));
+                        this.reinitializeAndRunWorker(managed, job, requestedLanguage);
+                        continue;
+                    }
+                }
+                // 4. If we have a worker ready, execute the job
+                if (managed) {
+                    const job = this.queue.shift();
+                    if (!job)
+                        continue;
+                    this.runWorker(managed, job);
+                    continue;
+                }
+                // No workers can be allocated right now (all busy and pool at capacity). Break work loop.
+                break;
             }
-            catch (err) {
-                const job = this.queue.shift();
-                job?.reject(err);
-                this.processQueue(); // Try next job
+        }
+        finally {
+            this.isProcessing = false;
+        }
+    }
+    /**
+     * Helper to dynamically instantiate a Tesseract worker, register it to the pool, and run the job.
+     */
+    async createAndRunWorker(job, requestedLanguage) {
+        // Priority: timeout.workerLoad (new) > 60 s default.
+        const loadTimeout = job.config.timeout?.workerLoad ?? 60000;
+        let managed = null;
+        try {
+            const { createWorker } = await import('tesseract.js');
+            const options = { logger: () => { } };
+            if (job.config.workerPath)
+                options.workerPath = job.config.workerPath;
+            if (job.config.corePath)
+                options.corePath = job.config.corePath;
+            if (job.config.langPath)
+                options.langPath = job.config.langPath;
+            const workerPromise = createWorker(requestedLanguage, 1, options);
+            // To prevent dangling worker threads on timeout or abort, we register a post-resolution hook
+            // that terminates the worker if the promise finishes after the timeout has fired or the job is finished.
+            let hasTimedOutOrAborted = false;
+            workerPromise.then(async (worker) => {
+                if (hasTimedOutOrAborted || job.isFinished) {
+                    try {
+                        await worker.terminate();
+                    }
+                    catch (e) { }
+                }
+            }, () => { });
+            const worker = loadTimeout > 0
+                ? await withTimeout(workerPromise, loadTimeout, `OCR worker initialization timed out after ${loadTimeout}ms`).catch(err => {
+                    hasTimedOutOrAborted = true;
+                    throw err;
+                })
+                : await workerPromise;
+            // If the job finished/aborted while loading, clean up the worker and skip execution.
+            if (job.isFinished) {
+                hasTimedOutOrAborted = true;
+                try {
+                    await worker.terminate();
+                }
+                catch (e) { }
+                this.processQueue();
                 return;
             }
+            managed = {
+                worker,
+                language: requestedLanguage,
+                lastUsed: Date.now(),
+                isBusy: false
+            };
+            this.pool.push(managed);
+            await this.runWorker(managed, job);
         }
-        // 3. If still not found and we are at capacity, find the LRU idle worker and re-initialize it
-        if (!managed) {
-            const idleWorkers = this.pool.filter(mw => !mw.isBusy);
-            if (idleWorkers.length > 0) {
-                // Find Least Recently Used idle worker
-                managed = idleWorkers.reduce((prev, curr) => (prev.lastUsed < curr.lastUsed ? prev : curr));
-                try {
-                    // Smart Re-initialization (v5 API)
-                    await managed.worker.reinitialize(requestedLanguage);
-                    managed.language = requestedLanguage;
+        catch (err) {
+            job.reject(err);
+            this.processQueue();
+        }
+    }
+    /**
+     * Helper to reinitialize an existing idle worker with a different language affinity and run the job.
+     */
+    async reinitializeAndRunWorker(managed, job, requestedLanguage) {
+        // Priority: timeout.workerLoad (new) > 60 s default.
+        const loadTimeout = job.config.timeout?.workerLoad ?? 60000;
+        managed.isBusy = true;
+        managed.lastUsed = Date.now();
+        managed.activeJob = job;
+        try {
+            const reinitPromise = managed.worker.reinitialize(requestedLanguage);
+            if (loadTimeout > 0) {
+                await withTimeout(reinitPromise, loadTimeout, `OCR worker re-initialization timed out after ${loadTimeout}ms`);
+            }
+            else {
+                await reinitPromise;
+            }
+            managed.language = requestedLanguage;
+            // If the job finished/aborted while reinitializing, clean up and skip execution.
+            if (job.isFinished) {
+                const index = this.pool.indexOf(managed);
+                if (index !== -1) {
+                    this.pool.splice(index, 1);
                 }
-                catch (err) {
-                    // If reinitialization fails, we might need to recreate it, but for simplicity 
-                    // we'll just fail this job and try another worker next time.
-                    const job = this.queue.shift();
-                    job?.reject(err);
-                    this.processQueue();
-                    return;
+                try {
+                    await managed.worker.terminate();
                 }
+                catch (e) { }
+                this.processQueue();
+                return;
             }
+            await this.runWorker(managed, job);
         }
-        // 4. If we have a worker ready, execute the job
-        if (managed) {
-            const job = this.queue.shift();
-            if (!job)
-                return;
-            managed.isBusy = true;
-            managed.lastUsed = Date.now();
+        catch (err) {
+            // Re-initialization failed/timed out, remove worker from pool and terminate
+            const index = this.pool.indexOf(managed);
+            if (index !== -1) {
+                this.pool.splice(index, 1);
+            }
             try {
-                const { data: { text } } = await managed.worker.recognize(job.image);
-                job.resolve(text);
+                await managed.worker.terminate();
             }
-            catch (err) {
-                job.reject(err);
+            catch (e) { }
+            job.reject(err);
+            this.processQueue();
+        }
+    }
+    /**
+     * Helper to execute OCR text recognition on the worker and return the results.
+     */
+    async runWorker(managed, job) {
+        // Priority: timeout.recognition (new) > 30 s default.
+        const recogTimeout = job.config.timeout?.recognition ?? 30000;
+        managed.isBusy = true;
+        managed.lastUsed = Date.now();
+        managed.activeJob = job;
+        try {
+            const recognizePromise = managed.worker.recognize(job.image);
+            const { data: { text } } = recogTimeout > 0
+                ? await withTimeout(recognizePromise, recogTimeout, `OCR recognition timed out after ${recogTimeout}ms`)
+                : await recognizePromise;
+            job.resolve(text);
+        }
+        catch (err) {
+            // If it timed out, terminate and remove worker to avoid reusing a stuck process
+            if (err.message?.includes('timed out')) {
+                const index = this.pool.indexOf(managed);
+                if (index !== -1) {
+                    this.pool.splice(index, 1);
+                }
+                try {
+                    await managed.worker.terminate();
+                }
+                catch (e) { }
             }
-            finally {
+            job.reject(err);
+        }
+        finally {
+            if (this.pool.includes(managed)) {
                 managed.isBusy = false;
+                managed.activeJob = undefined;
                 managed.lastUsed = Date.now();
-                // Check if there are more jobs waiting
-                this.processQueue();
             }
+            this.processQueue();
         }
-        // If no worker is available (all busy), the job stays in the queue 
-        // and will be picked up when a worker finishes.
     }
     /**
      * Terminates all workers in the pool and resets the state.