bunqueue 2.8.54 → 2.8.56

package/dist/application/queue-manager/ack.js

@@ -0,0 +1,242 @@
+import { ackJob, ackJobBatch, ackJobBatchWithResults, failJob } from '../operations/ack';
+import * as lockMgr from '../lockManager';
+import { QueueManagerDelivery } from './delivery';
+export class QueueManagerAck extends QueueManagerDelivery {
+    async ack(jobId, result, token, options = {}) {
+        try {
+            const lockCtx = this.contextFactory.getLockContext();
+            if (this.isRetiredOutcome(jobId, token))
+                return this.ignoredOutcome();
+            this.assertLeaseToken(jobId, token, lockCtx);
+            const location = this.jobIndex.get(jobId);
+            if (location?.type === 'queue') {
+                if (!this.isQueuedTimeoutGeneration(jobId) &&
+                    this.isStallRetried(jobId) &&
+                    (await this.completeStallRetriedJob(jobId, result, options.removeOnComplete))) {
+                    lockMgr.releaseLock(jobId, lockCtx, token);
+                    return;
+                }
+            }
+            const applied = await ackJob(jobId, result, this.contextFactory.getAckContext(), {
+                ...options,
+                leaseToken: token,
+            });
+            if (!applied) {
+                if (this.isRetiredOutcome(jobId, token))
+                    return this.ignoredOutcome();
+                if (!this.isQueuedTimeoutGeneration(jobId) &&
+                    this.isStallRetried(jobId) &&
+                    (await this.completeStallRetriedJob(jobId, result, options.removeOnComplete))) {
+                    lockMgr.releaseLock(jobId, lockCtx, token);
+                    return;
+                }
+                throw this.missingJobError(jobId);
+            }
+            lockMgr.releaseLock(jobId, lockCtx, token);
+        }
+        finally {
+            this.syncJobTimeout(jobId);
+        }
+    }
+    async ackBatch(jobIds, tokens) {
+        try {
+            const lockCtx = this.contextFactory.getLockContext();
+            const retiredOutcomes = jobIds.map((id, index) => this.isRetiredOutcome(id, tokens?.[index]));
+            for (let index = 0; index < jobIds.length; index++) {
+                if (!retiredOutcomes[index]) {
+                    this.assertLeaseToken(jobIds[index], tokens?.[index], lockCtx);
+                }
+            }
+            const candidateIndices = [];
+            for (let index = 0; index < jobIds.length; index++) {
+                const id = jobIds[index];
+                if (retiredOutcomes[index])
+                    continue;
+                if (this.jobIndex.get(id)?.type === 'queue') {
+                    if (!this.isQueuedTimeoutGeneration(id) && this.isStallRetried(id)) {
+                        await this.completeStallRetriedJob(id, undefined);
+                        lockMgr.releaseLock(id, lockCtx, tokens?.[index]);
+                        continue;
+                    }
+                }
+                candidateIndices.push(index);
+            }
+            const applied = await ackJobBatch(candidateIndices.map((index) => jobIds[index]), this.contextFactory.getAckContext(), candidateIndices.map((index) => tokens?.[index]));
+            for (let offset = 0; offset < candidateIndices.length; offset++) {
+                const index = candidateIndices[offset];
+                const id = jobIds[index];
+                if (applied[offset]) {
+                    lockMgr.releaseLock(id, lockCtx, tokens?.[index]);
+                }
+                else if (this.isRetiredOutcome(id, tokens?.[index])) {
+                    retiredOutcomes[index] = true;
+                }
+                else {
+                    throw this.missingJobError(id);
+                }
+            }
+            return this.batchOutcome(jobIds, retiredOutcomes);
+        }
+        finally {
+            for (const id of jobIds)
+                this.syncJobTimeout(id);
+        }
+    }
+    async ackBatchWithResults(items) {
+        try {
+            const lockCtx = this.contextFactory.getLockContext();
+            const retiredOutcomes = items.map((item) => this.isRetiredOutcome(item.id, item.token));
+            for (let index = 0; index < items.length; index++) {
+                const item = items[index];
+                if (!retiredOutcomes[index])
+                    this.assertLeaseToken(item.id, item.token, lockCtx);
+            }
+            const candidateIndices = [];
+            for (let index = 0; index < items.length; index++) {
+                const item = items[index];
+                if (retiredOutcomes[index])
+                    continue;
+                if (this.jobIndex.get(item.id)?.type === 'queue') {
+                    if (!this.isQueuedTimeoutGeneration(item.id) && this.isStallRetried(item.id)) {
+                        await this.completeStallRetriedJob(item.id, item.result, item.removeOnComplete);
+                        lockMgr.releaseLock(item.id, lockCtx, item.token);
+                        continue;
+                    }
+                }
+                candidateIndices.push(index);
+            }
+            const applied = await ackJobBatchWithResults(candidateIndices.map((index) => items[index]), this.contextFactory.getAckContext());
+            for (let offset = 0; offset < candidateIndices.length; offset++) {
+                const index = candidateIndices[offset];
+                const item = items[index];
+                if (applied[offset]) {
+                    lockMgr.releaseLock(item.id, lockCtx, item.token);
+                }
+                else if (this.isRetiredOutcome(item.id, item.token)) {
+                    retiredOutcomes[index] = true;
+                }
+                else {
+                    throw this.missingJobError(item.id);
+                }
+            }
+            return this.batchOutcome(items.map((item) => item.id), retiredOutcomes);
+        }
+        finally {
+            for (const item of items)
+                this.syncJobTimeout(item.id);
+        }
+    }
+    // biome-ignore lint/complexity/useMaxParams: public compatibility signature carries removal policy.
+    async fail(jobId, error, token, unrecoverable = false, stack, removeOnFail) {
+        return this.failWithOptions(jobId, error, token, { unrecoverable, stack, removeOnFail });
+    }
+    async failWithReason(jobId, error, failureReason) {
+        const options = { failureReason };
+        if (failureReason === "timeout" /* FailureReason.Timeout */) {
+            options.onClaim = (job) => this.retireTimedOutGeneration(job);
+        }
+        return this.failWithOptions(jobId, error, undefined, options, false);
+    }
+    isRetiredTimeoutOutcome(jobId, token) {
+        if (token)
+            return this.retiredTimeoutLeaseTokens.get(token)?.jobId === jobId;
+        const generation = this.timedOutJobs.get(jobId);
+        if (!generation || generation.token)
+            return false;
+        const location = this.jobIndex.get(jobId);
+        if (location?.type === 'processing')
+            return false;
+        if (location?.type === 'queue') {
+            const queued = this.shards[location.shardIdx].getQueue(location.queueName).find(jobId);
+            if (queued && queued.startedAt !== generation.startedAt)
+                return false;
+        }
+        if (location?.type === 'completed') {
+            const completed = this.completedJobsData.get(jobId);
+            if (completed && completed.startedAt !== generation.startedAt)
+                return false;
+        }
+        return true;
+    }
+    isRetiredOutcome(jobId, token) {
+        return this.isRetiredCronOutcome(jobId, token) || this.isRetiredTimeoutOutcome(jobId, token);
+    }
+    isQueuedTimeoutGeneration(jobId) {
+        const generation = this.timedOutJobs.get(jobId);
+        const location = this.jobIndex.get(jobId);
+        if (!generation || location?.type !== 'queue')
+            return false;
+        const queued = this.shards[location.shardIdx].getQueue(location.queueName).find(jobId);
+        return queued?.startedAt === generation.startedAt;
+    }
+    ignoredOutcome() {
+        return { applied: false, reason: 'already-finalized' };
+    }
+    batchOutcome(jobIds, ignored) {
+        const ignoredIndices = ignored.flatMap((value, index) => (value ? [index] : []));
+        if (ignoredIndices.length === 0)
+            return;
+        return { ignoredIndices, ignoredIds: ignoredIndices.map((index) => jobIds[index]) };
+    }
+    missingJobError(jobId) {
+        return new Error(`Job not found or not in processing state: ${jobId}`);
+    }
+    retireTimedOutGeneration(job) {
+        if (job.startedAt === null)
+            return;
+        const lock = lockMgr.getLockInfo(job.id, this.contextFactory.getLockContext());
+        const generation = { jobId: job.id, startedAt: job.startedAt, token: lock?.token };
+        this.timedOutJobs.set(job.id, generation);
+        if (lock)
+            this.retiredTimeoutLeaseTokens.set(lock.token, generation);
+        lockMgr.releaseLock(job.id, this.contextFactory.getLockContext(), lock?.token);
+        for (const [clientId, jobs] of this.clientJobs) {
+            jobs.delete(job.id);
+            if (jobs.size === 0)
+                this.clientJobs.delete(clientId);
+        }
+    }
+    async failWithOptions(jobId, error, token, options, enforceLease = true) {
+        try {
+            const lockCtx = this.contextFactory.getLockContext();
+            if (enforceLease && this.isRetiredOutcome(jobId, token))
+                return this.ignoredOutcome();
+            const hadLock = lockMgr.getLockInfo(jobId, lockCtx) !== null;
+            if (enforceLease)
+                this.assertLeaseToken(jobId, token, lockCtx);
+            if (enforceLease &&
+                token &&
+                !hadLock &&
+                !this.isQueuedTimeoutGeneration(jobId) &&
+                this.isStallRetried(jobId)) {
+                return this.ignoredOutcome();
+            }
+            if (hadLock && this.jobIndex.get(jobId)?.type !== 'processing') {
+                lockMgr.releaseLock(jobId, lockCtx, token);
+                return this.ignoredOutcome();
+            }
+            try {
+                await failJob(jobId, error, this.contextFactory.getAckContext(), options);
+            }
+            catch (caught) {
+                if (enforceLease && this.isRetiredOutcome(jobId, token)) {
+                    return this.ignoredOutcome();
+                }
+                if (hadLock &&
+                    caught instanceof Error &&
+                    caught.message.includes('not found') &&
+                    this.jobIndex.get(jobId)?.type === 'queue') {
+                    lockMgr.releaseLock(jobId, lockCtx, token);
+                    return this.ignoredOutcome();
+                }
+                throw caught;
+            }
+            if (options.failureReason !== "timeout" /* FailureReason.Timeout */) {
+                lockMgr.releaseLock(jobId, lockCtx, token);
+            }
+        }
+        finally {
+            this.syncJobTimeout(jobId);
+        }
+    }
+}

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

@@ -0,0 +1,27 @@
+import type { JobId, JobLock } from '../../domain/types/job';
+import type { JobLogEntry } from '../../domain/types/worker';
+import type { StallConfig } from '../../domain/types/stall';
+import type { DlqConfig } from '../../domain/types/dlq';
+import { QueueManagerLimits } from './limits';
+export declare class QueueManagerConfiguration extends QueueManagerLimits {
+    getDeduplicationJobId(queue: string, key: string): string | null;
+    removeDeduplicationKey(queue: string, key: string): Promise<number>;
+    removeJobDeduplicationKey(id: string): Promise<boolean>;
+    getAllJobResults(): Map<JobId, unknown>;
+    getAllJobLogs(): Map<JobId, JobLogEntry[]>;
+    getAllJobLocks(): Map<JobId, JobLock>;
+    setStallConfig(queue: string, config: Record<string, unknown>): void;
+    getStallConfig(queue: string): StallConfig;
+    setDlqConfig(queue: string, config: Record<string, unknown>): void;
+    getDlqConfig(queue: string): DlqConfig;
+    getCloudTelemetry(queueNames: string[]): {
+        perQueue: Record<string, {
+            uniqueKeys: number;
+            activeGroups: number;
+            waitingDeps: number;
+            waitingChildren: number;
+        }>;
+        eventSubscribers: number;
+        pendingDepChecks: number;
+    };
+}

package/dist/application/queue-manager/configuration.js

@@ -0,0 +1,84 @@
+import { jobId } from '../../domain/types/job';
+import { shardIndex } from '../../shared/hash';
+import { withWriteLock } from '../../shared/lock';
+import { QueueManagerLimits } from './limits';
+export class QueueManagerConfiguration extends QueueManagerLimits {
+    getDeduplicationJobId(queue, key) {
+        return this.shards[shardIndex(queue)].getUniqueKeyEntry(queue, key)?.jobId ?? null;
+    }
+    async removeDeduplicationKey(queue, key) {
+        const index = shardIndex(queue);
+        return withWriteLock(this.shardLocks[index], () => {
+            const shard = this.shards[index];
+            const owner = shard.getUniqueKeyEntry(queue, key)?.jobId;
+            if (!owner || !shard.releaseUniqueKeyIfOwned(queue, key, owner))
+                return 0;
+            this.storage?.clearJobUniqueKey(owner);
+            return 1;
+        });
+    }
+    async removeJobDeduplicationKey(id) {
+        const targetId = jobId(id);
+        const job = await this.getJob(targetId);
+        if (!job?.uniqueKey)
+            return false;
+        const uniqueKey = job.uniqueKey;
+        const index = shardIndex(job.queue);
+        return withWriteLock(this.shardLocks[index], () => {
+            const removed = this.shards[index].releaseUniqueKeyIfOwned(job.queue, uniqueKey, targetId);
+            if (removed)
+                this.storage?.clearJobUniqueKey(targetId);
+            return removed;
+        });
+    }
+    getAllJobResults() {
+        return new Map(this.jobResults.entries());
+    }
+    getAllJobLogs() {
+        return new Map(this.jobLogs.entries());
+    }
+    getAllJobLocks() {
+        return this.jobLocks;
+    }
+    setStallConfig(queue, config) {
+        this.shards[shardIndex(queue)].setStallConfig(queue, config);
+        this.persistQueueState(queue);
+    }
+    getStallConfig(queue) {
+        return this.shards[shardIndex(queue)].getStallConfig(queue);
+    }
+    setDlqConfig(queue, config) {
+        this.shards[shardIndex(queue)].setDlqConfig(queue, config);
+        this.persistQueueState(queue);
+    }
+    getDlqConfig(queue) {
+        return this.shards[shardIndex(queue)].getDlqConfig(queue);
+    }
+    getCloudTelemetry(queueNames) {
+        const perQueue = {};
+        for (const name of queueNames) {
+            const shard = this.shards[shardIndex(name)];
+            let waitingDeps = 0;
+            for (const job of shard.waitingDeps.values()) {
+                if (job.queue === name)
+                    waitingDeps++;
+            }
+            let waitingChildren = 0;
+            for (const job of shard.waitingChildren.values()) {
+                if (job.queue === name)
+                    waitingChildren++;
+            }
+            perQueue[name] = {
+                uniqueKeys: shard.uniqueKeys.get(name)?.size ?? 0,
+                activeGroups: shard.activeGroups.get(name)?.size ?? 0,
+                waitingDeps,
+                waitingChildren,
+            };
+        }
+        return {
+            perQueue,
+            eventSubscribers: this.eventsManager.subscriberCount,
+            pendingDepChecks: this.pendingDepChecks.size,
+        };
+    }
+}

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

@@ -0,0 +1,5 @@
+import type { ContextCallbacks, ContextDependencies } from '../contextFactory';
+import type { QueueManagerRuntime, QueueManagerStateView } from '../types';
+export declare function managerRuntime(value: unknown): QueueManagerRuntime;
+export declare function createContextDependencies(state: QueueManagerStateView): ContextDependencies;
+export declare function createContextCallbacks(runtime: QueueManagerRuntime): ContextCallbacks;

package/dist/application/queue-manager/context.js

@@ -0,0 +1,61 @@
+import { handleRepeat } from './repeat';
+export function managerRuntime(value) {
+    return value;
+}
+export function createContextDependencies(state) {
+    return {
+        config: state.config,
+        storage: state.storage,
+        shards: state.shards,
+        shardLocks: state.shardLocks,
+        customIdLock: state.customIdLock,
+        processingShards: state.processingShards,
+        processingLocks: state.processingLocks,
+        jobIndex: state.jobIndex,
+        completedJobs: state.completedJobs,
+        completedJobsData: state.completedJobsData,
+        depCompletions: state.depCompletions,
+        timedOutJobs: state.timedOutJobs,
+        retiredTimeoutLeaseTokens: state.retiredTimeoutLeaseTokens,
+        retiredCronLeaseTokens: state.retiredCronLeaseTokens,
+        timeoutScheduler: state.timeoutScheduler,
+        jobResults: state.jobResults,
+        dependencyResults: state.dependencyResults,
+        customIdMap: state.customIdMap,
+        jobLogs: state.jobLogs,
+        jobLocks: state.jobLocks,
+        clientJobs: state.clientJobs,
+        stalledCandidates: state.stalledCandidates,
+        pendingDepChecks: state.pendingDepChecks,
+        queueNamesCache: state.queueNamesCache,
+        repeatChain: state.repeatChain,
+        eventsManager: state.eventsManager,
+        webhookManager: state.webhookManager,
+        workerManager: state.workerManager,
+        monitoringState: state.monitoringState,
+        metrics: state.metrics,
+        startTime: state.startTime,
+        maxLogsPerJob: state.maxLogsPerJob,
+        perQueueMetrics: state.perQueueMetrics,
+    };
+}
+export function createContextCallbacks(runtime) {
+    return {
+        fail: async (id, error, failureReason) => {
+            if (failureReason)
+                await runtime.failWithReason(id, error, failureReason);
+            else
+                await runtime.fail(id, error);
+        },
+        registerQueueName: (queue) => runtime.registerQueueName(queue),
+        unregisterQueueName: (queue) => runtime.unregisterQueueName(queue),
+        onJobCompleted: (id) => runtime.onJobCompleted(id),
+        onJobFailed: (id) => runtime.onJobFailed(id),
+        onJobsCompleted: (ids) => runtime.onJobsCompleted(ids),
+        hasPendingDeps: () => runtime.hasPendingDeps(),
+        onRepeat: (job) => handleRepeat(runtime, job),
+        emitDashboardEvent: (event, data) => runtime.emitDashboardEvent(event, data),
+        onChildTerminalFailure: (job, error) => runtime.failParentOnChildFailure(job, error),
+        onChildDependencyOption: (job, error) => runtime.onChildDependencyOption(job, error),
+    };
+}

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

@@ -0,0 +1,17 @@
+import type { JobId } from '../../domain/types/job';
+import { QueueManagerQueries } from './queries';
+export declare class QueueManagerControl extends QueueManagerQueries {
+    pause(queue: string): void;
+    resume(queue: string): void;
+    isPaused(queue: string): boolean;
+    drain(queue: string): number;
+    obliterate(queue: string): void;
+    protected purgeQueueMetadata(queue: string): void;
+    listQueues(): string[];
+    protected registerQueueName(queue: string): void;
+    protected unregisterQueueName(queue: string): void;
+    protected releaseCompletionPins(dependencyIds: Iterable<JobId>): void;
+    protected reconcileCompletionPins(): void;
+    clean(queue: string, graceMs: number, state?: string, limit?: number): JobId[];
+    protected persistQueueState(_queue: string): void;
+}

package/dist/application/queue-manager/control.js

@@ -0,0 +1,133 @@
+import { reconcileDependencyCompletionPins, releaseDependencyCompletionPins, } from '../dependencyCompletions';
+import * as dlqOps from '../dlqManager';
+import * as queueControl from '../operations/queueControl';
+import { QueueManagerQueries } from './queries';
+export class QueueManagerControl extends QueueManagerQueries {
+    pause(queue) {
+        queueControl.pauseQueue(queue, this.contextFactory.getQueueControlContext());
+        this.persistQueueState(queue);
+        this.dashboardEmit?.('queue:paused', { queue });
+        this.eventsManager.broadcast({
+            eventType: "paused" /* EventType.Paused */,
+            queue,
+            jobId: '',
+            timestamp: Date.now(),
+        });
+    }
+    resume(queue) {
+        queueControl.resumeQueue(queue, this.contextFactory.getQueueControlContext());
+        this.persistQueueState(queue);
+        this.dashboardEmit?.('queue:resumed', { queue });
+        this.eventsManager.broadcast({
+            eventType: "resumed" /* EventType.Resumed */,
+            queue,
+            jobId: '',
+            timestamp: Date.now(),
+        });
+    }
+    isPaused(queue) {
+        return queueControl.isQueuePaused(queue, this.contextFactory.getQueueControlContext());
+    }
+    drain(queue) {
+        const count = queueControl.drainQueue(queue, this.contextFactory.getQueueControlContext());
+        if (count > 0)
+            this.dashboardEmit?.('queue:drained', { queue, count });
+        return count;
+    }
+    obliterate(queue) {
+        const shardJobs = queueControl.obliterateQueue(queue, this.contextFactory.getQueueControlContext());
+        dlqOps.purgeDlqJobs(queue, this.contextFactory.getDlqContext());
+        const toDrop = new Set(shardJobs);
+        for (const [jobId, location] of this.jobIndex) {
+            if (location.type === 'processing') {
+                const job = this.processingShards[location.shardIdx]?.get(jobId);
+                if (job?.queue === queue)
+                    toDrop.add(jobId);
+            }
+            else if (location.queueName === queue) {
+                toDrop.add(jobId);
+            }
+        }
+        for (const jobId of toDrop) {
+            const location = this.jobIndex.get(jobId);
+            if (location?.type === 'processing') {
+                this.processingShards[location.shardIdx]?.delete(jobId);
+            }
+            this.timeoutScheduler.cancel(jobId);
+            this.jobIndex.delete(jobId);
+            this.completedJobs.delete(jobId);
+            this.completedJobsData.delete(jobId);
+            this.jobResults.delete(jobId);
+            this.jobLogs.delete(jobId);
+            this.jobLocks.delete(jobId);
+            this.dependencyResults.releaseConsumer(jobId);
+            this.failedChildrenValues.delete(jobId);
+            this.ignoredChildrenFailures.delete(jobId);
+            this.pendingDepChecks.delete(jobId);
+            this.stalledCandidates.delete(jobId);
+            this.repeatChain.delete(jobId);
+            this.storage?.deleteJob(jobId);
+        }
+        const chainKeysToDelete = [];
+        for (const [oldId, newId] of this.repeatChain) {
+            if (toDrop.has(newId))
+                chainKeysToDelete.push(oldId);
+        }
+        for (const oldId of chainKeysToDelete)
+            this.repeatChain.delete(oldId);
+        const customIdsToDelete = [];
+        for (const [customId, jobId] of this.customIdMap.entries()) {
+            if (toDrop.has(jobId))
+                customIdsToDelete.push(customId);
+        }
+        for (const customId of customIdsToDelete)
+            this.customIdMap.delete(customId);
+        const removedCompletions = this.storage?.deleteDependencyCompletionsForQueue(queue) ?? [];
+        for (const jobId of removedCompletions)
+            this.depCompletions.delete(jobId);
+        this.reconcileCompletionPins();
+        this.purgeQueueMetadata(queue);
+        this.unregisterQueueName(queue);
+        this.dashboardEmit?.('queue:obliterated', { queue });
+        this.dashboardEmit?.('queue:removed', { queue });
+    }
+    purgeQueueMetadata(queue) {
+        this.perQueueMetrics.delete(queue);
+        this.telemetryJournal.clearQueue(queue);
+        this.storage?.deleteQueueState(queue);
+    }
+    listQueues() {
+        return Array.from(this.queueNamesCache);
+    }
+    registerQueueName(queue) {
+        const isNew = !this.queueNamesCache.has(queue);
+        this.queueNamesCache.add(queue);
+        if (isNew)
+            this.dashboardEmit?.('queue:created', { queue });
+    }
+    unregisterQueueName(queue) {
+        this.queueNamesCache.delete(queue);
+    }
+    releaseCompletionPins(dependencyIds) {
+        releaseDependencyCompletionPins(dependencyIds, {
+            storage: this.storage,
+            shards: this.shards,
+            depCompletions: this.depCompletions,
+            maxDependencyCompletions: this.config.maxCompletedJobs,
+        });
+    }
+    reconcileCompletionPins() {
+        reconcileDependencyCompletionPins({
+            storage: this.storage,
+            shards: this.shards,
+            depCompletions: this.depCompletions,
+            maxDependencyCompletions: this.config.maxCompletedJobs,
+        });
+    }
+    clean(queue, graceMs, state, limit) {
+        return queueControl.cleanQueue(queue, graceMs, this.contextFactory.getQueueControlContext(), state, limit);
+    }
+    persistQueueState(_queue) {
+        throw new Error('QueueManager limits module is not initialized');
+    }
+}

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

@@ -0,0 +1,32 @@
+import type { Job, JobId, JobInput, JobLock } from '../../domain/types/job';
+import type { AtomicFlowBatchInput, AtomicFlowBatchResult } from '../../domain/types/flow';
+import { QueueManagerState } from './state';
+export declare class QueueManagerDelivery extends QueueManagerState {
+    push(queue: string, input: JobInput): Promise<Job>;
+    pushBatch(queue: string, inputs: JobInput[]): Promise<JobId[]>;
+    pushFlow(batch: AtomicFlowBatchInput): Promise<AtomicFlowBatchResult>;
+    pull(queue: string, timeoutMs?: number, signal?: AbortSignal): Promise<Job | null>;
+    pullWithLock(queue: string, owner: string, timeoutMs?: number, lockTtl?: number, signal?: AbortSignal): Promise<{
+        job: Job | null;
+        token: string | null;
+    }>;
+    pullBatch(queue: string, count: number, timeoutMs?: number, signal?: AbortSignal): Promise<Job[]>;
+    pullBatchWithLock(queue: string, count: number, owner: string, timeoutMs?: number, lockTtl?: number, signal?: AbortSignal): Promise<{
+        jobs: Job[];
+        tokens: string[];
+    }>;
+    protected throwIfOwnershipConflict(jobId: JobId, lockCtx: {
+        jobLocks: Map<JobId, JobLock>;
+    }): void;
+    /** Require the exact current lease token whenever a lock record exists. */
+    protected assertLeaseToken(jobId: JobId, token: string | undefined, lockCtx: {
+        jobLocks: Map<JobId, JobLock>;
+    }): void;
+    protected isExpiredButOwned(jobId: JobId, token: string, lockCtx: {
+        jobLocks: Map<JobId, JobLock>;
+    }): boolean;
+    protected isStallRetried(jobId: JobId): boolean;
+    /** Match a late outcome to the exact cron lease retired by lock expiry. */
+    protected isRetiredCronOutcome(jobId: JobId, token: string | undefined): boolean;
+    protected completeStallRetriedJob(jobId: JobId, result: unknown, removeOnComplete?: boolean): Promise<boolean>;
+}