bunqueue 2.8.31 → 2.8.33

package/dist/application/operations/pull.js

@@ -8,65 +8,119 @@ import { shardIndex, processingShardIndex } from '../../shared/hash';
 import { latencyTracker } from '../latencyTracker';
 import { throughputTracker } from '../throughputTracker';
 /**
- * Try to dequeue next ready job from queue
- * Handles: expired skip, ready check, group blocking, timestamps
+ * Dequeue the highest-ranked eligible job without letting a delayed or
+ * group-blocked heap root stall unrelated work.
+ *
+ * The priority heap cannot encode time-varying readiness or active-group
+ * membership in its comparator. Temporarily park ineligible roots, select the
+ * first eligible entry (therefore the best eligible entry in heap order), and
+ * restore every parked job before leaving the shard critical section. Parked
+ * jobs remain logically queued throughout: their shard counters and jobIndex
+ * entries are deliberately untouched.
+ *
+ * Complexity is O((k + 1) log n) time and O(k) scratch space, where k is the
+ * number of higher-ranked ineligible jobs skipped. A separate delayed heap and
+ * per-group eligible-head heap can reduce this to O(log n), but this scan keeps
+ * the existing queue representation and state transitions intact.
  */
 function tryDequeueNextJob(shard, queue, now, ctx) {
     const q = shard.getQueue(queue);
-    const job = q.peek();
-    if (!job)
-        return { status: 'stop' };
-    // Skip expired jobs
-    if (isExpired(job, now)) {
-        q.pop();
-        shard.decrementQueued(job.id);
-        ctx.jobIndex.delete(job.id);
-        ctx.dashboardEmit?.('job:expired', {
-            queue,
-            jobId: String(job.id),
-            ttl: job.ttl,
-            age: now - job.createdAt,
-        });
-        return { status: 'skip' };
-    }
-    // Not ready yet (delayed)
-    if (!isReady(job, now))
-        return { status: 'stop' };
-    // FIFO group blocked
-    if (job.groupId && shard.isGroupActive(queue, job.groupId)) {
-        return { status: 'stop' };
-    }
-    // Dequeue and update
-    q.pop();
-    shard.decrementQueued(job.id);
-    if (job.groupId) {
-        shard.activateGroup(queue, job.groupId);
+    const parked = [];
+    let nextRunAt = null;
+    try {
+        while (true) {
+            const job = q.peek();
+            if (!job)
+                return { status: 'stop', nextRunAt };
+            // Expired entries are not parked: they are genuinely removed from the
+            // logical queue and therefore update counters/index exactly once.
+            if (isExpired(job, now)) {
+                q.pop();
+                shard.decrementQueued(job.id);
+                ctx.jobIndex.delete(job.id);
+                ctx.dashboardEmit?.('job:expired', {
+                    queue,
+                    jobId: String(job.id),
+                    ttl: job.ttl,
+                    age: now - job.createdAt,
+                });
+                continue;
+            }
+            if (!isReady(job, now)) {
+                const delayed = q.pop();
+                if (delayed)
+                    parked.push(delayed);
+                nextRunAt = nextRunAt === null ? job.runAt : Math.min(nextRunAt, job.runAt);
+                continue;
+            }
+            if (job.groupId && shard.isGroupActive(queue, job.groupId)) {
+                const blocked = q.pop();
+                if (blocked)
+                    parked.push(blocked);
+                continue;
+            }
+            // Check capacity only after proving that an eligible job exists. Check
+            // concurrency first because that slot can be returned if rate limiting
+            // rejects; rate-limit tokens have no rollback operation.
+            if (!shard.tryAcquireConcurrency(queue)) {
+                ctx.dashboardEmit?.('concurrency:rejected', { queue });
+                return { status: 'stop', nextRunAt };
+            }
+            if (!shard.tryAcquireRateLimit(queue)) {
+                shard.releaseConcurrency(queue);
+                ctx.dashboardEmit?.('ratelimit:rejected', { queue });
+                return { status: 'stop', nextRunAt };
+            }
+            // Dequeue and update. q.peek() and q.pop() are synchronous under the
+            // shard write lock, so pop returns the same eligible entry selected above.
+            const dequeued = q.pop();
+            if (!dequeued) {
+                shard.releaseConcurrency(queue);
+                return { status: 'stop', nextRunAt };
+            }
+            shard.decrementQueued(dequeued.id);
+            if (dequeued.groupId) {
+                shard.activateGroup(queue, dequeued.groupId);
+            }
+            dequeued.startedAt = now;
+            dequeued.lastHeartbeat = now;
+            if (dequeued.timeline.length < MAX_TIMELINE_ENTRIES) {
+                dequeued.timeline.push({ state: 'active', timestamp: now });
+            }
+            // Make the queue -> processing transition atomic for observers. From the
+            // pop above, the job is no longer findable in the shard queue, so a
+            // jobIndex entry still saying 'queue' would make getJob/getJobState return
+            // a false null/'unknown' for an existing job (JOB -> null -> JOB(active)
+            // flicker), and cleanOrphanedJobIndex would even drop its index entry.
+            // Insert into processingShards and flip the index HERE, in the same
+            // synchronous critical section as the pop (the caller holds the shard
+            // write lock; JS is single-threaded, so no other task can interleave).
+            // Writing processingShards without its RWLock is safe: until this
+            // statement the index said 'queue', so no id-targeted critical section
+            // (ack/fail/discard operate only on ids they find as 'processing') can be
+            // mid-operation on this id; a sync Map.set cannot corrupt a paused
+            // critical section; and lock-free sync access to processingShards is
+            // established practice (stallDetection phases 1/2, collectActiveJobs,
+            // getJobProgress). Acquiring the async RWLock here would instead hold the
+            // hot shard write lock across an await.
+            const procIdx = processingShardIndex(dequeued.id);
+            ctx.processingShards[procIdx].set(dequeued.id, dequeued);
+            ctx.jobIndex.set(dequeued.id, { type: 'processing', shardIdx: procIdx });
+            return { status: 'job', job: dequeued };
+        }
     }
-    job.startedAt = now;
-    job.lastHeartbeat = now;
-    if (job.timeline.length < MAX_TIMELINE_ENTRIES) {
-        job.timeline.push({ state: 'active', timestamp: now });
+    finally {
+        // Restore only the priority-queue membership. The logical queue counters,
+        // temporal index and global jobIndex never changed for parked entries.
+        for (const parkedJob of parked)
+            q.push(parkedJob);
     }
-    // Make the queue -> processing transition atomic for observers. From the
-    // pop above, the job is no longer findable in the shard queue, so a
-    // jobIndex entry still saying 'queue' would make getJob/getJobState return
-    // a false null/'unknown' for an existing job (JOB -> null -> JOB(active)
-    // flicker), and cleanOrphanedJobIndex would even drop its index entry.
-    // Insert into processingShards and flip the index HERE, in the same
-    // synchronous critical section as the pop (the caller holds the shard
-    // write lock; JS is single-threaded, so no other task can interleave).
-    // Writing processingShards without its RWLock is safe: until this
-    // statement the index said 'queue', so no id-targeted critical section
-    // (ack/fail/discard operate only on ids they find as 'processing') can be
-    // mid-operation on this id; a sync Map.set cannot corrupt a paused
-    // critical section; and lock-free sync access to processingShards is
-    // established practice (stallDetection phases 1/2, collectActiveJobs,
-    // getJobProgress). Acquiring the async RWLock here would instead hold the
-    // hot shard write lock across an await.
-    const procIdx = processingShardIndex(job.id);
-    ctx.processingShards[procIdx].set(job.id, job);
-    ctx.jobIndex.set(job.id, { type: 'processing', shardIdx: procIdx });
-    return { status: 'job', job };
+}
+/** Wait until either a notification arrives, the next delay matures, or the pull deadline. */
+async function waitForNextCandidate(shard, queue, deadline, now, nextRunAt) {
+    const remaining = deadline - now;
+    const untilNextRun = nextRunAt === null ? remaining : Math.max(1, nextRunAt - now);
+    await shard.waitForJob(queue, Math.min(remaining, untilNextRun));
 }
 /**
  * Finish the handoff of a dequeued job: persist active state and broadcast.
@@ -141,7 +195,7 @@ async function requeueJob(job, queue, idx, ctx) {
         shard.getQueue(queue).push(job);
         shard.incrementQueued(job.id, false, job.createdAt, queue, job.runAt);
         ctx.jobIndex.set(job.id, { type: 'queue', shardIdx: idx, queueName: queue });
-        shard.notify();
+        shard.notify(queue);
         requeued = true;
     });
     if (!requeued)
@@ -163,7 +217,8 @@ export async function pullJob(queue, timeoutMs, ctx) {
     const deadline = timeoutMs > 0 ? Date.now() + timeoutMs : 0;
     const idx = shardIndex(queue);
     while (true) {
-        const job = await tryPullFromShard(queue, idx, ctx);
+        const attempt = await tryPullFromShard(queue, idx, ctx);
+        const job = attempt.job;
         if (job) {
             let delivered = false;
             try {
@@ -186,9 +241,7 @@ export async function pullJob(queue, timeoutMs, ctx) {
         if (deadline === 0 || now >= deadline) {
             return null;
         }
-        // Wait for notification or timeout
-        const remaining = deadline - now;
-        await ctx.shards[idx].waitForJob(remaining);
+        await waitForNextCandidate(ctx.shards[idx], queue, deadline, now, attempt.nextRunAt);
     }
 }
 /**
@@ -199,27 +252,13 @@ async function tryPullFromShard(queue, idx, ctx) {
         const shard = ctx.shards[idx];
         const state = shard.getState(queue);
         if (state.paused) {
-            return null;
-        }
-        if (!shard.tryAcquireRateLimit(queue)) {
-            ctx.dashboardEmit?.('ratelimit:rejected', { queue });
-            return null;
-        }
-        if (!shard.tryAcquireConcurrency(queue)) {
-            ctx.dashboardEmit?.('concurrency:rejected', { queue });
-            return null;
+            return { job: null, nextRunAt: null };
         }
         const now = Date.now();
-        while (true) {
-            const result = tryDequeueNextJob(shard, queue, now, ctx);
-            if (result.status === 'job')
-                return result.job;
-            if (result.status === 'stop') {
-                shard.releaseConcurrency(queue);
-                return null;
-            }
-            // status === 'skip': continue loop
-        }
+        const result = tryDequeueNextJob(shard, queue, now, ctx);
+        return result.status === 'job'
+            ? { job: result.job, nextRunAt: null }
+            : { job: null, nextRunAt: result.nextRunAt };
     });
 }
 /**
@@ -230,7 +269,8 @@ export async function pullJobBatch(queue, count, timeoutMs, ctx) {
     const deadline = timeoutMs > 0 ? Date.now() + timeoutMs : 0;
     const idx = shardIndex(queue);
     while (true) {
-        const jobs = await tryPullBatchFromShard(queue, idx, count, ctx);
+        const attempt = await tryPullBatchFromShard(queue, idx, count, ctx);
+        const jobs = attempt.jobs;
         if (jobs.length > 0) {
             let delivered;
             try {
@@ -260,9 +300,7 @@ export async function pullJobBatch(queue, count, timeoutMs, ctx) {
         if (deadline === 0 || now >= deadline) {
             return [];
         }
-        // Wait for notification or timeout
-        const remaining = deadline - now;
-        await ctx.shards[idx].waitForJob(remaining);
+        await waitForNextCandidate(ctx.shards[idx], queue, deadline, now, attempt.nextRunAt);
     }
 }
 /**
@@ -274,28 +312,19 @@ async function tryPullBatchFromShard(queue, idx, count, ctx) {
         const state = shard.getState(queue);
         const jobs = [];
         if (state.paused)
-            return jobs;
+            return { jobs, nextRunAt: null };
         const now = Date.now();
+        let nextRunAt = null;
         while (jobs.length < count) {
-            // Check limits per job
-            if (!shard.tryAcquireRateLimit(queue)) {
-                break;
-            }
-            if (!shard.tryAcquireConcurrency(queue)) {
-                break;
-            }
             const result = tryDequeueNextJob(shard, queue, now, ctx);
             if (result.status === 'job') {
                 jobs.push(result.job);
             }
             else {
-                // 'stop' or 'skip': release the concurrency slot since no job was taken
-                shard.releaseConcurrency(queue);
-                if (result.status === 'stop')
-                    break;
-                // 'skip': continue loop to try next job
+                nextRunAt = result.nextRunAt;
+                break;
             }
         }
-        return jobs;
+        return { jobs, nextRunAt };
     });
 }

package/dist/application/operations/push.js

@@ -212,7 +212,7 @@ export async function pushJob(queue, input, ctx) {
         }
         // Insert to shard
         insertJobToShard(job, queue, shard, idx, ctx);
-        shard.notify();
+        shard.notify(queue);
         result = { job, persisted: true };
     });
     if (!result) {
@@ -274,7 +274,7 @@ export async function pushJobBatch(queue, inputs, ctx) {
             resultIds.push(job.id);
         }
         if (jobsToInsert.length > 0) {
-            shard.notifyBatch(jobsToInsert.length);
+            shard.notifyBatch(queue, jobsToInsert.length);
         }
     });
     if (jobsToInsert.length > 0) {

package/dist/application/operations/queryOperations.js

@@ -123,6 +123,17 @@ export function getJobProgress(jobId, ctx) {
         return null;
     return { progress: job.progress, message: job.progressMessage };
 }
+/** Stable total order used by both in-memory collection and SQL queries. */
+function compareJobsByCreatedAt(a, b, asc) {
+    if (a.createdAt !== b.createdAt) {
+        return asc ? a.createdAt - b.createdAt : b.createdAt - a.createdAt;
+    }
+    if (a.id === b.id)
+        return 0;
+    if (asc)
+        return a.id < b.id ? -1 : 1;
+    return a.id > b.id ? -1 : 1;
+}
 /** Resolve job state from SQLite when jobIndex has no entry (post-restart recovery). */
 function resolveStateFromStorage(jobId, storage) {
     if (!storage)
@@ -197,29 +208,25 @@ export async function getJobState(jobId, ctx) {
     return 'unknown';
 }
 /** Collect completed jobs for a queue from index + storage */
-function collectCompletedJobs(queue, ctx, maxCollect) {
+function collectCompletedJobs(queue, ctx) {
     const jobs = [];
     for (const [jId, location] of ctx.jobIndex) {
         if (location.type === 'completed' && location.queueName === queue) {
             const job = ctx.storage?.getJob(jId) ?? ctx.completedJobsData?.get(jId) ?? null;
             if (job) {
                 jobs.push(job);
-                if (jobs.length >= maxCollect)
-                    break;
             }
         }
     }
     return jobs;
 }
 /** Collect active jobs for a queue across all processing shards */
-function collectActiveJobs(queue, shardIdx, ctx, maxCollect) {
+function collectActiveJobs(queue, shardIdx, ctx) {
     const jobs = [];
     // Own shard first (most likely location)
     for (const job of ctx.processingShards[shardIdx].values()) {
         if (job.queue === queue)
             jobs.push(job);
-        if (jobs.length >= maxCollect)
-            return jobs;
     }
     // Other shards
     for (let i = 0; i < ctx.shardCount; i++) {
@@ -228,20 +235,15 @@ function collectActiveJobs(queue, shardIdx, ctx, maxCollect) {
         for (const job of ctx.processingShards[i].values()) {
             if (job.queue === queue)
                 jobs.push(job);
-            if (jobs.length >= maxCollect)
-                return jobs;
         }
     }
     return jobs;
 }
 /** Collect waiting/delayed/prioritized jobs in a single pass */
-function collectTemporalJobs(shard, queue, needs, maxCollect) {
+function collectTemporalJobs(shard, queue, needs, now = Date.now()) {
     const { waiting: needWaiting, prioritized: needPrioritized, delayed: needDelayed } = needs;
-    const now = Date.now();
     const jobs = [];
     for (const j of shard.getQueue(queue).values()) {
-        if (jobs.length >= maxCollect)
-            break;
         const isDelayed = j.runAt > now;
         if (isDelayed && needDelayed) {
             jobs.push(j);
@@ -262,8 +264,7 @@ function tagState(jobs, state) {
     return jobs;
 }
 /** Tag temporal jobs with their actual state based on runAt/priority */
-function tagTemporalState(jobs) {
-    const now = Date.now();
+function tagTemporalState(jobs, now = Date.now()) {
     for (const j of jobs) {
         const isDelayed = j.runAt > now;
         j._state = isDelayed
@@ -274,19 +275,15 @@ function tagTemporalState(jobs) {
     }
 }
 /** Collect waiting-children jobs from deps and children maps */
-function collectWaitingChildrenFromShard(shard, queue, max) {
+function collectWaitingChildrenFromShard(shard, queue) {
     const wcJobs = [];
     for (const job of shard.waitingDeps.values()) {
         if (job.queue === queue)
             wcJobs.push(job);
-        if (wcJobs.length >= max)
-            return wcJobs;
     }
     for (const job of shard.waitingChildren.values()) {
         if (job.queue === queue)
             wcJobs.push(job);
-        if (wcJobs.length >= max)
-            return wcJobs;
     }
     return wcJobs;
 }
@@ -312,34 +309,33 @@ function resolveStateNeeds(states, paused) {
     };
 }
 /** When paused, the queue's ready jobs (waiting + prioritized) ARE the paused set (#92). */
-function collectPausedJobs(shard, queue, maxPerSource) {
-    const pausedJobs = collectTemporalJobs(shard, queue, { waiting: true, prioritized: true, delayed: false }, maxPerSource);
+function collectPausedJobs(shard, queue, now) {
+    const pausedJobs = collectTemporalJobs(shard, queue, { waiting: true, prioritized: true, delayed: false }, now);
     return tagState(pausedJobs, 'paused');
 }
-function collectJobsByState(queue, shardIdx, states, ctx, maxPerSource = Infinity) {
+function collectJobsByState(queue, shardIdx, states, ctx, now = Date.now()) {
     const shard = ctx.shards[shardIdx];
     const jobs = [];
     const need = resolveStateNeeds(states, shard.getState(queue).paused);
     if (need.waiting || need.prioritized || need.delayed) {
-        const temporal = collectTemporalJobs(shard, queue, { waiting: need.waiting, prioritized: need.prioritized, delayed: need.delayed }, maxPerSource);
-        tagTemporalState(temporal);
+        const temporal = collectTemporalJobs(shard, queue, { waiting: need.waiting, prioritized: need.prioritized, delayed: need.delayed }, now);
+        tagTemporalState(temporal, now);
         jobs.push(...temporal);
     }
     if (need.paused) {
-        jobs.push(...collectPausedJobs(shard, queue, maxPerSource));
+        jobs.push(...collectPausedJobs(shard, queue, now));
     }
     if (need.active) {
-        jobs.push(...tagState(collectActiveJobs(queue, shardIdx, ctx, maxPerSource), 'active'));
+        jobs.push(...tagState(collectActiveJobs(queue, shardIdx, ctx), 'active'));
     }
     if (need.failed) {
-        const dlq = shard.getDlq(queue);
-        jobs.push(...tagState(maxPerSource < dlq.length ? dlq.slice(0, maxPerSource) : dlq, 'failed'));
+        jobs.push(...tagState(shard.getDlq(queue), 'failed'));
     }
     if (need.completed) {
-        jobs.push(...tagState(collectCompletedJobs(queue, ctx, maxPerSource), 'completed'));
+        jobs.push(...tagState(collectCompletedJobs(queue, ctx), 'completed'));
     }
     if (need.waitingChildren) {
-        jobs.push(...tagState(collectWaitingChildrenFromShard(shard, queue, maxPerSource), 'waiting-children'));
+        jobs.push(...tagState(collectWaitingChildrenFromShard(shard, queue), 'waiting-children'));
     }
     return jobs;
 }
@@ -356,38 +352,34 @@ function collectWaitingChildrenJobs(shard, queue) {
     }
     return jobs;
 }
-/** Query SQLite with priority/waiting translation */
-function querySqliteWithPriority(storage, queue, sqlFilteredStates, opts) {
-    const hasPrioritized = sqlFilteredStates.includes('prioritized');
-    const hasWaiting = sqlFilteredStates.includes('waiting');
-    if (!hasPrioritized && !hasWaiting) {
-        if (sqlFilteredStates.length === 1) {
-            return storage.queryJobs(queue, { state: sqlFilteredStates[0], ...opts });
-        }
-        return storage.queryJobs(queue, { states: sqlFilteredStates, ...opts });
-    }
-    // Map 'prioritized' to 'waiting' for SQLite, then post-filter by priority
-    const sqlStates = sqlFilteredStates
-        .map((s) => (s === 'prioritized' ? 'waiting' : s))
-        .filter((s, i, arr) => arr.indexOf(s) === i);
-    const overFetchOpts = { ...opts, limit: opts.limit * 2 };
-    let jobs = sqlStates.length === 1
-        ? storage.queryJobs(queue, { state: sqlStates[0], ...overFetchOpts })
-        : storage.queryJobs(queue, { states: sqlStates, ...overFetchOpts });
-    if (hasPrioritized && !hasWaiting) {
-        jobs = jobs.filter((j) => j.priority > 0);
+/** Query SQLite after translating persisted pending rows to their logical state. */
+function querySqliteByLogicalState(storage, queue, sqlFilteredStates, opts) {
+    if (opts.excludedIds.size === 0) {
+        return storage.queryJobsByLogicalStates(queue, sqlFilteredStates, opts);
     }
-    else if (hasWaiting && !hasPrioritized) {
-        jobs = jobs.filter((j) => j.priority <= 0);
-    }
-    return jobs.slice(0, opts.limit);
+    // waitingDeps/waitingChildren rows remain persisted as waiting/delayed. Fetch
+    // enough rows to account for every possible exclusion, then paginate the
+    // logical result so parked jobs cannot create short or shifted pages.
+    const pageEnd = opts.offset + opts.limit;
+    const jobs = storage.queryJobsByLogicalStates(queue, sqlFilteredStates, {
+        limit: pageEnd + opts.excludedIds.size,
+        offset: 0,
+        asc: opts.asc,
+        now: opts.now,
+    });
+    return jobs.filter((job) => !opts.excludedIds.has(job.id)).slice(opts.offset, pageEnd);
 }
 /** Merge SQL rows with in-memory extras (each gathered from index 0), sort by
  *  createdAt, and paginate [start, end) once — so offset-unaware extras don't
  *  duplicate or drop rows across pages (#92). */
 function mergePage(sqlJobs, extras, start, end, asc) {
-    const merged = sqlJobs.concat(extras);
-    merged.sort((a, b) => (asc ? a.createdAt - b.createdAt : b.createdAt - a.createdAt));
+    const byId = new Map();
+    for (const job of sqlJobs)
+        byId.set(job.id, job);
+    for (const job of extras)
+        byId.set(job.id, job);
+    const merged = Array.from(byId.values());
+    merged.sort((a, b) => compareJobsByCreatedAt(a, b, asc));
     return merged.slice(start, end);
 }
 /** Get jobs from queue with filters */
@@ -401,10 +393,10 @@ export function getJobs(queue, shardIdx, options, ctx) {
                 : state
             : [state];
     const limit = end - start;
+    const now = Date.now();
     if (ctx.storage) {
         const shard = ctx.shards[shardIdx];
         const isPaused = shard.getState(queue).paused;
-        const maxPerSource = end + 1;
         // Derived sources are NOT offset-aware (the DLQ and the paused/waiting-children
         // views come from in-memory maps). When any contributes, we must gather [0, end)
         // from EVERY source, merge, sort, then slice [start, end) exactly once — pushing
@@ -417,6 +409,19 @@ export function getJobs(queue, shardIdx, options, ctx) {
             const all = ctx.storage.queryJobs(queue, { limit: end, offset: 0, asc });
             return mergePage(all, dlq, start, end, asc);
         }
+        // jobs-table states. A paused queue reports its waiting/prioritized jobs under
+        // 'paused', so they must not also surface in the waiting/prioritized lists (#92).
+        const sqlFilteredStates = states.filter((s) => s !== 'failed' &&
+            s !== 'waiting-children' &&
+            s !== 'paused' &&
+            !(isPaused && (s === 'waiting' || s === 'prioritized')));
+        // In-memory parked state is authoritative over the persisted row. Initial
+        // dependency jobs are stored as waiting/delayed, while parents moved after
+        // a pull can still be stored as active.
+        const parkedJobs = states.includes('waiting-children') || sqlFilteredStates.length > 0
+            ? collectWaitingChildrenJobs(shard, queue)
+            : [];
+        const parkedIds = new Set(parkedJobs.map((job) => job.id));
         // States with no jobs-table row are collected from in-memory sources:
         //  - 'failed'           -> DLQ (the failed job lives in the dlq table) (#92)
         //  - 'waiting-children' -> deps/children maps
@@ -426,40 +431,39 @@ export function getJobs(queue, shardIdx, options, ctx) {
             extras.push(...tagState(shard.getDlq(queue), 'failed'));
         }
         if (states.includes('waiting-children')) {
-            extras.push(...collectWaitingChildrenJobs(shard, queue));
+            extras.push(...tagState(parkedJobs, 'waiting-children'));
         }
         if (states.includes('paused') && isPaused) {
-            const pausedJobs = collectTemporalJobs(shard, queue, { waiting: true, prioritized: true, delayed: false }, maxPerSource);
+            const pausedJobs = collectTemporalJobs(shard, queue, { waiting: true, prioritized: true, delayed: false }, now);
             extras.push(...tagState(pausedJobs, 'paused'));
         }
-        // jobs-table states. A paused queue reports its waiting/prioritized jobs under
-        // 'paused', so they must not also surface in the waiting/prioritized lists (#92).
-        const sqlFilteredStates = states.filter((s) => s !== 'failed' &&
-            s !== 'waiting-children' &&
-            s !== 'paused' &&
-            !(isPaused && (s === 'waiting' || s === 'prioritized')));
         // Fast path: only jobs-table states, no derived sources — SQL paginates directly.
         if (extras.length === 0) {
             return sqlFilteredStates.length > 0
-                ? querySqliteWithPriority(ctx.storage, queue, sqlFilteredStates, {
+                ? querySqliteByLogicalState(ctx.storage, queue, sqlFilteredStates, {
                     limit,
                     offset: start,
                     asc,
+                    now,
+                    excludedIds: parkedIds,
                 })
                 : [];
         }
         const sqlJobs = sqlFilteredStates.length > 0
-            ? querySqliteWithPriority(ctx.storage, queue, sqlFilteredStates, {
+            ? querySqliteByLogicalState(ctx.storage, queue, sqlFilteredStates, {
                 limit: end,
                 offset: 0,
                 asc,
+                now,
+                excludedIds: parkedIds,
             })
             : [];
         return mergePage(sqlJobs, extras, start, end, asc);
     }
     // In-memory path (embedded mode only)
-    const maxPerSource = end + 1;
-    const jobs = collectJobsByState(queue, shardIdx, states, ctx, maxPerSource);
-    jobs.sort((a, b) => (asc ? a.createdAt - b.createdAt : b.createdAt - a.createdAt));
+    // Every source must be filtered before the global order is applied. Limiting
+    // an insertion-ordered Map here loses newer rows on descending pages.
+    const jobs = collectJobsByState(queue, shardIdx, states, ctx, now);
+    jobs.sort((a, b) => compareJobsByCreatedAt(a, b, asc));
     return jobs.slice(start, end);
 }

package/dist/application/queueManager.d.ts

@@ -341,24 +341,19 @@ export declare class QueueManager {
         paused: boolean;
         counts: {
             waiting: number;
+            prioritized: number;
             active: number;
             completed: number;
             failed: number;
             delayed: number;
         };
     }>;
+    /** Get counts for every registered queue with one global aggregation pass. */
+    getAllQueueJobCounts(): Map<string, statsMgr.QueueJobCounts>;
+    /** Aggregate a selected group of queues without repeating global scans. */
+    getQueueJobCountsBatch(queueNames: Iterable<string>): Map<string, statsMgr.QueueJobCounts>;
     /** Get job counts for a specific queue */
-    getQueueJobCounts(queueName: string): {
-        waiting: number;
-        prioritized: number;
-        delayed: number;
-        active: number;
-        completed: number;
-        failed: number;
-        'waiting-children': number;
-        totalCompleted: number;
-        totalFailed: number;
-    };
+    getQueueJobCounts(queueName: string): statsMgr.QueueJobCounts;
     getMemoryStats(): statsMgr.MemoryStats;
     /** Get storage health status (disk full detection) */
     getStorageStatus(): {