@basaltkit/queue 1.1.0 → 1.2.1

package/dist/index.js

@@ -1,350 +1,88 @@
-// src/index.ts
-import { createToken, definePlugin } from "@basaltkit/core";
-
-// src/drivers/bullmq.ts
-import { Queue, Worker } from "bullmq";
-function toBullRetention(retention, fallback) {
-  if (retention === void 0) return fallback;
-  if (typeof retention === "boolean" || typeof retention === "number") return retention;
-  const out = {};
-  if (retention.ageMs !== void 0) out.age = Math.max(1, Math.round(retention.ageMs / 1e3));
-  if (retention.count !== void 0) out.count = retention.count;
-  return out;
-}
-var BullmqQueueDriver = class {
-  name = "bullmq";
-  capabilities = { delayed: true, priority: true, retries: true, backoff: true };
-  connection;
-  queues = /* @__PURE__ */ new Map();
-  workers = [];
-  executor;
-  constructor(options) {
-    this.connection = typeof options.connection === "string" ? parseRedisUrl(options.connection) : options.connection;
-  }
-  setExecutor(executor) {
-    this.executor = executor;
-  }
-  async add(queue, jobName, data, options) {
-    await this.queue(queue).add(jobName, data, {
-      attempts: options.attempts,
-      ...options.backoff ? { backoff: { type: options.backoff.type, delay: options.backoff.delayMs } } : {},
-      ...options.delayMs !== void 0 ? { delay: options.delayMs } : {},
-      ...options.priority !== void 0 ? { priority: options.priority } : {},
-      removeOnComplete: toBullRetention(options.removeOnComplete, { count: 1e3 }),
-      removeOnFail: toBullRetention(options.removeOnFail, false)
+import { createToken, definePlugin, ensureMetadata } from '@basaltkit/core';
+import { BullmqQueueDriver } from './drivers/bullmq.js';
+import { SyncQueueDriver } from './drivers/sync.js';
+import { QueueManager } from './manager.js';
+export { defineJob, JobValidationError, JobNotRegisteredError, } from './job.js';
+export { QueueManager, UnknownJobError, UnsupportedJobOptionError, } from './manager.js';
+export { queuedOn } from './bridge.js';
+export { SyncQueueDriver } from './drivers/sync.js';
+export { BullmqQueueDriver } from './drivers/bullmq.js';
+export const QUEUE = createToken('queue');
+export function queuePlugin(options = {}) {
+    return definePlugin({
+        name: 'basalt:queue',
+        register({ container }) {
+            registerQueueCommands(container);
+            container.singleton(QUEUE, () => {
+                const driver = options.driver ??
+                    (options.connection
+                        ? new BullmqQueueDriver({ connection: options.connection })
+                        : new SyncQueueDriver());
+                const manager = new QueueManager(driver, {
+                    ...(options.onUnsupported !== undefined ? { onUnsupported: options.onUnsupported } : {}),
+                    ...(options.removeOnComplete !== undefined ? { removeOnComplete: options.removeOnComplete } : {}),
+                    ...(options.removeOnFail !== undefined ? { removeOnFail: options.removeOnFail } : {}),
+                });
+                for (const job of options.jobs ?? [])
+                    manager.register(job);
+                return manager;
+            });
+        },
+        boot({ container }) {
+            const manager = container.get(QUEUE);
+            for (const worker of options.workers ?? []) {
+                manager.work(worker.queue, worker.concurrency !== undefined ? { concurrency: worker.concurrency } : {});
+            }
+        },
+        async shutdown({ container }) {
+            await container.get(QUEUE).close();
+        },
     });
-  }
-  startWorker(queue, options = {}) {
-    this.workers.push(
-      new Worker(queue, async (job) => this.executor?.(job.name, job.data), {
-        connection: this.connection,
-        concurrency: options.concurrency ?? 1
-      })
-    );
-  }
-  async close() {
-    await Promise.all(this.workers.map((worker) => worker.close()));
-    await Promise.all([...this.queues.values()].map((queue) => queue.close()));
-  }
-  queue(name) {
-    let queue = this.queues.get(name);
-    if (!queue) {
-      queue = new Queue(name, { connection: this.connection });
-      this.queues.set(name, queue);
-    }
-    return queue;
-  }
-};
-function parseRedisUrl(url) {
-  const parsed = new URL(url);
-  return {
-    host: parsed.hostname,
-    port: parsed.port ? Number(parsed.port) : 6379,
-    ...parsed.username ? { username: parsed.username } : {},
-    ...parsed.password ? { password: parsed.password } : {},
-    ...parsed.pathname && parsed.pathname !== "/" ? { db: Number(parsed.pathname.slice(1)) } : {},
-    ...parsed.protocol === "rediss:" ? { tls: {} } : {},
-    // required by BullMQ for workers
-    maxRetriesPerRequest: null
-  };
-}
-
-// src/drivers/sync.ts
-var SyncQueueDriver = class {
-  name = "sync";
-  // Runs inline on dispatch: retries are honored (immediately), but there is no
-  // deferred delivery and no ordering, so delayed/priority are not supported.
-  capabilities = { delayed: false, priority: false, retries: true, backoff: false };
-  executor;
-  /** execution history — useful in test assertions */
-  executed = [];
-  setExecutor(executor) {
-    this.executor = executor;
-  }
-  async add(queue, jobName, data, options) {
-    let lastError;
-    for (let attempt = 1; attempt <= options.attempts; attempt++) {
-      try {
-        await this.executor?.(jobName, data);
-        this.executed.push({ queue, jobName, attempts: attempt });
-        return;
-      } catch (error) {
-        lastError = error;
-      }
-    }
-    this.executed.push({ queue, jobName, attempts: options.attempts });
-    throw lastError;
-  }
-  startWorker() {
-  }
-  async close() {
-  }
-};
-
-// src/manager.ts
-import {
-  BasaltError as BasaltError2,
-  parseDuration,
-  runWithContext,
-  tryCtx
-} from "@basaltkit/core";
-
-// src/job.ts
-import { BasaltError } from "@basaltkit/core";
-var JobValidationError = class extends BasaltError {
-  constructor(job, issues) {
-    super("JOB_INVALID", `Invalid payload for job "${job}": ${JSON.stringify(issues)}`);
-    this.job = job;
-    this.issues = issues;
-  }
-  job;
-  issues;
-};
-var JobNotRegisteredError = class extends BasaltError {
-  constructor(job) {
-    super(
-      "QUEUE_JOB_NOT_REGISTERED",
-      `Job "${job}" has not been registered in a QueueManager yet. Add it to queuePlugin({ jobs: [...] }) or call manager.register(job).`
-    );
-  }
-};
-function defineJob(config) {
-  let dispatcher;
-  const job = {
-    name: config.name,
-    schema: config.schema,
-    queue: config.queue ?? "default",
-    attempts: config.attempts ?? 1,
-    backoff: config.backoff,
-    removeOnComplete: config.removeOnComplete,
-    removeOnFail: config.removeOnFail,
-    handle: config.handle,
-    async dispatch(payload, options) {
-      if (!dispatcher) throw new JobNotRegisteredError(config.name);
-      return dispatcher.dispatch(job, payload, options);
-    },
-    __bind(d) {
-      dispatcher = d;
-    }
-  };
-  return job;
-}
-function validatePayload(job, payload) {
-  if (!job.schema) return payload;
-  const result = job.schema.safeParse(payload);
-  if (!result.success) {
-    const issues = result.error?.issues ?? result.error ?? "unknown";
-    throw new JobValidationError(job.name, issues);
-  }
-  return result.data;
-}
-
-// src/manager.ts
-function resolveRetention(retention) {
-  if (retention === void 0) return void 0;
-  if (typeof retention === "boolean" || typeof retention === "number") return retention;
-  const out = {};
-  if (retention.age !== void 0) out.ageMs = parseDuration(retention.age);
-  if (retention.count !== void 0) out.count = retention.count;
-  return out;
-}
-var UnknownJobError = class extends BasaltError2 {
-  constructor(job) {
-    super(
-      "QUEUE_UNKNOWN_JOB",
-      `Job "${job}" reached the worker but is not registered in this process. Make sure the worker registers the same jobs as the producer.`
-    );
-  }
-};
-var UnsupportedJobOptionError = class extends BasaltError2 {
-  status = 500;
-  constructor(driver, job, features) {
-    super(
-      "QUEUE_UNSUPPORTED_OPTION",
-      `The "${driver}" queue driver does not support ${features.join(", ")} (job "${job}"). Use a driver that supports it, remove the option, or set queuePlugin({ onUnsupported: 'warn' | 'ignore' }).`
-    );
-  }
-};
-var requiredCapabilities = (options) => {
-  const needed = [];
-  if (options.delayMs !== void 0 && options.delayMs > 0) needed.push("delayed");
-  if (options.priority !== void 0) needed.push("priority");
-  if (options.attempts > 1) needed.push("retries");
-  if (options.backoff && options.attempts > 1) needed.push("backoff");
-  return needed;
-};
-var FEATURE_LABELS = {
-  delayed: "delayed jobs (delay)",
-  priority: "priority",
-  retries: "retries (attempts > 1)",
-  backoff: "retry backoff"
-};
-var SNAPSHOT_FIELDS = ["requestId", "correlationId", "traceId", "userId", "tenantId"];
-var QueueManager = class {
-  constructor(driver, options = {}) {
-    this.driver = driver;
-    this.onUnsupported = options.onUnsupported ?? "warn";
-    this.warn = options.warn ?? ((message) => console.warn(message));
-    this.defaultRemoveOnComplete = options.removeOnComplete;
-    this.defaultRemoveOnFail = options.removeOnFail;
-    driver.setExecutor((jobName, data) => this.execute(jobName, data));
-  }
-  driver;
-  jobs = /* @__PURE__ */ new Map();
-  onUnsupported;
-  warn;
-  warned = /* @__PURE__ */ new Set();
-  defaultRemoveOnComplete;
-  defaultRemoveOnFail;
-  /**
-   * Checks the dispatch's options against the driver's declared capabilities.
-   * A driver that omits `capabilities` is assumed fully capable (back-compat).
-   */
-  assertSupported(jobName, options) {
-    const caps = this.driver.capabilities;
-    if (!caps || this.onUnsupported === "ignore") return;
-    const missing = requiredCapabilities(options).filter((cap) => !caps[cap]);
-    if (missing.length === 0) return;
-    const driverName = this.driver.name ?? "queue";
-    const features = missing.map((cap) => FEATURE_LABELS[cap]);
-    if (this.onUnsupported === "throw") throw new UnsupportedJobOptionError(driverName, jobName, features);
-    const key = `${jobName}:${missing.join(",")}`;
-    if (this.warned.has(key)) return;
-    this.warned.add(key);
-    this.warn(
-      `[basalt/queue] The "${driverName}" driver does not support ${features.join(", ")} \u2014 job "${jobName}" will run without it.`
-    );
-  }
-  register(job) {
-    this.jobs.set(job.name, job);
-    job.__bind(this);
-    return this;
-  }
-  async dispatch(job, payload, options = {}) {
-    if (!this.jobs.has(job.name)) this.register(job);
-    const envelope = {
-      payload: validatePayload(job, payload),
-      context: snapshotContext()
-    };
-    const addOptions = {
-      attempts: job.attempts,
-      backoff: job.backoff ? { type: job.backoff.type, delayMs: parseDuration(job.backoff.delay) } : void 0,
-      delayMs: options.delay === void 0 ? void 0 : parseDuration(options.delay),
-      priority: options.priority,
-      // Per-job overrides the queuePlugin default; undefined leaves the driver default.
-      removeOnComplete: resolveRetention(job.removeOnComplete ?? this.defaultRemoveOnComplete),
-      removeOnFail: resolveRetention(job.removeOnFail ?? this.defaultRemoveOnFail)
-    };
-    this.assertSupported(job.name, addOptions);
-    await this.driver.add(job.queue, job.name, envelope, addOptions);
-  }
-  /** Starts a worker for the queue. With the sync driver it is a no-op. */
-  work(queue = "default", options = {}) {
-    this.driver.startWorker(queue, options);
-  }
-  async close() {
-    await this.driver.close();
-  }
-  /** Executes a job received from the driver: validates, restores the context, runs the handler. */
-  async execute(jobName, data) {
-    const job = this.jobs.get(jobName);
-    if (!job) throw new UnknownJobError(jobName);
-    const envelope = data;
-    const payload = validatePayload(job, envelope.payload);
-    await runWithContext({ ...envelope.context ?? {} }, () => job.handle(payload));
-  }
-};
-function snapshotContext() {
-  const context = tryCtx();
-  if (!context) return void 0;
-  const snapshot = {};
-  for (const field of SNAPSHOT_FIELDS) {
-    if (context[field] !== void 0) snapshot[field] = context[field];
-  }
-  const tenant = context["tenant"];
-  if (tenant?.id) snapshot["tenant"] = { id: tenant.id };
-  const user = context["user"];
-  if (user?.id && snapshot["userId"] === void 0) snapshot["userId"] = user.id;
-  return Object.keys(snapshot).length > 0 ? snapshot : void 0;
 }
-
-// src/bridge.ts
-function queuedOn(bus, manager, event, handler, options = {}) {
-  const job = defineJob({
-    name: `listener:${event.name}`,
-    ...event.schema ? { schema: event.schema } : {},
-    ...options.queue ? { queue: options.queue } : {},
-    ...options.attempts !== void 0 ? { attempts: options.attempts } : {},
-    ...options.backoff ? { backoff: options.backoff } : {},
-    handle: handler
-  });
-  manager.register(job);
-  return bus.on(event, async (payload) => {
-    await job.dispatch(payload);
-  });
-}
-
-// src/index.ts
-var QUEUE = createToken("queue");
-function queuePlugin(options = {}) {
-  return definePlugin({
-    name: "basalt:queue",
-    register({ container }) {
-      container.singleton(QUEUE, () => {
-        const driver = options.driver ?? (options.connection ? new BullmqQueueDriver({ connection: options.connection }) : new SyncQueueDriver());
-        const manager = new QueueManager(driver, {
-          ...options.onUnsupported !== void 0 ? { onUnsupported: options.onUnsupported } : {},
-          ...options.removeOnComplete !== void 0 ? { removeOnComplete: options.removeOnComplete } : {},
-          ...options.removeOnFail !== void 0 ? { removeOnFail: options.removeOnFail } : {}
-        });
-        for (const job of options.jobs ?? []) manager.register(job);
-        return manager;
-      });
-    },
-    boot({ container }) {
-      const manager = container.get(QUEUE);
-      for (const worker of options.workers ?? []) {
-        manager.work(
-          worker.queue,
-          worker.concurrency !== void 0 ? { concurrency: worker.concurrency } : {}
-        );
-      }
-    },
-    async shutdown({ container }) {
-      await container.get(QUEUE).close();
-    }
-  });
+/**
+ * Registers `queue:work`, `queue:stats` and `queue:retry` into the CLI command
+ * bucket. Commands resolve the manager lazily, so they work with whatever driver
+ * the app configured. Registered structurally to avoid a hard @basaltkit/cli dep.
+ */
+function registerQueueCommands(container) {
+    const manager = () => container.get(QUEUE);
+    const unsupported = 'Not supported by the active queue driver — the inline sync driver keeps no job state. Use the BullMQ driver (a Redis `connection`).';
+    ensureMetadata(container).add('commands', {
+        name: 'queue:work',
+        description: 'Run a worker that processes jobs for a queue (Ctrl+C to stop)',
+        async handle({ io, flags }) {
+            const queue = typeof flags['queue'] === 'string' ? flags['queue'] : 'default';
+            const concurrency = typeof flags['concurrency'] === 'string' ? Number(flags['concurrency']) : undefined;
+            manager().work(queue, concurrency !== undefined ? { concurrency } : {});
+            io.log(`Worker started on queue "${queue}"${concurrency ? ` (concurrency ${concurrency})` : ''}. Ctrl+C to stop.`);
+            await new Promise((resolve) => process.once('SIGINT', resolve));
+        },
+    });
+    ensureMetadata(container).add('commands', {
+        name: 'queue:stats',
+        description: 'Show job counts (waiting/active/completed/failed/delayed) for a queue',
+        async handle({ io, flags, }) {
+            const queue = typeof flags['queue'] === 'string' ? flags['queue'] : 'default';
+            const stats = await manager().stats(queue);
+            if (!stats) {
+                io.log(unsupported);
+                return;
+            }
+            io.table([{ queue, ...stats }]);
+        },
+    });
+    ensureMetadata(container).add('commands', {
+        name: 'queue:retry',
+        description: 'Re-enqueue failed jobs on a queue',
+        async handle({ io, flags, }) {
+            const queue = typeof flags['queue'] === 'string' ? flags['queue'] : 'default';
+            const limit = typeof flags['limit'] === 'string' ? Number(flags['limit']) : undefined;
+            const retried = await manager().retryFailed(queue, limit !== undefined ? { limit } : {});
+            if (retried === undefined) {
+                io.log(unsupported);
+                return;
+            }
+            io.log(`Re-enqueued ${retried} failed job(s) on "${queue}".`);
+        },
+    });
 }
-export {
-  BullmqQueueDriver,
-  JobNotRegisteredError,
-  JobValidationError,
-  QUEUE,
-  QueueManager,
-  SyncQueueDriver,
-  UnknownJobError,
-  UnsupportedJobOptionError,
-  defineJob,
-  queuePlugin,
-  queuedOn
-};

package/dist/job.d.ts

@@ -0,0 +1,76 @@
+import { BasaltError, type DurationInput } from '@basaltkit/core';
+/** Structural schema compatible with Zod. */
+export interface JobSchema<T> {
+    safeParse(input: unknown): {
+        success: boolean;
+        data?: T;
+        error?: unknown;
+    };
+}
+export declare class JobValidationError extends BasaltError {
+    readonly job: string;
+    readonly issues: unknown;
+    constructor(job: string, issues: unknown);
+}
+export declare class JobNotRegisteredError extends BasaltError {
+    constructor(job: string);
+}
+export interface DispatchOptions {
+    delay?: DurationInput;
+    priority?: number;
+}
+export interface JobBackoff {
+    type: 'exponential' | 'fixed';
+    delay: DurationInput;
+}
+/**
+ * Redis retention for finished jobs (BullMQ driver): `true` removes it as soon as
+ * it finishes, `false` keeps it forever, a number keeps that many most-recent, and
+ * `{ age, count }` keeps by age and/or count. Defaults: completed `{ count: 1000 }`,
+ * failed `false` (keep all). The sync driver ignores it (it stores nothing).
+ */
+export type JobRetention = boolean | number | {
+    age?: DurationInput;
+    count?: number;
+};
+export interface JobDefinition<T = unknown> {
+    readonly name: string;
+    readonly schema?: JobSchema<T> | undefined;
+    readonly queue: string;
+    readonly attempts: number;
+    readonly backoff?: JobBackoff | undefined;
+    /** Retention for completed jobs. Overrides the queuePlugin default. */
+    readonly removeOnComplete?: JobRetention | undefined;
+    /** Retention for failed jobs. Overrides the queuePlugin default. */
+    readonly removeOnFail?: JobRetention | undefined;
+    handle(payload: T): void | Promise<void>;
+    /** Enqueues the job — available after registration in a QueueManager. */
+    dispatch(payload: T, options?: DispatchOptions): Promise<void>;
+    /** @internal used by the QueueManager when registering */
+    __bind(dispatcher: JobDispatcher): void;
+}
+export interface JobDispatcher {
+    dispatch<T>(job: JobDefinition<T>, payload: T, options?: DispatchOptions): Promise<void>;
+}
+/**
+ * Defines a declarative job:
+ *
+ * export const SendWelcomeEmail = defineJob({
+ *   name: 'email.welcome',
+ *   schema: z.object({ userId: z.string() }),
+ *   attempts: 3,
+ *   backoff: { type: 'exponential', delay: '30s' },
+ *   async handle({ userId }) { ... },
+ * })
+ */
+export declare function defineJob<T = unknown>(config: {
+    name: string;
+    schema?: JobSchema<T>;
+    queue?: string;
+    attempts?: number;
+    backoff?: JobBackoff;
+    removeOnComplete?: JobRetention;
+    removeOnFail?: JobRetention;
+    handle(payload: T): void | Promise<void>;
+}): JobDefinition<T>;
+export declare function validatePayload<T>(job: JobDefinition<T>, payload: unknown): T;

package/dist/job.js

@@ -0,0 +1,59 @@
+import { BasaltError } from '@basaltkit/core';
+export class JobValidationError extends BasaltError {
+    job;
+    issues;
+    constructor(job, issues) {
+        super('JOB_INVALID', `Invalid payload for job "${job}": ${JSON.stringify(issues)}`);
+        this.job = job;
+        this.issues = issues;
+    }
+}
+export class JobNotRegisteredError extends BasaltError {
+    constructor(job) {
+        super('QUEUE_JOB_NOT_REGISTERED', `Job "${job}" has not been registered in a QueueManager yet. ` +
+            'Add it to queuePlugin({ jobs: [...] }) or call manager.register(job).');
+    }
+}
+/**
+ * Defines a declarative job:
+ *
+ * export const SendWelcomeEmail = defineJob({
+ *   name: 'email.welcome',
+ *   schema: z.object({ userId: z.string() }),
+ *   attempts: 3,
+ *   backoff: { type: 'exponential', delay: '30s' },
+ *   async handle({ userId }) { ... },
+ * })
+ */
+export function defineJob(config) {
+    let dispatcher;
+    const job = {
+        name: config.name,
+        schema: config.schema,
+        queue: config.queue ?? 'default',
+        attempts: config.attempts ?? 1,
+        backoff: config.backoff,
+        removeOnComplete: config.removeOnComplete,
+        removeOnFail: config.removeOnFail,
+        handle: config.handle,
+        async dispatch(payload, options) {
+            if (!dispatcher)
+                throw new JobNotRegisteredError(config.name);
+            return dispatcher.dispatch(job, payload, options);
+        },
+        __bind(d) {
+            dispatcher = d;
+        },
+    };
+    return job;
+}
+export function validatePayload(job, payload) {
+    if (!job.schema)
+        return payload;
+    const result = job.schema.safeParse(payload);
+    if (!result.success) {
+        const issues = result.error?.issues ?? result.error ?? 'unknown';
+        throw new JobValidationError(job.name, issues);
+    }
+    return result.data;
+}

package/dist/manager.d.ts

@@ -0,0 +1,61 @@
+import { BasaltError } from '@basaltkit/core';
+import type { QueueDriver, QueueStats } from './driver.js';
+import { type DispatchOptions, type JobDefinition, type JobDispatcher, type JobRetention } from './job.js';
+export declare class UnknownJobError extends BasaltError {
+    constructor(job: string);
+}
+/** A job used an option the active driver doesn't support (with policy 'throw'). */
+export declare class UnsupportedJobOptionError extends BasaltError {
+    readonly status = 500;
+    constructor(driver: string, job: string, features: string[]);
+}
+/**
+ * What to do when a dispatch uses an option the driver can't honor:
+ * - `throw`: raise {@link UnsupportedJobOptionError} (strict; recommended in prod)
+ * - `warn`: log once per job+feature and proceed (default — never silent)
+ * - `ignore`: proceed silently (legacy behavior)
+ */
+export type UnsupportedPolicy = 'throw' | 'warn' | 'ignore';
+export interface QueueManagerOptions {
+    /** Reaction when a job uses an option the driver can't honor. Default 'warn'. */
+    onUnsupported?: UnsupportedPolicy;
+    /** Sink for 'warn' diagnostics. Default console.warn. */
+    warn?: (message: string) => void;
+    /** Default retention for completed jobs (a job can override). Driver default: keep 1000. */
+    removeOnComplete?: JobRetention;
+    /** Default retention for failed jobs (a job can override). Driver default: keep all. */
+    removeOnFail?: JobRetention;
+}
+export declare class QueueManager implements JobDispatcher {
+    private readonly driver;
+    private readonly jobs;
+    private readonly onUnsupported;
+    private readonly warn;
+    private readonly warned;
+    private readonly defaultRemoveOnComplete;
+    private readonly defaultRemoveOnFail;
+    constructor(driver: QueueDriver, options?: QueueManagerOptions);
+    /**
+     * Checks the dispatch's options against the driver's declared capabilities.
+     * A driver that omits `capabilities` is assumed fully capable (back-compat).
+     */
+    private assertSupported;
+    register(job: JobDefinition<never> | JobDefinition<unknown>): this;
+    dispatch<T>(job: JobDefinition<T>, payload: T, options?: DispatchOptions): Promise<void>;
+    /** Starts a worker for the queue. With the sync driver it is a no-op. */
+    work(queue?: string, options?: {
+        concurrency?: number;
+    }): void;
+    /** Job counts per state, or `undefined` if the driver can't introspect. */
+    stats(queue?: string): Promise<QueueStats | undefined>;
+    /**
+     * Re-enqueues failed jobs; returns the count, or `undefined` if the driver
+     * doesn't support retrying (e.g. the inline sync driver).
+     */
+    retryFailed(queue?: string, options?: {
+        limit?: number;
+    }): Promise<number | undefined>;
+    close(): Promise<void>;
+    /** Executes a job received from the driver: validates, restores the context, runs the handler. */
+    private execute;
+}