@cj-tech-master/excelts 5.1.18 → 6.0.0-beta.1

package/dist/cjs/modules/archive/compression/worker-pool/pool.browser.js

@@ -0,0 +1,867 @@
+"use strict";
+/**
+ * Browser Worker Pool Implementation
+ *
+ * A worker pool for parallel compression/decompression in the browser.
+ * Automatically manages worker lifecycle, task scheduling, and load balancing.
+ *
+ * Features:
+ * - Automatic worker scaling based on workload
+ * - Task prioritization (high/normal/low)
+ * - Idle worker termination to save resources
+ * - Transferable objects for zero-copy data transfer
+ * - Task cancellation via AbortSignal
+ * - Graceful error handling and recovery
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WorkerPool = exports.hasWorkerSupport = void 0;
+exports.getDefaultWorkerPool = getDefaultWorkerPool;
+exports.terminateDefaultWorkerPool = terminateDefaultWorkerPool;
+exports.deflateWithPool = deflateWithPool;
+exports.inflateWithPool = inflateWithPool;
+exports.deflateBatchWithPool = deflateBatchWithPool;
+exports.inflateBatchWithPool = inflateBatchWithPool;
+const pool_base_1 = require("./pool.base");
+Object.defineProperty(exports, "hasWorkerSupport", { enumerable: true, get: function () { return pool_base_1.hasWorkerSupport; } });
+const worker_script_1 = require("./worker-script");
+const EMPTY_CHUNK = new Uint8Array(0);
+const DEFAULT_MAX_INFLIGHT_STREAM_CHUNKS = 8;
+const DEFAULT_STREAM_HANDLERS = {
+    onData: (_chunk) => { },
+    onEnd: () => { },
+    onError: (_err) => { }
+};
+function isStandaloneBuffer(data) {
+    return data.byteOffset === 0 && data.byteLength === data.buffer.byteLength;
+}
+/**
+ * When using Transferables, transferring a subarray/view would detach the entire
+ * underlying ArrayBuffer (including other views). Compact to a standalone buffer.
+ */
+function compactForTransfer(data) {
+    return isStandaloneBuffer(data) ? data : data.slice();
+}
+/**
+ * Browser Worker Pool
+ *
+ * Manages a pool of Web Workers for parallel compression/decompression.
+ */
+class WorkerPool {
+    _taskQueueSize() {
+        return this._taskQueue.length - this._taskQueueHead;
+    }
+    _compactTaskQueueIfNeeded() {
+        if (this._taskQueueHead > 32 && this._taskQueueHead * 2 >= this._taskQueue.length) {
+            this._taskQueue.splice(0, this._taskQueueHead);
+            this._taskQueueHead = 0;
+        }
+    }
+    _dequeueTask() {
+        if (this._taskQueueHead >= this._taskQueue.length) {
+            return undefined;
+        }
+        const task = this._taskQueue[this._taskQueueHead++];
+        this._compactTaskQueueIfNeeded();
+        return task;
+    }
+    _compactPendingStreamRequestsIfNeeded() {
+        if (this._pendingStreamRequestHead > 32 &&
+            this._pendingStreamRequestHead * 2 >= this._pendingStreamRequests.length) {
+            this._pendingStreamRequests.splice(0, this._pendingStreamRequestHead);
+            this._pendingStreamRequestHead = 0;
+        }
+    }
+    _dequeuePendingStreamRequest() {
+        if (this._pendingStreamRequestHead >= this._pendingStreamRequests.length) {
+            return undefined;
+        }
+        const resolve = this._pendingStreamRequests[this._pendingStreamRequestHead++];
+        this._compactPendingStreamRequestsIfNeeded();
+        return resolve;
+    }
+    _waitForStreamSlot(session) {
+        if (session.slotWaitPromise) {
+            return session.slotWaitPromise;
+        }
+        session.slotWaitPromise = new Promise(resolve => {
+            session.resolveSlotWait = () => {
+                session.slotWaitPromise = null;
+                session.resolveSlotWait = null;
+                resolve();
+            };
+        });
+        return session.slotWaitPromise;
+    }
+    _waitForStreamDrain(session) {
+        if (session.drainWaitPromise) {
+            return session.drainWaitPromise;
+        }
+        session.drainWaitPromise = new Promise(resolve => {
+            session.resolveDrainWait = () => {
+                session.drainWaitPromise = null;
+                session.resolveDrainWait = null;
+                resolve();
+            };
+        });
+        return session.drainWaitPromise;
+    }
+    _resolveSlotWaiter(session) {
+        session.resolveSlotWait?.();
+    }
+    _resolveDrainWaiter(session) {
+        session.resolveDrainWait?.();
+    }
+    constructor(options) {
+        this._workers = new Map();
+        this._taskQueue = [];
+        this._taskQueueHead = 0;
+        this._pendingTasks = new Map();
+        this._nextTaskId = 1;
+        this._nextWorkerId = 1;
+        this._terminated = false;
+        this._completedTasks = 0;
+        this._failedTasks = 0;
+        this._pendingStreamRequests = [];
+        this._pendingStreamRequestHead = 0;
+        this._options = (0, pool_base_1.resolvePoolOptions)(options);
+        // Use custom URL or generate inline worker
+        if (this._options.workerUrl) {
+            this._workerUrl = this._options.workerUrl;
+            this._useCustomUrl = true;
+        }
+        else {
+            this._workerUrl = (0, worker_script_1.getWorkerBlobUrl)();
+            this._useCustomUrl = false;
+        }
+        // Pre-warm minimum workers
+        for (let i = 0; i < this._options.minWorkers; i++) {
+            this._createWorker();
+        }
+    }
+    /**
+     * Execute a task in the worker pool
+     */
+    async execute(taskType, data, options) {
+        if (this._terminated) {
+            throw new Error("Worker pool has been terminated");
+        }
+        if (!(0, pool_base_1.hasWorkerSupport)()) {
+            throw new Error("Web Workers are not supported in this environment");
+        }
+        // Check if already aborted
+        if (options?.signal?.aborted) {
+            throw (0, pool_base_1.createAbortError)();
+        }
+        const taskId = this._nextTaskId++;
+        const priority = options?.priority ?? "normal";
+        const priorityValue = (0, pool_base_1.getPriorityValue)(priority);
+        return new Promise((resolve, reject) => {
+            const task = {
+                taskId,
+                taskType,
+                data,
+                level: options?.level,
+                priority,
+                priorityValue,
+                resolve,
+                reject,
+                signal: options?.signal,
+                allowTransfer: options?.allowTransfer,
+                startTime: performance.now()
+            };
+            // Set up abort handler
+            if (options?.signal) {
+                task.abortHandler = () => {
+                    this._cancelTask(taskId);
+                };
+                options.signal.addEventListener("abort", task.abortHandler, { once: true });
+            }
+            this._pendingTasks.set(taskId, task);
+            this._enqueueTask(task);
+            this._processQueue();
+        });
+    }
+    /**
+     * Get current pool statistics
+     */
+    getStats() {
+        const totalWorkers = this._workers.size;
+        let activeWorkers = 0;
+        for (const worker of this._workers.values()) {
+            if (worker.busy) {
+                activeWorkers++;
+            }
+        }
+        return {
+            totalWorkers,
+            activeWorkers,
+            idleWorkers: totalWorkers - activeWorkers,
+            pendingTasks: this._taskQueueSize(),
+            completedTasks: this._completedTasks,
+            failedTasks: this._failedTasks
+        };
+    }
+    /**
+     * Terminate all workers and clean up resources
+     */
+    terminate() {
+        if (this._terminated) {
+            return;
+        }
+        this._terminated = true;
+        // Terminate all workers
+        for (const poolWorker of this._workers.values()) {
+            this._terminateWorker(poolWorker);
+        }
+        this._workers.clear();
+        // Reject all pending tasks
+        const error = new Error("Worker pool terminated");
+        for (const task of this._pendingTasks.values()) {
+            this._cleanupTask(task);
+            task.reject(error);
+        }
+        this._pendingTasks.clear();
+        this._taskQueue.length = 0;
+        this._taskQueueHead = 0;
+        this._pendingStreamRequests.length = 0;
+        this._pendingStreamRequestHead = 0;
+        // Release blob URL if we created it
+        if (!this._useCustomUrl) {
+            (0, worker_script_1.releaseWorkerBlobUrl)();
+        }
+    }
+    /**
+     * Check if the pool has been terminated
+     */
+    isTerminated() {
+        return this._terminated;
+    }
+    /**
+     * Create a new worker
+     */
+    _createWorker() {
+        if (this._terminated || this._workers.size >= this._options.maxWorkers) {
+            return null;
+        }
+        const id = this._nextWorkerId++;
+        const worker = new Worker(this._workerUrl);
+        const poolWorker = {
+            id,
+            worker,
+            busy: false,
+            currentTaskId: null,
+            idleTimer: null,
+            streamSession: null
+        };
+        // Set up message handler
+        worker.onmessage = (event) => {
+            this._handleWorkerMessage(poolWorker, event.data);
+        };
+        // Set up error handler
+        worker.onerror = (event) => {
+            this._handleWorkerError(poolWorker, event);
+        };
+        this._workers.set(id, poolWorker);
+        return poolWorker;
+    }
+    /**
+     * Terminate a single worker
+     */
+    _terminateWorker(poolWorker) {
+        this._clearIdleTimer(poolWorker);
+        try {
+            poolWorker.worker.postMessage({ type: "terminate" });
+        }
+        catch {
+            // Worker may already be terminated
+        }
+        try {
+            poolWorker.worker.terminate();
+        }
+        catch {
+            // Ignore termination errors
+        }
+        this._workers.delete(poolWorker.id);
+    }
+    /**
+     * Clear a worker's idle timer if set
+     */
+    _clearIdleTimer(poolWorker) {
+        if (poolWorker.idleTimer !== null) {
+            clearTimeout(poolWorker.idleTimer);
+            poolWorker.idleTimer = null;
+        }
+    }
+    /**
+     * Find an idle worker
+     */
+    _findIdleWorker() {
+        for (const worker of this._workers.values()) {
+            if (!worker.busy) {
+                return worker;
+            }
+        }
+        return undefined;
+    }
+    /**
+     * Enqueue a task with priority ordering using binary search (O(log n))
+     */
+    _enqueueTask(task) {
+        const queue = this._taskQueue;
+        const priority = task.priorityValue;
+        this._compactTaskQueueIfNeeded();
+        // Binary search for insertion point (higher priority first)
+        let lo = this._taskQueueHead;
+        let hi = queue.length;
+        while (lo < hi) {
+            const mid = (lo + hi) >>> 1;
+            if (queue[mid].priorityValue >= priority) {
+                lo = mid + 1;
+            }
+            else {
+                hi = mid;
+            }
+        }
+        queue.splice(lo, 0, task);
+    }
+    /**
+     * Process the task queue
+     */
+    _processQueue() {
+        while (!this._terminated && this._taskQueueSize() > 0) {
+            // Find an idle worker or create one.
+            const idleWorker = this._findIdleWorker() ?? this._createWorker() ?? undefined;
+            // If still no worker available, wait for one to become idle.
+            if (!idleWorker) {
+                return;
+            }
+            while (true) {
+                // Get the next task
+                const task = this._dequeueTask();
+                if (!task) {
+                    return;
+                }
+                // Skip tasks cancelled while queued
+                if (task.signal?.aborted) {
+                    this._pendingTasks.delete(task.taskId);
+                    this._cleanupTask(task);
+                    task.reject((0, pool_base_1.createAbortError)());
+                    continue;
+                }
+                // Assign task to worker and move on to schedule more tasks/workers.
+                this._assignTask(idleWorker, task);
+                break;
+            }
+        }
+    }
+    /**
+     * Assign a task to a worker
+     */
+    _assignTask(poolWorker, task) {
+        this._clearIdleTimer(poolWorker);
+        poolWorker.busy = true;
+        poolWorker.currentTaskId = task.taskId;
+        // Only compact when we are actually transferring ownership.
+        // For normal postMessage cloning, avoid an eager extra copy here.
+        const shouldTransfer = this._options.useTransferables && task.allowTransfer === true;
+        const data = shouldTransfer ? compactForTransfer(task.data) : task.data;
+        const message = {
+            type: "task",
+            taskId: task.taskId,
+            taskType: task.taskType,
+            data,
+            level: task.level
+        };
+        // Use transferables for zero-copy
+        if (shouldTransfer) {
+            poolWorker.worker.postMessage(message, [data.buffer]);
+        }
+        else {
+            poolWorker.worker.postMessage(message);
+        }
+    }
+    /**
+     * Handle message from worker
+     */
+    _handleWorkerMessage(poolWorker, message) {
+        if (message.type === "ready") {
+            // Worker is initialized and ready
+            return;
+        }
+        // Streaming session messages
+        if (poolWorker.streamSession) {
+            const session = poolWorker.streamSession;
+            const streamType = message.type;
+            switch (streamType) {
+                case "started": {
+                    if (message.taskId !== session.taskId) {
+                        return;
+                    }
+                    session.startReady = true;
+                    session.resolveStart?.();
+                    session.resolveStart = null;
+                    session.rejectStart = null;
+                    return;
+                }
+                case "out": {
+                    if (message.taskId !== session.taskId) {
+                        return;
+                    }
+                    session.onData(message.data);
+                    return;
+                }
+                case "ack": {
+                    if (message.taskId !== session.taskId) {
+                        return;
+                    }
+                    if (session.inflightChunkCount > 0) {
+                        session.inflightChunkCount--;
+                    }
+                    this._resolveSlotWaiter(session);
+                    if (session.inflightChunkCount === 0 && session.resolveDrainWait) {
+                        this._resolveDrainWaiter(session);
+                    }
+                    return;
+                }
+                case "done": {
+                    if (message.taskId !== session.taskId) {
+                        return;
+                    }
+                    session.ended = true;
+                    session.inflightChunkCount = 0;
+                    session.startReady = true;
+                    // If we somehow complete without a start handshake, unblock writers.
+                    session.resolveStart?.();
+                    session.resolveStart = null;
+                    session.rejectStart = null;
+                    this._resolveSlotWaiter(session);
+                    this._resolveDrainWaiter(session);
+                    this._completedTasks++;
+                    const duration = message.duration ?? performance.now() - session.startTime;
+                    void duration;
+                    session.onEnd();
+                    poolWorker.streamSession = null;
+                    this._workerBecameIdle(poolWorker);
+                    return;
+                }
+                case "error": {
+                    if (message.taskId !== session.taskId) {
+                        return;
+                    }
+                    const error = new Error(message.error ?? "Unknown worker error");
+                    session.ended = true;
+                    session.inflightChunkCount = 0;
+                    session.startReady = true;
+                    // If the error happens during start, fail fast so writes don't hang.
+                    session.rejectStart?.(error);
+                    session.resolveStart = null;
+                    session.rejectStart = null;
+                    this._resolveSlotWaiter(session);
+                    this._resolveDrainWaiter(session);
+                    this._failedTasks++;
+                    session.onError(error);
+                    poolWorker.streamSession = null;
+                    this._workerBecameIdle(poolWorker);
+                    return;
+                }
+                default:
+                    break;
+            }
+        }
+        switch (message.type) {
+            case "result":
+            case "error": {
+                const taskId = message.taskId;
+                if (typeof taskId !== "number") {
+                    return;
+                }
+                const task = this._pendingTasks.get(taskId);
+                if (!task) {
+                    // Task was cancelled
+                    this._workerBecameIdle(poolWorker);
+                    return;
+                }
+                this._pendingTasks.delete(taskId);
+                this._cleanupTask(task);
+                if (message.type === "result") {
+                    this._completedTasks++;
+                    const duration = message.duration ?? performance.now() - task.startTime;
+                    task.resolve({
+                        data: message.data,
+                        duration
+                    });
+                }
+                else {
+                    this._failedTasks++;
+                    task.reject(new Error(message.error ?? "Unknown worker error"));
+                }
+                this._workerBecameIdle(poolWorker);
+                return;
+            }
+            default:
+                return;
+        }
+    }
+    /**
+     * Handle worker error
+     */
+    _handleWorkerError(poolWorker, event) {
+        const taskId = poolWorker.currentTaskId;
+        // Terminate the failed worker
+        this._terminateWorker(poolWorker);
+        // Fail the current task if any
+        if (taskId !== null) {
+            const task = this._pendingTasks.get(taskId);
+            if (task) {
+                this._pendingTasks.delete(taskId);
+                this._cleanupTask(task);
+                this._failedTasks++;
+                task.reject(new Error(event.message || "Worker error"));
+            }
+        }
+        // Try to process remaining tasks
+        this._processQueue();
+    }
+    /**
+     * Called when a worker becomes idle
+     */
+    _workerBecameIdle(poolWorker) {
+        poolWorker.busy = false;
+        poolWorker.currentTaskId = null;
+        // Prefer pending streaming requests (long-lived) over batch queue.
+        if (this._pendingStreamRequestHead < this._pendingStreamRequests.length) {
+            const resolve = this._dequeuePendingStreamRequest();
+            if (resolve) {
+                resolve(poolWorker);
+                return;
+            }
+        }
+        // Process more tasks if available
+        if (this._taskQueueSize() > 0) {
+            this._processQueue();
+        }
+        else if (this._workers.size > this._options.minWorkers && this._options.idleTimeout > 0) {
+            // Schedule idle timeout
+            poolWorker.idleTimer = setTimeout(() => {
+                // Double-check conditions before terminating
+                if (!poolWorker.busy &&
+                    this._workers.size > this._options.minWorkers &&
+                    !this._terminated) {
+                    this._terminateWorker(poolWorker);
+                }
+            }, this._options.idleTimeout);
+        }
+    }
+    /**
+     * Open a streaming session bound to a worker.
+     *
+     * This enables true chunk-by-chunk compression/decompression in the worker without buffering
+     * the entire input on the main thread.
+     */
+    openStream(taskType, options = DEFAULT_STREAM_HANDLERS) {
+        if (this._terminated) {
+            throw new Error("Worker pool has been terminated");
+        }
+        if (!(0, pool_base_1.hasWorkerSupport)()) {
+            throw new Error("Web Workers are not supported in this environment");
+        }
+        const taskId = this._nextTaskId++;
+        const allowTransfer = options.allowTransfer === true;
+        const shouldTransfer = this._options.useTransferables && allowTransfer;
+        const preparePayload = shouldTransfer ? compactForTransfer : (chunk) => chunk;
+        const postChunkMessage = shouldTransfer
+            ? (worker, message, payload) => {
+                worker.postMessage(message, [payload.buffer]);
+            }
+            : (worker, message, _payload) => {
+                worker.postMessage(message);
+            };
+        let sessionWorker = null;
+        let ensureWorkerPromise = null;
+        const ensureWorker = async () => {
+            if (sessionWorker) {
+                return sessionWorker;
+            }
+            if (ensureWorkerPromise) {
+                return ensureWorkerPromise;
+            }
+            ensureWorkerPromise = (async () => {
+                const idleWorker = this._findIdleWorker() ?? this._createWorker() ?? undefined;
+                if (idleWorker) {
+                    sessionWorker = idleWorker;
+                    this._bindStreamSession(sessionWorker, taskId, taskType, options.level, options);
+                    this._startStreamSession(sessionWorker);
+                    return sessionWorker;
+                }
+                // Wait for a worker to become idle
+                sessionWorker = await new Promise(resolve => {
+                    this._pendingStreamRequests.push(resolve);
+                });
+                this._bindStreamSession(sessionWorker, taskId, taskType, options.level, options);
+                this._startStreamSession(sessionWorker);
+                return sessionWorker;
+            })();
+            try {
+                return await ensureWorkerPromise;
+            }
+            finally {
+                ensureWorkerPromise = null;
+            }
+        };
+        // Kick off worker/session creation immediately to surface start errors early.
+        void ensureWorker();
+        const sendChunk = (worker, session, data) => {
+            const payload = preparePayload(data);
+            const message = session.chunkMessage;
+            message.data = payload;
+            postChunkMessage(worker.worker, message, payload);
+        };
+        const queueChunkWithBackpressure = (worker, session, data) => {
+            if (session.inflightChunkCount >= DEFAULT_MAX_INFLIGHT_STREAM_CHUNKS) {
+                return this._waitForStreamSlot(session).then(() => {
+                    if (session.ended) {
+                        return;
+                    }
+                    session.inflightChunkCount++;
+                    sendChunk(worker, session, data);
+                });
+            }
+            session.inflightChunkCount++;
+            sendChunk(worker, session, data);
+        };
+        const write = async (data) => {
+            if (data.byteLength === 0) {
+                return;
+            }
+            const worker = sessionWorker ?? (await ensureWorker());
+            const session = worker.streamSession;
+            if (!session || session.ended) {
+                throw new Error("Streaming session is not active");
+            }
+            // Serialize writes to guarantee ordering and keep a single in-flight ack.
+            session.writeChain = session.writeChain.then(() => {
+                if (session.ended) {
+                    return;
+                }
+                // Wait for the start handshake (or fail fast) before sending any chunks.
+                if (!session.startReady) {
+                    return session.startPromise.then(() => {
+                        if (session.ended) {
+                            return;
+                        }
+                        return queueChunkWithBackpressure(worker, session, data);
+                    });
+                }
+                return queueChunkWithBackpressure(worker, session, data);
+            });
+            await session.writeChain;
+        };
+        const end = async () => {
+            const worker = await ensureWorker();
+            const session = worker.streamSession;
+            if (!session || session.ended) {
+                return;
+            }
+            // If start failed, propagate the rejection.
+            if (!session.startReady) {
+                await session.startPromise;
+            }
+            // Flush any pending writes before ending.
+            await session.writeChain;
+            if (session.inflightChunkCount > 0) {
+                await this._waitForStreamDrain(session);
+            }
+            session.ended = true;
+            worker.worker.postMessage(session.endMessage);
+        };
+        const abort = (reason) => {
+            void ensureWorker().then(worker => {
+                const session = worker.streamSession;
+                if (!session) {
+                    return;
+                }
+                const message = session.abortMessage;
+                message.error = reason;
+                worker.worker.postMessage(message);
+            });
+        };
+        return { write, end, abort };
+    }
+    _bindStreamSession(worker, taskId, taskType, level, handlers) {
+        this._clearIdleTimer(worker);
+        worker.busy = true;
+        worker.currentTaskId = taskId;
+        let resolveStart = null;
+        let rejectStart = null;
+        const startPromise = new Promise((resolve, reject) => {
+            resolveStart = resolve;
+            rejectStart = reject;
+        });
+        // Safety net: avoid hanging forever if the worker never responds.
+        const START_TIMEOUT_MS = 5000;
+        const startTimeout = setTimeout(() => {
+            rejectStart?.(new Error("Worker stream start timeout"));
+        }, START_TIMEOUT_MS);
+        startPromise.finally(() => clearTimeout(startTimeout));
+        worker.streamSession = {
+            taskId,
+            taskType,
+            startTime: performance.now(),
+            started: false,
+            startReady: false,
+            startPromise,
+            resolveStart,
+            rejectStart,
+            level,
+            writeChain: Promise.resolve(),
+            inflightChunkCount: 0,
+            slotWaitPromise: null,
+            resolveSlotWait: null,
+            drainWaitPromise: null,
+            resolveDrainWait: null,
+            chunkMessage: {
+                type: "chunk",
+                taskId,
+                data: EMPTY_CHUNK
+            },
+            startMessage: {
+                type: "start",
+                taskId,
+                taskType,
+                level
+            },
+            endMessage: {
+                type: "end",
+                taskId
+            },
+            abortMessage: {
+                type: "abort",
+                taskId,
+                error: undefined
+            },
+            ended: false,
+            onData: handlers.onData,
+            onEnd: handlers.onEnd,
+            onError: handlers.onError
+        };
+    }
+    _startStreamSession(worker) {
+        const session = worker.streamSession;
+        if (!session || session.started) {
+            return;
+        }
+        session.started = true;
+        worker.worker.postMessage(session.startMessage);
+    }
+    /**
+     * Cancel a task
+     */
+    _cancelTask(taskId) {
+        const task = this._pendingTasks.get(taskId);
+        if (!task) {
+            return;
+        }
+        // Remove from pending
+        this._pendingTasks.delete(taskId);
+        this._cleanupTask(task);
+        // Remove from queue if still there
+        let queueIndex = -1;
+        for (let i = this._taskQueueHead; i < this._taskQueue.length; i++) {
+            if (this._taskQueue[i].taskId === taskId) {
+                queueIndex = i;
+                break;
+            }
+        }
+        if (queueIndex >= 0) {
+            this._taskQueue.splice(queueIndex, 1);
+        }
+        // Note: We can't cancel a task that's already running in a worker.
+        // The worker will complete, and we'll ignore the result.
+        task.reject((0, pool_base_1.createAbortError)());
+    }
+    /**
+     * Clean up task resources
+     */
+    _cleanupTask(task) {
+        if (task.abortHandler && task.signal) {
+            task.signal.removeEventListener("abort", task.abortHandler);
+        }
+    }
+    /**
+     * Execute multiple tasks in parallel
+     *
+     * @param tasks - Array of task definitions
+     * @returns Array of results in the same order as input
+     */
+    async executeBatch(tasks) {
+        const pending = new Array(tasks.length);
+        for (let i = 0; i < tasks.length; i++) {
+            const task = tasks[i];
+            pending[i] = this.execute(task.taskType, task.data, task.options);
+        }
+        return Promise.all(pending);
+    }
+}
+exports.WorkerPool = WorkerPool;
+// Singleton pool instance for convenience
+let _defaultPool = null;
+/**
+ * Get or create the default worker pool
+ */
+function getDefaultWorkerPool(options) {
+    if (!_defaultPool || _defaultPool.isTerminated()) {
+        _defaultPool = new WorkerPool(options);
+    }
+    return _defaultPool;
+}
+/**
+ * Terminate the default worker pool
+ */
+function terminateDefaultWorkerPool() {
+    if (_defaultPool) {
+        _defaultPool.terminate();
+        _defaultPool = null;
+    }
+}
+/**
+ * Execute a compression task using the default pool
+ */
+async function deflateWithPool(data, options) {
+    const result = await getDefaultWorkerPool().execute("deflate", data, options);
+    return result.data;
+}
+/**
+ * Execute a decompression task using the default pool
+ */
+async function inflateWithPool(data, options) {
+    const result = await getDefaultWorkerPool().execute("inflate", data, options);
+    return result.data;
+}
+/**
+ * Internal helper for batch operations
+ */
+async function executeBatchByType(taskType, items) {
+    const batchItems = new Array(items.length);
+    for (let i = 0; i < items.length; i++) {
+        const item = items[i];
+        batchItems[i] = { taskType, data: item.data, options: item.options };
+    }
+    const results = await getDefaultWorkerPool().executeBatch(batchItems);
+    const output = new Array(results.length);
+    for (let i = 0; i < results.length; i++) {
+        output[i] = results[i].data;
+    }
+    return output;
+}
+/**
+ * Batch compress multiple data chunks in parallel using the default pool
+ */
+async function deflateBatchWithPool(items) {
+    return executeBatchByType("deflate", items);
+}
+/**
+ * Batch decompress multiple data chunks in parallel using the default pool
+ */
+async function inflateBatchWithPool(items) {
+    return executeBatchByType("inflate", items);
+}