nestworker 2.1.0 → 2.1.3

package/dist/core/worker.pool.js

@@ -13,24 +13,50 @@ const PRIORITY_WEIGHT = {
     NORMAL: 2,
     LOW: 1,
 };
+// Per-worker state attached via a symbol-keyed slot — avoids a Map lookup
+// per message and per dispatch on the hot path.
+const STATE = Symbol('nestworker:state');
+function getState(worker) {
+    return worker[STATE];
+}
 class WorkerPool extends node_events_1.EventEmitter {
     services;
     size;
     shutdownTimeout;
     workers = [];
+    /**
+     * Available "slots" — each worker is pushed `concurrency` times when it
+     * becomes ready, then popped/pushed as jobs are dispatched/completed.
+     * This naturally supports per-worker pipelining without any per-job
+     * counter bookkeeping.
+     */
     idle = [];
     warmingUp = new Set();
+    // Head-index FIFO: queue.shift() is O(n); a head pointer makes pop O(1)
+    // and the array is compacted lazily when it grows wasteful.
     queue = [];
+    queueHead = 0;
     destroyed = false;
-    active = new Map();
+    activeCount = 0;
+    /**
+     * `schedule()` is invoked many times in a single synchronous burst (e.g.
+     * `for (...) ws.run(...)` floods 20k enqueues). Running the dispatch loop
+     * after every enqueue limits us to batches of size 1 per worker — the
+     * whole point of batching is then defeated. Defer to the next microtask
+     * so all synchronously-enqueued jobs land in one schedule pass and get
+     * coalesced into a single postMessage per worker.
+     */
+    scheduleQueued = false;
     /** Maps abortSignalId → worker currently running that job */
     signalWorkerMap = new Map();
+    concurrency;
     proxyMap = new Map();
-    constructor(services, proxyInstances, size = node_os_1.default.cpus().length, shutdownTimeout = 30_000) {
+    constructor(services, proxyInstances, size = node_os_1.default.cpus().length, shutdownTimeout = 30_000, concurrency = 1) {
         super();
         this.services = services;
         this.size = size;
         this.shutdownTimeout = shutdownTimeout;
+        this.concurrency = concurrency > 0 ? concurrency : 1;
         for (const { propertyKey, instance } of proxyInstances) {
             this.proxyMap.set(propertyKey, instance);
         }
@@ -38,7 +64,7 @@ class WorkerPool extends node_events_1.EventEmitter {
             this.spawnWorker();
         }
     }
-    execute(job, signal) {
+    execute(job, meta, signal) {
         if (this.destroyed)
             return Promise.reject(new Error('WorkerPool destroyed'));
         return new Promise((resolve, reject) => {
@@ -49,6 +75,10 @@ class WorkerPool extends node_events_1.EventEmitter {
             }
             const task = {
                 job,
+                priority: meta.priority,
+                timeout: meta.timeout,
+                retry: meta.retry,
+                retryDelay: meta.retryDelay,
                 resolve: resolve,
                 reject,
                 attempts: 0,
@@ -56,21 +86,29 @@ class WorkerPool extends node_events_1.EventEmitter {
             };
             if (signal) {
                 signal.addEventListener('abort', () => {
-                    // Remove from queue if not yet dispatched
-                    const idx = this.queue.indexOf(task);
-                    if (idx >= 0) {
-                        this.queue.splice(idx, 1);
-                        reject(new DOMException('Task aborted', 'AbortError'));
-                        return;
+                    // Remove from queue if not yet dispatched. Use head-index aware
+                    // search and tombstone with `undefined` to avoid an O(n) splice.
+                    const q = this.queue;
+                    for (let i = this.queueHead; i < q.length; i++) {
+                        if (q[i] === task) {
+                            q[i] = undefined;
+                            // If it's at the head, advance past it.
+                            while (this.queueHead < q.length && q[this.queueHead] === undefined) {
+                                this.queueHead++;
+                            }
+                            reject(new DOMException('Task aborted', 'AbortError'));
+                            return;
+                        }
                     }
                     // Already running — send abort signal to worker
-                    if (job.abortSignalId) {
+                    if (job.abortSignalId !== undefined) {
                         const worker = this.signalWorkerMap.get(job.abortSignalId);
                         if (worker) {
                             try {
                                 worker.postMessage({ type: 'abort', abortSignalId: job.abortSignalId });
                             }
-                            catch { /* worker gone */ }
+                            catch { /* worker gone */
+                            }
                         }
                     }
                 }, { once: true });
@@ -83,230 +121,369 @@ class WorkerPool extends node_events_1.EventEmitter {
         return {
             poolSize: this.size,
             idle: this.idle.length,
-            busy: this.active.size,
-            queued: this.queue.length,
+            busy: this.activeCount,
+            queued: this.queue.length - this.queueHead,
             warmingUp: this.warmingUp.size,
         };
     }
     spawnWorker() {
         const worker = new node_worker_threads_1.Worker(node_path_1.default.resolve(__dirname, '../worker/worker-runtime.js'), { workerData: { services: this.services } });
+        worker[STATE] = { active: new Map() };
         this.workers.push(worker);
         this.warmingUp.add(worker);
-        const onReady = (msg) => {
+        // ── Single persistent message listener ───────────────────────────────
+        // We used to add/remove a listener per dispatch — that allocated several
+        // closures and mutated the EventEmitter's listener array on every task.
+        // Instead we install one listener whose behaviour switches based on
+        // whether this worker is currently warming up or running a task.
+        const onMessage = (msg) => {
             const message = msg;
-            if (message?.type !== 'worker:ready')
+            if (this.warmingUp.has(worker)) {
+                if (message?.type !== 'worker:ready')
+                    return;
+                this.warmingUp.delete(worker);
+                if (!this.destroyed) {
+                    // Push the worker into the idle queue once per concurrency slot
+                    // so the scheduler will pipeline up to N jobs into it.
+                    for (let i = 0; i < this.concurrency; i++)
+                        this.idle.push(worker);
+                    this.schedule();
+                }
+                return;
+            }
+            // Spurious `worker:ready` after warmup → ignore.
+            if (message?.type === 'worker:ready')
+                return;
+            // IPC invoke from worker is not job-scoped — handle inline.
+            if (message?.type === 'ipc:invoke') {
+                this.handleIpcInvoke(worker, message);
                 return;
-            worker.removeListener('message', onReady);
-            this.warmingUp.delete(worker);
-            if (!this.destroyed) {
-                this.idle.push(worker);
-                this.schedule();
             }
+            // Batched job results — route each by jobId.
+            if (message?.type === 'results') {
+                const batch = message;
+                const state = getState(worker);
+                const results = batch.results;
+                for (let i = 0; i < results.length; i++) {
+                    const r = results[i];
+                    const slot = r.jobId !== undefined ? state.active.get(r.jobId) : undefined;
+                    if (!slot)
+                        continue;
+                    state.active.delete(r.jobId);
+                    this.completeJob(worker, slot, r);
+                }
+                if (!this.destroyed)
+                    this.schedule();
+                return;
+            }
+            // Job result — route by jobId to the right active slot.
+            const result = message;
+            const state = getState(worker);
+            const jobId = result.jobId;
+            let slot;
+            if (jobId !== undefined) {
+                slot = state.active.get(jobId);
+                if (slot)
+                    state.active.delete(jobId);
+            }
+            else if (state.active.size === 1) {
+                // Concurrency == 1 back-compat: single in-flight job, no need for ID.
+                const it = state.active.values().next();
+                slot = it.value;
+                state.active.clear();
+            }
+            if (!slot)
+                return; // late message for an aborted/timed-out task
+            this.completeJob(worker, slot, result);
+            if (!this.destroyed)
+                this.schedule();
         };
-        worker.on('message', onReady);
+        worker.on('message', onMessage);
         worker.once('error', (err) => this.handleWorkerError(worker, err));
         worker.once('exit', (code) => this.handleWorkerExit(worker, code));
         return worker;
     }
+    handleIpcInvoke(worker, req) {
+        const svcInstance = this.proxyMap.get(req.propertyKey);
+        const reply = (res) => {
+            try {
+                worker.postMessage(res);
+            }
+            catch {
+                try {
+                    worker.postMessage({
+                        type: 'ipc:result', callId: res.callId, ok: false,
+                        error: `IPC result for "${req.propertyKey}.${req.methodName}" ` +
+                            `is not structuredClone-compatible.`,
+                    });
+                }
+                catch { /* worker gone */ }
+            }
+        };
+        if (!svcInstance) {
+            reply({
+                type: 'ipc:result', callId: req.callId, ok: false,
+                error: `No proxy registered for "${req.propertyKey}"`,
+            });
+            return;
+        }
+        const method = svcInstance[req.methodName];
+        if (typeof method !== 'function') {
+            reply({
+                type: 'ipc:result', callId: req.callId, ok: false,
+                error: `Method "${req.methodName}" not found on "${req.propertyKey}"`,
+            });
+            return;
+        }
+        let p;
+        try {
+            p = svcInstance[req.methodName](...req.args);
+        }
+        catch (err) {
+            reply({
+                type: 'ipc:result', callId: req.callId, ok: false,
+                error: err.message ?? String(err),
+            });
+            return;
+        }
+        // Sync fast path for proxies that return plain values.
+        if (p === null || typeof p !== 'object' || typeof p.then !== 'function') {
+            reply({ type: 'ipc:result', callId: req.callId, ok: true, data: p });
+            return;
+        }
+        Promise.resolve(p).then((data) => reply({ type: 'ipc:result', callId: req.callId, ok: true, data }), (err) => reply({
+            type: 'ipc:result', callId: req.callId, ok: false,
+            error: err.message ?? String(err),
+        }));
+    }
     enqueue(task) {
-        const weight = PRIORITY_WEIGHT[task.job.priority];
-        let lo = 0, hi = this.queue.length;
+        const weight = PRIORITY_WEIGHT[task.priority];
+        const q = this.queue;
+        const head = this.queueHead;
+        const n = q.length;
+        // Fast path: empty queue, or tail has >= priority → just push (O(1)).
+        // This is by far the most common case under steady-state load.
+        if (n === head || PRIORITY_WEIGHT[q[n - 1].priority] >= weight) {
+            q.push(task);
+            return;
+        }
+        // Binary search over the live region [head, n) for the insertion point.
+        let lo = head, hi = n;
         while (lo < hi) {
             const mid = (lo + hi) >>> 1;
-            if (PRIORITY_WEIGHT[this.queue[mid].job.priority] < weight)
+            if (PRIORITY_WEIGHT[q[mid].priority] < weight)
                 hi = mid;
             else
                 lo = mid + 1;
         }
-        this.queue.splice(lo, 0, task);
+        q.splice(lo, 0, task);
     }
     schedule() {
+        if (this.destroyed || this.scheduleQueued)
+            return;
+        if (this.idle.length === 0 || this.queueHead >= this.queue.length)
+            return;
+        this.scheduleQueued = true;
+        queueMicrotask(this.drain);
+    }
+    /** Pre-bound for queueMicrotask — avoids closure allocation per schedule. */
+    drain = () => {
+        this.scheduleQueued = false;
         if (this.destroyed)
             return;
-        while (this.idle.length > 0 && this.queue.length > 0) {
-            const worker = this.idle.pop();
-            const task = this.queue.shift();
-            this.dispatch(worker, task);
+        const idle = this.idle;
+        const q = this.queue;
+        // Collect per-worker dispatches built during this schedule pass so we
+        // can ship them in ONE postMessage envelope per worker. Each postMessage
+        // pays a fixed structuredClone setup cost — batching amortises it.
+        let batches;
+        while (idle.length > 0 && this.queueHead < q.length) {
+            const worker = idle.pop();
+            const task = q[this.queueHead];
+            q[this.queueHead] = undefined;
+            this.queueHead++;
+            if (this.queueHead > 1024 && this.queueHead * 2 > q.length) {
+                q.splice(0, this.queueHead);
+                this.queueHead = 0;
+            }
+            this.prepareDispatch(worker, task);
+            if (!batches)
+                batches = new Map();
+            let arr = batches.get(worker);
+            if (!arr) {
+                arr = [];
+                batches.set(worker, arr);
+            }
+            arr.push(task.job);
         }
-    }
-    dispatch(worker, task) {
-        let settled = false;
-        let timeoutHandle;
-        const startedAt = Date.now();
+        if (!batches)
+            return;
+        for (const [worker, jobs] of batches) {
+            if (jobs.length === 1) {
+                worker.postMessage(jobs[0]);
+            }
+            else {
+                worker.postMessage({ type: 'batch', jobs });
+            }
+        }
+    };
+    prepareDispatch(worker, task) {
+        // Only pay the syscall cost when someone is actually listening.
+        const wantTiming = this.listenerCount('taskEnd') > 0 || this.listenerCount('taskStart') > 0;
+        const startedAt = wantTiming ? Date.now() : 0;
         task.attempts++;
-        task.job.attempt = task.attempts - 1;
-        this.active.set(worker, { task, priority: task.job.priority, startedAt });
-        if (task.job.abortSignalId) {
-            this.signalWorkerMap.set(task.job.abortSignalId, worker);
+        const sigId = task.job.abortSignalId;
+        if (sigId !== undefined) {
+            this.signalWorkerMap.set(sigId, worker);
         }
-        this.emit('taskStart', task.job);
-        const cleanup = () => {
-            worker.removeListener('message', onMessage);
-            if (timeoutHandle)
-                clearTimeout(timeoutHandle);
-            if (task.job.abortSignalId) {
-                this.signalWorkerMap.delete(task.job.abortSignalId);
-            }
-        };
-        const recycle = () => {
-            cleanup();
-            this.active.delete(worker);
-            if (!this.destroyed) {
-                this.idle.push(worker);
-                this.schedule();
+        const slot = { task, startedAt, settled: false };
+        const state = getState(worker);
+        state.active.set(task.job.jobId, slot);
+        this.activeCount++;
+        if (this.listenerCount('taskStart') > 0)
+            this.emit('taskStart', task.job);
+        if (task.timeout && task.timeout > 0) {
+            slot.timeoutHandle = setTimeout(() => this.handleTimeout(worker, slot), task.timeout);
+        }
+    }
+    /** Called from the persistent message listener when a job result arrives. */
+    completeJob(worker, slot, result) {
+        if (slot.settled)
+            return;
+        slot.settled = true;
+        if (slot.timeoutHandle)
+            clearTimeout(slot.timeoutHandle);
+        const sigId = slot.task.job.abortSignalId;
+        if (sigId !== undefined)
+            this.signalWorkerMap.delete(sigId);
+        this.activeCount--;
+        if (result.ok) {
+            if (this.listenerCount('taskEnd') > 0 && slot.startedAt > 0) {
+                this.emit('taskEnd', slot.task.job, Date.now() - slot.startedAt);
             }
-        };
-        const settle = (fn) => {
-            if (settled)
-                return;
-            settled = true;
-            fn();
-            recycle();
-        };
-        const handleFailure = (serializedError) => {
-            const { retry = 0, retryDelay = 0 } = task.job;
+            slot.task.resolve(result.data);
+        }
+        else {
+            this.handleFailure(slot.task, result.error ?? {
+                name: 'Error',
+                message: 'Unknown worker error',
+            });
+        }
+        // Give the slot back to the pool. Scheduling is the *caller*'s job so
+        // batched-result paths can release N slots before re-scheduling — that
+        // way schedule() can batch N new dispatches into a single postMessage
+        // back to the worker.
+        if (!this.destroyed) {
+            this.idle.push(worker);
+        }
+    }
+    handleFailure(task, serializedError) {
+        const retry = task.retry ?? 0;
+        const retryDelay = task.retryDelay ?? 0;
+        if (this.listenerCount('taskError') > 0) {
             this.emit('taskError', task.job, serializedError);
-            if (task.attempts < retry + 1) {
-                // Re-enqueue with delay
-                const delay = typeof retryDelay === 'number' ? retryDelay : 0;
-                const scheduleRetry = () => {
-                    this.enqueue(task);
-                    this.schedule();
-                };
-                if (delay > 0)
-                    setTimeout(scheduleRetry, delay);
-                else
-                    scheduleRetry();
-                return;
-            }
-            // All attempts exhausted → dead letter
-            const dlEvent = {
-                jobId: task.job.jobId,
-                serviceName: task.job.serviceName,
-                methodName: task.job.methodName,
-                args: task.job.args,
-                attempts: task.attempts,
-                error: serializedError,
-                failedAt: new Date(),
+        }
+        if (task.attempts < retry + 1) {
+            const scheduleRetry = () => {
+                this.enqueue(task);
+                this.schedule();
             };
-            this.emit('dead', dlEvent);
-            task.reject(deserializeError(serializedError));
-        };
-        const onMessage = async (msg) => {
-            const message = msg;
-            // ── IPC invoke from worker ────────────────────────────────────────
-            if (message.type === 'ipc:invoke') {
-                const req = message;
-                const svcInstance = this.proxyMap.get(req.propertyKey);
-                const reply = (res) => {
-                    try {
-                        worker.postMessage(res);
-                    }
-                    catch {
-                        try {
-                            worker.postMessage({
-                                type: 'ipc:result', callId: res.callId, ok: false,
-                                error: `IPC result for "${req.propertyKey}.${req.methodName}" ` +
-                                    `is not structuredClone-compatible.`,
-                            });
-                        }
-                        catch { /* worker gone */ }
-                    }
-                };
-                if (!svcInstance) {
-                    reply({ type: 'ipc:result', callId: req.callId, ok: false,
-                        error: `No proxy registered for "${req.propertyKey}"` });
-                    return;
-                }
-                const method = svcInstance[req.methodName];
-                if (typeof method !== 'function') {
-                    reply({ type: 'ipc:result', callId: req.callId, ok: false,
-                        error: `Method "${req.methodName}" not found on "${req.propertyKey}"` });
-                    return;
-                }
-                try {
-                    // Call via svcInstance[method]() to preserve `this` binding.
-                    // Detached call (const fn = svcInstance[m]; fn()) loses `this`
-                    // in strict mode, breaking any method that reads instance properties.
-                    const data = await svcInstance[req.methodName](...req.args);
-                    reply({ type: 'ipc:result', callId: req.callId, ok: true, data });
-                }
-                catch (err) {
-                    reply({ type: 'ipc:result', callId: req.callId, ok: false,
-                        error: err.message ?? String(err) });
-                }
-                return;
-            }
-            if (message.type === 'worker:ready')
-                return;
-            // ── Job result ────────────────────────────────────────────────────
-            const result = message;
-            const durationMs = Date.now() - startedAt;
-            settle(() => {
-                if (result.ok) {
-                    this.emit('taskEnd', task.job, durationMs);
-                    task.resolve(result.data);
-                }
-                else {
-                    handleFailure(result.error ?? {
-                        name: 'Error',
-                        message: 'Unknown worker error',
-                    });
-                }
-            });
+            if (retryDelay > 0)
+                setTimeout(scheduleRetry, retryDelay);
+            else
+                scheduleRetry();
+            return;
+        }
+        const dlEvent = {
+            jobId: task.job.jobId,
+            serviceName: task.job.serviceName,
+            methodName: task.job.methodName,
+            args: task.job.args,
+            attempts: task.attempts,
+            error: serializedError,
+            failedAt: new Date(),
         };
-        worker.on('message', onMessage);
-        if (task.job.timeout && task.job.timeout > 0) {
-            timeoutHandle = setTimeout(async () => {
-                if (settled)
-                    return;
-                settled = true;
-                cleanup();
-                this.active.delete(worker);
-                const serializedError = {
-                    name: 'TimeoutError',
-                    message: `Task "${task.job.serviceName}.${task.job.methodName}" ` +
-                        `timed out after ${task.job.timeout}ms`,
-                };
-                handleFailure(serializedError);
-                try {
-                    await worker.terminate();
-                }
-                catch { }
-                this.replaceWorker(worker);
-                this.schedule();
-            }, task.job.timeout);
+        this.emit('dead', dlEvent);
+        task.reject(deserializeError(serializedError));
+    }
+    async handleTimeout(worker, slot) {
+        if (slot.settled)
+            return;
+        slot.settled = true;
+        const sigId = slot.task.job.abortSignalId;
+        if (sigId !== undefined)
+            this.signalWorkerMap.delete(sigId);
+        const state = getState(worker);
+        state.active.delete(slot.task.job.jobId);
+        this.activeCount--;
+        this.handleFailure(slot.task, {
+            name: 'TimeoutError',
+            message: `Task "${slot.task.job.serviceName}.${slot.task.job.methodName}" ` +
+                `timed out after ${slot.task.timeout}ms`,
+        });
+        // Timeouts terminate the worker (its event loop may be wedged) and
+        // replace it. All other in-flight jobs on this worker fail too.
+        try {
+            await worker.terminate();
         }
-        worker.postMessage(task.job);
+        catch { /* ignore */ }
+        this.replaceWorker(worker);
+        this.schedule();
     }
     handleWorkerError(worker, err) {
-        const running = this.active.get(worker);
-        if (running) {
-            const { serviceName, methodName } = running.task.job;
-            const wrapped = new Error(`Worker crashed in "${serviceName}.${methodName}": ${err.message}`);
-            wrapped.stack = err.stack;
-            this.emit('error', wrapped, running.task.job);
-            running.task.reject(wrapped);
-            this.active.delete(worker);
+        const state = worker[STATE];
+        if (state) {
+            for (const slot of state.active.values()) {
+                if (slot.settled)
+                    continue;
+                slot.settled = true;
+                if (slot.timeoutHandle)
+                    clearTimeout(slot.timeoutHandle);
+                const sigId = slot.task.job.abortSignalId;
+                if (sigId !== undefined)
+                    this.signalWorkerMap.delete(sigId);
+                const { serviceName, methodName } = slot.task.job;
+                const wrapped = new Error(`Worker crashed in "${serviceName}.${methodName}": ${err.message}`);
+                wrapped.stack = err.stack;
+                this.emit('error', wrapped, slot.task.job);
+                slot.task.reject(wrapped);
+                this.activeCount--;
+            }
+            state.active.clear();
         }
         this.replaceWorker(worker);
     }
     handleWorkerExit(worker, code) {
         if (this.destroyed)
             return;
-        const running = this.active.get(worker);
-        if (running) {
-            running.task.reject(new Error(`Worker exited with code ${code} while running ` +
-                `"${running.task.job.serviceName}.${running.task.job.methodName}"`));
-            this.active.delete(worker);
+        const state = worker[STATE];
+        if (state) {
+            for (const slot of state.active.values()) {
+                if (slot.settled)
+                    continue;
+                slot.settled = true;
+                if (slot.timeoutHandle)
+                    clearTimeout(slot.timeoutHandle);
+                const sigId = slot.task.job.abortSignalId;
+                if (sigId !== undefined)
+                    this.signalWorkerMap.delete(sigId);
+                slot.task.reject(new Error(`Worker exited with code ${code} while running ` +
+                    `"${slot.task.job.serviceName}.${slot.task.job.methodName}"`));
+                this.activeCount--;
+            }
+            state.active.clear();
         }
         this.replaceWorker(worker);
     }
     replaceWorker(oldWorker) {
         const remove = (arr) => {
-            const i = arr.indexOf(oldWorker);
-            if (i >= 0)
-                arr.splice(i, 1);
+            // Remove ALL occurrences (idle holds up to `concurrency` slots per worker).
+            let w = 0;
+            for (let r = 0; r < arr.length; r++) {
+                if (arr[r] !== oldWorker)
+                    arr[w++] = arr[r];
+            }
+            arr.length = w;
         };
         remove(this.workers);
         remove(this.idle);
@@ -319,24 +496,39 @@ class WorkerPool extends node_events_1.EventEmitter {
     async destroy() {
         this.destroyed = true;
         // Drain: wait for all active jobs to finish, up to shutdownTimeout
-        if (this.active.size > 0) {
+        if (this.activeCount > 0) {
+            const activeTasks = [];
+            for (const worker of this.workers) {
+                const state = worker[STATE];
+                if (!state)
+                    continue;
+                for (const slot of state.active.values())
+                    activeTasks.push(slot.task);
+            }
             await Promise.race([
-                // Wait for all active jobs to settle
-                Promise.allSettled(Array.from(this.active.values()).map(({ task }) => new Promise((res) => {
+                Promise.allSettled(activeTasks.map((task) => new Promise((res) => {
                     const orig = task.resolve;
                     const origRej = task.reject;
-                    task.resolve = (v) => { orig(v); res(); };
-                    task.reject = (e) => { origRej(e); res(); };
+                    task.resolve = (v) => {
+                        orig(v);
+                        res();
+                    };
+                    task.reject = (e) => {
+                        origRej(e);
+                        res();
+                    };
                 }))),
-                // Force after timeout
                 new Promise((res) => setTimeout(res, this.shutdownTimeout)),
             ]);
         }
         // Reject anything still queued
-        for (const queued of this.queue) {
-            queued.reject(new Error('WorkerPool destroyed'));
+        for (let i = this.queueHead; i < this.queue.length; i++) {
+            const queued = this.queue[i];
+            if (queued)
+                queued.reject(new Error('WorkerPool destroyed'));
         }
         this.queue.length = 0;
+        this.queueHead = 0;
         await Promise.allSettled(this.workers.map((w) => w.terminate()));
         this.workers.length = 0;
         this.idle.length = 0;