@aguacerowx/mapsgl 0.0.57 → 0.0.58

package/src/WorkerPool.js

@@ -1,340 +1,340 @@
-export default class WorkerPool {
-    /**
-     * @param {typeof Worker | (() => Worker)} workerCtorOrFactory - A `class extends Worker`, or a zero-arg
-     *   factory. Prefer a factory that contains `new Worker(new URL('./worker.js', import.meta.url))` so Vite
-     *   can bundle workers in dev; a `class extends Worker { constructor() { super(url) } }` breaks that rewrite.
-     */
-    constructor(workerCtorOrFactory, poolSize = Math.min(8, Math.max(2, Math.floor(navigator.hardwareConcurrency * 0.75))), options = {}) {
-        if (typeof workerCtorOrFactory === 'function' && workerCtorOrFactory.prototype instanceof Worker) {
-            this._newWorker = () => new workerCtorOrFactory();
-        } else {
-            this._newWorker = () => workerCtorOrFactory();
-        }
-        this.poolSize = poolSize;
-        this.workers = [];
-        this.availableWorkers = [];
-        this.taskQueue = [];
-        this.isInitialized = false;
-
-        /** Called for every new Worker (including replacements) so satellite INIT_WORKER is never skipped. */
-        this.workerBootstrapFn = options.workerBootstrap || null;
-
-        this.debug = Boolean(options.debug);
-        this.enablePerfMarks = Boolean(options.enablePerfMarks);
-    }
-    
-    setWorkerBootstrap(fn) {
-        this.workerBootstrapFn = typeof fn === 'function' ? fn : null;
-    }
-
-    _log(...args) { if (this.debug) console.log(...args); }
-    _warn(...args) { if (this.debug) console.warn(...args); }
-    _error(...args) { if (this.debug) console.error(...args); }
-
-    _mark(name) {
-        if (!this.enablePerfMarks || typeof performance === 'undefined' || typeof performance.mark !== 'function') return;
-        performance.mark(name);
-    }
-
-    _measure(name, startMark, endMark) {
-        if (!this.enablePerfMarks || typeof performance === 'undefined' || typeof performance.measure !== 'function') return;
-        try {
-            performance.measure(name, startMark, endMark);
-            if (typeof performance.clearMeasures === 'function') {
-                performance.clearMeasures(name);
-            }
-        } catch (error) {
-            this._warn(`[Pool] Skipping perf measure "${name}"`, error);
-        }
-    }
-
-    _clearTaskMarks(taskId) {
-        if (!this.enablePerfMarks || typeof performance === 'undefined' || typeof performance.clearMarks !== 'function') return;
-        const marks = [
-            `Task-Queued-${taskId}`,
-            `Task-Sent-${taskId}`,
-            `Task-Received-${taskId}`,
-            `Main-Resolve-Start-${taskId}`,
-            `Main-Resolve-End-${taskId}`
-        ];
-        marks.forEach((mark) => {
-            try {
-                performance.clearMarks(mark);
-            } catch (error) {
-                this._warn(`[Pool] Failed to clear mark "${mark}"`, error);
-            }
-        });
-    }
-    
-    async initialize() {
-        if (this.isInitialized) return;
-        try {
-            for (let i = 0; i < this.poolSize; i++) {
-                this._createWorker(i);
-            }
-            this.isInitialized = true;
-        } catch (error) {
-            this._error('❌ Failed to initialize worker pool:', error);
-            throw error;
-        }
-    }
-
-    _createWorker(id) {
-        const worker = this._newWorker();
-        const workerInstance = { id: id, worker: worker, busy: false, currentTask: null };
-        
-        worker.onmessage = (e) => this.handleWorkerMessage(workerInstance, e);
-        worker.onerror = (error) => {
-            this._error(`❌ Worker ${id} error:`, error);
-            this.handleWorkerError(workerInstance, error);
-        };
-
-        if (this.workerBootstrapFn) {
-            try {
-                this.workerBootstrapFn(worker);
-            } catch (error) {
-                this._error(`❌ workerBootstrap failed for worker ${id}:`, error);
-            }
-        }
-
-        this.workers.push(workerInstance);
-        this.availableWorkers.push(workerInstance);
-        return workerInstance;
-    }
-
-    async broadcast(message) {
-        if (!this.isInitialized) await this.initialize();
-        this.workers.forEach(w => w.worker.postMessage(message));
-    }
-    
-    async execute(taskData, options = {}) {
-        if (!this.isInitialized) await this.initialize();
-        const { signal, priority = 0, transfer = [] } = options;
-        
-        return new Promise((resolve, reject) => {
-            if (signal?.aborted) return reject(new DOMException('Operation aborted', 'AbortError'));
-
-            const now = performance.now();
-            const taskId = `${taskData.type}_${Math.floor(now)}_${Math.random().toString(36).substr(2, 5)}`;
-            
-            this._mark(`Task-Queued-${taskId}`);
-
-            const task = {
-                id: taskId,
-                taskType: taskData.type,
-                data: taskData, transfer, resolve, reject, signal, priority, 
-                timeout: options.timeout || 30000,
-                retries: options.retries || 0, maxRetries: options.maxRetries || 2,
-                createdAt: now, startedAt: 0, enqueuedAt: now, isAborted: false
-            };
-
-            const abortHandler = () => {
-                task.isAborted = true;
-                const taskIndexInQueue = this.taskQueue.findIndex(t => t.id === task.id);
-                if (taskIndexInQueue !== -1) {
-                    this.taskQueue.splice(taskIndexInQueue, 1);
-                    task.reject(new DOMException('Operation aborted', 'AbortError'));
-                } 
-            };
-            
-            task.abortHandler = abortHandler;
-            signal?.addEventListener('abort', abortHandler, { once: true });
-            
-            this.taskQueue.push(task);
-            this.processQueue();
-        });
-    }
-    
-    processQueue() {
-        for (let i = this.taskQueue.length - 1; i >= 0; i--) {
-            if (this.taskQueue[i].signal?.aborted) {
-                this.taskQueue[i].reject(new DOMException('Operation aborted', 'AbortError'));
-                this.taskQueue.splice(i, 1);
-            }
-        }
-
-        this.taskQueue.sort((a, b) => {
-            if (b.priority !== a.priority) return b.priority - a.priority; 
-            return b.enqueuedAt - a.enqueuedAt; 
-        });
-
-        while (this.taskQueue.length > 0 && this.availableWorkers.length > 0) {
-            const task = this.taskQueue.shift();
-            const workerInstance = this.availableWorkers.shift();
-            this.assignTaskToWorker(workerInstance, task);
-        }
-    }
-    
-    assignTaskToWorker(workerInstance, task) {
-        if (task.signal?.aborted) {
-            task.reject(new DOMException('Operation aborted', 'AbortError'));
-            this.availableWorkers.push(workerInstance);
-            this.processQueue();
-            return;
-        }
-        
-        workerInstance.busy = true;
-        workerInstance.currentTask = task;
-        task.startedAt = performance.now();
-        
-        this._mark(`Task-Sent-${task.id}`);
-        this._measure(`QueueTime:${task.taskType}`, `Task-Queued-${task.id}`, `Task-Sent-${task.id}`);
-        
-        task.timeoutId = setTimeout(() => {
-            this._error(`[Pool] ⏰ Task ${task.id} TIMED OUT on Worker ${workerInstance.id}`);
-            this.handleTaskTimeout(workerInstance, task);
-        }, task.timeout);
-        
-        try {
-            const messageWithId = { ...task.data, __taskId: task.id };
-            workerInstance.worker.postMessage(messageWithId, task.transfer || []);
-            task.data = null;
-            task.transfer = null;
-        } catch (error) {
-            this._error(`❌ Failed to send task to worker ${workerInstance.id}:`, error);
-            this.handleWorkerError(workerInstance, error);
-        }
-    }
-
-    handleWorkerMessage(workerInstance, event) {
-        if (event?.data?.type === 'WGPU_INIT_FAILED') {
-            const error = new Error(event.data.error || 'WGPU initialization failed');
-            const task = workerInstance.currentTask;
-            if (task) {
-                this.handleTaskFailure(workerInstance, task, error);
-            }
-            this._replaceWorker(workerInstance);
-            return;
-        }
-
-        const responseTaskId = event.data.__taskId;
-        const task = (workerInstance.currentTask && workerInstance.currentTask.id === responseTaskId) 
-            ? workerInstance.currentTask : null;
-        
-        if (!task) {
-            this._warn(`[Pool] ⚠️ Stale response for task ${responseTaskId}`);
-            return; 
-        }
-        
-        this._mark(`Task-Received-${task.id}`);
-        this._measure(`WorkerProcess:${task.taskType}`, `Task-Sent-${task.id}`, `Task-Received-${task.id}`);
-        
-        if (task.timeoutId) clearTimeout(task.timeoutId);
-        task.signal?.removeEventListener('abort', task.abortHandler);
-        let shouldReplaceWorker = false;
-        
-        if (!task.isAborted) {
-            this._mark(`Main-Resolve-Start-${task.id}`);
-            
-            if (event.data.type === 'PROCESSING_ERROR' || event.data.type === 'VIEWPORT_PROCESSING_ERROR') {
-                task.reject(new Error(event.data.error));
-                if (event.data.wgpuRuntimeFailure) {
-                    shouldReplaceWorker = true;
-                }
-            } else if (event.data.type === 'WORKER_ERROR') {
-                task.reject(new Error(event.data.error || 'Worker error'));
-            } else {
-                task.resolve(event.data); 
-            }
-            
-            this._mark(`Main-Resolve-End-${task.id}`);
-            this._measure(`PoolResolveTrigger:${task.taskType}`, `Main-Resolve-Start-${task.id}`, `Main-Resolve-End-${task.id}`);
-        }
-
-        this._clearTaskMarks(task.id);
-        if (shouldReplaceWorker) {
-            this._replaceWorker(workerInstance);
-            return;
-        }
-        this.releaseWorker(workerInstance);
-    }
-    
-    handleWorkerError(workerInstance, error) {
-        const task = workerInstance.currentTask;
-        if (task) {
-            this.handleTaskFailure(workerInstance, task, error);
-        }
-        this._replaceWorker(workerInstance);
-    }
-    
-    handleTaskTimeout(workerInstance, task) {
-        this._warn(`[Pool] 💀 Terminating stuck Worker ${workerInstance.id}`);
-        workerInstance.worker.terminate();
-        this.handleTaskFailure(workerInstance, task, new Error('Task timeout'));
-        this._replaceWorker(workerInstance);
-    }
-    
-    handleTaskFailure(workerInstance, task, error) {
-        if (task.timeoutId) clearTimeout(task.timeoutId);
-        task.signal?.removeEventListener('abort', task.abortHandler);
-        
-        const canRetry = task.data !== null; 
-
-        if (canRetry && task.retries < task.maxRetries && error.name !== 'AbortError' && !task.isAborted) {
-            task.retries++;
-            delete task.timeoutId;
-            task.enqueuedAt = performance.now();
-            this.taskQueue.push(task); 
-            this.releaseWorker(workerInstance);
-        } else {
-            if (!task.isAborted) {
-                task.reject(error);
-            }
-            
-            this._clearTaskMarks(task.id);
-            if (this.workers.includes(workerInstance)) {
-                this.releaseWorker(workerInstance);
-            }
-        }
-    }
-    
-    releaseWorker(workerInstance) {
-        workerInstance.busy = false;
-        workerInstance.currentTask = null;
-        this.availableWorkers.push(workerInstance);
-        this.processQueue();
-    }
-    
-    _replaceWorker(oldWorkerInstance) {
-        try {
-            oldWorkerInstance?.worker?.terminate?.();
-        } catch (error) {
-            this._warn(`[Pool] Failed to terminate worker ${oldWorkerInstance?.id}`, error);
-        }
-
-        const idx = this.workers.findIndex(w => w.id === oldWorkerInstance.id);
-        if (idx !== -1) this.workers.splice(idx, 1);
-
-        const availIdx = this.availableWorkers.findIndex(w => w.id === oldWorkerInstance.id);
-        if (availIdx !== -1) this.availableWorkers.splice(availIdx, 1);
-
-        this._createWorker(oldWorkerInstance.id);
-        this.processQueue();
-    }
-
-    terminate() {
-        for (const t of this.taskQueue) {
-            if (!t.isAborted) t.reject(new Error('Pool terminated'));
-        }
-        this.taskQueue = [];
-
-        for (const w of this.workers) {
-            const task = w.currentTask;
-            if (task && !task.isAborted) {
-                if (task.timeoutId) clearTimeout(task.timeoutId);
-                task.signal?.removeEventListener('abort', task.abortHandler);
-                task.reject(new Error('Pool terminated'));
-                this._clearTaskMarks(task.id);
-            }
-            try {
-                w.worker.terminate();
-            } catch {
-                /* ignore */
-            }
-        }
-
-        this.workers = [];
-        this.availableWorkers = [];
-        this.isInitialized = false;
-    }
-}
+export default class WorkerPool {
+    /**
+     * @param {typeof Worker | (() => Worker)} workerCtorOrFactory - A `class extends Worker`, or a zero-arg
+     *   factory. Prefer a factory that contains `new Worker(new URL('./worker.js', import.meta.url))` so Vite
+     *   can bundle workers in dev; a `class extends Worker { constructor() { super(url) } }` breaks that rewrite.
+     */
+    constructor(workerCtorOrFactory, poolSize = Math.min(8, Math.max(2, Math.floor(navigator.hardwareConcurrency * 0.75))), options = {}) {
+        if (typeof workerCtorOrFactory === 'function' && workerCtorOrFactory.prototype instanceof Worker) {
+            this._newWorker = () => new workerCtorOrFactory();
+        } else {
+            this._newWorker = () => workerCtorOrFactory();
+        }
+        this.poolSize = poolSize;
+        this.workers = [];
+        this.availableWorkers = [];
+        this.taskQueue = [];
+        this.isInitialized = false;
+
+        /** Called for every new Worker (including replacements) so satellite INIT_WORKER is never skipped. */
+        this.workerBootstrapFn = options.workerBootstrap || null;
+
+        this.debug = Boolean(options.debug);
+        this.enablePerfMarks = Boolean(options.enablePerfMarks);
+    }
+    
+    setWorkerBootstrap(fn) {
+        this.workerBootstrapFn = typeof fn === 'function' ? fn : null;
+    }
+
+    _log(...args) { if (this.debug) console.log(...args); }
+    _warn(...args) { if (this.debug) console.warn(...args); }
+    _error(...args) { if (this.debug) console.error(...args); }
+
+    _mark(name) {
+        if (!this.enablePerfMarks || typeof performance === 'undefined' || typeof performance.mark !== 'function') return;
+        performance.mark(name);
+    }
+
+    _measure(name, startMark, endMark) {
+        if (!this.enablePerfMarks || typeof performance === 'undefined' || typeof performance.measure !== 'function') return;
+        try {
+            performance.measure(name, startMark, endMark);
+            if (typeof performance.clearMeasures === 'function') {
+                performance.clearMeasures(name);
+            }
+        } catch (error) {
+            this._warn(`[Pool] Skipping perf measure "${name}"`, error);
+        }
+    }
+
+    _clearTaskMarks(taskId) {
+        if (!this.enablePerfMarks || typeof performance === 'undefined' || typeof performance.clearMarks !== 'function') return;
+        const marks = [
+            `Task-Queued-${taskId}`,
+            `Task-Sent-${taskId}`,
+            `Task-Received-${taskId}`,
+            `Main-Resolve-Start-${taskId}`,
+            `Main-Resolve-End-${taskId}`
+        ];
+        marks.forEach((mark) => {
+            try {
+                performance.clearMarks(mark);
+            } catch (error) {
+                this._warn(`[Pool] Failed to clear mark "${mark}"`, error);
+            }
+        });
+    }
+    
+    async initialize() {
+        if (this.isInitialized) return;
+        try {
+            for (let i = 0; i < this.poolSize; i++) {
+                this._createWorker(i);
+            }
+            this.isInitialized = true;
+        } catch (error) {
+            this._error('❌ Failed to initialize worker pool:', error);
+            throw error;
+        }
+    }
+
+    _createWorker(id) {
+        const worker = this._newWorker();
+        const workerInstance = { id: id, worker: worker, busy: false, currentTask: null };
+        
+        worker.onmessage = (e) => this.handleWorkerMessage(workerInstance, e);
+        worker.onerror = (error) => {
+            this._error(`❌ Worker ${id} error:`, error);
+            this.handleWorkerError(workerInstance, error);
+        };
+
+        if (this.workerBootstrapFn) {
+            try {
+                this.workerBootstrapFn(worker);
+            } catch (error) {
+                this._error(`❌ workerBootstrap failed for worker ${id}:`, error);
+            }
+        }
+
+        this.workers.push(workerInstance);
+        this.availableWorkers.push(workerInstance);
+        return workerInstance;
+    }
+
+    async broadcast(message) {
+        if (!this.isInitialized) await this.initialize();
+        this.workers.forEach(w => w.worker.postMessage(message));
+    }
+    
+    async execute(taskData, options = {}) {
+        if (!this.isInitialized) await this.initialize();
+        const { signal, priority = 0, transfer = [] } = options;
+        
+        return new Promise((resolve, reject) => {
+            if (signal?.aborted) return reject(new DOMException('Operation aborted', 'AbortError'));
+
+            const now = performance.now();
+            const taskId = `${taskData.type}_${Math.floor(now)}_${Math.random().toString(36).substr(2, 5)}`;
+            
+            this._mark(`Task-Queued-${taskId}`);
+
+            const task = {
+                id: taskId,
+                taskType: taskData.type,
+                data: taskData, transfer, resolve, reject, signal, priority, 
+                timeout: options.timeout || 30000,
+                retries: options.retries || 0, maxRetries: options.maxRetries || 2,
+                createdAt: now, startedAt: 0, enqueuedAt: now, isAborted: false
+            };
+
+            const abortHandler = () => {
+                task.isAborted = true;
+                const taskIndexInQueue = this.taskQueue.findIndex(t => t.id === task.id);
+                if (taskIndexInQueue !== -1) {
+                    this.taskQueue.splice(taskIndexInQueue, 1);
+                    task.reject(new DOMException('Operation aborted', 'AbortError'));
+                } 
+            };
+            
+            task.abortHandler = abortHandler;
+            signal?.addEventListener('abort', abortHandler, { once: true });
+            
+            this.taskQueue.push(task);
+            this.processQueue();
+        });
+    }
+    
+    processQueue() {
+        for (let i = this.taskQueue.length - 1; i >= 0; i--) {
+            if (this.taskQueue[i].signal?.aborted) {
+                this.taskQueue[i].reject(new DOMException('Operation aborted', 'AbortError'));
+                this.taskQueue.splice(i, 1);
+            }
+        }
+
+        this.taskQueue.sort((a, b) => {
+            if (b.priority !== a.priority) return b.priority - a.priority; 
+            return b.enqueuedAt - a.enqueuedAt; 
+        });
+
+        while (this.taskQueue.length > 0 && this.availableWorkers.length > 0) {
+            const task = this.taskQueue.shift();
+            const workerInstance = this.availableWorkers.shift();
+            this.assignTaskToWorker(workerInstance, task);
+        }
+    }
+    
+    assignTaskToWorker(workerInstance, task) {
+        if (task.signal?.aborted) {
+            task.reject(new DOMException('Operation aborted', 'AbortError'));
+            this.availableWorkers.push(workerInstance);
+            this.processQueue();
+            return;
+        }
+        
+        workerInstance.busy = true;
+        workerInstance.currentTask = task;
+        task.startedAt = performance.now();
+        
+        this._mark(`Task-Sent-${task.id}`);
+        this._measure(`QueueTime:${task.taskType}`, `Task-Queued-${task.id}`, `Task-Sent-${task.id}`);
+        
+        task.timeoutId = setTimeout(() => {
+            this._error(`[Pool] ⏰ Task ${task.id} TIMED OUT on Worker ${workerInstance.id}`);
+            this.handleTaskTimeout(workerInstance, task);
+        }, task.timeout);
+        
+        try {
+            const messageWithId = { ...task.data, __taskId: task.id };
+            workerInstance.worker.postMessage(messageWithId, task.transfer || []);
+            task.data = null;
+            task.transfer = null;
+        } catch (error) {
+            this._error(`❌ Failed to send task to worker ${workerInstance.id}:`, error);
+            this.handleWorkerError(workerInstance, error);
+        }
+    }
+
+    handleWorkerMessage(workerInstance, event) {
+        if (event?.data?.type === 'WGPU_INIT_FAILED') {
+            const error = new Error(event.data.error || 'WGPU initialization failed');
+            const task = workerInstance.currentTask;
+            if (task) {
+                this.handleTaskFailure(workerInstance, task, error);
+            }
+            this._replaceWorker(workerInstance);
+            return;
+        }
+
+        const responseTaskId = event.data.__taskId;
+        const task = (workerInstance.currentTask && workerInstance.currentTask.id === responseTaskId) 
+            ? workerInstance.currentTask : null;
+        
+        if (!task) {
+            this._warn(`[Pool] ⚠️ Stale response for task ${responseTaskId}`);
+            return; 
+        }
+        
+        this._mark(`Task-Received-${task.id}`);
+        this._measure(`WorkerProcess:${task.taskType}`, `Task-Sent-${task.id}`, `Task-Received-${task.id}`);
+        
+        if (task.timeoutId) clearTimeout(task.timeoutId);
+        task.signal?.removeEventListener('abort', task.abortHandler);
+        let shouldReplaceWorker = false;
+        
+        if (!task.isAborted) {
+            this._mark(`Main-Resolve-Start-${task.id}`);
+            
+            if (event.data.type === 'PROCESSING_ERROR' || event.data.type === 'VIEWPORT_PROCESSING_ERROR') {
+                task.reject(new Error(event.data.error));
+                if (event.data.wgpuRuntimeFailure) {
+                    shouldReplaceWorker = true;
+                }
+            } else if (event.data.type === 'WORKER_ERROR') {
+                task.reject(new Error(event.data.error || 'Worker error'));
+            } else {
+                task.resolve(event.data); 
+            }
+            
+            this._mark(`Main-Resolve-End-${task.id}`);
+            this._measure(`PoolResolveTrigger:${task.taskType}`, `Main-Resolve-Start-${task.id}`, `Main-Resolve-End-${task.id}`);
+        }
+
+        this._clearTaskMarks(task.id);
+        if (shouldReplaceWorker) {
+            this._replaceWorker(workerInstance);
+            return;
+        }
+        this.releaseWorker(workerInstance);
+    }
+    
+    handleWorkerError(workerInstance, error) {
+        const task = workerInstance.currentTask;
+        if (task) {
+            this.handleTaskFailure(workerInstance, task, error);
+        }
+        this._replaceWorker(workerInstance);
+    }
+    
+    handleTaskTimeout(workerInstance, task) {
+        this._warn(`[Pool] 💀 Terminating stuck Worker ${workerInstance.id}`);
+        workerInstance.worker.terminate();
+        this.handleTaskFailure(workerInstance, task, new Error('Task timeout'));
+        this._replaceWorker(workerInstance);
+    }
+    
+    handleTaskFailure(workerInstance, task, error) {
+        if (task.timeoutId) clearTimeout(task.timeoutId);
+        task.signal?.removeEventListener('abort', task.abortHandler);
+        
+        const canRetry = task.data !== null; 
+
+        if (canRetry && task.retries < task.maxRetries && error.name !== 'AbortError' && !task.isAborted) {
+            task.retries++;
+            delete task.timeoutId;
+            task.enqueuedAt = performance.now();
+            this.taskQueue.push(task); 
+            this.releaseWorker(workerInstance);
+        } else {
+            if (!task.isAborted) {
+                task.reject(error);
+            }
+            
+            this._clearTaskMarks(task.id);
+            if (this.workers.includes(workerInstance)) {
+                this.releaseWorker(workerInstance);
+            }
+        }
+    }
+    
+    releaseWorker(workerInstance) {
+        workerInstance.busy = false;
+        workerInstance.currentTask = null;
+        this.availableWorkers.push(workerInstance);
+        this.processQueue();
+    }
+    
+    _replaceWorker(oldWorkerInstance) {
+        try {
+            oldWorkerInstance?.worker?.terminate?.();
+        } catch (error) {
+            this._warn(`[Pool] Failed to terminate worker ${oldWorkerInstance?.id}`, error);
+        }
+
+        const idx = this.workers.findIndex(w => w.id === oldWorkerInstance.id);
+        if (idx !== -1) this.workers.splice(idx, 1);
+
+        const availIdx = this.availableWorkers.findIndex(w => w.id === oldWorkerInstance.id);
+        if (availIdx !== -1) this.availableWorkers.splice(availIdx, 1);
+
+        this._createWorker(oldWorkerInstance.id);
+        this.processQueue();
+    }
+
+    terminate() {
+        for (const t of this.taskQueue) {
+            if (!t.isAborted) t.reject(new Error('Pool terminated'));
+        }
+        this.taskQueue = [];
+
+        for (const w of this.workers) {
+            const task = w.currentTask;
+            if (task && !task.isAborted) {
+                if (task.timeoutId) clearTimeout(task.timeoutId);
+                task.signal?.removeEventListener('abort', task.abortHandler);
+                task.reject(new Error('Pool terminated'));
+                this._clearTaskMarks(task.id);
+            }
+            try {
+                w.worker.terminate();
+            } catch {
+                /* ignore */
+            }
+        }
+
+        this.workers = [];
+        this.availableWorkers = [];
+        this.isInitialized = false;
+    }
+}