bunqueue 2.8.53 → 2.8.56

package/dist/mcp/backend/tcp/jobs.js

@@ -0,0 +1,122 @@
+import { TcpBackendBase } from './base';
+export class TcpJobBackend extends TcpBackendBase {
+    async addJob(queue, name, data, opts) {
+        const response = await this.send({
+            cmd: 'PUSH',
+            queue,
+            name,
+            data,
+            priority: opts?.priority,
+            delay: opts?.delay,
+            maxAttempts: opts?.attempts,
+        });
+        return { jobId: String(response.id) };
+    }
+    async addJobsBulk(queue, jobs) {
+        const response = await this.send({
+            cmd: 'PUSHB',
+            queue,
+            jobs: jobs.map((job) => ({
+                name: job.name,
+                data: job.data,
+                priority: job.priority,
+                delay: job.delay,
+            })),
+        });
+        return { jobIds: (response.ids ?? []).map(String) };
+    }
+    async getJob(id) {
+        const response = await this.send({ cmd: 'GetJob', id });
+        return response.job ? this.parseJob(response.job) : null;
+    }
+    async getJobState(id) {
+        const response = await this.send({ cmd: 'GetState', id });
+        return response.state ?? 'unknown';
+    }
+    async getJobResult(id) {
+        return (await this.send({ cmd: 'GetResult', id })).result;
+    }
+    async cancelJob(id) {
+        const response = await this.send({ cmd: 'Cancel', id });
+        return response.ok ?? false;
+    }
+    async promoteJob(id) {
+        const response = await this.send({ cmd: 'Promote', id });
+        return response.ok ?? false;
+    }
+    async updateProgress(id, progress, message) {
+        const response = await this.send({ cmd: 'Progress', id, progress, message });
+        return response.ok ?? false;
+    }
+    async updateJobData(id, data) {
+        const response = await this.send({ cmd: 'Update', id, data });
+        return response.ok ?? false;
+    }
+    async changeJobPriority(id, priority) {
+        const response = await this.send({ cmd: 'ChangePriority', id, priority });
+        return response.ok ?? false;
+    }
+    async moveToDelayed(id, delay) {
+        const response = await this.send({ cmd: 'MoveToDelayed', id, delay });
+        return response.ok ?? false;
+    }
+    async discardJob(id) {
+        const response = await this.send({ cmd: 'Discard', id });
+        return response.ok ?? false;
+    }
+    async getChildrenValues(parentJobId) {
+        const response = await this.send({ cmd: 'GetChildrenValues', id: parentJobId });
+        const data = response.data;
+        return (data?.values ?? {});
+    }
+    async getJobByCustomId(customId) {
+        const response = await this.send({ cmd: 'GetJobByCustomId', customId });
+        return response.job ? this.parseJob(response.job) : null;
+    }
+    async waitForJobCompletion(id, timeoutMs) {
+        const response = await this.send({ cmd: 'WaitJob', id, timeout: timeoutMs });
+        return response.ok ?? false;
+    }
+    async getProgress(id) {
+        const response = await this.send({ cmd: 'GetProgress', id });
+        if (response.progress === undefined)
+            return null;
+        return {
+            progress: response.progress ?? 0,
+            message: response.message ?? null,
+        };
+    }
+    async changeDelay(id, delay) {
+        const response = await this.send({ cmd: 'MoveToDelayed', id, delay });
+        return response.ok ?? false;
+    }
+    async extendLock(id, token, duration) {
+        const response = await this.send({ cmd: 'JobHeartbeat', id, token, duration });
+        return response.ok ?? false;
+    }
+    async pullJob(queue, timeoutMs) {
+        const response = await this.send({ cmd: 'PULL', queue, timeout: timeoutMs });
+        return response.job ? this.parseJob(response.job) : null;
+    }
+    async pullJobBatch(queue, count, timeoutMs) {
+        const response = await this.send({ cmd: 'PULLB', queue, count, timeout: timeoutMs });
+        return (response.jobs ?? []).map((job) => this.parseJob(job));
+    }
+    async ackJob(id, result) {
+        await this.send({ cmd: 'ACK', id, result });
+    }
+    async ackJobBatch(ids) {
+        await this.send({ cmd: 'ACKB', ids });
+    }
+    async failJob(id, error) {
+        await this.send({ cmd: 'FAIL', id, error });
+    }
+    async jobHeartbeat(id) {
+        const response = await this.send({ cmd: 'JobHeartbeat', id });
+        return response.ok ?? false;
+    }
+    async jobHeartbeatBatch(ids) {
+        const response = await this.send({ cmd: 'JobHeartbeatB', ids });
+        return response.count ?? 0;
+    }
+}

package/dist/mcp/backend/tcp/queues.d.ts

@@ -0,0 +1,27 @@
+import type { JobCounts } from '../../types/adapter';
+import { TcpJobBackend } from './jobs';
+export declare class TcpQueueBackend extends TcpJobBackend {
+    getJobs(queue: string, opts?: {
+        state?: string;
+        start?: number;
+        end?: number;
+    }): Promise<import("../../adapter").SerializedJob[]>;
+    getJobCounts(queue: string): Promise<JobCounts>;
+    pauseQueue(queue: string): Promise<void>;
+    resumeQueue(queue: string): Promise<void>;
+    drainQueue(queue: string): Promise<number>;
+    obliterateQueue(queue: string): Promise<void>;
+    listQueues(): Promise<string[]>;
+    countJobs(queue: string): Promise<number>;
+    cleanQueue(queue: string, graceMs: number, state?: string, limit?: number): Promise<string[]>;
+    isPaused(queue: string): Promise<boolean>;
+    getCountsPerPriority(queue: string): Promise<Record<number, number>>;
+    getDlq(queue: string, limit?: number): Promise<import("../../adapter").SerializedJob[]>;
+    retryDlq(queue: string, id?: string): Promise<number>;
+    purgeDlq(queue: string): Promise<number>;
+    retryCompleted(queue: string, id?: string): Promise<number>;
+    setRateLimit(queue: string, limit: number): Promise<void>;
+    clearRateLimit(queue: string): Promise<void>;
+    setConcurrency(queue: string, limit: number): Promise<void>;
+    clearConcurrency(queue: string): Promise<void>;
+}

package/dist/mcp/backend/tcp/queues.js

@@ -0,0 +1,89 @@
+import { TcpJobBackend } from './jobs';
+export class TcpQueueBackend extends TcpJobBackend {
+    async getJobs(queue, opts) {
+        const start = opts?.start ?? 0;
+        const hasEnd = opts?.end !== undefined && opts.end >= 0;
+        const response = await this.send({
+            cmd: 'GetJobs',
+            queue,
+            state: opts?.state,
+            offset: start,
+            limit: hasEnd ? Math.max(0, opts?.end - start) : undefined,
+        });
+        return (response.jobs ?? []).map((job) => this.parseJob(job));
+    }
+    async getJobCounts(queue) {
+        const response = await this.send({ cmd: 'GetJobCounts', queue });
+        const counts = response.counts ?? {};
+        return {
+            waiting: counts.waiting ?? 0,
+            prioritized: counts.prioritized ?? 0,
+            delayed: counts.delayed ?? 0,
+            active: counts.active ?? 0,
+            completed: counts.completed ?? 0,
+            failed: counts.failed ?? 0,
+            paused: counts.paused ?? 0,
+        };
+    }
+    async pauseQueue(queue) {
+        await this.send({ cmd: 'Pause', queue });
+    }
+    async resumeQueue(queue) {
+        await this.send({ cmd: 'Resume', queue });
+    }
+    async drainQueue(queue) {
+        const response = await this.send({ cmd: 'Drain', queue });
+        return response.removed ?? 0;
+    }
+    async obliterateQueue(queue) {
+        await this.send({ cmd: 'Obliterate', queue });
+    }
+    async listQueues() {
+        const response = await this.send({ cmd: 'ListQueues' });
+        return response.queues ?? [];
+    }
+    async countJobs(queue) {
+        const response = await this.send({ cmd: 'Count', queue });
+        return response.count ?? 0;
+    }
+    async cleanQueue(queue, graceMs, state, limit) {
+        const response = await this.send({ cmd: 'Clean', queue, grace: graceMs, state, limit });
+        return response.ids ?? [];
+    }
+    async isPaused(queue) {
+        const response = await this.send({ cmd: 'IsPaused', queue });
+        return response.paused ?? false;
+    }
+    async getCountsPerPriority(queue) {
+        const response = await this.send({ cmd: 'GetCountsPerPriority', queue });
+        return response.counts ?? {};
+    }
+    async getDlq(queue, limit) {
+        const response = await this.send({ cmd: 'Dlq', queue, count: limit });
+        return (response.jobs ?? []).map((job) => this.parseJob(job));
+    }
+    async retryDlq(queue, id) {
+        const response = await this.send({ cmd: 'RetryDlq', queue, id });
+        return response.retried ?? 0;
+    }
+    async purgeDlq(queue) {
+        const response = await this.send({ cmd: 'PurgeDlq', queue });
+        return response.purged ?? 0;
+    }
+    async retryCompleted(queue, id) {
+        const response = await this.send({ cmd: 'RetryCompleted', queue, id });
+        return response.retried ?? 0;
+    }
+    async setRateLimit(queue, limit) {
+        await this.send({ cmd: 'RateLimit', queue, limit });
+    }
+    async clearRateLimit(queue) {
+        await this.send({ cmd: 'RateLimitClear', queue });
+    }
+    async setConcurrency(queue, limit) {
+        await this.send({ cmd: 'SetConcurrency', queue, limit });
+    }
+    async clearConcurrency(queue) {
+        await this.send({ cmd: 'ClearConcurrency', queue });
+    }
+}

package/dist/mcp/backend/tcp/services.d.ts

@@ -0,0 +1,30 @@
+import type { CronJobInput } from '../../../domain/types/cron';
+import type { JobLogEntry } from '../../../domain/types/worker';
+import type { SerializedCron, WebhookInfo, WorkerInfo } from '../../types/adapter';
+import { TcpQueueBackend } from './queues';
+export declare class TcpServiceBackend extends TcpQueueBackend {
+    addCron(input: CronJobInput): Promise<SerializedCron>;
+    listCrons(): Promise<SerializedCron[]>;
+    getCron(name: string): Promise<SerializedCron | null>;
+    deleteCron(name: string): Promise<boolean>;
+    addWebhook(url: string, events: string[], queue?: string): Promise<WebhookInfo>;
+    removeWebhook(id: string): Promise<boolean>;
+    listWebhooks(): Promise<WebhookInfo[]>;
+    setWebhookEnabled(id: string, enabled: boolean): Promise<boolean>;
+    registerWorker(name: string, queues: string[]): Promise<WorkerInfo>;
+    unregisterWorker(id: string): Promise<boolean>;
+    workerHeartbeat(id: string): Promise<boolean>;
+    listWorkers(): Promise<WorkerInfo[]>;
+    getStats(): Promise<Record<string, unknown>>;
+    getJobLogs(id: string): Promise<JobLogEntry[]>;
+    addJobLog(id: string, message: string, level?: 'info' | 'warn' | 'error'): Promise<boolean>;
+    getPerQueueStats(): Promise<Record<string, unknown>>;
+    getMemoryStats(): Promise<Record<string, unknown>>;
+    getPrometheusMetrics(): Promise<string>;
+    clearJobLogs(id: string, _keepLogs?: number): Promise<void>;
+    compactMemory(): Promise<void>;
+    getStorageStatus(): Promise<{
+        diskFull: boolean;
+        error: string | null;
+    }>;
+}

package/dist/mcp/backend/tcp/services.js

@@ -0,0 +1,161 @@
+import { TcpQueueBackend } from './queues';
+function serializeTcpCron(value) {
+    if (!value || typeof value !== 'object')
+        throw new Error('Invalid cron response from broker');
+    const cron = value;
+    const schedule = cron.schedule;
+    const repeatEvery = cron.repeatEvery;
+    if (typeof cron.name !== 'string' ||
+        typeof cron.queue !== 'string' ||
+        typeof cron.nextRun !== 'number' ||
+        !Number.isFinite(cron.nextRun) ||
+        (schedule != null && typeof schedule !== 'string') ||
+        (repeatEvery != null && (typeof repeatEvery !== 'number' || !Number.isFinite(repeatEvery)))) {
+        throw new Error('Invalid cron response from broker');
+    }
+    const nextRun = new Date(cron.nextRun);
+    if (Number.isNaN(nextRun.getTime()))
+        throw new Error('Invalid cron response from broker');
+    return {
+        name: cron.name,
+        queue: cron.queue,
+        schedule: schedule ?? undefined,
+        repeatEvery: repeatEvery ?? undefined,
+        nextRun: nextRun.toISOString(),
+        executions: typeof cron.executions === 'number' ? cron.executions : 0,
+    };
+}
+export class TcpServiceBackend extends TcpQueueBackend {
+    async addCron(input) {
+        const response = await this.send({
+            cmd: 'Cron',
+            ...input,
+            jobName: input.jobName ?? 'default',
+        });
+        if (response.ok !== true) {
+            throw new Error(typeof response.error === 'string' ? response.error : 'Failed to add cron');
+        }
+        return serializeTcpCron(response.cron);
+    }
+    async listCrons() {
+        const response = await this.send({ cmd: 'CronList' });
+        return (response.crons ?? []).map(serializeTcpCron);
+    }
+    async getCron(name) {
+        const response = await this.send({ cmd: 'CronGet', name });
+        if (!response.ok)
+            return null;
+        return serializeTcpCron(response.cron);
+    }
+    async deleteCron(name) {
+        const response = await this.send({ cmd: 'CronDelete', name });
+        return response.ok ?? true;
+    }
+    async addWebhook(url, events, queue) {
+        const response = await this.send({ cmd: 'AddWebhook', url, events, queue });
+        return { id: String(response.id ?? '0'), url, events, queue, enabled: true };
+    }
+    async removeWebhook(id) {
+        const response = await this.send({ cmd: 'RemoveWebhook', id });
+        return response.ok ?? true;
+    }
+    async listWebhooks() {
+        const response = await this.send({ cmd: 'ListWebhooks' });
+        return (response.webhooks ?? []).map((webhook) => ({
+            id: String(webhook.id),
+            url: webhook.url,
+            events: webhook.events ?? [],
+            queue: webhook.queue,
+            enabled: webhook.enabled ?? true,
+        }));
+    }
+    async setWebhookEnabled(id, enabled) {
+        const response = await this.send({ cmd: 'SetWebhookEnabled', id, enabled });
+        return response.ok ?? true;
+    }
+    async registerWorker(name, queues) {
+        const response = await this.send({ cmd: 'RegisterWorker', name, queues });
+        return {
+            id: String(response.id ?? '0'),
+            name,
+            queues,
+            active: 0,
+            processed: 0,
+            failed: 0,
+            lastHeartbeat: Date.now(),
+        };
+    }
+    async unregisterWorker(id) {
+        const response = await this.send({ cmd: 'UnregisterWorker', workerId: id });
+        return response.ok ?? true;
+    }
+    async workerHeartbeat(id) {
+        const response = await this.send({ cmd: 'Heartbeat', id });
+        return response.ok ?? true;
+    }
+    async listWorkers() {
+        const response = await this.send({ cmd: 'ListWorkers' });
+        const data = response.data;
+        const workers = data?.workers ?? response.workers ?? [];
+        return workers.map((worker) => ({
+            id: String(worker.id),
+            name: worker.name,
+            queues: worker.queues ?? [],
+            active: worker.activeJobs ?? 0,
+            processed: worker.processedJobs ?? worker.processed ?? 0,
+            failed: worker.failedJobs ?? worker.failed ?? 0,
+            lastHeartbeat: worker.lastSeen ?? worker.lastHeartbeat ?? 0,
+        }));
+    }
+    async getStats() {
+        return this.send({ cmd: 'Stats' });
+    }
+    async getJobLogs(id) {
+        const response = await this.send({ cmd: 'GetLogs', id });
+        return response.logs ?? [];
+    }
+    async addJobLog(id, message, level) {
+        const response = await this.send({ cmd: 'AddLog', id, message, level });
+        return response.ok ?? true;
+    }
+    async getPerQueueStats() {
+        const response = await this.send({ cmd: 'DashboardQueues' });
+        const data = response.data;
+        const result = {};
+        for (const queue of data?.queues ?? []) {
+            const name = queue.name;
+            if (typeof name !== 'string')
+                continue;
+            result[name] = {
+                waiting: queue.waiting ?? 0,
+                prioritized: queue.prioritized ?? 0,
+                delayed: queue.delayed ?? 0,
+                active: queue.active ?? 0,
+                dlq: queue.dlq ?? 0,
+            };
+        }
+        return result;
+    }
+    async getMemoryStats() {
+        const response = await this.send({ cmd: 'Stats' });
+        return response.memory ?? {};
+    }
+    async getPrometheusMetrics() {
+        const response = await this.send({ cmd: 'Prometheus' });
+        return response.metrics ?? '';
+    }
+    async clearJobLogs(id, _keepLogs) {
+        await this.send({ cmd: 'ClearLogs', id });
+    }
+    async compactMemory() {
+        await this.send({ cmd: 'CompactMemory' });
+    }
+    async getStorageStatus() {
+        const response = await this.send({ cmd: 'StorageStatus' });
+        const data = response.data;
+        return {
+            diskFull: data?.diskFull ?? false,
+            error: data?.error ?? null,
+        };
+    }
+}

package/dist/mcp/types/adapter.d.ts

@@ -0,0 +1,176 @@
+import type { CronJobInput } from '../../domain/types/cron';
+import type { JobLogEntry } from '../../domain/types/worker';
+export interface JobCounts {
+    waiting: number;
+    prioritized: number;
+    delayed: number;
+    active: number;
+    completed: number;
+    failed: number;
+    paused: number;
+}
+export interface SerializedJob {
+    id: string;
+    name: string;
+    queue: string;
+    data: unknown;
+    priority: number;
+    state?: string;
+    progress: number;
+    attempts: number;
+    maxAttempts: number;
+    createdAt: string;
+    startedAt?: string;
+}
+export interface SerializedCron {
+    name: string;
+    queue: string;
+    schedule?: string;
+    repeatEvery?: number;
+    nextRun: string | null;
+    executions: number;
+}
+export interface WebhookInfo {
+    id: string;
+    url: string;
+    events: string[];
+    queue?: string;
+    enabled: boolean;
+}
+export interface WorkerInfo {
+    id: string;
+    name: string;
+    queues: string[];
+    active: number;
+    processed: number;
+    failed: number;
+    lastHeartbeat: number;
+}
+export interface FlowJobInput {
+    name: string;
+    queueName: string;
+    data?: Record<string, unknown>;
+    opts?: {
+        priority?: number;
+        delay?: number;
+        attempts?: number;
+    };
+    children?: FlowJobInput[];
+}
+export interface FlowStepInput {
+    name: string;
+    queueName: string;
+    data: Record<string, unknown>;
+    opts?: {
+        priority?: number;
+        delay?: number;
+        attempts?: number;
+    };
+}
+export interface FlowNodeResult {
+    jobId: string;
+    name: string;
+    queueName: string;
+    children?: FlowNodeResult[];
+}
+/** Common backend contract; all methods are async for TCP compatibility. */
+export interface McpBackend {
+    addJob(queue: string, name: string, data: unknown, opts?: {
+        priority?: number;
+        delay?: number;
+        attempts?: number;
+    }): Promise<{
+        jobId: string;
+    }>;
+    addJobsBulk(queue: string, jobs: Array<{
+        name: string;
+        data: unknown;
+        priority?: number;
+        delay?: number;
+    }>): Promise<{
+        jobIds: string[];
+    }>;
+    getJob(jobId: string): Promise<SerializedJob | null>;
+    getJobState(jobId: string): Promise<string>;
+    getJobResult(jobId: string): Promise<unknown>;
+    getProgress(jobId: string): Promise<{
+        progress: number;
+        message: string | null;
+    } | null>;
+    cancelJob(jobId: string): Promise<boolean>;
+    promoteJob(jobId: string): Promise<boolean>;
+    updateProgress(jobId: string, progress: number, message?: string): Promise<boolean>;
+    updateJobData(jobId: string, data: unknown): Promise<boolean>;
+    changeJobPriority(jobId: string, priority: number): Promise<boolean>;
+    moveToDelayed(jobId: string, delay: number): Promise<boolean>;
+    changeDelay(jobId: string, delay: number): Promise<boolean>;
+    discardJob(jobId: string): Promise<boolean>;
+    getChildrenValues(parentJobId: string): Promise<Record<string, unknown>>;
+    getJobByCustomId(customId: string): Promise<SerializedJob | null>;
+    waitForJobCompletion(jobId: string, timeoutMs: number): Promise<boolean>;
+    pullJob(queue: string, timeoutMs?: number): Promise<SerializedJob | null>;
+    pullJobBatch(queue: string, count: number, timeoutMs?: number): Promise<SerializedJob[]>;
+    ackJob(jobId: string, result?: unknown): Promise<void>;
+    ackJobBatch(jobIds: string[]): Promise<void>;
+    failJob(jobId: string, error?: string): Promise<void>;
+    jobHeartbeat(jobId: string): Promise<boolean>;
+    jobHeartbeatBatch(jobIds: string[]): Promise<number>;
+    extendLock(jobId: string, token: string, duration: number): Promise<boolean>;
+    getJobs(queue: string, opts?: {
+        state?: string;
+        start?: number;
+        end?: number;
+    }): Promise<SerializedJob[]>;
+    getJobCounts(queue: string): Promise<JobCounts>;
+    pauseQueue(queue: string): Promise<void>;
+    resumeQueue(queue: string): Promise<void>;
+    drainQueue(queue: string): Promise<number>;
+    obliterateQueue(queue: string): Promise<void>;
+    listQueues(): Promise<string[]>;
+    countJobs(queue: string): Promise<number>;
+    cleanQueue(queue: string, graceMs: number, state?: string, limit?: number): Promise<string[]>;
+    isPaused(queue: string): Promise<boolean>;
+    getCountsPerPriority(queue: string): Promise<Record<number, number>>;
+    getDlq(queue: string, limit?: number): Promise<SerializedJob[]>;
+    retryDlq(queue: string, jobId?: string): Promise<number>;
+    purgeDlq(queue: string): Promise<number>;
+    retryCompleted(queue: string, jobId?: string): Promise<number>;
+    setRateLimit(queue: string, limit: number): Promise<void>;
+    clearRateLimit(queue: string): Promise<void>;
+    setConcurrency(queue: string, limit: number): Promise<void>;
+    clearConcurrency(queue: string): Promise<void>;
+    addCron(input: CronJobInput): Promise<SerializedCron>;
+    getCron(name: string): Promise<SerializedCron | null>;
+    listCrons(): Promise<SerializedCron[]>;
+    deleteCron(name: string): Promise<boolean>;
+    addWebhook(url: string, events: string[], queue?: string): Promise<WebhookInfo>;
+    removeWebhook(id: string): Promise<boolean>;
+    listWebhooks(): Promise<WebhookInfo[]>;
+    setWebhookEnabled(id: string, enabled: boolean): Promise<boolean>;
+    registerWorker(name: string, queues: string[]): Promise<WorkerInfo>;
+    unregisterWorker(id: string): Promise<boolean>;
+    workerHeartbeat(id: string): Promise<boolean>;
+    listWorkers(): Promise<WorkerInfo[]>;
+    getStats(): Promise<Record<string, unknown>>;
+    getPerQueueStats(): Promise<Record<string, unknown>>;
+    getMemoryStats(): Promise<Record<string, unknown>>;
+    getPrometheusMetrics(): Promise<string>;
+    getStorageStatus(): Promise<{
+        diskFull: boolean;
+        error: string | null;
+    }>;
+    getJobLogs(jobId: string): Promise<JobLogEntry[]>;
+    addJobLog(jobId: string, message: string, level?: 'info' | 'warn' | 'error'): Promise<boolean>;
+    clearJobLogs(jobId: string, keepLogs?: number): Promise<void>;
+    compactMemory(): Promise<void>;
+    addFlow(flow: FlowJobInput): Promise<FlowNodeResult>;
+    addFlowChain(steps: FlowStepInput[]): Promise<{
+        jobIds: string[];
+    }>;
+    addFlowBulkThen(parallel: FlowStepInput[], final: FlowStepInput): Promise<{
+        parallelIds: string[];
+        finalId: string;
+    }>;
+    getFlow(jobId: string, queueName: string, depth?: number, maxChildren?: number): Promise<FlowNodeResult | null>;
+    shutdown(): void;
+}

package/dist/mcp/types/adapter.js

@@ -0,0 +1 @@
+export {};

package/dist/shared/asyncLock.d.ts

@@ -0,0 +1,13 @@
+/** FIFO asynchronous mutex with direct ownership handoff. */
+import type { LockGuard } from './types/lock';
+export declare class AsyncLock {
+    private locked;
+    private readonly queue;
+    acquire(timeoutMs?: number): Promise<LockGuard>;
+    isLocked(): boolean;
+    /** Queue size includes lazily pruned timed-out entries. */
+    getQueueLength(): number;
+    private timeout;
+    private drain;
+    private createGuard;
+}

package/dist/shared/asyncLock.js

@@ -0,0 +1,65 @@
+/** FIFO asynchronous mutex with direct ownership handoff. */
+import { LockTimeoutError } from './lockError';
+import { DEFAULT_LOCK_TIMEOUT_MS } from './lockTimeout';
+export class AsyncLock {
+    locked = false;
+    queue = [];
+    acquire(timeoutMs = DEFAULT_LOCK_TIMEOUT_MS) {
+        if (!this.locked && this.queue.length === 0) {
+            this.locked = true;
+            return Promise.resolve(this.createGuard());
+        }
+        if (timeoutMs <= 0)
+            return Promise.reject(new LockTimeoutError());
+        return new Promise((resolve, reject) => {
+            const waiter = {
+                resolve,
+                reject,
+                settled: false,
+            };
+            waiter.timer = setTimeout(() => this.timeout(waiter), timeoutMs);
+            this.queue.push(waiter);
+            this.drain();
+        });
+    }
+    isLocked() {
+        return this.locked;
+    }
+    /** Queue size includes lazily pruned timed-out entries. */
+    getQueueLength() {
+        return this.queue.length;
+    }
+    timeout(waiter) {
+        if (waiter.settled)
+            return;
+        waiter.settled = true;
+        waiter.reject(new LockTimeoutError());
+        this.drain();
+    }
+    drain() {
+        if (this.locked)
+            return;
+        let waiter = this.queue.shift();
+        while (waiter?.settled)
+            waiter = this.queue.shift();
+        if (!waiter)
+            return;
+        waiter.settled = true;
+        if (waiter.timer)
+            clearTimeout(waiter.timer);
+        this.locked = true;
+        waiter.resolve(this.createGuard());
+    }
+    createGuard() {
+        let released = false;
+        return {
+            release: () => {
+                if (released)
+                    return;
+                released = true;
+                this.locked = false;
+                this.drain();
+            },
+        };
+    }
+}