@embedpdf/engines 2.0.0-next.2 → 2.0.0

package/dist/lib/converters/node.d.ts

@@ -0,0 +1,51 @@
+import { PdfImage, ImageConversionTypes } from '@embedpdf/models';
+import { ImageDataConverter } from './types';
+/**
+ * Node.js implementation using Sharp
+ * This requires the 'sharp' package to be installed
+ *
+ * @example
+ * ```typescript
+ * import sharp from 'sharp';
+ * import { createNodeImageDataToBufferConverter } from '@embedpdf/engines';
+ *
+ * const imageDataConverter = createNodeImageDataToBufferConverter(sharp);
+ * const engine = new PdfiumEngine(pdfiumModule, { logger, imageDataConverter });
+ * ```
+ */
+export declare function createNodeImageDataToBufferConverter(sharp: any): ImageDataConverter<Buffer>;
+/**
+ * Alternative Node.js implementation using canvas (node-canvas)
+ * This requires the 'canvas' package to be installed
+ *
+ * @example
+ * ```typescript
+ * import { createCanvas } from 'canvas';
+ * import { createNodeCanvasImageDataToBlobConverter } from '@embedpdf/engines';
+ *
+ * const imageDataConverter = createNodeCanvasImageDataToBlobConverter(createCanvas);
+ * const engine = new PdfiumEngine(pdfiumModule, { logger, imageDataConverter });
+ * ```
+ */
+export declare function createNodeCanvasImageDataToBlobConverter(createCanvas: any): ImageDataConverter<Buffer>;
+/**
+ * Generic Node.js implementation that works with any image processing library
+ * that can handle raw RGBA data
+ *
+ * @example
+ * ```typescript
+ * const converter = createCustomImageDataToBlobConverter(async (imageData) => {
+ *   // Your custom image processing logic here
+ *   // Return a Buffer that will be wrapped in a Blob
+ *   return processImageWithYourLibrary(imageData);
+ * });
+ * ```
+ */
+export declare function createCustomImageDataToBlobConverter(processor: (imageData: PdfImage, imageType?: ImageConversionTypes, imageQuality?: number) => Promise<Buffer>): ImageDataConverter;
+/**
+ * Create a custom converter that returns a Buffer
+ * @param processor - function to process the image data
+ * @param imageType - image type
+ * @returns ImageDataToBlobConverter<Buffer>
+ */
+export declare function createCustomImageDataToBufferConverter(processor: (imageData: PdfImage, imageType: ImageConversionTypes, imageQuality?: number) => Promise<Buffer>): ImageDataConverter<Buffer>;

package/dist/lib/converters/types.d.ts

@@ -1,9 +1,12 @@
-import { PdfImage } from '@embedpdf/models';
+import { PdfImage, ImageConversionTypes } from '@embedpdf/models';
+export type { ImageConversionTypes } from '@embedpdf/models';
+/**
+ * Lazy image data getter function
+ */
 export type LazyImageData = () => PdfImage;
 /**
- * Function type for converting ImageData to Blob
+ * Function type for converting ImageData to Blob or other format
  * In browser: uses OffscreenCanvas
  * In Node.js: can use Sharp or other image processing libraries
  */
 export type ImageDataConverter<T = Blob> = (getImageData: LazyImageData, imageType?: ImageConversionTypes, imageQuality?: number) => Promise<T>;
-export type ImageConversionTypes = 'image/webp' | 'image/png' | 'image/jpeg';

package/dist/lib/image-encoder/image-encoder-worker.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Dedicated worker for image encoding operations
+ * Offloads OffscreenCanvas.convertToBlob() from the main PDFium worker
+ */
+export interface EncodeImageRequest {
+    id: string;
+    type: 'encode';
+    data: {
+        imageData: {
+            data: Uint8ClampedArray;
+            width: number;
+            height: number;
+        };
+        imageType: 'image/png' | 'image/jpeg' | 'image/webp';
+        quality?: number;
+    };
+}
+export interface EncodeImageResponse {
+    id: string;
+    type: 'result' | 'error';
+    data: Blob | {
+        message: string;
+    };
+}

package/dist/lib/image-encoder/index.d.ts

@@ -0,0 +1,2 @@
+export * from './worker-pool';
+export type { EncodeImageRequest, EncodeImageResponse } from './image-encoder-worker';

package/dist/lib/image-encoder/worker-pool.d.ts

@@ -0,0 +1,61 @@
+import { Logger } from '@embedpdf/models';
+/**
+ * Pool of image encoding workers to offload OffscreenCanvas operations
+ * from the main PDFium worker thread
+ */
+export declare class ImageEncoderWorkerPool {
+    private poolSize;
+    private workerUrl;
+    private workers;
+    private pendingTasks;
+    private nextWorkerId;
+    private requestCounter;
+    private logger;
+    /**
+     * Create a pool of image encoding workers
+     * @param poolSize - Number of workers to create (default: 2)
+     * @param workerUrl - URL to the worker script
+     * @param logger - Logger instance
+     */
+    constructor(poolSize: number | undefined, workerUrl: string, logger?: Logger);
+    /**
+     * Initialize the worker pool
+     */
+    private initialize;
+    /**
+     * Handle messages from workers
+     */
+    private handleWorkerMessage;
+    /**
+     * Handle worker errors
+     */
+    private handleWorkerError;
+    /**
+     * Get the next available worker using round-robin
+     */
+    private getNextWorker;
+    /**
+     * Encode ImageData to Blob using a worker from the pool
+     * @param imageData - Raw image data
+     * @param imageType - Target image format
+     * @param quality - Image quality (0-1) for lossy formats
+     * @returns Promise that resolves to encoded Blob
+     */
+    encode(imageData: {
+        data: Uint8ClampedArray;
+        width: number;
+        height: number;
+    }, imageType?: 'image/png' | 'image/jpeg' | 'image/webp', quality?: number): Promise<Blob>;
+    /**
+     * Destroy all workers in the pool
+     */
+    destroy(): void;
+    /**
+     * Get the number of active workers in the pool
+     */
+    get activeWorkers(): number;
+    /**
+     * Get the number of pending encoding tasks
+     */
+    get pendingTasksCount(): number;
+}

package/dist/lib/orchestrator/index.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Orchestrator layer for PDF engines
+ *
+ * This module provides the "smart" orchestration layer that wraps
+ * the "dumb" executor (PdfiumNative or RemoteExecutor) with:
+ * - Priority-based task scheduling
+ * - Visibility-aware task ranking
+ * - Parallel image encoding
+ * - Multi-page operation orchestration
+ *
+ * @packageDocumentation
+ */
+export * from './task-queue';
+export * from './pdf-engine';
+export * from './remote-executor';
+export * from './pdfium-native-runner';

package/dist/lib/orchestrator/pdf-engine.d.ts

@@ -0,0 +1,99 @@
+import { Logger, PdfEngine as IPdfEngine, PdfDocumentObject, PdfPageObject, PdfTask, PdfErrorReason, PdfFileUrl, PdfFile, PdfOpenDocumentUrlOptions, PdfOpenDocumentBufferOptions, PdfMetadataObject, PdfBookmarksObject, PdfBookmarkObject, PdfRenderPageOptions, PdfRenderThumbnailOptions, PdfRenderPageAnnotationOptions, PdfAnnotationObject, PdfTextRectObject, PdfSearchAllPagesOptions, SearchAllPagesResult, PdfPageSearchProgress, PdfAnnotationsProgress, PdfAttachmentObject, PdfAddAttachmentParams, PdfWidgetAnnoObject, FormFieldValue, PdfFlattenPageOptions, PdfPageFlattenResult, PdfRedactTextOptions, Rect, PageTextSlice, PdfGlyphObject, PdfPageGeometry, PdfPrintOptions, PdfEngineFeature, PdfEngineOperation, PdfSignatureObject, AnnotationCreateContext, CompoundTask, IPdfiumExecutor } from '@embedpdf/models';
+import { ImageDataConverter } from '../converters/types';
+export type { ImageDataConverter } from '../converters/types';
+export type { ImageDataLike, IPdfiumExecutor, BatchProgress } from '@embedpdf/models';
+export interface PdfEngineOptions<T> {
+    /**
+     * Image data converter (for encoding raw image data to Blob/other format)
+     */
+    imageConverter: ImageDataConverter<T>;
+    /**
+     * Fetch function for fetching remote URLs
+     */
+    fetcher?: typeof fetch;
+    /**
+     * Logger instance
+     */
+    logger?: Logger;
+}
+/**
+ * PdfEngine orchestrator
+ *
+ * This is the "smart" layer that:
+ * - Implements the PdfEngine interface
+ * - Uses WorkerTaskQueue for priority-based task scheduling
+ * - Orchestrates complex multi-page operations
+ * - Handles image encoding with separate encoder pool
+ * - Manages visibility-based task ranking
+ */
+export declare class PdfEngine<T = Blob> implements IPdfEngine<T> {
+    private executor;
+    private workerQueue;
+    private logger;
+    private options;
+    constructor(executor: IPdfiumExecutor, options: PdfEngineOptions<T>);
+    /**
+     * Split an array into chunks of a given size
+     */
+    private chunkArray;
+    isSupport(feature: PdfEngineFeature): PdfTask<PdfEngineOperation[]>;
+    destroy(): PdfTask<boolean>;
+    openDocumentUrl(file: PdfFileUrl, options?: PdfOpenDocumentUrlOptions): PdfTask<PdfDocumentObject>;
+    openDocumentBuffer(file: PdfFile, options?: PdfOpenDocumentBufferOptions): PdfTask<PdfDocumentObject>;
+    getMetadata(doc: PdfDocumentObject): PdfTask<PdfMetadataObject>;
+    setMetadata(doc: PdfDocumentObject, metadata: Partial<PdfMetadataObject>): PdfTask<boolean>;
+    getDocPermissions(doc: PdfDocumentObject): PdfTask<number>;
+    getDocUserPermissions(doc: PdfDocumentObject): PdfTask<number>;
+    getSignatures(doc: PdfDocumentObject): PdfTask<PdfSignatureObject[]>;
+    getBookmarks(doc: PdfDocumentObject): PdfTask<PdfBookmarksObject>;
+    setBookmarks(doc: PdfDocumentObject, bookmarks: PdfBookmarkObject[]): PdfTask<boolean>;
+    deleteBookmarks(doc: PdfDocumentObject): PdfTask<boolean>;
+    renderPage(doc: PdfDocumentObject, page: PdfPageObject, options?: PdfRenderPageOptions): PdfTask<T>;
+    renderPageRect(doc: PdfDocumentObject, page: PdfPageObject, rect: Rect, options?: PdfRenderPageOptions): PdfTask<T>;
+    renderThumbnail(doc: PdfDocumentObject, page: PdfPageObject, options?: PdfRenderThumbnailOptions): PdfTask<T>;
+    renderPageAnnotation(doc: PdfDocumentObject, page: PdfPageObject, annotation: PdfAnnotationObject, options?: PdfRenderPageAnnotationOptions): PdfTask<T>;
+    /**
+     * Helper to render and encode in two stages with priority queue
+     */
+    private renderWithEncoding;
+    /**
+     * Encode image using encoder pool or inline
+     */
+    private encodeImage;
+    getPageAnnotations(doc: PdfDocumentObject, page: PdfPageObject): PdfTask<PdfAnnotationObject[]>;
+    createPageAnnotation<A extends PdfAnnotationObject>(doc: PdfDocumentObject, page: PdfPageObject, annotation: A, context?: AnnotationCreateContext<A>): PdfTask<string>;
+    updatePageAnnotation(doc: PdfDocumentObject, page: PdfPageObject, annotation: PdfAnnotationObject): PdfTask<boolean>;
+    removePageAnnotation(doc: PdfDocumentObject, page: PdfPageObject, annotation: PdfAnnotationObject): PdfTask<boolean>;
+    /**
+     * Get all annotations across all pages
+     * Uses batched operations to reduce queue overhead
+     */
+    getAllAnnotations(doc: PdfDocumentObject): CompoundTask<Record<number, PdfAnnotationObject[]>, PdfErrorReason, PdfAnnotationsProgress>;
+    getPageTextRects(doc: PdfDocumentObject, page: PdfPageObject): PdfTask<PdfTextRectObject[]>;
+    /**
+     * Search across all pages
+     * Uses batched operations to reduce queue overhead
+     */
+    searchAllPages(doc: PdfDocumentObject, keyword: string, options?: PdfSearchAllPagesOptions): PdfTask<SearchAllPagesResult, PdfPageSearchProgress>;
+    getAttachments(doc: PdfDocumentObject): PdfTask<PdfAttachmentObject[]>;
+    addAttachment(doc: PdfDocumentObject, params: PdfAddAttachmentParams): PdfTask<boolean>;
+    removeAttachment(doc: PdfDocumentObject, attachment: PdfAttachmentObject): PdfTask<boolean>;
+    readAttachmentContent(doc: PdfDocumentObject, attachment: PdfAttachmentObject): PdfTask<ArrayBuffer>;
+    setFormFieldValue(doc: PdfDocumentObject, page: PdfPageObject, annotation: PdfWidgetAnnoObject, value: FormFieldValue): PdfTask<boolean>;
+    flattenPage(doc: PdfDocumentObject, page: PdfPageObject, options?: PdfFlattenPageOptions): PdfTask<PdfPageFlattenResult>;
+    extractPages(doc: PdfDocumentObject, pageIndexes: number[]): PdfTask<ArrayBuffer>;
+    extractText(doc: PdfDocumentObject, pageIndexes: number[]): PdfTask<string>;
+    redactTextInRects(doc: PdfDocumentObject, page: PdfPageObject, rects: Rect[], options?: PdfRedactTextOptions): PdfTask<boolean>;
+    getTextSlices(doc: PdfDocumentObject, slices: PageTextSlice[]): PdfTask<string[]>;
+    getPageGlyphs(doc: PdfDocumentObject, page: PdfPageObject): PdfTask<PdfGlyphObject[]>;
+    getPageGeometry(doc: PdfDocumentObject, page: PdfPageObject): PdfTask<PdfPageGeometry>;
+    merge(files: PdfFile[]): PdfTask<PdfFile>;
+    mergePages(mergeConfigs: Array<{
+        docId: string;
+        pageIndices: number[];
+    }>): PdfTask<PdfFile>;
+    preparePrintDocument(doc: PdfDocumentObject, options?: PdfPrintOptions): PdfTask<ArrayBuffer>;
+    saveAsCopy(doc: PdfDocumentObject): PdfTask<ArrayBuffer>;
+    closeDocument(doc: PdfDocumentObject): PdfTask<boolean>;
+    closeAllDocuments(): PdfTask<boolean>;
+}

package/dist/lib/orchestrator/pdfium-native-runner.d.ts

@@ -0,0 +1,65 @@
+import { Logger, TaskError } from '@embedpdf/models';
+import { PdfiumNative } from '../pdfium/engine';
+/**
+ * Request message from main thread
+ */
+export interface WorkerRequest {
+    id: string;
+    type: 'execute' | 'init';
+    method?: string;
+    args?: any[];
+    wasmUrl?: string;
+}
+/**
+ * Response message to main thread
+ */
+export interface WorkerResponse {
+    id: string;
+    type: 'result' | 'error' | 'progress' | 'ready';
+    data?: any;
+    error?: TaskError<any>;
+    progress?: any;
+}
+/**
+ * PdfiumNativeRunner - Worker runner for PdfiumNative
+ *
+ * This handles:
+ * - Initialization of PdfiumNative in worker context
+ * - Message handling from main thread
+ * - Task execution and result forwarding
+ * - Progress tracking
+ */
+export declare class PdfiumNativeRunner {
+    native: PdfiumNative | null;
+    logger: Logger;
+    private activeTasks;
+    constructor(logger?: Logger);
+    /**
+     * Initialize PDFium with WASM binary
+     */
+    prepare(wasmBinary: ArrayBuffer, logger?: Logger): Promise<void>;
+    /**
+     * Start listening for messages
+     */
+    listen(): void;
+    /**
+     * Handle incoming messages
+     */
+    handle(evt: MessageEvent<WorkerRequest>): void;
+    /**
+     * Handle initialization request
+     */
+    private handleInit;
+    /**
+     * Handle method execution request
+     */
+    private handleExecute;
+    /**
+     * Send response back to main thread
+     */
+    private respond;
+    /**
+     * Ready notification
+     */
+    ready(): void;
+}

package/dist/lib/orchestrator/remote-executor.d.ts

@@ -0,0 +1,93 @@
+import { BatchProgress, Logger, PdfDocumentObject, PdfPageObject, PdfTask, PdfFile, PdfOpenDocumentBufferOptions, PdfMetadataObject, PdfBookmarksObject, PdfBookmarkObject, PdfRenderPageOptions, PdfRenderThumbnailOptions, PdfRenderPageAnnotationOptions, PdfAnnotationObject, PdfTextRectObject, PdfAttachmentObject, PdfAddAttachmentParams, PdfWidgetAnnoObject, FormFieldValue, PdfFlattenPageOptions, PdfPageFlattenResult, PdfRedactTextOptions, Rect, PageTextSlice, PdfGlyphObject, PdfPageGeometry, PdfPrintOptions, PdfSignatureObject, AnnotationCreateContext, SearchResult, IPdfiumExecutor, ImageDataLike } from '@embedpdf/models';
+/**
+ * Options for creating a RemoteExecutor
+ */
+export interface RemoteExecutorOptions {
+    /**
+     * URL to the pdfium.wasm file (required)
+     */
+    wasmUrl: string;
+    /**
+     * Logger instance for debugging
+     */
+    logger?: Logger;
+}
+/**
+ * RemoteExecutor - Proxy for worker communication
+ *
+ * This implements IPdfExecutor but forwards all calls to a Web Worker.
+ * It handles:
+ * - Serialization/deserialization of messages
+ * - Promise/Task conversion
+ * - Error handling
+ * - Progress tracking
+ */
+export declare class RemoteExecutor implements IPdfiumExecutor {
+    private worker;
+    private static READY_TASK_ID;
+    private pendingRequests;
+    private requestCounter;
+    private logger;
+    private readyTask;
+    constructor(worker: Worker, options: RemoteExecutorOptions);
+    /**
+     * Generate unique request ID
+     */
+    private generateId;
+    /**
+     * Send a message to the worker and return a Task
+     * Waits for worker to be ready before sending
+     */
+    private send;
+    /**
+     * Handle messages from worker
+     */
+    private handleMessage;
+    /**
+     * Cleanup and terminate worker
+     */
+    destroy(): void;
+    openDocumentBuffer(file: PdfFile, options?: PdfOpenDocumentBufferOptions): PdfTask<PdfDocumentObject>;
+    getMetadata(doc: PdfDocumentObject): PdfTask<PdfMetadataObject>;
+    setMetadata(doc: PdfDocumentObject, metadata: Partial<PdfMetadataObject>): PdfTask<boolean>;
+    getDocPermissions(doc: PdfDocumentObject): PdfTask<number>;
+    getDocUserPermissions(doc: PdfDocumentObject): PdfTask<number>;
+    getSignatures(doc: PdfDocumentObject): PdfTask<PdfSignatureObject[]>;
+    getBookmarks(doc: PdfDocumentObject): PdfTask<PdfBookmarksObject>;
+    setBookmarks(doc: PdfDocumentObject, bookmarks: PdfBookmarkObject[]): PdfTask<boolean>;
+    deleteBookmarks(doc: PdfDocumentObject): PdfTask<boolean>;
+    renderPageRaw(doc: PdfDocumentObject, page: PdfPageObject, options?: PdfRenderPageOptions): PdfTask<ImageDataLike>;
+    renderPageRect(doc: PdfDocumentObject, page: PdfPageObject, rect: Rect, options?: PdfRenderPageOptions): PdfTask<ImageDataLike>;
+    renderThumbnailRaw(doc: PdfDocumentObject, page: PdfPageObject, options?: PdfRenderThumbnailOptions): PdfTask<ImageDataLike>;
+    renderPageAnnotationRaw(doc: PdfDocumentObject, page: PdfPageObject, annotation: PdfAnnotationObject, options?: PdfRenderPageAnnotationOptions): PdfTask<ImageDataLike>;
+    getPageAnnotationsRaw(doc: PdfDocumentObject, page: PdfPageObject): PdfTask<PdfAnnotationObject[]>;
+    getPageAnnotations(doc: PdfDocumentObject, page: PdfPageObject): PdfTask<PdfAnnotationObject[]>;
+    createPageAnnotation<A extends PdfAnnotationObject>(doc: PdfDocumentObject, page: PdfPageObject, annotation: A, context?: AnnotationCreateContext<A>): PdfTask<string>;
+    updatePageAnnotation(doc: PdfDocumentObject, page: PdfPageObject, annotation: PdfAnnotationObject): PdfTask<boolean>;
+    removePageAnnotation(doc: PdfDocumentObject, page: PdfPageObject, annotation: PdfAnnotationObject): PdfTask<boolean>;
+    getPageTextRects(doc: PdfDocumentObject, page: PdfPageObject): PdfTask<PdfTextRectObject[]>;
+    searchInPage(doc: PdfDocumentObject, page: PdfPageObject, keyword: string, flags: number): PdfTask<SearchResult[]>;
+    getAnnotationsBatch(doc: PdfDocumentObject, pages: PdfPageObject[]): PdfTask<Record<number, PdfAnnotationObject[]>, BatchProgress<PdfAnnotationObject[]>>;
+    searchBatch(doc: PdfDocumentObject, pages: PdfPageObject[], keyword: string, flags: number): PdfTask<Record<number, SearchResult[]>, BatchProgress<SearchResult[]>>;
+    getAttachments(doc: PdfDocumentObject): PdfTask<PdfAttachmentObject[]>;
+    addAttachment(doc: PdfDocumentObject, params: PdfAddAttachmentParams): PdfTask<boolean>;
+    removeAttachment(doc: PdfDocumentObject, attachment: PdfAttachmentObject): PdfTask<boolean>;
+    readAttachmentContent(doc: PdfDocumentObject, attachment: PdfAttachmentObject): PdfTask<ArrayBuffer>;
+    setFormFieldValue(doc: PdfDocumentObject, page: PdfPageObject, annotation: PdfWidgetAnnoObject, value: FormFieldValue): PdfTask<boolean>;
+    flattenPage(doc: PdfDocumentObject, page: PdfPageObject, options?: PdfFlattenPageOptions): PdfTask<PdfPageFlattenResult>;
+    extractPages(doc: PdfDocumentObject, pageIndexes: number[]): PdfTask<ArrayBuffer>;
+    extractText(doc: PdfDocumentObject, pageIndexes: number[]): PdfTask<string>;
+    redactTextInRects(doc: PdfDocumentObject, page: PdfPageObject, rects: Rect[], options?: PdfRedactTextOptions): PdfTask<boolean>;
+    getTextSlices(doc: PdfDocumentObject, slices: PageTextSlice[]): PdfTask<string[]>;
+    getPageGlyphs(doc: PdfDocumentObject, page: PdfPageObject): PdfTask<PdfGlyphObject[]>;
+    getPageGeometry(doc: PdfDocumentObject, page: PdfPageObject): PdfTask<PdfPageGeometry>;
+    merge(files: PdfFile[]): PdfTask<PdfFile>;
+    mergePages(mergeConfigs: Array<{
+        docId: string;
+        pageIndices: number[];
+    }>): PdfTask<PdfFile>;
+    preparePrintDocument(doc: PdfDocumentObject, options?: PdfPrintOptions): PdfTask<ArrayBuffer>;
+    saveAsCopy(doc: PdfDocumentObject): PdfTask<ArrayBuffer>;
+    closeDocument(doc: PdfDocumentObject): PdfTask<boolean>;
+    closeAllDocuments(): PdfTask<boolean>;
+}

package/dist/lib/orchestrator/task-queue.d.ts

@@ -0,0 +1,87 @@
+import { Task, Logger } from '@embedpdf/models';
+export declare enum Priority {
+    CRITICAL = 3,
+    HIGH = 2,
+    MEDIUM = 1,
+    LOW = 0
+}
+/**
+ * Extract result type from Task
+ */
+export type ExtractTaskResult<T> = T extends Task<infer R, any, any> ? R : never;
+/**
+ * Extract error type from Task
+ */
+export type ExtractTaskError<T> = T extends Task<any, infer D, any> ? D : never;
+/**
+ * Extract progress type from Task
+ */
+export type ExtractTaskProgress<T> = T extends Task<any, any, infer P> ? P : never;
+export interface QueuedTask<T extends Task<any, any, any>> {
+    id: string;
+    priority: Priority;
+    meta?: Record<string, unknown>;
+    executeFactory: () => T;
+    cancelled?: boolean;
+}
+export interface EnqueueOptions {
+    priority?: Priority;
+    meta?: Record<string, unknown>;
+    fifo?: boolean;
+}
+export type TaskComparator = (a: QueuedTask<any>, b: QueuedTask<any>) => number;
+export type TaskRanker = (task: QueuedTask<any>) => number;
+export interface WorkerTaskQueueOptions {
+    concurrency?: number;
+    comparator?: TaskComparator;
+    ranker?: TaskRanker;
+    onIdle?: () => void;
+    maxQueueSize?: number;
+    autoStart?: boolean;
+    logger?: Logger;
+}
+export declare class WorkerTaskQueue {
+    private queue;
+    private running;
+    private resultTasks;
+    private logger;
+    private opts;
+    constructor(options?: WorkerTaskQueueOptions);
+    setComparator(comparator?: TaskComparator): void;
+    setRanker(ranker?: TaskRanker): void;
+    size(): number;
+    inFlight(): number;
+    isIdle(): boolean;
+    drain(): Promise<void>;
+    private idleListeners;
+    private notifyIdle;
+    private onIdle;
+    private offIdle;
+    /**
+     * Enqueue a task factory - with automatic type inference!
+     *
+     * The factory function is ONLY called when it's the task's turn to execute.
+     *
+     * Usage:
+     *   const task = queue.enqueue({
+     *     execute: () => this.executor.getMetadata(doc),  // Factory - not called yet!
+     *     meta: { operation: 'getMetadata' }
+     *   }, { priority: Priority.LOW });
+     *
+     * The returned task has the SAME type as executor.getMetadata() would return!
+     */
+    enqueue<T extends Task<any, any, any>>(taskDef: {
+        execute: () => T;
+        meta?: Record<string, unknown>;
+    }, options?: EnqueueOptions): T;
+    /**
+     * Cancel/remove a task from the queue
+     */
+    private cancel;
+    private kick;
+    private process;
+    private sortQueue;
+    private defaultRank;
+    private generateId;
+    private extractTime;
+}