bunqueue-client 0.2.0 → 0.2.1

package/dist/index.js

@@ -187,6 +187,18 @@ class BatchExecution {
     };
   }
 }
+// ../../src/domain/job/constants.ts
+var DEFAULT_MAX_BACKOFF = 3600000;
+var JOB_DEFAULTS = {
+  priority: 0,
+  maxAttempts: 3,
+  backoff: 1000,
+  lifo: false,
+  removeOnComplete: false,
+  removeOnFail: false,
+  stackTraceLimit: 10
+};
+var MAX_BACKOFF_DELAY = 86400000;
 // ../../src/domain/job/payload.ts
 var DEFAULT_JOB_NAME = "default";
 var MAX_JOB_NAME_LENGTH = 256;
@@ -225,6 +237,13 @@ function normalizeLegacyJobPayload(source, fallback = DEFAULT_JOB_NAME) {
     return { name: checkedName(legacy.name), data: legacy.data, legacy: true };
   return { name: checkedName(fallback), data: source.data, legacy: false };
 }
+
+// ../../src/domain/job/create.ts
+function parseMaxDelay(value) {
+  if (typeof value !== "number" || !Number.isFinite(value))
+    return;
+  return value >= 0 && value <= MAX_BACKOFF_DELAY ? value : undefined;
+}
 // src/canonical-transport/runtime.ts
 import { access, unlink } from "node:fs/promises";
 import { createHash, randomBytes } from "node:crypto";
@@ -340,6 +359,17 @@ function jobId(id) {
 function generateJobId() {
   return uuid();
 }
+// ../../src/domain/job/state.ts
+function calculateDelayedErrorDelay(job) {
+  const base = job.backoffConfig ? job.backoffConfig.delay : job.backoff;
+  const maxDelay = job.backoffConfig?.maxDelay;
+  const cap = isPositiveFinite(maxDelay) ? maxDelay : DEFAULT_MAX_BACKOFF;
+  const wait = typeof base === "number" && base > 0 ? base : JOB_DEFAULTS.backoff;
+  return Math.min(wait, cap);
+}
+function isPositiveFinite(value) {
+  return typeof value === "number" && Number.isFinite(value) && value > 0;
+}
 // ../../src/client/jobHelpers.ts
 function resolvePublicJobPayload(job) {
   const payload = normalizeLegacyJobPayload(job);
@@ -387,7 +417,12 @@ function buildParentOpts(job) {
   return;
 }
 function buildJobOpts(job) {
-  const backoff = job.backoffConfig ? { type: job.backoffConfig.type, delay: job.backoffConfig.delay } : job.backoff;
+  const config = job.backoffConfig;
+  const backoff = config ? {
+    type: config.type,
+    delay: config.delay,
+    ...typeof config.maxDelay === "number" ? { maxDelay: config.maxDelay } : {}
+  } : job.backoff;
   return {
     priority: job.priority,
     delay: job.runAt > job.createdAt ? job.runAt - job.createdAt : 0,
@@ -1322,13 +1357,14 @@ async function handleDelayedError(internalJob, config, context) {
   if (config.shouldAbandonOutcome?.())
     return;
   try {
+    const delay = calculateDelayedErrorDelay(internalJob);
     if (embedded) {
-      await getSharedManager().moveToDelayed(internalJob.id, internalJob.backoff || 1000, context.token ?? undefined);
+      await getSharedManager().moveToDelayed(internalJob.id, delay, context.token ?? undefined);
     } else if (tcp) {
       await tcp.send({
         cmd: "MoveToDelayed",
         id: internalJob.id,
-        delay: internalJob.backoff || 1000,
+        delay,
         ...context.token ? { token: context.token } : {}
       });
     }
@@ -1536,6 +1572,17 @@ var WORKER_CONSTANTS = {
 };
 
 // ../../src/client/worker/jobParser.ts
+function parseBackoffConfig(value) {
+  if (typeof value !== "object" || value === null)
+    return null;
+  const { type, delay, maxDelay } = value;
+  if (type !== "fixed" && type !== "exponential")
+    return null;
+  if (typeof delay !== "number" || !Number.isFinite(delay))
+    return null;
+  const cap = parseMaxDelay(maxDelay);
+  return cap === undefined ? { type, delay } : { type, delay, maxDelay: cap };
+}
 function parseJobFromResponse(jobData, queueName) {
   const payload = normalizeLegacyJobPayload({ name: jobData.name, data: jobData.data });
   return {
@@ -1551,6 +1598,7 @@ function parseJobFromResponse(jobData, queueName) {
     attempts: jobData.attempts ?? 0,
     maxAttempts: jobData.maxAttempts ?? 3,
     backoff: jobData.backoff ?? 1000,
+    backoffConfig: parseBackoffConfig(jobData.backoffConfig),
     ttl: jobData.ttl ?? null,
     timeout: jobData.timeout ?? null,
     uniqueKey: jobData.uniqueKey ?? null,
@@ -10867,7 +10915,7 @@ class FlowProducer extends EventEmitter7 {
   }
 }
 // src/index.ts
-var __version__ = "0.2.0";
+var __version__ = "0.2.1";
 export {
   AuthError2 as AuthError,
   Bunqueue,

package/dist/legacy.js

@@ -2057,7 +2057,7 @@ class FlowProducer {
 }
 
 // src/legacy.ts
-var __version__ = "0.2.0";
+var __version__ = "0.2.1";
 export {
   AuthError2 as AuthError,
   Bunqueue,

package/dist/types/sdk/typescript/src/index.d.ts

@@ -7,4 +7,4 @@ export { AuthError, BunqueueError, CommandError, CommandTimeoutError, Connection
 export { consoleLogger, noopLogger } from "./observability.js";
 export type { Logger, LogLevel, Observability, TelemetryEvent, TelemetryHandler, } from "./observability.js";
 export { MAX_FRAME_SIZE, PROTOCOL_VERSION } from "./frame.js";
-export declare const __version__ = "0.2.0";
+export declare const __version__ = "0.2.1";

package/dist/types/sdk/typescript/src/legacy.d.ts

@@ -24,4 +24,4 @@ export type { BatchResponse, CountResponse, DataResponse, JobCountsResponse, Job
 export type { BackoffOptions, DeduplicationOptions, JobCounts, JobOptions, JobStateName, RepeatOptions, } from "./types.js";
 export { Worker } from "./worker.js";
 export type { AckBatchOptions, Processor, WorkerEventMap, WorkerOptions } from "./worker-types.js";
-export declare const __version__ = "0.2.0";
+export declare const __version__ = "0.2.1";

package/dist/types/src/application/clientOwnership.d.ts

@@ -0,0 +1,65 @@
+/**
+ * Client Ownership - which connection owns a job's current delivery.
+ *
+ * `clientJobs` maps a connection to the jobs it pulled. `clientJobOwners` is
+ * its reverse index: one record per owned job naming the owning connection and
+ * the delivery it owns. A delivery is identified by the processing
+ * `JobLocation` object the pull installed in `jobIndex`. Only a pull installs a
+ * processing location, and every pull installs a fresh object, so the record
+ * of an earlier delivery never matches a later delivery of the same job id.
+ *
+ * Every mutation of the two maps goes through this module so they stay in
+ * step: a job is in `clientJobs.get(c)` exactly when its owner record names
+ * `c`. Every operation is O(1) per job.
+ */
+import type { JobId } from "../domain/types/job.js";
+import type { JobLocation } from "../domain/types/queue.js";
+/** The connection that registered a job's delivery, and that delivery. */
+export interface ClientJobOwner {
+    readonly clientId: string;
+    /** The `jobIndex` entry current when the connection registered the job. */
+    readonly delivery: JobLocation | undefined;
+}
+/** The two ownership maps plus the index that identifies deliveries. */
+export interface ClientOwnershipContext {
+    jobIndex: Map<JobId, JobLocation>;
+    clientJobs: Map<string, Set<JobId>>;
+    clientJobOwners: Map<JobId, ClientJobOwner>;
+}
+/** The maps a detach touches; it never needs the job index. */
+export type ClientOwnershipMaps = Pick<ClientOwnershipContext, 'clientJobs' | 'clientJobOwners'>;
+/**
+ * Register `clientId` as the owner of the job's current delivery (called after
+ * PULL). A delivery has one owner, so any previous owner is detached first.
+ */
+export declare function registerClientJob(clientId: string, jobId: JobId, ctx: ClientOwnershipContext): void;
+/**
+ * Remove one connection's claim on a job (ACK/FAIL handled on that
+ * connection). Another connection's record for the same job is left alone: it
+ * may already own a newer delivery.
+ */
+export declare function unregisterClientJob(clientId: string | undefined, jobId: JobId, ctx: ClientOwnershipMaps): void;
+/**
+ * End ownership of a job's delivery, whoever holds it. Every transition that
+ * ends a delivery without the owner's ACK/FAIL calls this (stall recovery,
+ * orphan recovery, lock expiry, timeout, management claims, disconnect
+ * release), so a silent connection never keeps a job it no longer runs.
+ */
+export declare function detachClientJob(jobId: JobId, ctx: ClientOwnershipMaps): void;
+/**
+ * True only when `clientId` registered the job's current delivery: the job is
+ * processing and its processing entry is the one the connection registered.
+ * Disconnect release acts on nothing else, so a stale registration can never
+ * release or expire a later delivery owned by another worker.
+ */
+export declare function ownsCurrentDelivery(clientId: string, jobId: JobId, ctx: ClientOwnershipContext): boolean;
+/** Forget a disconnected client: its set and only its own owner records. */
+export declare function dropClient(clientId: string, ctx: ClientOwnershipMaps): void;
+/**
+ * Detach every record whose delivery has ended. An outcome sent on another
+ * connection than the pull (pooled clients) unregisters the sender, not the
+ * owner, so such records would otherwise live as long as the pulling
+ * connection. Runs synchronously from periodic cleanup.
+ * @returns the number of records removed.
+ */
+export declare function pruneEndedClientDeliveries(ctx: ClientOwnershipContext): number;

package/dist/types/src/application/clientTracking.d.ts

@@ -2,28 +2,24 @@
  * Client Tracking - Client-job relationship management
  * Handles job ownership and release on client disconnect
  */
-import type { JobId } from "../domain/types/job.js";
 import type { LockContext } from "./types/index.js";
-/**
- * Register a job as owned by a client (called on PULL).
- */
-export declare function registerClientJob(clientId: string, jobId: JobId, ctx: LockContext): void;
-/**
- * Unregister a job from a client (called on ACK/FAIL).
- */
-export declare function unregisterClientJob(clientId: string | undefined, jobId: JobId, ctx: LockContext): void;
+export { registerClientJob, unregisterClientJob } from "./clientOwnership.js";
 /**
  * Release all jobs owned by a client back to queue (called on TCP disconnect).
  * Returns the number of jobs released.
  *
- * Uses proper locking to prevent race conditions.
+ * Only deliveries the client still owns are touched (`ownsCurrentDelivery`): a
+ * job recovered from this client and delivered again to another worker is not
+ * this client's to release. The rule is checked when collecting and again
+ * under the shard and processing write locks.
  */
 export declare function releaseClientJobs(clientId: string, ctx: LockContext): Promise<number>;
 /**
  * Force-release client tracking without acquiring queue locks.
  * Used as a last-resort fallback when releaseClientJobs has exhausted its
  * retry budget (e.g. persistent lock contention on TCP disconnect). For each
- * orphaned job:
+ * job whose current delivery the client still owns (`ownsCurrentDelivery`;
+ * a stale registration must not expire another worker's delivery):
  *   - clears `jobLocks` so a stale lock token can't survive the disconnect
  *     until its TTL expires;
  *   - expires both `lastHeartbeat` (so stall detection's heartbeat check

package/dist/types/src/application/operations/jobClaim.d.ts

@@ -3,9 +3,9 @@
  * job before its worker can ACK or FAIL it.
  */
 import type { JobId, JobLock } from "../../domain/types/job.js";
-export interface JobClaimContext {
+import { type ClientOwnershipMaps } from "../clientOwnership.js";
+export interface JobClaimContext extends ClientOwnershipMaps {
     jobLocks: Map<JobId, JobLock>;
-    clientJobs: Map<string, Set<JobId>>;
 }
 /**
  * Release the live lease and detach the job from its TCP client owner.

package/dist/types/src/application/operations/jobManagement.d.ts

@@ -10,6 +10,7 @@ import type { WebhookManager } from "../webhookManager.js";
 import type { EventsManager } from "../eventsManager.js";
 import { type RWLock } from "../../shared/lock.js";
 import type { DependencyResultTracker } from "../dependencyResultTracker.js";
+import type { ClientJobOwner } from "../clientOwnership.js";
 import { type DependencyCompletionTracker } from "../dependencyCompletions.js";
 export { discardJob, moveJobToDelayed } from "./jobMoveOperations.js";
 /** Context for job management operations */
@@ -22,6 +23,7 @@ export interface JobManagementContext {
     jobIndex: Map<JobId, JobLocation>;
     jobLocks: Map<JobId, JobLock>;
     clientJobs: Map<string, Set<JobId>>;
+    clientJobOwners: Map<JobId, ClientJobOwner>;
     webhookManager: WebhookManager;
     eventsManager: EventsManager;
     repeatChain?: Map<JobId, JobId>;

package/dist/types/src/application/orphanRecovery.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Orphan Recovery - cleanup's backstop for the stall checker.
+ *
+ * An orphan is an active job that has shown no liveness for longer than both
+ * a 30-minute floor and its own stall window, on a queue whose stall detection
+ * is enabled. It is recovered through the stall path, so anything recovered
+ * here the stall checker would also consider stalled. One difference: like lock
+ * expiration and startup recovery, it treats `maxStalls: 0` as unlimited,
+ * while the stall checker sends a job to the DLQ on its first stall.
+ */
+import type { BackgroundContext } from "./types/index.js";
+/** The shortest silence after which an active job can be an orphan. */
+export declare const ORPHAN_WINDOW_FLOOR_MS: number;
+/**
+ * An orphan is a stalled job the stall checker did not reclaim (for example
+ * its recovery attempt failed on a lock timeout), so it takes the stall
+ * recovery path: concurrency, group and unique-key resources are released,
+ * the attempt is counted, client ownership is detached, and the job is retried
+ * with backoff or moved to the DLQ, persisted and announced like any stalled
+ * job. `handleStalledJob` holds `shardLocks` then `processingLocks`, confirms
+ * the same job object is still processing, and only then re-runs this whole
+ * predicate (configuration included), because a heartbeat, progress update,
+ * lock renewal or stall-config change can land while the sweep waits.
+ */
+export declare function recoverOrphanedProcessingEntries(ctx: BackgroundContext, now: number): Promise<void>;

package/dist/types/src/application/queue-manager/state.d.ts

@@ -19,6 +19,7 @@ import { DependencyCompletionTracker } from "../dependencyCompletions.js";
 import { JobTimeoutScheduler } from "../background/timeouts.js";
 import type { RetiredTimeoutGeneration } from "../types/background.js";
 import { QueueTelemetryJournal } from "../queueTelemetryJournal.js";
+import type { ClientJobOwner } from "../clientOwnership.js";
 export type { QueueManagerConfig };
 export declare abstract class QueueManagerState {
     protected readonly config: typeof DEFAULT_CONFIG & {
@@ -52,6 +53,7 @@ export declare abstract class QueueManagerState {
     protected depFlushRunning: boolean;
     protected readonly jobLocks: Map<JobId, JobLock>;
     protected readonly clientJobs: Map<string, Set<JobId>>;
+    protected readonly clientJobOwners: Map<JobId, ClientJobOwner>;
     protected readonly repeatChain: Map<JobId, JobId>;
     protected readonly failedChildrenValues: Map<JobId, Record<string, string>>;
     protected readonly ignoredChildrenFailures: Map<JobId, Record<string, string>>;

package/dist/types/src/application/stallDetection.d.ts

@@ -2,9 +2,25 @@
  * Stall Detection - Job stall detection and recovery
  * Uses two-phase detection (like BullMQ) to prevent false positives
  */
+import type { Job } from "../domain/types/job.js";
+import { StallAction } from "../domain/types/stall.js";
 import type { BackgroundContext } from "./types/index.js";
 /**
  * Check for stalled jobs and handle them
  * Uses two-phase detection to prevent false positives
  */
 export declare function checkStalledJobs(ctx: BackgroundContext): void;
+/**
+ * Caller-specific condition evaluated with both write locks held, right after
+ * the stall path confirms the same job object is still in processing. Returning
+ * false leaves the job untouched, so a caller can re-verify its own trigger
+ * (for example cleanup's orphan liveness rule) atomically with the transition.
+ */
+export type StallRecheck = (job: Job, now: number) => boolean;
+/**
+ * Recover a stalled job: retry it with the attempt counted and backoff applied,
+ * or move it to the DLQ once attempts are exhausted or `action` says so.
+ * Takes `shardLocks[idx]` then `processingLocks[procIdx]` (lock hierarchy).
+ * @returns true when this call performed the transition.
+ */
+export declare function handleStalledJob(job: Job, action: StallAction, ctx: BackgroundContext, recheck?: StallRecheck): Promise<boolean>;

package/dist/types/src/application/types/contextFactory.d.ts

@@ -1,4 +1,5 @@
 import type { Shard } from "../../domain/queue/shard.js";
+import type { ClientJobOwner } from "../clientOwnership.js";
 import type { FailureReason } from "../../domain/types/dlq.js";
 import type { Job, JobId, JobLock } from "../../domain/types/job.js";
 import type { JobLocation } from "../../domain/types/queue.js";
@@ -41,6 +42,7 @@ export interface ContextDependencies {
     jobLogQueues: Map<JobId, string>;
     jobLocks: Map<JobId, JobLock>;
     clientJobs: Map<string, Set<JobId>>;
+    clientJobOwners: Map<JobId, ClientJobOwner>;
     stalledCandidates: Set<JobId>;
     pendingDepChecks: Set<JobId>;
     pendingQueueAdmissions: Map<string, number>;

package/dist/types/src/application/types/contexts.d.ts

@@ -1,4 +1,5 @@
 import type { Shard } from "../../domain/queue/shard.js";
+import type { ClientJobOwner } from "../clientOwnership.js";
 import type { FailureReason } from "../../domain/types/dlq.js";
 import type { Job, JobId, JobLock } from "../../domain/types/job.js";
 import type { JobLocation } from "../../domain/types/queue.js";
@@ -38,6 +39,7 @@ export interface QueueManagerState {
     readonly retiredCronLeaseTokens: MapLike<JobId, string>;
     readonly timeoutScheduler: JobTimeoutScheduler;
     readonly clientJobs: Map<string, Set<JobId>>;
+    readonly clientJobOwners: Map<JobId, ClientJobOwner>;
     readonly stalledCandidates: Set<JobId>;
     readonly pendingDepChecks: Set<JobId>;
     readonly pendingQueueAdmissions: Map<string, number>;
@@ -70,6 +72,7 @@ export interface LockContext {
     jobLocks: Map<JobId, JobLock>;
     retiredCronLeaseTokens: MapLike<JobId, string>;
     clientJobs: Map<string, Set<JobId>>;
+    clientJobOwners: Map<JobId, ClientJobOwner>;
     processingShards: Map<JobId, Job>[];
     processingLocks: RWLock[];
     shards: Shard[];

package/dist/types/src/application/types/queueManager.d.ts

@@ -1,4 +1,5 @@
 import type { Shard } from "../../domain/queue/shard.js";
+import type { ClientJobOwner } from "../clientOwnership.js";
 import type { DlqEntry } from "../../domain/types/dlq.js";
 import type { FailureReason } from "../../domain/types/dlq.js";
 import type { Job, JobId, JobInput, JobLock } from "../../domain/types/job.js";
@@ -48,6 +49,7 @@ export interface QueueManagerStateView {
     stalledCandidates: Set<JobId>;
     jobLocks: Map<JobId, JobLock>;
     clientJobs: Map<string, Set<JobId>>;
+    clientJobOwners: Map<JobId, ClientJobOwner>;
     repeatChain: Map<JobId, JobId>;
     queueNamesCache: Set<string>;
     eventsManager: EventsManager;

package/dist/types/src/client/forwarder.d.ts

@@ -9,9 +9,10 @@
  * outages and process restarts; memory-only sources provide no such guarantee.
  *
  * Idempotency: every forwarded job carries the deterministic remote jobId
- * `fwd:<localQueueKey>:<localJobId>`. The server dedupes custom jobIds while
- * their ownership is retained; after bounded retention or removal, downstream
- * effects must still tolerate at-least-once delivery.
+ * `fwd:<localQueueKey>:<localJobId>`. The server dedupes a custom jobId only
+ * while that job is live (waiting, delayed or active); completion or the DLQ
+ * releases the id, so a re-forward after that creates a new remote job.
+ * Downstream effects must tolerate at-least-once delivery.
  */
 import { EventEmitter } from 'events';
 import type { ConnectionOptions, QueueOptions } from "./types.js";

package/dist/types/src/client/types/options.d.ts

@@ -5,6 +5,8 @@ export interface ParentOpts {
 export interface BackoffOptions {
     type: 'fixed' | 'exponential';
     delay: number;
+    /** Upper bound for one retry delay in ms (0 to 86,400,000). Defaults to 1 hour. */
+    maxDelay?: number;
 }
 export interface KeepJobs {
     age?: number;

package/dist/types/src/domain/job/constants.d.ts

@@ -10,3 +10,5 @@ export declare const JOB_DEFAULTS: {
     readonly removeOnFail: false;
     readonly stackTraceLimit: 10;
 };
+/** Upper bound accepted for `backoff`, `backoff.delay` and `backoff.maxDelay` (24 hours). */
+export declare const MAX_BACKOFF_DELAY = 86400000;

package/dist/types/src/domain/job/create.d.ts

@@ -1,2 +1,9 @@
 import type { Job, JobId, JobInput } from "../types/jobs/model.js";
+/**
+ * Keep a caller-supplied retry-delay cap only when it is usable. Embedded and
+ * cron admission do not pass through the server validator, so a non-numeric,
+ * non-finite, negative or over-limit value is dropped and the default cap applies
+ * instead of turning the retry delay into NaN or an unbounded wait.
+ */
+export declare function parseMaxDelay(value: unknown): number | undefined;
 export declare function createJob(id: JobId, queue: string, input: JobInput, now?: number): Job;

package/dist/types/src/domain/job/locks.d.ts

@@ -1,4 +1,16 @@
-import type { JobId, JobLock } from "../types/jobs/model.js";
+import type { Job, JobId, JobLock } from "../types/jobs/model.js";
 export declare function createJobLock(jobId: JobId, owner: string, ttl?: number, now?: number): JobLock;
 export declare function isLockExpired(lock: JobLock, now?: number): boolean;
 export declare function renewLock(lock: JobLock, newTtl?: number, now?: number): void;
+/**
+ * True when `lock` was created for an earlier processing generation of `job`,
+ * that is, the job was pulled again after the lease was granted. Stall retry
+ * deliberately keeps the previous lease as a stale-outcome guard, so a lease in
+ * `jobLocks` is not necessarily the current one.
+ *
+ * Pull stamps `startedAt` from a clock read taken before the lease is created
+ * in the same delivery, so a lease from the current pull always has
+ * `createdAt >= startedAt`. The comparison is strict: a lease created in the
+ * same millisecond as the pull belongs to the current generation.
+ */
+export declare function isLeaseFromEarlierGeneration(job: Pick<Job, 'startedAt'>, lock: Pick<JobLock, 'createdAt'>): boolean;

package/dist/types/src/domain/job/state.d.ts

@@ -5,4 +5,19 @@ export declare function isReady(job: Job, now?: number): boolean;
 export declare function isExpired(job: Job, now?: number): boolean;
 export declare function isTimedOut(job: Job, now?: number): boolean;
 export declare function calculateBackoff(job: Job): number;
+/**
+ * Wait applied when a processor throws `DelayedError`. It is always a positive
+ * finite number of milliseconds: DelayedError never counts an attempt, so a zero
+ * wait would let a processor that keeps throwing it re-pull the job in a tight
+ * loop with nothing to stop it.
+ *
+ * The base is the configured delay with no attempt growth and no jitter:
+ * `backoff.delay` for the object form, otherwise the numeric `backoff`. A base
+ * that is not a positive number (0, missing, negative or NaN) falls back to the
+ * 1000 ms default. The base is then capped at `backoff.maxDelay` when that is a
+ * positive finite number, otherwise at DEFAULT_MAX_BACKOFF. A `maxDelay` of 0
+ * means "retry failures immediately" and does not apply here, because
+ * DelayedError is not a failure: such a job waits its capped base delay.
+ */
+export declare function calculateDelayedErrorDelay(job: Pick<Job, 'backoff' | 'backoffConfig'>): number;
 export declare function canRetry(job: Job): boolean;

package/dist/types/src/domain/types/commands/core.d.ts

@@ -1,5 +1,5 @@
 import type { AtomicFlowJobInput } from "../flow.js";
-import type { JobInput } from "../job.js";
+import type { BackoffConfig, JobInput } from "../job.js";
 import type { GroupPullOptions } from "../group.js";
 import type { BaseCommand } from "./base.js";
 export interface PushCommand extends BaseCommand {
@@ -10,10 +10,7 @@ export interface PushCommand extends BaseCommand {
     readonly priority?: number;
     readonly delay?: number;
     readonly maxAttempts?: number;
-    readonly backoff?: number | {
-        type: 'fixed' | 'exponential';
-        delay: number;
-    };
+    readonly backoff?: number | BackoffConfig;
     readonly ttl?: number;
     readonly timeout?: number;
     readonly uniqueKey?: string;

package/dist/types/src/domain/types/cron.d.ts

@@ -1,6 +1,7 @@
 /**
  * Cron job domain types
  */
+import type { BackoffConfig } from "./jobs/model.js";
 /** Deduplication config for cron-spawned jobs */
 export interface CronDedup {
     readonly ttl?: number;
@@ -14,10 +15,7 @@ export interface CronDedup {
  */
 export interface CronJobOptions {
     readonly maxAttempts?: number;
-    readonly backoff?: number | {
-        type: 'fixed' | 'exponential';
-        delay: number;
-    };
+    readonly backoff?: number | BackoffConfig;
     readonly timeout?: number;
     readonly delay?: number;
     readonly stallTimeout?: number;

package/dist/types/src/domain/types/jobs/model.d.ts

@@ -93,10 +93,7 @@ export interface JobInput {
     priority?: number;
     delay?: number;
     maxAttempts?: number;
-    backoff?: number | {
-        type: 'fixed' | 'exponential';
-        delay: number;
-    };
+    backoff?: number | BackoffConfig;
     ttl?: number;
     timeout?: number;
     uniqueKey?: string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bunqueue-client",
-  "version": "0.2.0",
+  "version": "0.2.1",
   "description": "Cross-runtime TypeScript client for the bunqueue job queue server — Node.js, Bun, Deno and Cloudflare Workers",
   "license": "MIT",
   "type": "module",

package/src/index.ts

@@ -22,4 +22,4 @@ export type {
   TelemetryHandler,
 } from './observability.js';
 export { MAX_FRAME_SIZE, PROTOCOL_VERSION } from './frame.js';
-export const __version__ = '0.2.0';
+export const __version__ = '0.2.1';

package/src/legacy.ts

@@ -88,4 +88,4 @@ export type {
 export { Worker } from './worker.js';
 export type { AckBatchOptions, Processor, WorkerEventMap, WorkerOptions } from './worker-types.js';
 
-export const __version__ = '0.2.0';
+export const __version__ = '0.2.1';