@openclaw/whatsapp 2026.7.2-beta.4 → 2026.7.2-beta.7

package/node_modules/baileys/node_modules/p-queue/dist/index.js

@@ -0,0 +1,806 @@
+import { EventEmitter } from 'eventemitter3';
+import pTimeout from 'p-timeout';
+import PriorityQueue from './priority-queue.js';
+/**
+Promise queue with concurrency control.
+*/
+export default class PQueue extends EventEmitter {
+    #carryoverIntervalCount;
+    #isIntervalIgnored;
+    #intervalCount = 0;
+    #intervalCap;
+    #rateLimitedInInterval = false;
+    #rateLimitFlushScheduled = false;
+    #interval;
+    /*
+    Timestamp when the current interval window ends. Kept accurate at every window transition: `#initializeIntervalIfNeeded` sets it when a window starts and `#onInterval` advances it as the recurring timer rolls into each new window. This is the source of truth for whether a task added after the queue goes idle belongs to a fresh window, so it must not go stale.
+    */
+    #intervalEnd = 0;
+    // Recurring timer that drives windows while the queue is actively processing. Absent (`undefined`) once the queue goes idle.
+    #intervalId;
+    // One-shot timer used while idle to resume at the next window boundary, since `#intervalId` is cleared when idle.
+    #timeoutId;
+    #strict;
+    // Circular buffer implementation for better performance
+    #strictTicks = [];
+    #strictTicksStartIndex = 0;
+    #queue;
+    #queueClass;
+    #pending = 0;
+    // The `!` is needed because of https://github.com/microsoft/TypeScript/issues/32194
+    #concurrency;
+    #isPaused;
+    // Use to assign a unique identifier to a promise function, if not explicitly specified
+    #idAssigner = 1n;
+    // Track currently running tasks for debugging
+    #runningTasks = new Map();
+    #queueAbortListenerCleanupFunctions = new Set();
+    /**
+    Get or set the default timeout for all tasks. Can be changed at runtime.
+
+    Operations will throw a `TimeoutError` if they don't complete within the specified time.
+
+    The timeout begins when the operation is dequeued and starts execution, not while it's waiting in the queue.
+
+    @example
+    ```
+    const queue = new PQueue({timeout: 5000});
+
+    // Change timeout for all future tasks
+    queue.timeout = 10000;
+    ```
+    */
+    timeout;
+    constructor(options) {
+        super();
+        // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+        options = {
+            carryoverIntervalCount: false,
+            intervalCap: Number.POSITIVE_INFINITY,
+            interval: 0,
+            concurrency: Number.POSITIVE_INFINITY,
+            autoStart: true,
+            queueClass: PriorityQueue,
+            strict: false,
+            ...options,
+        };
+        if (!(typeof options.intervalCap === 'number' && options.intervalCap >= 1)) {
+            throw new TypeError(`Expected \`intervalCap\` to be a number from 1 and up, got \`${options.intervalCap?.toString() ?? ''}\` (${typeof options.intervalCap})`);
+        }
+        if (options.interval === undefined || !(Number.isFinite(options.interval) && options.interval >= 0)) {
+            throw new TypeError(`Expected \`interval\` to be a finite number >= 0, got \`${options.interval?.toString() ?? ''}\` (${typeof options.interval})`);
+        }
+        if (options.strict && options.interval === 0) {
+            throw new TypeError('The `strict` option requires a non-zero `interval`');
+        }
+        if (options.strict && options.intervalCap === Number.POSITIVE_INFINITY) {
+            throw new TypeError('The `strict` option requires a finite `intervalCap`');
+        }
+        // TODO: Remove this fallback in the next major version
+        // eslint-disable-next-line @typescript-eslint/no-deprecated
+        this.#carryoverIntervalCount = options.carryoverIntervalCount ?? options.carryoverConcurrencyCount ?? false;
+        this.#isIntervalIgnored = options.intervalCap === Number.POSITIVE_INFINITY || options.interval === 0;
+        this.#intervalCap = options.intervalCap;
+        this.#interval = options.interval;
+        this.#strict = options.strict;
+        this.#queue = new options.queueClass();
+        this.#queueClass = options.queueClass;
+        this.concurrency = options.concurrency;
+        if (options.timeout !== undefined && !(Number.isFinite(options.timeout) && options.timeout > 0)) {
+            throw new TypeError(`Expected \`timeout\` to be a positive finite number, got \`${options.timeout}\` (${typeof options.timeout})`);
+        }
+        this.timeout = options.timeout;
+        this.#isPaused = options.autoStart === false;
+        this.#setupRateLimitTracking();
+    }
+    #cleanupStrictTicks(now) {
+        // Remove ticks outside the current interval window using circular buffer approach
+        while (this.#strictTicksStartIndex < this.#strictTicks.length) {
+            const oldestTick = this.#strictTicks[this.#strictTicksStartIndex];
+            if (oldestTick !== undefined && now - oldestTick >= this.#interval) {
+                this.#strictTicksStartIndex++;
+            }
+            else {
+                break;
+            }
+        }
+        // Compact the array when it becomes inefficient or fully consumed
+        // Compact when: (start index is large AND more than half wasted) OR all ticks expired
+        const shouldCompact = (this.#strictTicksStartIndex > 100 && this.#strictTicksStartIndex > this.#strictTicks.length / 2)
+            || this.#strictTicksStartIndex === this.#strictTicks.length;
+        if (shouldCompact) {
+            this.#strictTicks = this.#strictTicks.slice(this.#strictTicksStartIndex);
+            this.#strictTicksStartIndex = 0;
+        }
+    }
+    // Helper methods for interval consumption
+    #consumeIntervalSlot(now) {
+        if (this.#strict) {
+            this.#strictTicks.push(now);
+        }
+        else {
+            this.#intervalCount++;
+        }
+    }
+    #rollbackIntervalSlot() {
+        if (this.#strict) {
+            // Pop from the end of the actual data (not from start index)
+            if (this.#strictTicks.length > this.#strictTicksStartIndex) {
+                this.#strictTicks.pop();
+            }
+        }
+        else if (this.#intervalCount > 0) {
+            this.#intervalCount--;
+        }
+    }
+    #getActiveTicksCount() {
+        return this.#strictTicks.length - this.#strictTicksStartIndex;
+    }
+    get #doesIntervalAllowAnother() {
+        if (this.#isIntervalIgnored) {
+            return true;
+        }
+        if (this.#strict) {
+            // Cleanup already done by #isIntervalPausedAt before this is called
+            return this.#getActiveTicksCount() < this.#intervalCap;
+        }
+        return this.#intervalCount < this.#intervalCap;
+    }
+    get #doesConcurrentAllowAnother() {
+        return this.#pending < this.#concurrency;
+    }
+    #next() {
+        this.#pending--;
+        if (this.#pending === 0) {
+            this.emit('pendingZero');
+        }
+        this.#tryToStartAnother();
+        this.emit('next');
+    }
+    #onResumeInterval() {
+        // Clear timeout ID before processing to prevent race condition
+        // Must clear before #onInterval to allow new timeouts to be scheduled
+        this.#timeoutId = undefined;
+        this.#onInterval();
+        this.#initializeIntervalIfNeeded();
+    }
+    #isIntervalPausedAt(now) {
+        // Strict mode: check if we need to wait for oldest tick to age out
+        if (this.#strict) {
+            this.#cleanupStrictTicks(now);
+            // If at capacity, need to wait for oldest tick to age out
+            const activeTicksCount = this.#getActiveTicksCount();
+            if (activeTicksCount >= this.#intervalCap) {
+                const oldestTick = this.#strictTicks[this.#strictTicksStartIndex];
+                // After cleanup, remaining ticks are within interval, so delay is always > 0
+                const delay = this.#interval - (now - oldestTick);
+                this.#createIntervalTimeout(delay);
+                return true;
+            }
+            return false;
+        }
+        // Fixed window mode. While the recurring timer runs it already governs the windows, so pausing is only decided here when the queue is idle (the timer is absent) and we rely on `#intervalEnd`.
+        if (this.#intervalId === undefined) {
+            const delay = this.#intervalEnd - now;
+            if (delay < 0) {
+                // The interval expired while idle, so reset the count for the new window.
+                this.#intervalCount = this.#carryoverIntervalCount ? this.#pending : 0;
+            }
+            else {
+                // Still inside the previous window; wait out the remaining time before starting the next task.
+                this.#createIntervalTimeout(delay);
+                return true;
+            }
+        }
+        return false;
+    }
+    #createIntervalTimeout(delay) {
+        if (this.#timeoutId !== undefined) {
+            return;
+        }
+        this.#timeoutId = setTimeout(() => {
+            this.#onResumeInterval();
+        }, delay);
+    }
+    #clearIntervalTimer() {
+        if (this.#intervalId) {
+            clearInterval(this.#intervalId);
+            this.#intervalId = undefined;
+        }
+    }
+    #clearTimeoutTimer() {
+        if (this.#timeoutId) {
+            clearTimeout(this.#timeoutId);
+            this.#timeoutId = undefined;
+        }
+    }
+    #tryToStartAnother() {
+        if (this.#queue.size === 0) {
+            // We can clear the interval ("pause")
+            // Because we can redo it later ("resume")
+            this.#clearIntervalTimer();
+            this.emit('empty');
+            if (this.#pending === 0) {
+                // Clear timeout as well when completely idle
+                this.#clearTimeoutTimer();
+                // Compact strict ticks when idle to free memory
+                if (this.#strict && this.#strictTicksStartIndex > 0) {
+                    const now = Date.now();
+                    this.#cleanupStrictTicks(now);
+                }
+                this.emit('idle');
+            }
+            return false;
+        }
+        let taskStarted = false;
+        if (!this.#isPaused) {
+            const now = Date.now();
+            const canInitializeInterval = !this.#isIntervalPausedAt(now);
+            if (this.#doesIntervalAllowAnother && this.#doesConcurrentAllowAnother) {
+                const job = this.#queue.dequeue();
+                if (!this.#isIntervalIgnored) {
+                    this.#consumeIntervalSlot(now);
+                    this.#scheduleRateLimitUpdate();
+                }
+                if (canInitializeInterval) {
+                    this.#initializeIntervalIfNeeded();
+                }
+                this.emit('active');
+                job();
+                taskStarted = true;
+            }
+        }
+        return taskStarted;
+    }
+    #initializeIntervalIfNeeded() {
+        if (this.#isIntervalIgnored || this.#intervalId !== undefined) {
+            return;
+        }
+        // Strict mode uses timeouts instead of interval timers
+        if (this.#strict) {
+            return;
+        }
+        this.#intervalId = setInterval(() => {
+            this.#onInterval();
+        }, this.#interval);
+        this.#intervalEnd = Date.now() + this.#interval;
+    }
+    #onInterval() {
+        // Non-strict mode uses interval timers and intervalCount
+        if (!this.#strict) {
+            // Only touch the recurring interval timer here. When resumed via a timeout instead, `#intervalId` is undefined and `#initializeIntervalIfNeeded` sets `#intervalEnd` right after.
+            if (this.#intervalId !== undefined) {
+                if (this.#intervalCount === 0 && this.#pending === 0) {
+                    this.#clearIntervalTimer();
+                }
+                else {
+                    // The recurring timer fired, starting a new window. Keep the boundary accurate so tasks added after the queue later goes idle are scheduled against the correct window.
+                    this.#intervalEnd = Date.now() + this.#interval;
+                }
+            }
+            this.#intervalCount = this.#carryoverIntervalCount ? this.#pending : 0;
+        }
+        this.#processQueue();
+        this.#scheduleRateLimitUpdate();
+    }
+    /**
+    Executes all queued functions until it reaches the limit.
+    */
+    #processQueue() {
+        // eslint-disable-next-line no-empty
+        while (this.#tryToStartAnother()) { }
+    }
+    get concurrency() {
+        return this.#concurrency;
+    }
+    set concurrency(newConcurrency) {
+        if (!(typeof newConcurrency === 'number' && newConcurrency >= 1)) {
+            throw new TypeError(`Expected \`concurrency\` to be a number from 1 and up, got \`${newConcurrency}\` (${typeof newConcurrency})`);
+        }
+        this.#concurrency = newConcurrency;
+        this.#processQueue();
+    }
+    /**
+    Updates the priority of a promise function by its id, affecting its execution order. Requires a defined concurrency limit to take effect.
+
+    For example, this can be used to prioritize a promise function to run earlier.
+
+    ```js
+    import PQueue from 'p-queue';
+
+    const queue = new PQueue({concurrency: 1});
+
+    queue.add(async () => '🦄', {priority: 1});
+    queue.add(async () => '🦀', {priority: 0, id: '🦀'});
+    queue.add(async () => '🦄', {priority: 1});
+    queue.add(async () => '🦄', {priority: 1});
+
+    queue.setPriority('🦀', 2);
+    ```
+
+    In this case, the promise function with `id: '🦀'` runs second.
+
+    You can also deprioritize a promise function to delay its execution:
+
+    ```js
+    import PQueue from 'p-queue';
+
+    const queue = new PQueue({concurrency: 1});
+
+    queue.add(async () => '🦄', {priority: 1});
+    queue.add(async () => '🦀', {priority: 1, id: '🦀'});
+    queue.add(async () => '🦄');
+    queue.add(async () => '🦄', {priority: 0});
+
+    queue.setPriority('🦀', -1);
+    ```
+    Here, the promise function with `id: '🦀'` executes last.
+    */
+    setPriority(id, priority) {
+        if (typeof priority !== 'number' || !Number.isFinite(priority)) {
+            throw new TypeError(`Expected \`priority\` to be a finite number, got \`${priority}\` (${typeof priority})`);
+        }
+        this.#queue.setPriority(id, priority);
+    }
+    async add(function_, options = {}) {
+        // Create a copy to avoid mutating the original options object
+        options = {
+            timeout: this.timeout,
+            ...options,
+            // Assign unique ID if not provided
+            id: options.id ?? (this.#idAssigner++).toString(),
+        };
+        if (options.timeout !== undefined && !(Number.isFinite(options.timeout) && options.timeout > 0)) {
+            throw new TypeError(`Expected \`timeout\` to be a positive finite number, got \`${options.timeout}\` (${typeof options.timeout})`);
+        }
+        return new Promise((resolve, reject) => {
+            // Create a unique symbol for tracking this task
+            const taskSymbol = Symbol(`task-${options.id}`);
+            let cleanupQueueAbortHandler = () => undefined;
+            const run = async () => {
+                // Task is now running — remove the queued-state abort listener
+                cleanupQueueAbortHandler();
+                this.#pending++;
+                // Track this running task
+                this.#runningTasks.set(taskSymbol, {
+                    id: options.id,
+                    priority: options.priority ?? 0, // Match priority-queue default
+                    startTime: Date.now(),
+                    timeout: options.timeout,
+                });
+                let eventListener;
+                try {
+                    // Check abort signal - if aborted, need to decrement the counter
+                    // that was incremented in tryToStartAnother
+                    try {
+                        options.signal?.throwIfAborted();
+                    }
+                    catch (error) {
+                        this.#rollbackIntervalConsumption();
+                        // Clean up tracking before throwing
+                        this.#runningTasks.delete(taskSymbol);
+                        throw error;
+                    }
+                    let operation = function_({ signal: options.signal });
+                    if (options.timeout !== undefined) {
+                        operation = pTimeout(Promise.resolve(operation), {
+                            milliseconds: options.timeout,
+                            message: `Task timed out after ${options.timeout}ms (queue has ${this.#pending} running, ${this.#queue.size} waiting)`,
+                        });
+                    }
+                    if (options.signal) {
+                        const { signal } = options;
+                        operation = Promise.race([operation, new Promise((_resolve, reject) => {
+                                eventListener = () => {
+                                    reject(signal.reason);
+                                };
+                                signal.addEventListener('abort', eventListener, { once: true });
+                            })]);
+                    }
+                    const result = await operation;
+                    resolve(result);
+                    this.emit('completed', result);
+                }
+                catch (error) {
+                    reject(error);
+                    this.emit('error', error);
+                }
+                finally {
+                    // Clean up abort event listener
+                    if (eventListener) {
+                        options.signal?.removeEventListener('abort', eventListener);
+                    }
+                    // Remove from running tasks
+                    this.#runningTasks.delete(taskSymbol);
+                    // Use queueMicrotask to prevent deep recursion while maintaining timing
+                    queueMicrotask(() => {
+                        this.#next();
+                    });
+                }
+            };
+            this.#queue.enqueue(run, options);
+            const removeQueuedTask = () => {
+                if (this.#queue instanceof PriorityQueue) {
+                    this.#queue.remove(run);
+                    return;
+                }
+                this.#queue.remove?.(options.id); // Intentionally best-effort: queued abort removal is only supported for queue classes that implement `.remove()`.
+            };
+            // Handle abort while task is waiting in the queue
+            if (options.signal) {
+                const { signal } = options;
+                const queueAbortHandler = () => {
+                    cleanupQueueAbortHandler();
+                    removeQueuedTask();
+                    reject(signal.reason);
+                    this.#tryToStartAnother();
+                    this.emit('next');
+                };
+                cleanupQueueAbortHandler = () => {
+                    signal.removeEventListener('abort', queueAbortHandler);
+                    this.#queueAbortListenerCleanupFunctions.delete(cleanupQueueAbortHandler);
+                };
+                if (signal.aborted) {
+                    queueAbortHandler();
+                    return;
+                }
+                signal.addEventListener('abort', queueAbortHandler, { once: true });
+                this.#queueAbortListenerCleanupFunctions.add(cleanupQueueAbortHandler);
+            }
+            this.emit('add');
+            this.#tryToStartAnother();
+        });
+    }
+    async addAll(functions, options) {
+        return Promise.all(functions.map(async (function_) => this.add(function_, options)));
+    }
+    /**
+    Start (or resume) executing enqueued tasks within concurrency limit. No need to call this if queue is not paused (via `options.autoStart = false` or by `.pause()` method.)
+    */
+    start() {
+        if (!this.#isPaused) {
+            return this;
+        }
+        this.#isPaused = false;
+        this.#processQueue();
+        return this;
+    }
+    /**
+    Put queue execution on hold.
+    */
+    pause() {
+        this.#isPaused = true;
+    }
+    /**
+    Clear the queue.
+    */
+    clear() {
+        for (const cleanupQueueAbortHandler of this.#queueAbortListenerCleanupFunctions) {
+            cleanupQueueAbortHandler();
+        }
+        this.#queue = new this.#queueClass();
+        // Clear interval timer since queue is now empty (consistent with #tryToStartAnother)
+        this.#clearIntervalTimer();
+        // Note: We preserve strict mode rate-limiting state (ticks and timeout)
+        // because clear() only clears queued tasks, not rate limit history.
+        // This ensures that rate limits are still enforced after clearing the queue.
+        // Note: We don't clear #runningTasks as those tasks are still running
+        // They will be removed when they complete in the finally block
+        // Force synchronous update since clear() should have immediate effect
+        this.#updateRateLimitState();
+        // Emit events so waiters (onEmpty, onIdle, onSizeLessThan) can resolve
+        this.emit('empty');
+        if (this.#pending === 0) {
+            this.#clearTimeoutTimer();
+            this.emit('idle');
+        }
+        this.emit('next');
+    }
+    /**
+    Can be called multiple times. Useful if you for example add additional items at a later time.
+
+    @returns A promise that settles when the queue becomes empty.
+    */
+    async onEmpty() {
+        // Instantly resolve if the queue is empty
+        if (this.#queue.size === 0) {
+            return;
+        }
+        await this.#onEvent('empty');
+    }
+    /**
+    @returns A promise that settles when the queue size is less than the given limit: `queue.size < limit`.
+
+    If you want to avoid having the queue grow beyond a certain size you can `await queue.onSizeLessThan()` before adding a new item.
+
+    Note that this only limits the number of items waiting to start. There could still be up to `concurrency` jobs already running that this call does not include in its calculation.
+    */
+    async onSizeLessThan(limit) {
+        // Instantly resolve if the size is already below the limit.
+        if (this.#queue.size < limit) {
+            return;
+        }
+        // Listen on both `'next'` (task completion, queued abort, `clear()`) and `'active'` (every dequeue),
+        // so waiters wake even when the queue drains without a completion (`start()`, a runtime `concurrency`
+        // increase, or an interval tick).
+        await this.#onEvent(['next', 'active'], () => this.#queue.size < limit);
+    }
+    /**
+    The difference with `.onEmpty` is that `.onIdle` guarantees that all work from the queue has finished. `.onEmpty` merely signals that the queue is empty, but it could mean that some promises haven't completed yet.
+
+    @returns A promise that settles when the queue becomes empty, and all promises have completed; `queue.size === 0 && queue.pending === 0`.
+    */
+    async onIdle() {
+        // Instantly resolve if none pending and if nothing else is queued
+        if (this.#pending === 0 && this.#queue.size === 0) {
+            return;
+        }
+        await this.#onEvent('idle');
+    }
+    /**
+    The difference with `.onIdle` is that `.onPendingZero` only waits for currently running tasks to finish, ignoring queued tasks.
+
+    @returns A promise that settles when all currently running tasks have completed; `queue.pending === 0`.
+    */
+    async onPendingZero() {
+        if (this.#pending === 0) {
+            return;
+        }
+        await this.#onEvent('pendingZero');
+    }
+    /**
+    @returns A promise that settles when the queue becomes rate-limited due to intervalCap.
+    */
+    async onRateLimit() {
+        if (this.isRateLimited) {
+            return;
+        }
+        await this.#onEvent('rateLimit');
+    }
+    /**
+    @returns A promise that settles when the queue is no longer rate-limited.
+    */
+    async onRateLimitCleared() {
+        if (!this.isRateLimited) {
+            return;
+        }
+        await this.#onEvent('rateLimitCleared');
+    }
+    /**
+    @returns A promise that rejects when any task in the queue errors.
+
+    Use with `Promise.race([queue.onError(), queue.onIdle()])` to fail fast on the first error while still resolving normally when the queue goes idle.
+
+    Important: The promise returned by `add()` still rejects. You must handle each `add()` promise (for example, `.catch(() => {})`) to avoid unhandled rejections.
+
+    @example
+    ```
+    import PQueue from 'p-queue';
+
+    const queue = new PQueue({concurrency: 2});
+
+    queue.add(() => fetchData(1)).catch(() => {});
+    queue.add(() => fetchData(2)).catch(() => {});
+    queue.add(() => fetchData(3)).catch(() => {});
+
+    // Stop processing on first error
+    try {
+        await Promise.race([
+            queue.onError(),
+            queue.onIdle()
+        ]);
+    } catch (error) {
+        queue.pause(); // Stop processing remaining tasks
+        console.error('Queue failed:', error);
+    }
+    ```
+    */
+    // eslint-disable-next-line @typescript-eslint/promise-function-async
+    onError() {
+        return new Promise((_resolve, reject) => {
+            const handleError = (error) => {
+                this.off('error', handleError);
+                reject(error);
+            };
+            this.on('error', handleError);
+        });
+    }
+    async #onEvent(events, filter) {
+        const eventList = Array.isArray(events) ? events : [events];
+        return new Promise(resolve => {
+            const listener = () => {
+                if (filter && !filter()) {
+                    return;
+                }
+                for (const event of eventList) {
+                    this.off(event, listener);
+                }
+                resolve();
+            };
+            for (const event of eventList) {
+                this.on(event, listener);
+            }
+        });
+    }
+    /**
+    Size of the queue, the number of queued items waiting to run.
+    */
+    get size() {
+        return this.#queue.size;
+    }
+    /**
+    Size of the queue, filtered by the given options.
+
+    For example, this can be used to find the number of items remaining in the queue with a specific priority level.
+    */
+    sizeBy(options) {
+        // eslint-disable-next-line unicorn/no-array-callback-reference
+        return this.#queue.filter(options).length;
+    }
+    /**
+    Number of running items (no longer in the queue).
+    */
+    get pending() {
+        return this.#pending;
+    }
+    /**
+    Whether the queue is currently paused.
+    */
+    get isPaused() {
+        return this.#isPaused;
+    }
+    #setupRateLimitTracking() {
+        // Only schedule updates when rate limiting is enabled
+        if (this.#isIntervalIgnored) {
+            return;
+        }
+        // Wire up to lifecycle events that affect rate limit state
+        // Only 'add' and 'next' can actually change rate limit state
+        this.on('add', () => {
+            if (this.#queue.size > 0) {
+                this.#scheduleRateLimitUpdate();
+            }
+        });
+        this.on('next', () => {
+            this.#scheduleRateLimitUpdate();
+        });
+    }
+    #scheduleRateLimitUpdate() {
+        // Skip if rate limiting is not enabled or already scheduled
+        if (this.#isIntervalIgnored || this.#rateLimitFlushScheduled) {
+            return;
+        }
+        this.#rateLimitFlushScheduled = true;
+        queueMicrotask(() => {
+            this.#rateLimitFlushScheduled = false;
+            this.#updateRateLimitState();
+        });
+    }
+    #rollbackIntervalConsumption() {
+        if (this.#isIntervalIgnored) {
+            return;
+        }
+        this.#rollbackIntervalSlot();
+        this.#scheduleRateLimitUpdate();
+    }
+    #updateRateLimitState() {
+        const previous = this.#rateLimitedInInterval;
+        // Early exit if rate limiting is disabled or queue is empty
+        if (this.#isIntervalIgnored || this.#queue.size === 0) {
+            if (previous) {
+                this.#rateLimitedInInterval = false;
+                this.emit('rateLimitCleared');
+            }
+            return;
+        }
+        // Get the current count based on mode
+        let count;
+        if (this.#strict) {
+            const now = Date.now();
+            this.#cleanupStrictTicks(now);
+            count = this.#getActiveTicksCount();
+        }
+        else {
+            count = this.#intervalCount;
+        }
+        const shouldBeRateLimited = count >= this.#intervalCap;
+        if (shouldBeRateLimited !== previous) {
+            this.#rateLimitedInInterval = shouldBeRateLimited;
+            this.emit(shouldBeRateLimited ? 'rateLimit' : 'rateLimitCleared');
+        }
+    }
+    /**
+    Whether the queue is currently rate-limited due to intervalCap.
+    */
+    get isRateLimited() {
+        return this.#rateLimitedInInterval;
+    }
+    /**
+    Whether the queue is saturated. Returns `true` when:
+    - All concurrency slots are occupied and tasks are waiting, OR
+    - The queue is rate-limited and tasks are waiting
+
+    Useful for detecting backpressure and potential hanging tasks.
+
+    ```js
+    import PQueue from 'p-queue';
+
+    const queue = new PQueue({concurrency: 2});
+
+    // Backpressure handling
+    if (queue.isSaturated) {
+        console.log('Queue is saturated, waiting for capacity...');
+        await queue.onSizeLessThan(queue.concurrency);
+    }
+
+    // Monitoring for stuck tasks
+    setInterval(() => {
+        if (queue.isSaturated) {
+            console.warn(`Queue saturated: ${queue.pending} running, ${queue.size} waiting`);
+        }
+    }, 60000);
+    ```
+    */
+    get isSaturated() {
+        return (this.#pending === this.#concurrency && this.#queue.size > 0)
+            || (this.isRateLimited && this.#queue.size > 0);
+    }
+    /**
+    The tasks currently being executed. Each task includes its `id`, `priority`, `startTime`, `timeout` (if set), and `timeoutRemaining` (milliseconds until the task times out, or `undefined` if no timeout is set).
+
+    Returns an array of task info objects.
+
+    ```js
+    import PQueue from 'p-queue';
+
+    const queue = new PQueue({concurrency: 2, timeout: 10000});
+
+    // Add tasks with IDs for better debugging
+    queue.add(() => fetchUser(123), {id: 'user-123'});
+    queue.add(() => fetchPosts(456), {id: 'posts-456', priority: 1});
+
+    // Check what's running
+    console.log(queue.runningTasks);
+    // => [{
+    //   id: 'user-123',
+    //   priority: 0,
+    //   startTime: 1759253001716,
+    //   timeout: 10000,
+    //   timeoutRemaining: 9700
+    // }, {
+    //   id: 'posts-456',
+    //   priority: 1,
+    //   startTime: 1759253001916,
+    //   timeout: 10000,
+    //   timeoutRemaining: 9900
+    // }]
+    ```
+    */
+    get runningTasks() {
+        // Return fresh array with fresh objects to prevent mutations
+        return [...this.#runningTasks.values()].map(task => ({
+            ...task,
+            timeoutRemaining: task.timeout ? Math.max(0, task.startTime + task.timeout - Date.now()) : undefined,
+        }));
+    }
+}
+export { default as PriorityQueue } from './priority-queue.js';
+/**
+Error thrown when a task times out.
+
+@example
+```
+import PQueue, {TimeoutError} from 'p-queue';
+
+const queue = new PQueue({timeout: 1000});
+
+try {
+    await queue.add(() => someTask());
+} catch (error) {
+    if (error instanceof TimeoutError) {
+        console.log('Task timed out');
+    }
+}
+```
+*/
+export { TimeoutError } from 'p-timeout';