bunqueue 2.8.53 → 2.8.56

package/dist/domain/types/cron.js

@@ -1,13 +1,16 @@
 /**
  * Cron job domain types
  */
+import { normalizeJobPayload } from '../job/payload';
 /** Create a new cron job */
 export function createCronJob(input, nextRun) {
     if (!input.schedule && !input.repeatEvery) {
         throw new Error('Cron job must have either schedule or repeatEvery');
     }
+    const payload = normalizeJobPayload({ name: input.jobName, data: input.data });
     return {
         name: input.name,
+        jobName: payload.name,
         queue: input.queue,
         data: input.data,
         schedule: input.schedule ?? null,

package/dist/domain/types/dlq.d.ts

@@ -35,6 +35,23 @@ export interface AttemptRecord {
     /** Duration of this attempt in ms */
     readonly duration: number;
 }
+/** Internal lifecycle state carried while a DLQ auto-retry is live. */
+export interface DlqRetryState {
+    readonly enteredAt: number | null;
+    readonly expiresAt: number | null;
+    readonly attempts: AttemptRecord[];
+    readonly retryCount: number;
+    readonly lastRetryAt: number | null;
+    readonly nextRetryAt: number | null;
+}
+/** Read internal DLQ state without exposing it on the public Job wire shape. */
+export declare function getDlqRetryState(job: Job): DlqRetryState | null;
+/** Restore internal DLQ state from SQLite as a non-enumerable Job property. */
+export declare function setDlqRetryState(job: Job, state: DlqRetryState | null): void;
+/** Retain a non-terminal failed attempt so a later DLQ entry has full history. */
+export declare function recordJobFailureAttempt(job: Job, reason: FailureReason, error: string | null, failedAt?: number): void;
+/** Carry a dispatched DLQ entry through its live auto-retry execution. */
+export declare function retainDlqRetryState(job: Job, entry: DlqEntry): void;
 /** DLQ Entry with full metadata */
 export interface DlqEntry {
     /** Original job */

package/dist/domain/types/dlq.js

@@ -2,6 +2,58 @@
  * Dead Letter Queue Types
  * Enhanced DLQ with metadata, auto-retry, and lifecycle management
  */
+const DLQ_RETRY_STATE = Symbol('bunqueue.dlqRetryState');
+/** Read internal DLQ state without exposing it on the public Job wire shape. */
+export function getDlqRetryState(job) {
+    return job[DLQ_RETRY_STATE] ?? null;
+}
+/** Restore internal DLQ state from SQLite as a non-enumerable Job property. */
+export function setDlqRetryState(job, state) {
+    if (state === null) {
+        delete job[DLQ_RETRY_STATE];
+        return;
+    }
+    Object.defineProperty(job, DLQ_RETRY_STATE, {
+        value: state,
+        writable: true,
+        configurable: true,
+        enumerable: false,
+    });
+}
+function createAttemptRecord(job, reason, error, failedAt = Date.now()) {
+    return {
+        attempt: job.attempts,
+        startedAt: job.startedAt ?? job.createdAt,
+        failedAt,
+        reason,
+        error,
+        duration: job.startedAt ? failedAt - job.startedAt : 0,
+    };
+}
+/** Retain a non-terminal failed attempt so a later DLQ entry has full history. */
+export function recordJobFailureAttempt(job, reason, error, failedAt = Date.now()) {
+    const state = getDlqRetryState(job) ?? {
+        enteredAt: null,
+        expiresAt: null,
+        attempts: [],
+        retryCount: 0,
+        lastRetryAt: null,
+        nextRetryAt: null,
+    };
+    state.attempts.push(createAttemptRecord(job, reason, error, failedAt));
+    setDlqRetryState(job, state);
+}
+/** Carry a dispatched DLQ entry through its live auto-retry execution. */
+export function retainDlqRetryState(job, entry) {
+    setDlqRetryState(job, {
+        enteredAt: entry.enteredAt,
+        expiresAt: entry.expiresAt,
+        attempts: [...entry.attempts],
+        retryCount: entry.retryCount,
+        lastRetryAt: entry.lastRetryAt,
+        nextRetryAt: entry.nextRetryAt,
+    });
+}
 /** Default DLQ configuration */
 export const DEFAULT_DLQ_CONFIG = {
     autoRetry: false,
@@ -13,24 +65,28 @@ export const DEFAULT_DLQ_CONFIG = {
 /** Create a DLQ entry from a failed job */
 export function createDlqEntry(job, reason, error, config = DEFAULT_DLQ_CONFIG) {
     const now = Date.now();
-    const attemptRecord = {
-        attempt: job.attempts,
-        startedAt: job.startedAt ?? job.createdAt,
-        failedAt: now,
-        reason,
-        error,
-        duration: job.startedAt ? now - job.startedAt : 0,
-    };
+    const retained = getDlqRetryState(job);
+    const alreadyEntered = retained?.enteredAt !== null && retained?.enteredAt !== undefined;
+    const attemptRecord = createAttemptRecord(job, reason, error, now);
+    setDlqRetryState(job, null);
     return {
         job,
-        enteredAt: now,
+        enteredAt: alreadyEntered ? retained.enteredAt : now,
         reason,
         error,
-        attempts: [attemptRecord],
-        retryCount: 0,
-        lastRetryAt: null,
-        nextRetryAt: config.autoRetry ? now + config.autoRetryInterval : null,
-        expiresAt: config.maxAge ? now + config.maxAge : null,
+        attempts: [...(retained?.attempts ?? []), attemptRecord],
+        retryCount: retained?.retryCount ?? 0,
+        lastRetryAt: retained?.lastRetryAt ?? null,
+        nextRetryAt: alreadyEntered
+            ? retained.nextRetryAt
+            : config.autoRetry
+                ? now + config.autoRetryInterval
+                : null,
+        expiresAt: alreadyEntered
+            ? retained.expiresAt
+            : config.maxAge !== null
+                ? now + config.maxAge
+                : null,
     };
 }
 /** Add attempt record to existing DLQ entry */

package/dist/domain/types/index.d.ts

@@ -3,6 +3,8 @@
  */
 export * from './job';
 export type * from './command';
+export type * from './metrics';
 export * from './response';
 export * from './queue';
 export * from './cron';
+export * from './protocol';

package/dist/domain/types/index.js

@@ -5,3 +5,4 @@ export * from './job';
 export * from './response';
 export * from './queue';
 export * from './cron';
+export * from './protocol';

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

@@ -1,269 +1,8 @@
-/**
- * Job domain types
- * Core job structure and related types
- */
-/** Branded type for Job IDs (UUIDv7) */
-export type JobId = string & {
-    readonly __brand: 'JobId';
-};
-/** Create a JobId from string */
-export declare function jobId(id: string): JobId;
-/** Generate a new UUIDv7 JobId */
-export declare function generateJobId(): JobId;
-/** Job state enumeration */
-export declare const enum JobState {
-    Waiting = "waiting",
-    Prioritized = "prioritized",
-    Delayed = "delayed",
-    Active = "active",
-    Completed = "completed",
-    Failed = "failed"
-}
-/** Repeat configuration for repeatable jobs */
-export interface RepeatConfig {
-    /** Repeat every N milliseconds */
-    readonly every?: number;
-    /** Maximum number of repetitions (null = infinite) */
-    readonly limit?: number;
-    /** Cron pattern (alternative to every) */
-    readonly pattern?: string;
-    /** Current repeat count */
-    count: number;
-    /** Start date timestamp */
-    readonly startDate?: number;
-    /** End date timestamp */
-    readonly endDate?: number;
-    /** Timezone for cron pattern */
-    readonly tz?: string;
-    /** Execute immediately on start */
-    readonly immediately?: boolean;
-    /** Previous execution timestamp */
-    prevMillis?: number;
-    /** Offset in milliseconds */
-    readonly offset?: number;
-    /** Custom job ID for repeat jobs */
-    readonly jobId?: string;
-}
-/** Backoff configuration */
-export interface BackoffConfig {
-    /** Backoff strategy type */
-    readonly type: 'fixed' | 'exponential';
-    /** Base delay in milliseconds */
-    readonly delay: number;
-    /** Maximum delay in milliseconds (default: 3600000 = 1 hour) */
-    readonly maxDelay?: number;
-}
-/** Default maximum backoff delay: 1 hour */
-export declare const DEFAULT_MAX_BACKOFF = 3600000;
-/** Timeline entry — tracks each state transition */
-export interface JobTimelineEntry {
-    readonly state: string;
-    readonly timestamp: number;
-    readonly worker?: string;
-    readonly error?: string;
-    readonly attempt?: number;
-}
-/** Max timeline entries per job (prevents unbounded growth) */
-export declare const MAX_TIMELINE_ENTRIES = 20;
-/** Core job structure */
-export interface Job {
-    readonly id: JobId;
-    readonly queue: string;
-    readonly data: unknown;
-    readonly priority: number;
-    readonly createdAt: number;
-    readonly lifo: boolean;
-    runAt: number;
-    startedAt: number | null;
-    completedAt: number | null;
-    attempts: number;
-    readonly maxAttempts: number;
-    /** Backoff delay in ms or backoff configuration */
-    readonly backoff: number;
-    /** Backoff configuration (if using object-based backoff) */
-    readonly backoffConfig: BackoffConfig | null;
-    readonly ttl: number | null;
-    readonly timeout: number | null;
-    readonly uniqueKey: string | null;
-    readonly customId: string | null;
-    readonly dependsOn: JobId[];
-    readonly parentId: JobId | null;
-    childrenIds: JobId[];
-    childrenCompleted: number;
-    readonly tags: string[];
-    readonly groupId: string | null;
-    progress: number;
-    progressMessage: string | null;
-    /** Last failure's stack trace lines (trimmed, capped at stackTraceLimit). Null until a FAIL carries a stack. (#74) */
-    stacktrace: string[] | null;
-    readonly removeOnComplete: boolean;
-    readonly removeOnFail: boolean;
-    readonly repeat: RepeatConfig | null;
-    lastHeartbeat: number;
-    readonly stallTimeout: number | null;
-    stallCount: number;
-    /** Maximum stack trace lines to store */
-    readonly stackTraceLimit: number;
-    /** Maximum number of log entries to keep */
-    readonly keepLogs: number | null;
-    /** Maximum job data size in bytes */
-    readonly sizeLimit: number | null;
-    /** Fail parent job if this child job fails */
-    readonly failParentOnFailure: boolean;
-    /** Remove dependency relationship if this job fails */
-    readonly removeDependencyOnFailure: boolean;
-    /** Continue parent processing even if this child fails */
-    readonly continueParentOnFailure: boolean;
-    /** Move job to parent's failed dependencies instead of blocking parent */
-    readonly ignoreDependencyOnFailure: boolean;
-    /** Deduplication TTL in milliseconds */
-    readonly deduplicationTtl: number | null;
-    /** Extend deduplication TTL on duplicate */
-    readonly deduplicationExtend: boolean;
-    /** Replace job data on duplicate while in delayed state */
-    readonly deduplicationReplace: boolean;
-    /** Debounce ID */
-    readonly debounceId: string | null;
-    /** Debounce TTL in milliseconds */
-    readonly debounceTtl: number | null;
-    /** State transition timeline (in-memory only, not persisted to SQLite) */
-    timeline: JobTimelineEntry[];
-}
-/** Input for creating a new job */
-export interface JobInput {
-    data: unknown;
-    priority?: number;
-    delay?: number;
-    maxAttempts?: number;
-    /** Backoff delay in ms or backoff configuration */
-    backoff?: number | {
-        type: 'fixed' | 'exponential';
-        delay: number;
-    };
-    ttl?: number;
-    timeout?: number;
-    uniqueKey?: string;
-    customId?: string;
-    dependsOn?: JobId[];
-    childrenIds?: JobId[];
-    parentId?: JobId;
-    tags?: string[];
-    groupId?: string;
-    lifo?: boolean;
-    removeOnComplete?: boolean;
-    removeOnFail?: boolean;
-    stallTimeout?: number;
-    repeat?: {
-        every?: number;
-        limit?: number;
-        pattern?: string;
-        /** Current count (for internal use when re-queueing) */
-        count?: number;
-        /** Start date timestamp */
-        startDate?: number;
-        /** End date timestamp */
-        endDate?: number;
-        /** Timezone for cron pattern */
-        tz?: string;
-        /** Execute immediately on start */
-        immediately?: boolean;
-        /** Previous execution timestamp */
-        prevMillis?: number;
-        /** Offset in milliseconds */
-        offset?: number;
-        /** Custom job ID for repeat jobs */
-        jobId?: string;
-    };
-    /** Advanced deduplication options */
-    dedup?: {
-        /** TTL for unique key in milliseconds */
-        ttl?: number;
-        /** Extend TTL on duplicate instead of rejecting */
-        extend?: boolean;
-        /** Replace job data on duplicate instead of rejecting */
-        replace?: boolean;
-    };
-    /**
-     * Force immediate persistence to disk (bypass write buffer).
-     * Use for critical jobs where data loss is unacceptable.
-     * Default: false (uses buffered writes for better throughput)
-     */
-    durable?: boolean;
-    /** Maximum stack trace lines to store */
-    stackTraceLimit?: number;
-    /** Maximum number of log entries to keep */
-    keepLogs?: number;
-    /** Maximum job data size in bytes */
-    sizeLimit?: number;
-    /** Fail parent job if this child job fails */
-    failParentOnFailure?: boolean;
-    /** Remove dependency relationship if this job fails */
-    removeDependencyOnFailure?: boolean;
-    /** Continue parent processing even if this child fails */
-    continueParentOnFailure?: boolean;
-    /** Move job to parent's failed dependencies instead of blocking parent */
-    ignoreDependencyOnFailure?: boolean;
-    /** Debounce ID */
-    debounceId?: string;
-    /** Debounce TTL in milliseconds */
-    debounceTtl?: number;
-    /** Job creation timestamp (default: Date.now()) */
-    timestamp?: number;
-}
-/** Job creation defaults */
-export declare const JOB_DEFAULTS: {
-    readonly priority: 0;
-    readonly maxAttempts: 3;
-    readonly backoff: 1000;
-    readonly lifo: false;
-    readonly removeOnComplete: false;
-    readonly removeOnFail: false;
-    readonly stackTraceLimit: 10;
-};
-/** Create a new job from input */
-export declare function createJob(id: JobId, queue: string, input: JobInput, now?: number): Job;
-/**
- * Normalize raw stack lines for persistence: keep only strings, trim, drop
- * empties, cap at `limit` (job.stackTraceLimit). Returns null when nothing
- * remains (e.g. stackTraceLimit: 0), matching the 2.6.110 event semantics. (#74)
- */
-export declare function normalizeStacktrace(lines: readonly unknown[] | undefined, limit: number): string[] | null;
-/** Check if job is delayed */
-export declare function isDelayed(job: Job, now?: number): boolean;
-/** Check if job is ready to process */
-export declare function isReady(job: Job, now?: number): boolean;
-/** Check if job is expired (TTL exceeded) */
-export declare function isExpired(job: Job, now?: number): boolean;
-/** Check if job has timed out during processing */
-export declare function isTimedOut(job: Job, now?: number): boolean;
-/** Calculate next retry delay with backoff strategy, jitter, and max cap */
-export declare function calculateBackoff(job: Job): number;
-/** Check if job can retry */
-export declare function canRetry(job: Job): boolean;
-/** Lock token type (UUID) */
-export type LockToken = string & {
-    readonly __brand: 'LockToken';
-};
-/** Create a LockToken from string */
-export declare function lockToken(token: string): LockToken;
-/** Generate a new lock token */
-export declare function generateLockToken(): LockToken;
-/** Job lock structure - tracks ownership of job processing */
-export interface JobLock {
-    readonly jobId: JobId;
-    readonly token: LockToken;
-    readonly owner: string;
-    readonly createdAt: number;
-    expiresAt: number;
-    lastRenewalAt: number;
-    renewalCount: number;
-    readonly ttl: number;
-}
-/** Default lock TTL in milliseconds (30 seconds like BullMQ) */
-export declare const DEFAULT_LOCK_TTL = 30000;
-/** Create a new job lock */
-export declare function createJobLock(jobId: JobId, owner: string, ttl?: number, now?: number): JobLock;
-/** Check if lock is expired */
-export declare function isLockExpired(lock: JobLock, now?: number): boolean;
-/** Renew a lock, extending its expiration */
-export declare function renewLock(lock: JobLock, newTtl?: number, now?: number): void;
+/** Stable import surface for job types and domain operations. */
+export * from './jobs/model';
+export * from '../job/constants';
+export * from '../job/create';
+export * from '../job/ids';
+export * from '../job/locks';
+export * from '../job/payload';
+export * from '../job/state';

package/dist/domain/types/job.js

@@ -1,234 +1,8 @@
-/**
- * Job domain types
- * Core job structure and related types
- */
-/** Create a JobId from string */
-export function jobId(id) {
-    return id;
-}
-/** Generate a new UUIDv7 JobId */
-export function generateJobId() {
-    return Bun.randomUUIDv7();
-}
-/** Default maximum backoff delay: 1 hour */
-export const DEFAULT_MAX_BACKOFF = 3_600_000;
-/** Max timeline entries per job (prevents unbounded growth) */
-export const MAX_TIMELINE_ENTRIES = 20;
-/** Job creation defaults */
-export const JOB_DEFAULTS = {
-    priority: 0,
-    maxAttempts: 3,
-    backoff: 1000,
-    lifo: false,
-    removeOnComplete: false,
-    removeOnFail: false,
-    stackTraceLimit: 10,
-};
-/** Parse backoff from input (can be number or object) */
-function parseBackoff(input) {
-    if (typeof input === 'object') {
-        return {
-            backoff: input.delay,
-            backoffConfig: { type: input.type, delay: input.delay },
-        };
-    }
-    return { backoff: input ?? JOB_DEFAULTS.backoff, backoffConfig: null };
-}
-/** Parse repeat config from input */
-function parseRepeatConfig(repeat) {
-    if (!repeat)
-        return null;
-    return {
-        every: repeat.every,
-        limit: repeat.limit,
-        pattern: repeat.pattern,
-        count: repeat.count ?? 0,
-        startDate: repeat.startDate,
-        endDate: repeat.endDate,
-        tz: repeat.tz,
-        immediately: repeat.immediately,
-        prevMillis: repeat.prevMillis,
-        offset: repeat.offset,
-        jobId: repeat.jobId,
-    };
-}
-/** Parse core job options with defaults */
-/** Coerce a wire value to boolean. The JobInput boundary is not type-safe at
- * runtime — a hand-crafted/legacy client can send a non-boolean. See issue #90. */
-function toBoolean(value, fallback) {
-    return value === undefined ? fallback : Boolean(value);
-}
-function parseCoreOptions(input) {
-    return {
-        priority: input.priority ?? JOB_DEFAULTS.priority,
-        lifo: input.lifo ?? JOB_DEFAULTS.lifo,
-        maxAttempts: input.maxAttempts ?? JOB_DEFAULTS.maxAttempts,
-        // Coerce to boolean: a stray number/object forwarded over the wire must not
-        // persist as a non-boolean and diverge from embedded mode. See issue #90.
-        removeOnComplete: toBoolean(input.removeOnComplete, JOB_DEFAULTS.removeOnComplete),
-        removeOnFail: toBoolean(input.removeOnFail, JOB_DEFAULTS.removeOnFail),
-    };
-}
-/** Parse optional fields (nullable) */
-function parseOptionalFields(input) {
-    return {
-        ttl: input.ttl ?? null,
-        timeout: input.timeout ?? null,
-        uniqueKey: input.uniqueKey ?? null,
-        customId: input.customId ?? null,
-        parentId: input.parentId ?? null,
-        groupId: input.groupId ?? null,
-        stallTimeout: input.stallTimeout ?? null,
-    };
-}
-/** Parse BullMQ v5 specific options */
-function parseBullMQV5Options(input) {
-    return {
-        stackTraceLimit: input.stackTraceLimit ?? JOB_DEFAULTS.stackTraceLimit,
-        keepLogs: input.keepLogs ?? null,
-        sizeLimit: input.sizeLimit ?? null,
-        failParentOnFailure: input.failParentOnFailure ?? false,
-        removeDependencyOnFailure: input.removeDependencyOnFailure ?? false,
-        continueParentOnFailure: input.continueParentOnFailure ?? false,
-        ignoreDependencyOnFailure: input.ignoreDependencyOnFailure ?? false,
-        deduplicationTtl: input.dedup?.ttl ?? null,
-        deduplicationExtend: input.dedup?.extend ?? false,
-        deduplicationReplace: input.dedup?.replace ?? false,
-        debounceId: input.debounceId ?? null,
-        debounceTtl: input.debounceTtl ?? null,
-    };
-}
-/** Create a new job from input */
-export function createJob(id, queue, input, now = Date.now()) {
-    const { backoff, backoffConfig } = parseBackoff(input.backoff);
-    const coreOpts = parseCoreOptions(input);
-    const optionalFields = parseOptionalFields(input);
-    const v5Opts = parseBullMQV5Options(input);
-    const createdAt = input.timestamp ?? now;
-    return {
-        id,
-        queue,
-        data: input.data,
-        createdAt,
-        runAt: createdAt + (input.delay ?? 0),
-        startedAt: null,
-        completedAt: null,
-        attempts: 0,
-        backoff,
-        backoffConfig,
-        dependsOn: input.dependsOn ?? [],
-        childrenIds: input.childrenIds ?? [],
-        childrenCompleted: 0,
-        tags: input.tags ?? [],
-        progress: 0,
-        progressMessage: null,
-        stacktrace: null,
-        repeat: parseRepeatConfig(input.repeat),
-        lastHeartbeat: createdAt,
-        stallCount: 0,
-        ...coreOpts,
-        ...optionalFields,
-        ...v5Opts,
-        timeline: [],
-    };
-}
-/**
- * Normalize raw stack lines for persistence: keep only strings, trim, drop
- * empties, cap at `limit` (job.stackTraceLimit). Returns null when nothing
- * remains (e.g. stackTraceLimit: 0), matching the 2.6.110 event semantics. (#74)
- */
-export function normalizeStacktrace(lines, limit) {
-    if (!lines || lines.length === 0)
-        return null;
-    const out = [];
-    for (const line of lines) {
-        if (out.length >= limit)
-            break;
-        if (typeof line !== 'string')
-            continue;
-        const trimmed = line.trim();
-        if (trimmed)
-            out.push(trimmed);
-    }
-    return out.length > 0 ? out : null;
-}
-/** Check if job is delayed */
-export function isDelayed(job, now = Date.now()) {
-    return job.runAt > now;
-}
-/** Check if job is ready to process */
-export function isReady(job, now = Date.now()) {
-    return job.runAt <= now;
-}
-/** Check if job is expired (TTL exceeded) */
-export function isExpired(job, now = Date.now()) {
-    if (job.ttl === null)
-        return false;
-    return now > job.createdAt + job.ttl;
-}
-/** Check if job has timed out during processing */
-export function isTimedOut(job, now = Date.now()) {
-    if (job.timeout === null || job.startedAt === null)
-        return false;
-    return now > job.startedAt + job.timeout;
-}
-/** Calculate next retry delay with backoff strategy, jitter, and max cap */
-export function calculateBackoff(job) {
-    const maxDelay = job.backoffConfig?.maxDelay ?? DEFAULT_MAX_BACKOFF;
-    if (job.backoffConfig) {
-        if (job.backoffConfig.type === 'fixed') {
-            // Fixed backoff with ±20% jitter
-            const base = job.backoffConfig.delay;
-            const jittered = base * (0.8 + Math.random() * 0.4);
-            return Math.min(jittered, maxDelay);
-        }
-        else {
-            // Exponential backoff with ±50% jitter
-            const base = job.backoffConfig.delay * Math.pow(2, job.attempts);
-            const jittered = base * (0.5 + Math.random());
-            return Math.min(jittered, maxDelay);
-        }
-    }
-    // Default: exponential backoff with ±50% jitter and max cap
-    const base = job.backoff * Math.pow(2, job.attempts);
-    const jittered = base * (0.5 + Math.random());
-    return Math.min(jittered, maxDelay);
-}
-/** Check if job can retry */
-export function canRetry(job) {
-    return job.attempts < job.maxAttempts;
-}
-/** Create a LockToken from string */
-export function lockToken(token) {
-    return token;
-}
-/** Generate a new lock token */
-export function generateLockToken() {
-    return Bun.randomUUIDv7();
-}
-/** Default lock TTL in milliseconds (30 seconds like BullMQ) */
-export const DEFAULT_LOCK_TTL = 30_000;
-/** Create a new job lock */
-export function createJobLock(jobId, owner, ttl = DEFAULT_LOCK_TTL, now = Date.now()) {
-    return {
-        jobId,
-        token: generateLockToken(),
-        owner,
-        createdAt: now,
-        expiresAt: now + ttl,
-        lastRenewalAt: now,
-        renewalCount: 0,
-        ttl,
-    };
-}
-/** Check if lock is expired */
-export function isLockExpired(lock, now = Date.now()) {
-    return now >= lock.expiresAt;
-}
-/** Renew a lock, extending its expiration */
-export function renewLock(lock, newTtl, now = Date.now()) {
-    const ttl = newTtl ?? lock.ttl;
-    lock.expiresAt = now + ttl;
-    lock.lastRenewalAt = now;
-    lock.renewalCount++;
-}
+/** Stable import surface for job types and domain operations. */
+export * from './jobs/model';
+export * from '../job/constants';
+export * from '../job/create';
+export * from '../job/ids';
+export * from '../job/locks';
+export * from '../job/payload';
+export * from '../job/state';