nestworker 2.1.6 → 2.1.7

package/dist/core/worker.pool.js

@@ -3,16 +3,27 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.WorkerPool = void 0;
+exports.WorkerPool = exports.QueueFullError = void 0;
 const node_worker_threads_1 = require("node:worker_threads");
 const node_events_1 = require("node:events");
 const node_os_1 = __importDefault(require("node:os"));
 const node_path_1 = __importDefault(require("node:path"));
-const PRIORITY_WEIGHT = {
-    HIGH: 3,
-    NORMAL: 2,
-    LOW: 1,
-};
+/** Cross-version AbortError factory (DOMException only since Node 17). */
+function makeAbortError(message) {
+    if (typeof DOMException === 'function') {
+        return new DOMException(message, 'AbortError');
+    }
+    const err = new Error(message);
+    err.name = 'AbortError';
+    return err;
+}
+class QueueFullError extends Error {
+    constructor(depth) {
+        super(`WorkerPool queue is full (maxQueueDepth=${depth})`);
+        this.name = 'QueueFullError';
+    }
+}
+exports.QueueFullError = QueueFullError;
 // 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');
@@ -32,10 +43,17 @@ class WorkerPool extends node_events_1.EventEmitter {
      */
     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;
+    // Per-priority FIFO buckets. Replaces the single sorted queue: enqueue is
+    // now O(1) push (no binary search + splice), dequeue is O(1) pop from the
+    // highest non-empty bucket. Long bursts of mixed-priority jobs no longer
+    // pay an O(n) shift cost.
+    queueHigh = [];
+    queueNormal = [];
+    queueLow = [];
+    queueHighHead = 0;
+    queueNormalHead = 0;
+    queueLowHead = 0;
+    queuedCount = 0;
     destroyed = false;
     activeCount = 0;
     /**
@@ -47,16 +65,17 @@ class WorkerPool extends node_events_1.EventEmitter {
      * coalesced into a single postMessage per worker.
      */
     scheduleQueued = false;
-    /** Maps abortSignalId → worker currently running that job */
-    signalWorkerMap = new Map();
     concurrency;
+    maxQueueDepth;
     proxyMap = new Map();
-    constructor(services, proxyInstances, size = node_os_1.default.cpus().length, shutdownTimeout = 30_000, concurrency = 1) {
+    constructor(services, proxyInstances, size = node_os_1.default.cpus().length, shutdownTimeout = 30_000, concurrency = 1, maxQueueDepth = Number.POSITIVE_INFINITY) {
         super();
         this.services = services;
         this.size = size;
         this.shutdownTimeout = shutdownTimeout;
         this.concurrency = concurrency > 0 ? concurrency : 1;
+        this.maxQueueDepth =
+            maxQueueDepth > 0 ? maxQueueDepth : Number.POSITIVE_INFINITY;
         for (const { propertyKey, instance } of proxyInstances) {
             this.proxyMap.set(propertyKey, instance);
         }
@@ -70,7 +89,13 @@ class WorkerPool extends node_events_1.EventEmitter {
         return new Promise((resolve, reject) => {
             // Reject immediately if already aborted
             if (signal?.aborted) {
-                reject(new DOMException('Task aborted before enqueue', 'AbortError'));
+                reject(makeAbortError('Task aborted before enqueue'));
+                return;
+            }
+            // Backpressure: enforce queue depth before allocating anything.
+            const depth = this.queuedCount;
+            if (depth >= this.maxQueueDepth) {
+                reject(new QueueFullError(this.maxQueueDepth));
                 return;
             }
             const task = {
@@ -85,60 +110,85 @@ class WorkerPool extends node_events_1.EventEmitter {
                 signal,
             };
             if (signal) {
-                signal.addEventListener('abort', () => {
-                    // 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++;
+                const handler = () => {
+                    // Tombstone the task in its bucket if it's still queued. We don't
+                    // know which bucket it lives in without checking, so try each;
+                    // each scan walks ONLY the live region (head..length) of its
+                    // bucket. In the worst case the task isn't queued at all (already
+                    // dispatched), so we fall through to the running-task path.
+                    const buckets = [
+                        [this.queueHigh, this.queueHighHead],
+                        [this.queueNormal, this.queueNormalHead],
+                        [this.queueLow, this.queueLowHead],
+                    ];
+                    for (const [bucket, head] of buckets) {
+                        for (let i = head; i < bucket.length; i++) {
+                            if (bucket[i] === task) {
+                                bucket[i] = undefined;
+                                this.queuedCount--;
+                                this.detachAbort(task);
+                                reject(makeAbortError('Task aborted'));
+                                return;
                             }
-                            reject(new DOMException('Task aborted', 'AbortError'));
-                            return;
                         }
                     }
-                    // Already running — send abort signal to worker
-                    if (job.abortSignalId !== undefined) {
-                        const worker = this.signalWorkerMap.get(job.abortSignalId);
-                        if (worker) {
-                            try {
-                                worker.postMessage({ type: 'abort', abortSignalId: job.abortSignalId });
-                            }
-                            catch {
-                                /* worker gone */
-                            }
+                    // Already running — forward abort to its worker.
+                    const worker = task.worker;
+                    if (worker && job.abortSignalId !== undefined) {
+                        try {
+                            worker.postMessage({
+                                type: 'abort',
+                                abortSignalId: job.abortSignalId,
+                            });
+                        }
+                        catch {
+                            /* worker gone */
                         }
                     }
-                }, { once: true });
+                };
+                task.abortHandler = handler;
+                signal.addEventListener('abort', handler, { once: true });
             }
             this.enqueue(task);
             this.schedule();
         });
     }
+    /** Remove the abort listener installed in `execute()` (idempotent). */
+    detachAbort(task) {
+        if (task.abortHandler && task.signal) {
+            try {
+                task.signal.removeEventListener('abort', task.abortHandler);
+            }
+            catch {
+                /* ignore */
+            }
+            task.abortHandler = undefined;
+        }
+    }
     stats() {
+        const queued = this.queuedCount;
+        const cap = this.maxQueueDepth;
         return {
             poolSize: this.size,
             idle: this.idle.length,
             busy: this.activeCount,
-            queued: this.queue.length - this.queueHead,
+            queued,
             warmingUp: this.warmingUp.size,
+            saturation: Number.isFinite(cap) ? queued / cap : 0,
+            maxQueueDepth: cap,
         };
     }
     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() };
+        worker[STATE] = {
+            active: new Map(),
+            replaced: false,
+        };
         this.workers.push(worker);
         this.warmingUp.add(worker);
         // ── 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 (this.warmingUp.has(worker)) {
@@ -146,8 +196,6 @@ class WorkerPool extends node_events_1.EventEmitter {
                     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();
@@ -157,7 +205,6 @@ class WorkerPool extends node_events_1.EventEmitter {
             // 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;
@@ -169,7 +216,9 @@ class WorkerPool extends node_events_1.EventEmitter {
                 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 (r.jobId === undefined)
+                        continue;
+                    const slot = state.active.get(r.jobId);
                     if (!slot)
                         continue;
                     state.active.delete(r.jobId);
@@ -179,31 +228,24 @@ class WorkerPool extends node_events_1.EventEmitter {
                     this.dispatchNow();
                 return;
             }
-            // Job result — route by jobId to the right active slot.
+            // Single job result — route by jobId.
             const result = message;
+            if (result.jobId === undefined)
+                return;
             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();
-            }
+            const slot = state.active.get(result.jobId);
             if (!slot)
                 return; // late message for an aborted/timed-out task
+            state.active.delete(result.jobId);
             this.completeJob(worker, slot, result);
             if (!this.destroyed)
                 this.dispatchNow();
         };
         worker.on('message', onMessage);
-        worker.once('error', (err) => this.handleWorkerError(worker, err));
-        worker.once('exit', (code) => this.handleWorkerExit(worker, code));
+        // Use .on (not .once): a wedged worker can emit multiple errors before
+        // exit. handleWorkerError is idempotent via WorkerState.replaced.
+        worker.on('error', (err) => this.handleWorkerError(worker, err));
+        worker.on('exit', (code) => this.handleWorkerExit(worker, code));
         return worker;
     }
     handleIpcInvoke(worker, req) {
@@ -246,9 +288,18 @@ class WorkerPool extends node_events_1.EventEmitter {
             });
             return;
         }
+        // Forward the originating task's AbortSignal as the last arg when the
+        // worker provided one — lets proxy implementations honour cancellation
+        // (fetch, child_process, etc.) instead of running past it.
+        let callArgs = req.args;
+        if (req.abortSignalId !== undefined) {
+            const sig = this.findSignalById(req.abortSignalId);
+            if (sig)
+                callArgs = [...req.args, sig];
+        }
         let p;
         try {
-            p = svcInstance[req.methodName](...req.args);
+            p = method.apply(svcInstance, callArgs);
         }
         catch (err) {
             reply({
@@ -273,73 +324,140 @@ class WorkerPool extends node_events_1.EventEmitter {
             error: err.message ?? String(err),
         }));
     }
+    /**
+     * Look up the original caller's AbortSignal by abortSignalId. Used by
+     * `handleIpcInvoke` to forward cancellation into proxy methods.
+     * Scan is bounded by `concurrency * poolSize` and only happens on proxy
+     * calls from signal-bearing tasks, so we don't bother with a side index.
+     */
+    findSignalById(abortSignalId) {
+        for (const worker of this.workers) {
+            const state = worker[STATE];
+            if (!state)
+                continue;
+            for (const slot of state.active.values()) {
+                if (slot.task.job.abortSignalId === abortSignalId)
+                    return slot.task.signal;
+            }
+        }
+        return undefined;
+    }
     enqueue(task) {
-        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;
+        const bucket = task.priority === 'HIGH'
+            ? this.queueHigh
+            : task.priority === 'LOW'
+                ? this.queueLow
+                : this.queueNormal;
+        bucket.push(task);
+        this.queuedCount++;
+    }
+    /**
+     * Pop the next ready task in priority order (HIGH > NORMAL > LOW). Skips
+     * tombstoned entries (aborted-while-queued) and lazily compacts each
+     * bucket once its head pointer wastes >1024 slots.
+     *
+     * Returns `undefined` when all buckets are empty or contain only
+     * tombstones — caller must check.
+     */
+    dequeue() {
+        // HIGH
+        while (this.queueHighHead < this.queueHigh.length) {
+            const t = this.queueHigh[this.queueHighHead];
+            this.queueHigh[this.queueHighHead] = undefined;
+            this.queueHighHead++;
+            this.maybeCompact(this.queueHigh, 'queueHighHead');
+            if (t) {
+                this.queuedCount--;
+                return t;
+            }
         }
-        // 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[q[mid].priority] < weight)
-                hi = mid;
-            else
-                lo = mid + 1;
+        // NORMAL
+        while (this.queueNormalHead < this.queueNormal.length) {
+            const t = this.queueNormal[this.queueNormalHead];
+            this.queueNormal[this.queueNormalHead] = undefined;
+            this.queueNormalHead++;
+            this.maybeCompact(this.queueNormal, 'queueNormalHead');
+            if (t) {
+                this.queuedCount--;
+                return t;
+            }
+        }
+        // LOW
+        while (this.queueLowHead < this.queueLow.length) {
+            const t = this.queueLow[this.queueLowHead];
+            this.queueLow[this.queueLowHead] = undefined;
+            this.queueLowHead++;
+            this.maybeCompact(this.queueLow, 'queueLowHead');
+            if (t) {
+                this.queuedCount--;
+                return t;
+            }
         }
-        q.splice(lo, 0, task);
+        return undefined;
+    }
+    maybeCompact(bucket, headProp) {
+        const head = this[headProp];
+        if (head > 1024 && head * 2 > bucket.length) {
+            bucket.splice(0, head);
+            this[headProp] = 0;
+        }
+    }
+    /** True iff at least one bucket has a non-tombstone entry remaining. */
+    hasQueued() {
+        return this.queuedCount > 0;
     }
     schedule() {
         if (this.destroyed || this.scheduleQueued)
             return;
-        if (this.idle.length === 0 || this.queueHead >= this.queue.length)
+        if (this.idle.length === 0 || !this.hasQueued())
             return;
         this.scheduleQueued = true;
         queueMicrotask(this.drain);
     }
     /**
-     * Synchronous drain used on the COMPLETION path — when a worker becomes
-     * idle as a result of a result message arriving, we want to hand it the
-     * next queued job in the SAME tick. The microtask-deferred `schedule()`
-     * adds a full microtask hop per round-trip, which dominates throughput
-     * for short tasks with concurrency=1.
-     *
-     * Initial-burst dispatch still goes through the deferred `schedule()` so
-     * synchronous floods of `execute()` calls get coalesced into per-worker
-     * batches.
+     * Synchronous drain used on the COMPLETION path. Initial-burst dispatch
+     * still goes through the deferred `schedule()` so synchronous floods of
+     * `execute()` calls get coalesced into per-worker batches.
      */
     dispatchNow() {
         if (this.destroyed)
             return;
-        const idle = this.idle;
-        const q = this.queue;
-        // If a microtask drain is already queued (initial burst still in flight),
-        // let it own the dispatch — running both would race and double-dispatch.
+        // If a microtask drain is already queued, let it own the dispatch.
         if (this.scheduleQueued)
             return;
-        if (idle.length === 0 || this.queueHead >= q.length)
+        this.flushDispatch(true);
+    }
+    /** Pre-bound for queueMicrotask — avoids closure allocation per schedule. */
+    drain = () => {
+        this.scheduleQueued = false;
+        if (this.destroyed)
+            return;
+        this.flushDispatch(false);
+    };
+    /**
+     * Common dispatch loop shared by `dispatchNow` (synchronous, post-result)
+     * and `drain` (microtask, post-burst). Pops idle slots and ships jobs as
+     * either bare `WorkerJob` (single) or `WorkerJobBatch` envelopes.
+     *
+     * @param fastSingle When true, take a fast path for "exactly one job to
+     *   exactly one idle worker" that skips the per-worker Map allocation.
+     */
+    flushDispatch(fastSingle) {
+        const idle = this.idle;
+        if (idle.length === 0 || !this.hasQueued())
             return;
         let batches;
-        while (idle.length > 0 && this.queueHead < q.length) {
+        while (idle.length > 0) {
+            const task = this.dequeue();
+            if (!task)
+                break;
             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);
-            // Fast path for the overwhelmingly common case: ONE worker idle,
-            // ONE job to dispatch. Skip the Map allocation and ship directly.
-            if (batches === undefined && (idle.length === 0 || this.queueHead >= q.length)) {
-                worker.postMessage(task.job);
+            // Fast path: ONE worker idle, ONE job dispatched — ship immediately.
+            if (fastSingle &&
+                batches === undefined &&
+                (idle.length === 0 || !this.hasQueued())) {
+                this.safePostJob(worker, task, task.job);
                 return;
             }
             if (batches === undefined)
@@ -355,63 +473,72 @@ class WorkerPool extends node_events_1.EventEmitter {
             return;
         for (const [worker, jobs] of batches) {
             if (jobs.length === 1) {
-                worker.postMessage(jobs[0]);
+                const slot = getState(worker).active.get(jobs[0].jobId);
+                this.safePostJob(worker, slot?.task, jobs[0]);
             }
             else {
-                worker.postMessage({ type: 'batch', jobs });
+                this.safePostBatch(worker, jobs);
             }
         }
     }
-    /** Pre-bound for queueMicrotask — avoids closure allocation per schedule. */
-    drain = () => {
-        this.scheduleQueued = false;
-        if (this.destroyed)
-            return;
-        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;
+    /**
+     * Post a single job; on serialization failure synthesise a failure result
+     * so the caller's promise rejects instead of hanging on the active map.
+     */
+    safePostJob(worker, task, job) {
+        try {
+            worker.postMessage(job);
+        }
+        catch (err) {
+            const state = getState(worker);
+            const slot = state.active.get(job.jobId);
+            if (slot) {
+                state.active.delete(job.jobId);
+                this.completeJob(worker, slot, {
+                    type: 'result',
+                    ok: false,
+                    jobId: job.jobId,
+                    error: {
+                        name: 'DataCloneError',
+                        message: `Failed to postMessage job "${job.serviceName}.${job.methodName}": ` +
+                            (err.message ?? String(err)),
+                    },
+                });
             }
-            this.prepareDispatch(worker, task);
-            if (!batches)
-                batches = new Map();
-            let arr = batches.get(worker);
-            if (!arr) {
-                arr = [];
-                batches.set(worker, arr);
+            else if (task) {
+                task.reject(err);
             }
-            arr.push(task.job);
         }
-        if (!batches)
-            return;
-        for (const [worker, jobs] of batches) {
-            if (jobs.length === 1) {
-                worker.postMessage(jobs[0]);
-            }
-            else {
-                worker.postMessage({ type: 'batch', jobs });
+    }
+    safePostBatch(worker, jobs) {
+        try {
+            worker.postMessage({ type: 'batch', jobs });
+        }
+        catch (err) {
+            // Batch-level failure: fail every job in this batch individually.
+            const state = getState(worker);
+            const message = `Failed to postMessage batch: ` +
+                (err.message ?? String(err));
+            for (let i = 0; i < jobs.length; i++) {
+                const j = jobs[i];
+                const slot = state.active.get(j.jobId);
+                if (!slot)
+                    continue;
+                state.active.delete(j.jobId);
+                this.completeJob(worker, slot, {
+                    type: 'result',
+                    ok: false,
+                    jobId: j.jobId,
+                    error: { name: 'DataCloneError', message },
+                });
             }
         }
-    };
+    }
     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++;
-        const sigId = task.job.abortSignalId;
-        if (sigId !== undefined) {
-            this.signalWorkerMap.set(sigId, worker);
-        }
+        task.worker = worker;
         const slot = { task, startedAt, settled: false };
         const state = getState(worker);
         state.active.set(task.job.jobId, slot);
@@ -429,14 +556,13 @@ class WorkerPool extends node_events_1.EventEmitter {
         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);
             }
+            this.detachAbort(slot.task);
+            slot.task.worker = undefined;
             slot.task.resolve(result.data);
         }
         else {
@@ -445,27 +571,40 @@ class WorkerPool extends node_events_1.EventEmitter {
                 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) {
+            // Resolve retryDelay main-side: numeric value, or invoke fn(attempt).
+            let delay = 0;
+            const rd = task.retryDelay;
+            if (typeof rd === 'number')
+                delay = rd;
+            else if (typeof rd === 'function') {
+                try {
+                    delay = Math.max(0, Number(rd(task.attempts)) || 0);
+                }
+                catch {
+                    delay = 0;
+                }
+            }
+            task.worker = undefined;
             const scheduleRetry = () => {
+                if (this.destroyed) {
+                    task.reject(new Error('WorkerPool destroyed'));
+                    return;
+                }
                 this.enqueue(task);
                 this.schedule();
             };
-            if (retryDelay > 0)
-                setTimeout(scheduleRetry, retryDelay);
+            if (delay > 0)
+                setTimeout(scheduleRetry, delay);
             else
                 scheduleRetry();
             return;
@@ -480,25 +619,20 @@ class WorkerPool extends node_events_1.EventEmitter {
             failedAt: new Date(),
         };
         this.emit('dead', dlEvent);
+        this.detachAbort(task);
+        task.worker = undefined;
         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.
+        // Terminate FIRST so the wedged worker is gone before any retry can be
+        // scheduled (which would otherwise race back into a worker we're about
+        // to destroy and either fail to dispatch or wedge again).
         try {
             await worker.terminate();
         }
@@ -506,51 +640,56 @@ class WorkerPool extends node_events_1.EventEmitter {
             /* ignore */
         }
         this.replaceWorker(worker);
+        this.handleFailure(slot.task, {
+            name: 'TimeoutError',
+            message: `Task "${slot.task.job.serviceName}.${slot.task.job.methodName}" ` +
+                `timed out after ${slot.task.timeout}ms`,
+        });
         this.schedule();
     }
     handleWorkerError(worker, err) {
         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();
+        if (!state || state.replaced)
+            return;
+        state.replaced = true;
+        for (const slot of state.active.values()) {
+            if (slot.settled)
+                continue;
+            slot.settled = true;
+            if (slot.timeoutHandle)
+                clearTimeout(slot.timeoutHandle);
+            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);
+            this.detachAbort(slot.task);
+            slot.task.worker = undefined;
+            slot.task.reject(wrapped);
+            this.activeCount--;
         }
+        state.active.clear();
         this.replaceWorker(worker);
     }
     handleWorkerExit(worker, code) {
         if (this.destroyed)
             return;
         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();
+        if (!state || state.replaced)
+            return;
+        state.replaced = true;
+        for (const slot of state.active.values()) {
+            if (slot.settled)
+                continue;
+            slot.settled = true;
+            if (slot.timeoutHandle)
+                clearTimeout(slot.timeoutHandle);
+            this.detachAbort(slot.task);
+            slot.task.worker = undefined;
+            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) {
@@ -573,7 +712,10 @@ class WorkerPool extends node_events_1.EventEmitter {
     }
     async destroy() {
         this.destroyed = true;
-        // Drain: wait for all active jobs to finish, up to shutdownTimeout
+        // Drain: wait for all active jobs to finish, up to shutdownTimeout.
+        // We track per-task settle Promises (created at execute-time) instead
+        // of monkey-patching task.resolve/reject — that approach silently
+        // dropped duplicate-settle calls and could deadlock the race.
         if (this.activeCount > 0) {
             const activeTasks = [];
             for (const worker of this.workers) {
@@ -587,26 +729,41 @@ class WorkerPool extends node_events_1.EventEmitter {
                 Promise.allSettled(activeTasks.map((task) => new Promise((res) => {
                     const orig = task.resolve;
                     const origRej = task.reject;
+                    let done = false;
                     task.resolve = (v) => {
+                        if (!done) {
+                            done = true;
+                            res();
+                        }
                         orig(v);
-                        res();
                     };
                     task.reject = (e) => {
+                        if (!done) {
+                            done = true;
+                            res();
+                        }
                         origRej(e);
-                        res();
                     };
                 }))),
                 new Promise((res) => setTimeout(res, this.shutdownTimeout)),
             ]);
         }
-        // Reject anything still queued
-        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;
+        // Reject anything still queued — walk each bucket and reject live entries.
+        const drainBucket = (bucket, head) => {
+            for (let i = head; i < bucket.length; i++) {
+                const queued = bucket[i];
+                if (queued) {
+                    this.detachAbort(queued);
+                    queued.reject(new Error('WorkerPool destroyed'));
+                }
+            }
+            bucket.length = 0;
+        };
+        drainBucket(this.queueHigh, this.queueHighHead);
+        drainBucket(this.queueNormal, this.queueNormalHead);
+        drainBucket(this.queueLow, this.queueLowHead);
+        this.queueHighHead = this.queueNormalHead = this.queueLowHead = 0;
+        this.queuedCount = 0;
         await Promise.allSettled(this.workers.map((w) => w.terminate()));
         this.workers.length = 0;
         this.idle.length = 0;