bunqueue 2.8.54 → 2.8.57

package/dist/application/operations/query/state.js

@@ -0,0 +1,63 @@
+import { withReadLock } from '../../../shared/lock';
+function resolveStateFromStorage(jobId, storage) {
+    if (!storage)
+        return 'unknown';
+    if (storage.hasDlqEntry(jobId))
+        return "failed" /* JobState.Failed */;
+    const persisted = storage.getJobStateRaw(jobId);
+    if (persisted === 'completed')
+        return "completed" /* JobState.Completed */;
+    if (persisted === 'active')
+        return "active" /* JobState.Active */;
+    if (persisted !== 'waiting' && persisted !== 'delayed')
+        return 'unknown';
+    const row = storage.getJob(jobId);
+    if (!row)
+        return 'unknown';
+    if (row.runAt > Date.now())
+        return "delayed" /* JobState.Delayed */;
+    return row.priority > 0 ? "prioritized" /* JobState.Prioritized */ : "waiting" /* JobState.Waiting */;
+}
+export async function getJobState(jobId, ctx) {
+    for (let pass = 0; pass < 4; pass++) {
+        const location = ctx.jobIndex.get(jobId);
+        if (ctx.completedJobs.has(jobId))
+            return "completed" /* JobState.Completed */;
+        if (!location)
+            return resolveStateFromStorage(jobId, ctx.storage);
+        switch (location.type) {
+            case 'queue': {
+                const result = await withReadLock(ctx.shardLocks[location.shardIdx], () => {
+                    const shard = ctx.shards[location.shardIdx];
+                    const queueJob = shard.getQueue(location.queueName).find(jobId);
+                    if (queueJob)
+                        return { job: queueJob, waitingDeps: false, waitingChildren: false };
+                    const depsJob = shard.waitingDeps.get(jobId);
+                    if (depsJob)
+                        return { job: depsJob, waitingDeps: true, waitingChildren: false };
+                    const childrenJob = shard.waitingChildren.get(jobId);
+                    if (childrenJob)
+                        return { job: childrenJob, waitingDeps: false, waitingChildren: true };
+                    return null;
+                });
+                if (!result) {
+                    if (ctx.jobIndex.get(jobId) === location)
+                        return 'unknown';
+                    break;
+                }
+                if (result.waitingDeps || result.waitingChildren)
+                    return 'waiting-children';
+                if (result.job.runAt > Date.now())
+                    return "delayed" /* JobState.Delayed */;
+                return result.job.priority > 0 ? "prioritized" /* JobState.Prioritized */ : "waiting" /* JobState.Waiting */;
+            }
+            case 'processing':
+                return "active" /* JobState.Active */;
+            case 'completed':
+                return "completed" /* JobState.Completed */;
+            case 'dlq':
+                return "failed" /* JobState.Failed */;
+        }
+    }
+    return 'unknown';
+}

package/dist/application/operations/queryOperations.d.ts

@@ -1,50 +1,5 @@
-/**
- * Query Operations
- * Get job, get result, get progress
- */
-import type { Job, JobId } from '../../domain/types/job';
-import { JobState } from '../../domain/types/job';
-import type { JobLocation } from '../../domain/types/queue';
-import type { Shard } from '../../domain/queue/shard';
-import type { SqliteStorage } from '../../infrastructure/persistence/sqlite';
-import { type RWLock } from '../../shared/lock';
-import type { SetLike, MapLike } from '../../shared/lru';
-import type { DependencyResultTracker } from '../dependencyResultTracker';
-/** Context for query operations */
-export interface QueryContext {
-    storage: SqliteStorage | null;
-    shards: Shard[];
-    shardLocks: RWLock[];
-    processingShards: Map<JobId, Job>[];
-    processingLocks: RWLock[];
-    jobIndex: Map<JobId, JobLocation>;
-    completedJobs: SetLike<JobId>;
-    completedJobsData: MapLike<JobId, Job>;
-    jobResults: MapLike<JobId, unknown>;
-    dependencyResults: DependencyResultTracker;
-    customIdMap: MapLike<string, JobId>;
-}
-/** Get job by ID */
-export declare function getJob(jobId: JobId, ctx: QueryContext): Promise<Job | null>;
-/** Get job result */
-export declare function getJobResult(jobId: JobId, ctx: QueryContext): unknown;
-/** Get job by custom ID */
-export declare function getJobByCustomId(customId: string, ctx: QueryContext): Job | null;
-/** Get job progress */
-export declare function getJobProgress(jobId: JobId, ctx: QueryContext): {
-    progress: number;
-    message: string | null;
-} | null;
-/** Extended context for getJobs (needs SHARD_COUNT) */
-export interface GetJobsContext extends QueryContext {
-    shardCount: number;
-}
-/** Get job state by ID */
-export declare function getJobState(jobId: JobId, ctx: QueryContext): Promise<JobState | 'unknown'>;
-/** Get jobs from queue with filters */
-export declare function getJobs(queue: string, shardIdx: number, options: {
-    state?: string | string[];
-    start?: number;
-    end?: number;
-    asc?: boolean;
-}, ctx: GetJobsContext): Job[];
+/** Stable query-operation import surface. */
+export { getJob, getJobByCustomId, getJobProgress, getJobResult } from './query/jobLookup';
+export { getJobs } from './query/pagination';
+export { getJobState } from './query/state';
+export type { GetJobsContext, QueryContext } from '../types/query';

package/dist/application/operations/queryOperations.js

@@ -1,474 +1,4 @@
-/**
- * Query Operations
- * Get job, get result, get progress
- */
-import { withReadLock } from '../../shared/lock';
-import { shardIndex } from '../../shared/hash';
-/** Get job by ID */
-export async function getJob(jobId, ctx) {
-    // The location snapshot is only valid until the first await: while this
-    // reader waits on the shard read lock (writers have priority), a concurrent
-    // pull can pop the job and move it queue -> processing. The pull updates
-    // jobIndex atomically with the pop (tryDequeueNextJob), so on a miss the
-    // index re-read below is authoritative: an identity change means the job
-    // MOVED, and we chase the new location instead of returning a false null
-    // for a job that still exists (getJob(id) === null must be permanent for
-    // never-reused uuidv7 ids). Bounded: every extra pass requires a further
-    // state transition of this very job (queue -> active -> completed/removed),
-    // so 4 passes cover any realistic chase; index entries are always replaced
-    // (never mutated), which makes the identity comparison exact.
-    for (let pass = 0; pass < 4; pass++) {
-        const location = ctx.jobIndex.get(jobId);
-        if (!location) {
-            // Fallback: jobIndex may not be populated after restart for completed/DLQ jobs.
-            // Consult SQLite directly so getJob survives recovery.
-            if (ctx.storage) {
-                const job = ctx.storage.getJob(jobId);
-                if (job)
-                    return job;
-                const dlqEntry = ctx.storage.getDlqEntry(jobId);
-                if (dlqEntry)
-                    return dlqEntry.job;
-            }
-            return ctx.completedJobsData.get(jobId) ?? null;
-        }
-        let found = null;
-        switch (location.type) {
-            case 'queue': {
-                found = await withReadLock(ctx.shardLocks[location.shardIdx], () => {
-                    const shard = ctx.shards[location.shardIdx];
-                    return (shard.getQueue(location.queueName).find(jobId) ??
-                        shard.waitingDeps.get(jobId) ??
-                        shard.waitingChildren.get(jobId) ??
-                        null);
-                });
-                break;
-            }
-            case 'processing': {
-                found = await withReadLock(ctx.processingLocks[location.shardIdx], () => {
-                    return ctx.processingShards[location.shardIdx].get(jobId) ?? null;
-                });
-                break;
-            }
-            case 'completed':
-                found = ctx.storage?.getJob(jobId) ?? ctx.completedJobsData.get(jobId) ?? null;
-                break;
-            case 'dlq': {
-                if (ctx.storage) {
-                    const dlqEntry = ctx.storage.getDlqEntry(jobId);
-                    if (dlqEntry)
-                        return dlqEntry.job;
-                    const job = ctx.storage.getJob(jobId);
-                    if (job)
-                        return job;
-                }
-                const dlqShardIdx = shardIndex(location.queueName);
-                const dlqJobs = ctx.shards[dlqShardIdx].getDlq(location.queueName);
-                found = dlqJobs.find((j) => j.id === jobId) ?? null;
-                break;
-            }
-        }
-        if (found)
-            return found;
-        if (ctx.jobIndex.get(jobId) === location)
-            return null; // no move: genuine miss
-        // The job moved while we held the stale snapshot: chase it.
-    }
-    return null;
-}
-/** Get job result */
-export function getJobResult(jobId, ctx) {
-    if (ctx.jobResults.has(jobId))
-        return ctx.jobResults.get(jobId);
-    if (ctx.dependencyResults.has(jobId))
-        return ctx.dependencyResults.get(jobId);
-    return ctx.storage?.getResult(jobId);
-}
-/** Get job by custom ID */
-export function getJobByCustomId(customId, ctx) {
-    const jobId = ctx.customIdMap.get(customId);
-    if (!jobId)
-        return null;
-    const location = ctx.jobIndex.get(jobId);
-    if (!location)
-        return null;
-    if (location.type === 'queue') {
-        const shard = ctx.shards[location.shardIdx];
-        return (shard.getQueue(location.queueName).find(jobId) ??
-            shard.waitingDeps.get(jobId) ??
-            shard.waitingChildren.get(jobId) ??
-            null);
-    }
-    if (location.type === 'processing') {
-        return ctx.processingShards[location.shardIdx].get(jobId) ?? null;
-    }
-    if (location.type === 'completed') {
-        return ctx.storage?.getJob(jobId) ?? ctx.completedJobsData.get(jobId) ?? null;
-    }
-    if (location.type === 'dlq') {
-        if (ctx.storage) {
-            const job = ctx.storage.getJob(jobId);
-            if (job)
-                return job;
-        }
-        const dlqShardIdx = shardIndex(location.queueName);
-        const dlqJobs = ctx.shards[dlqShardIdx].getDlq(location.queueName);
-        return dlqJobs.find((j) => j.id === jobId) ?? null;
-    }
-    return null;
-}
-/** Get job progress */
-export function getJobProgress(jobId, ctx) {
-    const location = ctx.jobIndex.get(jobId);
-    if (location?.type !== 'processing')
-        return null;
-    const job = ctx.processingShards[location.shardIdx].get(jobId);
-    if (!job)
-        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)
-        return 'unknown';
-    if (storage.hasDlqEntry(jobId))
-        return "failed" /* JobState.Failed */;
-    const persisted = storage.getJobStateRaw(jobId);
-    if (persisted === 'completed')
-        return "completed" /* JobState.Completed */;
-    if (persisted === 'active')
-        return "active" /* JobState.Active */;
-    if (persisted !== 'waiting' && persisted !== 'delayed')
-        return 'unknown';
-    const row = storage.getJob(jobId);
-    if (!row)
-        return 'unknown';
-    if (row.runAt > Date.now())
-        return "delayed" /* JobState.Delayed */;
-    return row.priority > 0 ? "prioritized" /* JobState.Prioritized */ : "waiting" /* JobState.Waiting */;
-}
-/** Get job state by ID */
-export async function getJobState(jobId, ctx) {
-    // Same stale-snapshot chase as getJob: a 'queue' location read before the
-    // read-lock await may be outdated by a concurrent pull (queue -> processing)
-    // by the time the lookup runs. On a miss with a changed index entry, retry
-    // with the fresh location instead of reporting a false 'unknown'.
-    for (let pass = 0; pass < 4; pass++) {
-        const location = ctx.jobIndex.get(jobId);
-        // Check completed set first (fast path)
-        if (ctx.completedJobs.has(jobId)) {
-            return "completed" /* JobState.Completed */;
-        }
-        if (!location) {
-            return resolveStateFromStorage(jobId, ctx.storage);
-        }
-        switch (location.type) {
-            case 'queue': {
-                // Check if job is delayed, waiting, or waiting for children/deps
-                const result = await withReadLock(ctx.shardLocks[location.shardIdx], () => {
-                    const shard = ctx.shards[location.shardIdx];
-                    const queueJob = shard.getQueue(location.queueName).find(jobId);
-                    if (queueJob)
-                        return { job: queueJob, waitingDeps: false, waitingChildren: false };
-                    const depsJob = shard.waitingDeps.get(jobId);
-                    if (depsJob)
-                        return { job: depsJob, waitingDeps: true, waitingChildren: false };
-                    const childrenJob = shard.waitingChildren.get(jobId);
-                    if (childrenJob)
-                        return { job: childrenJob, waitingDeps: false, waitingChildren: true };
-                    return null;
-                });
-                if (!result) {
-                    if (ctx.jobIndex.get(jobId) === location)
-                        return 'unknown'; // no move
-                    break; // moved mid-lookup: chase the new location
-                }
-                if (result.waitingDeps || result.waitingChildren)
-                    return 'waiting-children';
-                const now = Date.now();
-                if (result.job.runAt > now)
-                    return "delayed" /* JobState.Delayed */;
-                return result.job.priority > 0 ? "prioritized" /* JobState.Prioritized */ : "waiting" /* JobState.Waiting */;
-            }
-            case 'processing':
-                return "active" /* JobState.Active */;
-            case 'completed':
-                return "completed" /* JobState.Completed */;
-            case 'dlq':
-                return "failed" /* JobState.Failed */;
-        }
-    }
-    return 'unknown';
-}
-/** Collect completed jobs for a queue from index + storage */
-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);
-            }
-        }
-    }
-    return jobs;
-}
-/** Collect active jobs for a queue across all processing shards */
-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);
-    }
-    // Other shards
-    for (let i = 0; i < ctx.shardCount; i++) {
-        if (i === shardIdx)
-            continue;
-        for (const job of ctx.processingShards[i].values()) {
-            if (job.queue === queue)
-                jobs.push(job);
-        }
-    }
-    return jobs;
-}
-/** Collect waiting/delayed/prioritized jobs in a single pass */
-function collectTemporalJobs(shard, queue, needs, now = Date.now()) {
-    const { waiting: needWaiting, prioritized: needPrioritized, delayed: needDelayed } = needs;
-    const jobs = [];
-    for (const j of shard.getQueue(queue).values()) {
-        const isDelayed = j.runAt > now;
-        if (isDelayed && needDelayed) {
-            jobs.push(j);
-        }
-        else if (!isDelayed) {
-            // BullMQ v5: priority>0 → "prioritized", priority=0 → "waiting"
-            if (j.priority > 0 ? needPrioritized : needWaiting) {
-                jobs.push(j);
-            }
-        }
-    }
-    return jobs;
-}
-/** Collect jobs from in-memory structures by state filter */
-function tagState(jobs, state) {
-    for (const j of jobs)
-        j._state = state;
-    return jobs;
-}
-/** Tag temporal jobs with their actual state based on runAt/priority */
-function tagTemporalState(jobs, now = Date.now()) {
-    for (const j of jobs) {
-        const isDelayed = j.runAt > now;
-        j._state = isDelayed
-            ? 'delayed'
-            : j.priority > 0
-                ? 'prioritized'
-                : 'waiting';
-    }
-}
-/** Collect waiting-children jobs from deps and children maps */
-function collectWaitingChildrenFromShard(shard, queue) {
-    const wcJobs = [];
-    for (const job of shard.waitingDeps.values()) {
-        if (job.queue === queue)
-            wcJobs.push(job);
-    }
-    for (const job of shard.waitingChildren.values()) {
-        if (job.queue === queue)
-            wcJobs.push(job);
-    }
-    return wcJobs;
-}
-/**
- * Resolve which sources to collect for a state filter.
- *
- * When the queue is paused, an EXPLICIT waiting/prioritized query returns nothing:
- * those jobs are reported under 'paused' instead (BullMQ semantics, #92). An
- * unfiltered query (states === null) still lists them by their temporal state.
- */
-function resolveStateNeeds(states, paused) {
-    const want = (s) => !states || states.includes(s);
-    const suppressReady = !!states && paused;
-    return {
-        waiting: want('waiting') && !suppressReady,
-        prioritized: want('prioritized') && !suppressReady,
-        delayed: want('delayed'),
-        paused: !!states && states.includes('paused') && paused,
-        active: want('active'),
-        failed: want('failed'),
-        completed: want('completed'),
-        waitingChildren: want('waiting-children'),
-    };
-}
-/** When paused, the queue's ready jobs (waiting + prioritized) ARE the paused set (#92). */
-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, 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 }, now);
-        tagTemporalState(temporal, now);
-        jobs.push(...temporal);
-    }
-    if (need.paused) {
-        jobs.push(...collectPausedJobs(shard, queue, now));
-    }
-    if (need.active) {
-        jobs.push(...tagState(collectActiveJobs(queue, shardIdx, ctx), 'active'));
-    }
-    if (need.failed) {
-        jobs.push(...tagState(shard.getDlq(queue), 'failed'));
-    }
-    if (need.completed) {
-        jobs.push(...tagState(collectCompletedJobs(queue, ctx), 'completed'));
-    }
-    if (need.waitingChildren) {
-        jobs.push(...tagState(collectWaitingChildrenFromShard(shard, queue), 'waiting-children'));
-    }
-    return jobs;
-}
-/** Collect waiting-children jobs from in-memory shard maps */
-function collectWaitingChildrenJobs(shard, queue) {
-    const jobs = [];
-    for (const job of shard.waitingDeps.values()) {
-        if (job.queue === queue)
-            jobs.push(job);
-    }
-    for (const job of shard.waitingChildren.values()) {
-        if (job.queue === queue)
-            jobs.push(job);
-    }
-    return jobs;
-}
-/** 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);
-    }
-    // Legacy waitingDeps/waitingChildren rows may be persisted as waiting/delayed,
-    // while current inserts retain waiting-children. 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 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 */
-export function getJobs(queue, shardIdx, options, ctx) {
-    const { state, start = 0, end = 100, asc = true } = options;
-    const states = !state
-        ? null
-        : Array.isArray(state)
-            ? state.length === 0
-                ? null
-                : state
-            : [state];
-    const limit = end - start;
-    const now = Date.now();
-    if (ctx.storage) {
-        const shard = ctx.shards[shardIdx];
-        const isPaused = shard.getState(queue).paused;
-        // 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
-        // `offset` into the SQL query would drop rows and duplicate across pages (#92).
-        if (!states) {
-            const dlq = tagState(shard.getDlq(queue), 'failed');
-            if (dlq.length === 0) {
-                return ctx.storage.queryJobs(queue, { limit, offset: start, asc });
-            }
-            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. Current
-        // inserts retain waiting-children; legacy rows may still be 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
-        //  - 'paused'           -> when paused, the would-be-waiting jobs ARE the paused set (#92)
-        const extras = [];
-        if (states.includes('failed')) {
-            extras.push(...tagState(shard.getDlq(queue), 'failed'));
-        }
-        if (states.includes('waiting-children')) {
-            extras.push(...tagState(parkedJobs, 'waiting-children'));
-        }
-        if (states.includes('paused') && isPaused) {
-            const pausedJobs = collectTemporalJobs(shard, queue, { waiting: true, prioritized: true, delayed: false }, now);
-            extras.push(...tagState(pausedJobs, 'paused'));
-        }
-        // Fast path: only jobs-table states, no derived sources — SQL paginates directly.
-        if (extras.length === 0) {
-            return sqlFilteredStates.length > 0
-                ? querySqliteByLogicalState(ctx.storage, queue, sqlFilteredStates, {
-                    limit,
-                    offset: start,
-                    asc,
-                    now,
-                    excludedIds: parkedIds,
-                })
-                : [];
-        }
-        const sqlJobs = sqlFilteredStates.length > 0
-            ? 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)
-    // 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);
-}
+/** Stable query-operation import surface. */
+export { getJob, getJobByCustomId, getJobProgress, getJobResult } from './query/jobLookup';
+export { getJobs } from './query/pagination';
+export { getJobState } from './query/state';

package/dist/application/queue-manager/ack.d.ts

@@ -0,0 +1,23 @@
+import type { JobId } from '../../domain/types/job';
+import { FailureReason } from '../../domain/types/dlq';
+import type { AckBatchOutcome, AckOutcome, CompletionOptions } from '../types/ack';
+import { QueueManagerDelivery } from './delivery';
+export declare class QueueManagerAck extends QueueManagerDelivery {
+    ack(jobId: JobId, result?: unknown, token?: string, options?: CompletionOptions): Promise<AckOutcome>;
+    ackBatch(jobIds: JobId[], tokens?: string[]): Promise<AckBatchOutcome>;
+    ackBatchWithResults(items: Array<{
+        id: JobId;
+        result: unknown;
+        token?: string;
+    } & CompletionOptions>): Promise<AckBatchOutcome>;
+    fail(jobId: JobId, error?: string, token?: string, unrecoverable?: boolean, stack?: string[], removeOnFail?: boolean): Promise<AckOutcome>;
+    failWithReason(jobId: JobId, error: string | undefined, failureReason: FailureReason): Promise<AckOutcome>;
+    private isRetiredTimeoutOutcome;
+    private isRetiredOutcome;
+    private isQueuedTimeoutGeneration;
+    private ignoredOutcome;
+    private batchOutcome;
+    private missingJobError;
+    private retireTimedOutGeneration;
+    private failWithOptions;
+}