bunqueue-client 0.2.0 → 0.2.1

package/dist/embedded.js

@@ -199,1069 +199,1409 @@ async function withWriteLock(lock, fn, timeoutMs) {
   }
 }
 
-// ../../src/application/dependencyCompletions.ts
-class DependencyCompletionTracker {
-  onRecentEvict;
-  recent = new Set;
-  recentOrder = [];
-  recentOrderTokens = [];
-  recentTokens = new Map;
-  recentOrderHead = 0;
-  nextRecentToken = 0;
-  pinned = new Set;
-  owners = new Map;
-  maxRecent;
-  constructor(maxRecent, onRecentEvict) {
-    this.onRecentEvict = onRecentEvict;
-    this.maxRecent = Math.max(1, Math.trunc(maxRecent));
-  }
-  add(jobId, queue) {
-    if (queue !== undefined)
-      this.owners.set(jobId, queue);
-    if (this.pinned.has(jobId) || this.recent.has(jobId))
-      return;
-    if (this.recent.size >= this.maxRecent)
-      this.evictOldestRecent();
-    if (this.nextRecentToken >= Number.MAX_SAFE_INTEGER)
-      this.compactRecentOrder(true);
-    const token = this.nextRecentToken++;
-    this.recent.add(jobId);
-    this.recentTokens.set(jobId, token);
-    this.recentOrder.push(jobId);
-    this.recentOrderTokens.push(token);
-  }
-  pin(jobId, queue) {
-    if (queue !== undefined)
-      this.owners.set(jobId, queue);
-    if (this.recent.delete(jobId)) {
-      this.recentTokens.delete(jobId);
-      this.compactRecentOrder();
-    }
-    this.pinned.add(jobId);
-  }
-  unpin(jobId, retainAsRecent) {
-    this.pinned.delete(jobId);
-    if (retainAsRecent)
-      this.add(jobId);
-    else
-      this.delete(jobId);
-  }
-  hydrate(records) {
-    this.clear();
-    for (const record of records) {
-      if (record.pinned)
-        this.pin(record.jobId, record.queue);
-      else
-        this.add(record.jobId, record.queue);
-    }
-  }
-  pinnedValues() {
-    return this.pinned.values();
-  }
-  has(jobId) {
-    return this.pinned.has(jobId) || this.recent.has(jobId);
-  }
-  delete(jobId) {
-    const wasPinned = this.pinned.delete(jobId);
-    const wasRecent = this.recent.delete(jobId);
-    if (wasRecent) {
-      this.recentTokens.delete(jobId);
-      this.compactRecentOrder();
-    }
-    this.owners.delete(jobId);
-    return wasRecent || wasPinned;
-  }
-  deleteForQueue(queue) {
-    const removed = [];
-    for (const [jobId, owner] of this.owners) {
-      if (owner !== queue)
-        continue;
-      if (this.delete(jobId))
-        removed.push(jobId);
-    }
-    return removed;
-  }
-  clear() {
-    this.recent.clear();
-    this.recentOrder = [];
-    this.recentOrderTokens = [];
-    this.recentTokens.clear();
-    this.recentOrderHead = 0;
-    this.nextRecentToken = 0;
-    this.pinned.clear();
-    this.owners.clear();
-  }
-  get size() {
-    return this.recent.size + this.pinned.size;
-  }
-  evictOldestRecent() {
-    while (this.recentOrderHead < this.recentOrder.length) {
-      const index = this.recentOrderHead++;
-      const oldest = this.recentOrder[index];
-      const token = this.recentOrderTokens[index];
-      if (this.recentTokens.get(oldest) !== token)
-        continue;
-      this.recent.delete(oldest);
-      this.recentTokens.delete(oldest);
-      this.owners.delete(oldest);
-      this.compactRecentOrder();
-      this.onRecentEvict?.(oldest);
-      return;
-    }
+// ../../src/application/clientOwnership.ts
+function removeFromClient(clientId, jobId, ctx) {
+  const jobs = ctx.clientJobs.get(clientId);
+  if (!jobs)
+    return;
+  jobs.delete(jobId);
+  if (jobs.size === 0)
+    ctx.clientJobs.delete(clientId);
+}
+function registerClientJob(clientId, jobId, ctx) {
+  const previous = ctx.clientJobOwners.get(jobId);
+  if (previous && previous.clientId !== clientId) {
+    removeFromClient(previous.clientId, jobId, ctx);
   }
-  compactRecentOrder(force = false) {
-    const pending = this.recentOrder.length - this.recentOrderHead;
-    if (!force && this.recentOrderHead < this.maxRecent && pending < this.maxRecent * 2)
-      return;
-    const order = [];
-    const tokens = [];
-    for (let index = this.recentOrderHead;index < this.recentOrder.length; index++) {
-      const jobId = this.recentOrder[index];
-      const token = this.recentOrderTokens[index];
-      if (this.recentTokens.get(jobId) !== token)
-        continue;
-      const compactedToken = order.length;
-      order.push(jobId);
-      tokens.push(compactedToken);
-    }
-    this.recentTokens.clear();
-    for (let index = 0;index < order.length; index++) {
-      this.recentTokens.set(order[index], tokens[index]);
-    }
-    this.recentOrder = order;
-    this.recentOrderTokens = tokens;
-    this.recentOrderHead = 0;
-    this.nextRecentToken = order.length;
+  ctx.clientJobOwners.set(jobId, { clientId, delivery: ctx.jobIndex.get(jobId) });
+  let jobs = ctx.clientJobs.get(clientId);
+  if (!jobs) {
+    jobs = new Set;
+    ctx.clientJobs.set(clientId, jobs);
   }
+  jobs.add(jobId);
 }
-function hasDependencyWaiters(shards, jobId) {
-  return shards.some((shard) => (shard.getJobsWaitingFor(jobId)?.size ?? 0) > 0);
-}
-function commitRemovedCompletion(job, ctx, completedAt = Date.now()) {
-  const pinned = hasDependencyWaiters(ctx.shards, job.id);
-  ctx.storage?.commitRemovedCompletion(job, ctx.maxDependencyCompletions, pinned, completedAt);
-  if (pinned)
-    ctx.depCompletions?.pin(job.id, job.queue);
-  else
-    ctx.depCompletions?.add(job.id, job.queue);
+function unregisterClientJob(clientId, jobId, ctx) {
+  if (!clientId)
+    return;
+  removeFromClient(clientId, jobId, ctx);
+  if (ctx.clientJobOwners.get(jobId)?.clientId === clientId)
+    ctx.clientJobOwners.delete(jobId);
 }
-function releaseDependencyCompletionPins(dependencyIds, ctx) {
-  const candidates = [...new Set(dependencyIds)].filter((id) => !hasDependencyWaiters(ctx.shards, id));
-  if (candidates.length === 0)
+function detachClientJob(jobId, ctx) {
+  const owner = ctx.clientJobOwners.get(jobId);
+  if (!owner)
     return;
-  if (ctx.storage) {
-    const records = ctx.storage.unpinDependencyCompletions(candidates, ctx.maxDependencyCompletions);
-    ctx.depCompletions?.hydrate(records);
+  ctx.clientJobOwners.delete(jobId);
+  removeFromClient(owner.clientId, jobId, ctx);
+}
+function ownsCurrentDelivery(clientId, jobId, ctx) {
+  const owner = ctx.clientJobOwners.get(jobId);
+  if (owner?.clientId !== clientId)
+    return false;
+  const location = ctx.jobIndex.get(jobId);
+  return location?.type === "processing" && location === owner.delivery;
+}
+function dropClient(clientId, ctx) {
+  const jobs = ctx.clientJobs.get(clientId);
+  ctx.clientJobs.delete(clientId);
+  if (!jobs)
     return;
+  for (const jobId of jobs) {
+    if (ctx.clientJobOwners.get(jobId)?.clientId === clientId)
+      ctx.clientJobOwners.delete(jobId);
   }
-  for (const id of candidates)
-    ctx.depCompletions?.unpin(id, true);
 }
-function reconcileDependencyCompletionPins(ctx) {
-  const referenced = new Set;
-  for (const shard of ctx.shards) {
-    for (const dependencyId of shard.dependencyIndex.keys())
-      referenced.add(dependencyId);
-  }
-  if (ctx.storage) {
-    const records = ctx.storage.reconcileDependencyCompletionPins(referenced, ctx.maxDependencyCompletions);
-    ctx.depCompletions?.hydrate(records);
-    return;
+function pruneEndedClientDeliveries(ctx) {
+  let pruned = 0;
+  for (const [jobId, owner] of ctx.clientJobOwners) {
+    const location = ctx.jobIndex.get(jobId);
+    if (location?.type === "processing" && location === owner.delivery)
+      continue;
+    ctx.clientJobOwners.delete(jobId);
+    removeFromClient(owner.clientId, jobId, ctx);
+    pruned++;
   }
-  for (const id of ctx.depCompletions?.pinnedValues() ?? []) {
-    if (!referenced.has(id))
-      ctx.depCompletions?.unpin(id, true);
+  return pruned;
+}
+// ../../src/domain/job/constants.ts
+var DEFAULT_MAX_BACKOFF = 3600000;
+var MAX_TIMELINE_ENTRIES = 20;
+var DEFAULT_LOCK_TTL = 30000;
+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;
+function legacyEnvelope(data) {
+  if (typeof data !== "object" || data === null || Array.isArray(data))
+    return null;
+  const record = data;
+  if (typeof record.name !== "string")
+    return null;
+  const { name, ...userData } = record;
+  return { name, data: userData };
+}
+function validateJobName(name) {
+  if (typeof name !== "string" || name.length === 0 || name.length > MAX_JOB_NAME_LENGTH) {
+    return "Job name must be a non-empty string of at most 256 characters";
   }
+  return null;
 }
-
-// ../../src/shared/serialization.ts
-function compareSqliteBinaryText(left, right) {
-  if (left === right)
-    return 0;
-  let leftIndex = 0;
-  let rightIndex = 0;
-  while (leftIndex < left.length && rightIndex < right.length) {
-    const leftPoint = left.codePointAt(leftIndex);
-    const rightPoint = right.codePointAt(rightIndex);
-    if (leftPoint === undefined || rightPoint === undefined)
-      break;
-    if (leftPoint !== rightPoint)
-      return leftPoint - rightPoint;
-    leftIndex += leftPoint > 65535 ? 2 : 1;
-    rightIndex += rightPoint > 65535 ? 2 : 1;
+function checkedName(name) {
+  const error = validateJobName(name);
+  if (error)
+    throw new Error(error);
+  return name;
+}
+function normalizeJobPayload(source, fallback = DEFAULT_JOB_NAME) {
+  if (source.name !== undefined) {
+    return { name: checkedName(source.name), data: source.data, legacy: false };
   }
-  return left.length - leftIndex - (right.length - rightIndex);
+  return { name: checkedName(fallback), data: source.data, legacy: false };
+}
+function normalizeLegacyJobPayload(source, fallback = DEFAULT_JOB_NAME) {
+  if (source.name !== undefined)
+    return normalizeJobPayload(source, fallback);
+  const legacy = legacyEnvelope(source.data);
+  if (legacy)
+    return { name: checkedName(legacy.name), data: legacy.data, legacy: true };
+  return { name: checkedName(fallback), data: source.data, legacy: false };
 }
 
-// ../../src/application/completedCleanup.ts
-function memoryCandidates(queue, completedBefore, limit, ctx) {
-  return [...ctx.jobIndex].flatMap(([jobId, location]) => {
-    if (location.type !== "completed")
-      return [];
-    if (queue !== null && location.queueName !== queue)
-      return [];
-    if (ctx.dependencyResults.hasConsumers(jobId))
-      return [];
-    const job = ctx.completedJobsData.get(jobId);
-    const timestamp = job?.completedAt ?? job?.createdAt ?? 0;
-    return timestamp <= completedBefore ? [{ jobId, timestamp }] : [];
-  }).sort((left, right) => left.timestamp - right.timestamp || compareSqliteBinaryText(left.jobId, right.jobId)).slice(0, limit).map(({ jobId }) => ({ jobId, queue: ctx.jobIndex.get(jobId)?.queueName ?? "" }));
+// ../../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;
 }
-function cleanCompletedJobs(queue, completedBefore, limit, ctx) {
-  const normalizedLimit = Number.isFinite(limit) ? Math.max(0, Math.trunc(limit)) : 0;
-  if (normalizedLimit === 0 || !Number.isFinite(completedBefore))
-    return [];
-  const removals = ctx.storage ? ctx.storage.cleanCompletedJobs(queue, completedBefore, normalizedLimit, (jobId) => ctx.dependencyResults.hasConsumers(jobId)) : memoryCandidates(queue, completedBefore, normalizedLimit, ctx);
-  for (const { jobId, queue: ownerQueue } of removals) {
-    const location = ctx.jobIndex.get(jobId);
-    const ownsCurrentCompletion = location?.type === "completed" && location.queueName === ownerQueue;
-    const hasNoCurrentGeneration = location === undefined;
-    const resultOwner = ctx.jobResultQueues?.get(jobId);
-    if (resultOwner === ownerQueue || resultOwner === undefined && ownsCurrentCompletion) {
-      ctx.jobResults?.delete(jobId);
-      ctx.jobResultQueues?.delete(jobId);
-    }
-    const logOwner = ctx.jobLogQueues?.get(jobId);
-    if (logOwner === ownerQueue || logOwner === undefined && ownsCurrentCompletion) {
-      ctx.jobLogs?.delete(jobId);
-      ctx.jobLogQueues?.delete(jobId);
-    }
-    if (!hasNoCurrentGeneration && !ownsCurrentCompletion)
-      continue;
-    ctx.completedJobs.delete(jobId);
-    ctx.completedJobsData.delete(jobId);
-    ctx.jobIndex.delete(jobId);
-    ctx.dependencyResults.releaseConsumer(jobId);
+function parseBackoff(input) {
+  if (typeof input === "object" && input !== null) {
+    const maxDelay = parseMaxDelay(input.maxDelay);
+    return {
+      backoff: input.delay,
+      backoffConfig: maxDelay === undefined ? { type: input.type, delay: input.delay } : { type: input.type, delay: input.delay, maxDelay }
+    };
   }
-  return removals.map(({ jobId }) => jobId);
+  return { backoff: input ?? JOB_DEFAULTS.backoff, backoffConfig: null };
 }
-
-// ../../src/application/emptyQueueCleanup.ts
-function collectOccupiedQueues(ctx) {
-  const occupied = new Set;
-  for (const [jobId, location] of ctx.jobIndex) {
-    if (location.type !== "processing")
-      continue;
-    occupied.add(location.queueName);
-    const processingJob = ctx.processingShards[location.shardIdx]?.get(jobId);
-    if (processingJob)
-      occupied.add(processingJob.queue);
-  }
-  for (const processing of ctx.processingShards) {
-    for (const job of processing.values())
-      occupied.add(job.queue);
-  }
-  for (const shard of ctx.shards) {
-    for (const job of shard.waitingDeps.values())
-      occupied.add(job.queue);
-    for (const job of shard.waitingChildren.values())
-      occupied.add(job.queue);
-  }
-  for (const [queue, count] of ctx.pendingQueueAdmissions) {
-    if (count > 0)
-      occupied.add(queue);
-  }
-  return occupied;
+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
+  };
 }
-function collectConfiguredQueues(ctx) {
-  const configured = new Set;
-  for (const shard of ctx.shards) {
-    for (const queue of shard.getConfiguredQueueNames())
-      configured.add(queue);
-  }
-  return configured;
+function toBoolean(value, fallback) {
+  return value === undefined ? fallback : Boolean(value);
 }
-function collectBufferedCompletedQueues(ctx) {
-  const queues = new Set;
-  for (const job of ctx.storage?.getBufferedJobs() ?? []) {
-    if (job.completedAt === null)
-      continue;
-    const location = ctx.jobIndex.get(job.id);
-    if (location && (location.type !== "completed" || location.queueName !== job.queue))
-      continue;
-    queues.add(job.queue);
-  }
-  return queues;
+function parseCoreOptions(input) {
+  return {
+    priority: input.priority ?? JOB_DEFAULTS.priority,
+    lifo: input.lifo ?? JOB_DEFAULTS.lifo,
+    maxAttempts: input.maxAttempts ?? JOB_DEFAULTS.maxAttempts,
+    removeOnComplete: toBoolean(input.removeOnComplete, JOB_DEFAULTS.removeOnComplete),
+    removeOnFail: toBoolean(input.removeOnFail, JOB_DEFAULTS.removeOnFail)
+  };
 }
-function collectCompletedCounts(ctx, registered) {
-  if (ctx.storage)
-    return ctx.storage.countCompletedJobsByQueue(registered);
-  const registeredSet = new Set(registered);
-  const counts = new Map;
-  for (const [jobId, location] of ctx.jobIndex) {
-    if (location.type !== "completed" || !registeredSet.has(location.queueName) || !ctx.completedJobs.has(jobId)) {
-      continue;
-    }
-    counts.set(location.queueName, (counts.get(location.queueName) ?? 0) + 1);
-  }
-  return counts;
+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
+  };
 }
-function cleanEmptyQueues(ctx) {
-  const registered = Array.from(ctx.queueNamesCache);
-  const completedCounts = collectCompletedCounts(ctx, registered);
-  const bufferedCompletedQueues = collectBufferedCompletedQueues(ctx);
-  const occupied = collectOccupiedQueues(ctx);
-  const configured = collectConfiguredQueues(ctx);
-  const removed = [];
-  for (const queueName of registered) {
-    const shard = ctx.shards[shardIndex(queueName)];
-    const hasLiveRuntime = (shard.queues.get(queueName)?.size ?? 0) > 0 || shard.getDlqCount(queueName) > 0 || occupied.has(queueName);
-    if (hasLiveRuntime)
-      continue;
-    shard.queues.delete(queueName);
-    shard.clearEmptyGroupRuntime(queueName);
-    if ((completedCounts.get(queueName) ?? 0) > 0 || bufferedCompletedQueues.has(queueName) || configured.has(queueName)) {
-      continue;
-    }
-    ctx.storage?.deleteQueueState(queueName);
-    ctx.storage?.deleteGroupState(queueName);
-    ctx.unregisterQueueName(queueName);
-    shard.obliterate(queueName);
-    removed.push(queueName);
-  }
-  for (const shard of ctx.shards)
-    shard.cleanOrphanedTemporalEntries();
-  for (const queue of removed)
-    ctx.dashboardEmit?.("queue:removed", { queue });
+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
+  };
 }
-
-// ../../src/application/cleanupTasks.ts
-async function cleanup(ctx) {
-  const now = Date.now();
-  const stallTimeout = 30 * 60 * 1000;
-  const retention = ctx.config.completedRetentionMs;
-  if (retention !== null && retention !== undefined) {
-    const removed = cleanCompletedJobs(null, now - retention, 1000, ctx);
-    if (removed.length > 0) {
-      ctx.dashboardEmit?.("cleanup:completed-removed", { count: removed.length });
-    }
-  }
-  for (let i = 0;i < SHARD_COUNT; i++) {
-    ctx.shards[i].refreshDelayedCount(now);
-  }
-  for (let i = 0;i < SHARD_COUNT; i++) {
-    for (const q of ctx.shards[i].queues.values()) {
-      if (q.needsCompaction(0.2)) {
-        q.compact();
-      }
-    }
-  }
-  await cleanOrphanedProcessingEntries(ctx, now, stallTimeout);
-  await cleanStaleWaitingDependencies(ctx, now);
-  cleanUniqueKeysAndGroups(ctx, now);
-  cleanStalledCandidates(ctx);
-  await cleanOrphanedJobIndex(ctx);
-  cleanOrphanedJobLocks(ctx);
-  cleanEmptyQueues(ctx);
+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;
+  const payload = normalizeJobPayload(input);
+  return {
+    id,
+    queue,
+    name: payload.name,
+    data: payload.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),
+    durable: input.durable ?? false,
+    lastHeartbeat: createdAt,
+    stallCount: 0,
+    ...coreOpts,
+    ...optionalFields,
+    ...v5Opts,
+    timeline: []
+  };
 }
-async function cleanOrphanedProcessingEntries(ctx, now, stallTimeout) {
-  for (let i = 0;i < SHARD_COUNT; i++) {
-    const orphaned = [];
-    for (const [jobId, job] of ctx.processingShards[i]) {
-      if (job.startedAt && now - job.startedAt > stallTimeout) {
-        orphaned.push(jobId);
-      }
+// ../../src/domain/job/ids.ts
+function isWellFormedJobId(id) {
+  for (let index = 0;index < id.length; index++) {
+    const unit = id.charCodeAt(index);
+    if (unit >= 55296 && unit <= 56319) {
+      const next = id.charCodeAt(++index);
+      if (!(next >= 56320 && next <= 57343))
+        return false;
+    } else if (unit >= 56320 && unit <= 57343) {
+      return false;
     }
-    if (orphaned.length === 0)
-      continue;
-    await withWriteLock(ctx.processingLocks[i], () => {
-      let removed = 0;
-      for (const jobId of orphaned) {
-        const job = ctx.processingShards[i].get(jobId);
-        if (job) {
-          ctx.processingShards[i].delete(jobId);
-          ctx.timeoutScheduler.cancel(jobId);
-          ctx.jobIndex.delete(jobId);
-          removed++;
-        }
-      }
-      if (removed > 0)
-        ctx.dashboardEmit?.("cleanup:orphans-removed", { count: removed });
-    });
   }
+  return true;
 }
-async function cleanStaleWaitingDependencies(ctx, now) {
-  const depTimeout = 60 * 60 * 1000;
-  for (let i = 0;i < SHARD_COUNT; i++) {
-    const shard = ctx.shards[i];
-    const staleIds = [];
-    for (const [_id, job] of shard.waitingDeps) {
-      if (now - job.createdAt > depTimeout) {
-        staleIds.push(job.id);
-      }
-    }
-    if (staleIds.length === 0)
-      continue;
-    const removed = await withWriteLock(ctx.shardLocks[i], () => {
-      let count = 0;
-      const released = [];
-      for (const id of staleIds) {
-        const job = shard.waitingDeps.get(id);
-        if (!job || now - job.createdAt <= depTimeout)
-          continue;
-        ctx.storage?.deleteJob(job.id);
-        shard.waitingDeps.delete(job.id);
-        shard.unregisterDependencies(job.id, job.dependsOn);
-        released.push(...job.dependsOn);
-        if (job.uniqueKey && shard.getUniqueKeyEntry(job.queue, job.uniqueKey)?.jobId === job.id) {
-          shard.releaseUniqueKeyIfOwned(job.queue, job.uniqueKey, job.id);
-        }
-        if (job.customId && ctx.customIdMap.get(job.customId) === job.id) {
-          ctx.customIdMap.delete(job.customId);
-        }
-        ctx.dependencyResults?.releaseConsumer(job.id);
-        ctx.jobIndex.delete(job.id);
-        count++;
-      }
-      return { count, released };
-    });
-    releaseDependencyCompletionPins(removed.released, ctx);
-    if (removed.count > 0) {
-      ctx.dashboardEmit?.("cleanup:stale-deps-removed", { count: removed.count });
-    }
-  }
+function assertWellFormedJobId(id, name = "job ID") {
+  if (!isWellFormedJobId(id))
+    throw new Error(`${name} must be well-formed Unicode`);
 }
-function cleanUniqueKeysAndGroups(ctx, now) {
-  for (let i = 0;i < SHARD_COUNT; i++) {
-    const shard = ctx.shards[i];
-    shard.cleanExpiredGroupWindows(now);
-    shard.cleanExpiredUniqueKeys();
-    for (const [_queueName, keys] of shard.uniqueKeys) {
-      if (keys.size > 1000) {
-        const toRemove = Math.floor(keys.size / 2);
-        const iter = keys.keys();
-        for (let j = 0;j < toRemove; j++) {
-          const { value, done } = iter.next();
-          if (done)
-            break;
-          keys.delete(value);
-        }
-      }
-    }
-  }
+function jobId(id) {
+  return id;
 }
-function cleanStalledCandidates(ctx) {
-  for (const jobId of ctx.stalledCandidates) {
-    const loc = ctx.jobIndex.get(jobId);
-    if (loc?.type !== "processing") {
-      ctx.stalledCandidates.delete(jobId);
-    }
-  }
+function generateJobId() {
+  return Bun.randomUUIDv7();
 }
-async function cleanOrphanedJobIndex(ctx) {
-  if (ctx.jobIndex.size <= 1e5)
-    return;
-  const processingCandidates = new Map;
-  const queueCandidates = new Map;
-  for (const [jobId, loc] of ctx.jobIndex) {
-    if (loc.type === "processing") {
-      const procIdx = processingShardIndex(jobId);
-      let list = processingCandidates.get(procIdx);
-      if (!list) {
-        list = [];
-        processingCandidates.set(procIdx, list);
-      }
-      list.push(jobId);
-    } else if (loc.type === "queue") {
-      let list = queueCandidates.get(loc.shardIdx);
-      if (!list) {
-        list = [];
-        queueCandidates.set(loc.shardIdx, list);
-      }
-      list.push({ jobId, queueName: loc.queueName });
-    }
-  }
-  for (const [procIdx, candidates] of processingCandidates) {
-    await withWriteLock(ctx.processingLocks[procIdx], () => {
-      for (const jobId of candidates) {
-        if (!ctx.processingShards[procIdx].has(jobId)) {
-          ctx.jobIndex.delete(jobId);
-        }
-      }
-    });
-  }
-  for (const [shardIdx, candidates] of queueCandidates) {
-    await withWriteLock(ctx.shardLocks[shardIdx], () => {
-      const shard = ctx.shards[shardIdx];
-      for (const { jobId, queueName } of candidates) {
-        if (!shard.getQueue(queueName).has(jobId)) {
-          ctx.jobIndex.delete(jobId);
-        }
-      }
-    });
-  }
+function generateLockToken() {
+  return Bun.randomUUIDv7();
 }
-function cleanOrphanedJobLocks(ctx) {
-  for (const jobId of ctx.jobLocks.keys()) {
-    const loc = ctx.jobIndex.get(jobId);
-    if (loc?.type !== "processing") {
-      ctx.jobLocks.delete(jobId);
-    }
-  }
+// ../../src/domain/job/locks.ts
+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
+  };
 }
-// ../../src/domain/job/constants.ts
-var DEFAULT_MAX_BACKOFF = 3600000;
-var MAX_TIMELINE_ENTRIES = 20;
-var DEFAULT_LOCK_TTL = 30000;
-var JOB_DEFAULTS = {
-  priority: 0,
-  maxAttempts: 3,
-  backoff: 1000,
-  lifo: false,
-  removeOnComplete: false,
-  removeOnFail: false,
-  stackTraceLimit: 10
-};
-// ../../src/domain/job/payload.ts
-var DEFAULT_JOB_NAME = "default";
-var MAX_JOB_NAME_LENGTH = 256;
-function legacyEnvelope(data) {
-  if (typeof data !== "object" || data === null || Array.isArray(data))
-    return null;
-  const record = data;
-  if (typeof record.name !== "string")
-    return null;
-  const { name, ...userData } = record;
-  return { name, data: userData };
+function isLockExpired(lock, now = Date.now()) {
+  return now >= lock.expiresAt;
 }
-function validateJobName(name) {
-  if (typeof name !== "string" || name.length === 0 || name.length > MAX_JOB_NAME_LENGTH) {
-    return "Job name must be a non-empty string of at most 256 characters";
+function renewLock(lock, newTtl, now = Date.now()) {
+  const ttl = newTtl ?? lock.ttl;
+  lock.expiresAt = now + ttl;
+  lock.lastRenewalAt = now;
+  lock.renewalCount++;
+}
+function isLeaseFromEarlierGeneration(job, lock) {
+  return job.startedAt !== null && job.startedAt !== undefined && job.startedAt > lock.createdAt;
+}
+// ../../src/domain/job/state.ts
+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 null;
+  return out.length > 0 ? out : null;
 }
-function checkedName(name) {
-  const error = validateJobName(name);
-  if (error)
-    throw new Error(error);
-  return name;
+function isReady(job, now = Date.now()) {
+  return job.runAt <= now;
 }
-function normalizeJobPayload(source, fallback = DEFAULT_JOB_NAME) {
-  if (source.name !== undefined) {
-    return { name: checkedName(source.name), data: source.data, legacy: false };
+function isExpired(job, now = Date.now()) {
+  if (job.ttl === null)
+    return false;
+  return now > job.createdAt + job.ttl;
+}
+function calculateBackoff(job) {
+  const maxDelay = job.backoffConfig?.maxDelay ?? DEFAULT_MAX_BACKOFF;
+  if (job.backoffConfig) {
+    if (job.backoffConfig.type === "fixed") {
+      const base = job.backoffConfig.delay;
+      const jittered = base * (0.8 + Math.random() * 0.4);
+      return Math.min(jittered, maxDelay);
+    }
+    const base = job.backoffConfig.delay * Math.pow(2, job.attempts);
+    const jittered = base * (0.5 + Math.random());
+    return Math.min(jittered, maxDelay);
   }
-  return { name: checkedName(fallback), data: source.data, legacy: false };
+  const base = job.backoff * Math.pow(2, job.attempts);
+  const jittered = base * (0.5 + Math.random());
+  return Math.min(jittered, maxDelay);
 }
-function normalizeLegacyJobPayload(source, fallback = DEFAULT_JOB_NAME) {
-  if (source.name !== undefined)
-    return normalizeJobPayload(source, fallback);
-  const legacy = legacyEnvelope(source.data);
-  if (legacy)
-    return { name: checkedName(legacy.name), data: legacy.data, legacy: true };
-  return { name: checkedName(fallback), data: source.data, legacy: false };
+function canRetry(job) {
+  return job.attempts < job.maxAttempts;
 }
-
-// ../../src/domain/job/create.ts
-function parseBackoff(input) {
-  if (typeof input === "object") {
+// ../../src/domain/types/stall.ts
+var DEFAULT_STALL_CONFIG = {
+  enabled: true,
+  stallInterval: 30000,
+  maxStalls: 3,
+  gracePeriod: 5000
+};
+function checkStall(job, config = DEFAULT_STALL_CONFIG, now = Date.now()) {
+  if (job.startedAt === null) {
     return {
-      backoff: input.delay,
-      backoffConfig: { type: input.type, delay: input.delay }
+      isStalled: false,
+      stalledFor: 0,
+      shouldMoveToDlq: false,
+      newStallCount: job.stallCount
     };
   }
-  return { backoff: input ?? JOB_DEFAULTS.backoff, backoffConfig: null };
-}
-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
+  if (now - job.startedAt < config.gracePeriod) {
+    return {
+      isStalled: false,
+      stalledFor: 0,
+      shouldMoveToDlq: false,
+      newStallCount: job.stallCount
+    };
+  }
+  const stallInterval = job.stallTimeout ?? config.stallInterval;
+  const stalledFor = now - job.lastHeartbeat;
+  const isStalled = stalledFor > stallInterval;
+  if (!isStalled) {
+    return {
+      isStalled: false,
+      stalledFor,
+      shouldMoveToDlq: false,
+      newStallCount: job.stallCount
+    };
+  }
+  const newStallCount = job.stallCount + 1;
+  const shouldMoveToDlq = newStallCount >= config.maxStalls;
+  return {
+    isStalled: true,
+    stalledFor,
+    shouldMoveToDlq,
+    newStallCount
   };
 }
-function toBoolean(value, fallback) {
-  return value === undefined ? fallback : Boolean(value);
+function getStallAction(job, config = DEFAULT_STALL_CONFIG, now = Date.now()) {
+  const result = checkStall(job, config, now);
+  if (!result.isStalled) {
+    return "keep" /* Keep */;
+  }
+  if (result.shouldMoveToDlq) {
+    return "move_to_dlq" /* MoveToDlq */;
+  }
+  return "retry" /* Retry */;
 }
-function parseCoreOptions(input) {
+function incrementStallCount(job) {
+  job.stallCount++;
+  return job.stallCount;
+}
+
+// ../../src/shared/logger.ts
+var LOG_LEVEL_PRIORITY = {
+  debug: 0,
+  info: 1,
+  warn: 2,
+  error: 3
+};
+
+class Logger {
+  component;
+  static jsonMode = false;
+  static level = "info";
+  constructor(component) {
+    this.component = component;
+  }
+  static enableJsonMode() {
+    Logger.jsonMode = true;
+  }
+  static disableJsonMode() {
+    Logger.jsonMode = false;
+  }
+  static setLevel(level) {
+    Logger.level = level;
+  }
+  debug(message, data) {
+    this.log("debug", message, data);
+  }
+  debugToStderr(message, data) {
+    this.log("debug", message, data, true);
+  }
+  info(message, data) {
+    this.log("info", message, data);
+  }
+  infoToStderr(message, data) {
+    this.log("info", message, data, true);
+  }
+  warn(message, data) {
+    this.log("warn", message, data);
+  }
+  error(message, data) {
+    this.log("error", message, data);
+  }
+  log(level, message, data, forceStderr = false) {
+    if (LOG_LEVEL_PRIORITY[level] < LOG_LEVEL_PRIORITY[Logger.level])
+      return;
+    if (Logger.jsonMode) {
+      const entry = {
+        timestamp: new Date().toISOString(),
+        level,
+        component: this.component,
+        message,
+        ...data && { data }
+      };
+      if (forceStderr)
+        console.error(JSON.stringify(entry));
+      else
+        console.log(JSON.stringify(entry));
+    } else {
+      const prefix = `[${this.component}]`;
+      const dataStr = data ? ` ${JSON.stringify(data)}` : "";
+      switch (level) {
+        case "debug":
+          if (forceStderr)
+            console.error(`${prefix} ${message}${dataStr}`);
+          else
+            console.debug(`${prefix} ${message}${dataStr}`);
+          break;
+        case "info":
+          if (forceStderr)
+            console.error(`${prefix} ${message}${dataStr}`);
+          else
+            console.log(`${prefix} ${message}${dataStr}`);
+          break;
+        case "warn":
+          console.warn(`${prefix} ${message}${dataStr}`);
+          break;
+        case "error":
+          console.error(`${prefix} ${message}${dataStr}`);
+          break;
+      }
+    }
+  }
+}
+function createLogger(component) {
+  return new Logger(component);
+}
+var serverLog = createLogger("Server");
+var tcpLog = createLogger("TCP");
+var httpLog = createLogger("HTTP");
+var wsLog = createLogger("WS");
+var cronLog = createLogger("Cron");
+var statsLog = createLogger("Stats");
+var storageLog = createLogger("Storage");
+var queueLog = createLogger("Queue");
+var webhookLog = createLogger("Webhook");
+var backupLog = createLogger("Backup");
+
+// ../../src/domain/types/dlq.ts
+var DLQ_RETRY_STATE = Symbol("bunqueue.dlqRetryState");
+function getDlqRetryState(job) {
+  return job[DLQ_RETRY_STATE] ?? null;
+}
+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 {
-    priority: input.priority ?? JOB_DEFAULTS.priority,
-    lifo: input.lifo ?? JOB_DEFAULTS.lifo,
-    maxAttempts: input.maxAttempts ?? JOB_DEFAULTS.maxAttempts,
-    removeOnComplete: toBoolean(input.removeOnComplete, JOB_DEFAULTS.removeOnComplete),
-    removeOnFail: toBoolean(input.removeOnFail, JOB_DEFAULTS.removeOnFail)
+    attempt: job.attempts,
+    startedAt: job.startedAt ?? job.createdAt,
+    failedAt,
+    reason,
+    error,
+    duration: job.startedAt ? failedAt - job.startedAt : 0
   };
 }
-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
+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);
 }
-function parseBullMQV5Options(input) {
+function retainDlqRetryState(job, entry) {
+  setDlqRetryState(job, {
+    enteredAt: entry.enteredAt,
+    expiresAt: entry.expiresAt,
+    attempts: [...entry.attempts],
+    retryCount: entry.retryCount,
+    lastRetryAt: entry.lastRetryAt,
+    nextRetryAt: entry.nextRetryAt
+  });
+}
+var DEFAULT_DLQ_CONFIG = {
+  autoRetry: false,
+  autoRetryInterval: 60 * 60 * 1000,
+  maxAutoRetries: 3,
+  maxAge: 7 * 24 * 60 * 60 * 1000,
+  maxEntries: 1e4
+};
+function createDlqEntry(job, reason, error, config = DEFAULT_DLQ_CONFIG, now = Date.now()) {
+  const retained = getDlqRetryState(job);
+  const alreadyEntered = retained?.enteredAt !== null && retained?.enteredAt !== undefined;
+  const attemptRecord = createAttemptRecord(job, reason, error, now);
+  setDlqRetryState(job, null);
   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
+    job,
+    enteredAt: alreadyEntered ? retained.enteredAt : now,
+    reason,
+    error,
+    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
   };
 }
-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;
-  const payload = normalizeJobPayload(input);
-  return {
-    id,
-    queue,
-    name: payload.name,
-    data: payload.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),
-    durable: input.durable ?? false,
-    lastHeartbeat: createdAt,
-    stallCount: 0,
-    ...coreOpts,
-    ...optionalFields,
-    ...v5Opts,
-    timeline: []
+function isDlqEntryExpired(entry, now = Date.now()) {
+  return entry.expiresAt !== null && now >= entry.expiresAt;
+}
+function canAutoRetry(entry, config, now = Date.now()) {
+  if (!config.autoRetry)
+    return false;
+  if (entry.retryCount >= config.maxAutoRetries)
+    return false;
+  if (entry.nextRetryAt === null)
+    return false;
+  return now >= entry.nextRetryAt;
+}
+function scheduleNextRetry(entry, config) {
+  const now = Date.now();
+  entry.retryCount++;
+  entry.lastRetryAt = now;
+  if (entry.retryCount < config.maxAutoRetries) {
+    const backoffMultiplier = Math.pow(2, entry.retryCount - 1);
+    entry.nextRetryAt = now + config.autoRetryInterval * backoffMultiplier;
+  } else {
+    entry.nextRetryAt = null;
+  }
+}
+
+// ../../src/domain/types/queue.ts
+function createQueueState(name) {
+  return {
+    name,
+    paused: false,
+    rateLimit: null,
+    rateLimitDuration: null,
+    rateLimitExpiresAt: null,
+    concurrencyLimit: null,
+    activeCount: 0
   };
 }
-// ../../src/domain/job/ids.ts
-function isWellFormedJobId(id) {
-  for (let index = 0;index < id.length; index++) {
-    const unit = id.charCodeAt(index);
-    if (unit >= 55296 && unit <= 56319) {
-      const next = id.charCodeAt(++index);
-      if (!(next >= 56320 && next <= 57343))
-        return false;
-    } else if (unit >= 56320 && unit <= 57343) {
-      return false;
+
+class RateLimiter {
+  capacity;
+  refillRate;
+  tokens;
+  lastRefill;
+  constructor(capacity, refillRate = capacity) {
+    this.capacity = capacity;
+    this.refillRate = refillRate;
+    this.tokens = capacity;
+    this.lastRefill = Date.now();
+  }
+  tryAcquire() {
+    this.refill();
+    if (this.tokens >= 1) {
+      this.tokens -= 1;
+      return true;
+    }
+    return false;
+  }
+  refill() {
+    const now = Date.now();
+    const elapsed = (now - this.lastRefill) / 1000;
+    const tokensToAdd = elapsed * this.refillRate;
+    this.tokens = Math.min(this.capacity, this.tokens + tokensToAdd);
+    this.lastRefill = now;
+  }
+  getTokens() {
+    this.refill();
+    return this.tokens;
+  }
+  getTtl(maxJobs) {
+    const tokens = this.getTokens();
+    const consumed = this.capacity - tokens;
+    if (maxJobs !== undefined && consumed < maxJobs)
+      return 0;
+    if (tokens >= 1 || this.refillRate <= 0)
+      return 0;
+    return Math.ceil((1 - tokens) / this.refillRate * 1000);
+  }
+}
+
+class ConcurrencyLimiter {
+  limit;
+  active = 0;
+  constructor(limit) {
+    this.limit = limit;
+  }
+  tryAcquire() {
+    if (this.active < this.limit) {
+      this.active += 1;
+      return true;
+    }
+    return false;
+  }
+  release() {
+    if (this.active > 0) {
+      this.active -= 1;
+    }
+  }
+  getActive() {
+    return this.active;
+  }
+  getLimit() {
+    return this.limit;
+  }
+  setLimit(limit) {
+    this.limit = limit;
+  }
+}
+
+// ../../src/application/stallDetection.ts
+function checkStalledJobs(ctx) {
+  const now = Date.now();
+  const confirmedStalled = [];
+  for (const jobId of ctx.stalledCandidates) {
+    const procIdx = processingShardIndex(jobId);
+    const job = ctx.processingShards[procIdx].get(jobId);
+    if (!job) {
+      ctx.stalledCandidates.delete(jobId);
+      continue;
+    }
+    const stallConfig = ctx.shards[shardIndex(job.queue)].getStallConfig(job.queue);
+    if (!stallConfig.enabled) {
+      ctx.stalledCandidates.delete(jobId);
+      continue;
+    }
+    const action = getStallAction(job, stallConfig, now);
+    if (action !== "keep" /* Keep */) {
+      confirmedStalled.push({ job, action });
+    }
+    ctx.stalledCandidates.delete(jobId);
+  }
+  for (let i = 0;i < SHARD_COUNT; i++) {
+    const procShard = ctx.processingShards[i];
+    for (const [jobId, job] of procShard) {
+      const stallConfig = ctx.shards[shardIndex(job.queue)].getStallConfig(job.queue);
+      if (!stallConfig.enabled)
+        continue;
+      const action = getStallAction(job, stallConfig, now);
+      if (action !== "keep" /* Keep */) {
+        ctx.stalledCandidates.add(jobId);
+      }
+    }
+  }
+  const stillStalled = (job, lockedNow) => {
+    const config = ctx.shards[shardIndex(job.queue)].getStallConfig(job.queue);
+    return config.enabled && getStallAction(job, config, lockedNow) !== "keep" /* Keep */;
+  };
+  for (const { job, action } of confirmedStalled) {
+    handleStalledJob(job, action, ctx, stillStalled).catch((err) => {
+      queueLog.error("Failed to handle stalled job", {
+        jobId: String(job.id),
+        error: String(err)
+      });
+    });
+  }
+}
+async function handleStalledJob(job, action, ctx, recheck) {
+  const idx = shardIndex(job.queue);
+  const procIdx = processingShardIndex(job.id);
+  let handled = false;
+  let handledAction = action;
+  await withWriteLock(ctx.shardLocks[idx], async () => {
+    await withWriteLock(ctx.processingLocks[procIdx], () => {
+      if (ctx.processingShards[procIdx].get(job.id) !== job) {
+        return;
+      }
+      if (recheck && !recheck(job, Date.now()))
+        return;
+      const shard = ctx.shards[idx];
+      const attemptsExhausted = job.attempts + 1 >= job.maxAttempts;
+      if (action === "move_to_dlq" /* MoveToDlq */ || attemptsExhausted) {
+        handledAction = "move_to_dlq" /* MoveToDlq */;
+        moveStalliedJobToDlq(job, ctx, shard, procIdx, attemptsExhausted);
+      } else {
+        retryStalliedJob(job, ctx, shard, procIdx, idx);
+      }
+      detachClientJob(job.id, ctx);
+      handled = true;
+    });
+  });
+  if (handled) {
+    ctx.dashboardEmit?.("job:stalled", {
+      jobId: String(job.id),
+      queue: job.queue,
+      stallCount: job.stallCount,
+      action: handledAction
+    });
+    ctx.eventsManager.broadcast({
+      eventType: "stalled" /* Stalled */,
+      queue: job.queue,
+      jobId: job.id,
+      timestamp: Date.now(),
+      data: { stallCount: job.stallCount, action: handledAction }
+    });
+    ctx.webhookManager.trigger("stalled", String(job.id), job.queue, {
+      data: { stallCount: job.stallCount, action: handledAction }
+    });
+  }
+  return handled;
+}
+function moveStalliedJobToDlq(job, ctx, shard, procIdx, attemptsExhausted) {
+  ctx.processingShards[procIdx].delete(job.id);
+  ctx.timeoutScheduler.cancel(job.id);
+  shard.releaseJobResources(job.queue, job.uniqueKey, job.groupId, job.id);
+  if (job.uniqueKey?.startsWith("cron:")) {
+    ctx.jobIndex.delete(job.id);
+    ctx.storage?.deleteJob(job.id);
+    return;
+  }
+  incrementStallCount(job);
+  job.attempts++;
+  job.startedAt = null;
+  job.lastHeartbeat = Date.now();
+  const entry = shard.addToDlq(job, attemptsExhausted ? "max_attempts_exceeded" /* MaxAttemptsExceeded */ : "stalled" /* Stalled */, attemptsExhausted ? `Job stalled at max attempts (${job.maxAttempts})` : `Job stalled ${job.stallCount} times`);
+  ctx.jobIndex.set(job.id, { type: "dlq", queueName: job.queue });
+  ctx.storage?.saveDlqEntry(entry);
+  ctx.storage?.deleteJob(job.id);
+}
+function retryStalliedJob(job, ctx, shard, procIdx, idx) {
+  if (job.uniqueKey?.startsWith("cron:")) {
+    ctx.processingShards[procIdx].delete(job.id);
+    ctx.timeoutScheduler.cancel(job.id);
+    shard.releaseJobResources(job.queue, job.uniqueKey, job.groupId, job.id);
+    ctx.jobIndex.delete(job.id);
+    ctx.storage?.deleteJob(job.id);
+    return;
+  }
+  incrementStallCount(job);
+  job.attempts++;
+  const stallNow = Date.now();
+  recordJobFailureAttempt(job, "stalled" /* Stalled */, "stalled", stallNow);
+  job.startedAt = null;
+  job.runAt = stallNow + calculateBackoff(job);
+  job.lastHeartbeat = stallNow;
+  if (job.timeline.length < MAX_TIMELINE_ENTRIES) {
+    job.timeline.push({
+      state: "failed",
+      timestamp: stallNow,
+      error: "stalled",
+      attempt: job.attempts
+    });
+    job.timeline.push({ state: "waiting", timestamp: stallNow, attempt: job.attempts + 1 });
+  }
+  ctx.processingShards[procIdx].delete(job.id);
+  ctx.timeoutScheduler.cancel(job.id);
+  shard.releaseJobResources(job.queue, job.uniqueKey, job.groupId, job.id);
+  shard.getQueue(job.queue).push(job);
+  const isDelayed = job.runAt > Date.now();
+  shard.incrementQueued(job.id, isDelayed, job.createdAt, job.queue, job.runAt);
+  ctx.jobIndex.set(job.id, { type: "queue", shardIdx: idx, queueName: job.queue });
+  ctx.storage?.updateForRetry(job);
+}
+
+// ../../src/application/orphanRecovery.ts
+var ORPHAN_WINDOW_FLOOR_MS = 30 * 60 * 1000;
+function isOrphanedProcessingEntry(job, lock, now, ctx) {
+  if (!job.startedAt)
+    return false;
+  const config = ctx.shards[shardIndex(job.queue)].getStallConfig(job.queue);
+  if (!config.enabled)
+    return false;
+  if (now - job.startedAt < config.gracePeriod)
+    return false;
+  if (lock && !isLockExpired(lock, now) && !isLeaseFromEarlierGeneration(job, lock))
+    return false;
+  const window = Math.max(ORPHAN_WINDOW_FLOOR_MS, job.stallTimeout ?? config.stallInterval);
+  const lastActivity = Math.max(job.startedAt, job.lastHeartbeat || 0);
+  return now - lastActivity > window;
+}
+function orphanStallAction(job, ctx) {
+  const { maxStalls } = ctx.shards[shardIndex(job.queue)].getStallConfig(job.queue);
+  return maxStalls > 0 && job.stallCount + 1 >= maxStalls ? "move_to_dlq" /* MoveToDlq */ : "retry" /* Retry */;
+}
+async function recoverOrphanedProcessingEntries(ctx, now) {
+  const orphans = [];
+  for (let i = 0;i < SHARD_COUNT; i++) {
+    for (const [jobId, job] of ctx.processingShards[i]) {
+      if (isOrphanedProcessingEntry(job, ctx.jobLocks.get(jobId), now, ctx)) {
+        orphans.push(job);
+      }
+    }
+  }
+  if (orphans.length === 0)
+    return;
+  const stillOrphaned = (job, lockedNow) => isOrphanedProcessingEntry(job, ctx.jobLocks.get(job.id), lockedNow, ctx);
+  let recovered = 0;
+  for (const job of orphans) {
+    try {
+      if (await handleStalledJob(job, orphanStallAction(job, ctx), ctx, stillOrphaned)) {
+        recovered++;
+      }
+    } catch (err) {
+      queueLog.error("Failed to recover orphaned processing entry", {
+        jobId: String(job.id),
+        error: String(err)
+      });
+    }
+  }
+  if (recovered > 0)
+    ctx.dashboardEmit?.("cleanup:orphans-removed", { count: recovered });
+}
+
+// ../../src/application/dependencyCompletions.ts
+class DependencyCompletionTracker {
+  onRecentEvict;
+  recent = new Set;
+  recentOrder = [];
+  recentOrderTokens = [];
+  recentTokens = new Map;
+  recentOrderHead = 0;
+  nextRecentToken = 0;
+  pinned = new Set;
+  owners = new Map;
+  maxRecent;
+  constructor(maxRecent, onRecentEvict) {
+    this.onRecentEvict = onRecentEvict;
+    this.maxRecent = Math.max(1, Math.trunc(maxRecent));
+  }
+  add(jobId, queue) {
+    if (queue !== undefined)
+      this.owners.set(jobId, queue);
+    if (this.pinned.has(jobId) || this.recent.has(jobId))
+      return;
+    if (this.recent.size >= this.maxRecent)
+      this.evictOldestRecent();
+    if (this.nextRecentToken >= Number.MAX_SAFE_INTEGER)
+      this.compactRecentOrder(true);
+    const token = this.nextRecentToken++;
+    this.recent.add(jobId);
+    this.recentTokens.set(jobId, token);
+    this.recentOrder.push(jobId);
+    this.recentOrderTokens.push(token);
+  }
+  pin(jobId, queue) {
+    if (queue !== undefined)
+      this.owners.set(jobId, queue);
+    if (this.recent.delete(jobId)) {
+      this.recentTokens.delete(jobId);
+      this.compactRecentOrder();
+    }
+    this.pinned.add(jobId);
+  }
+  unpin(jobId, retainAsRecent) {
+    this.pinned.delete(jobId);
+    if (retainAsRecent)
+      this.add(jobId);
+    else
+      this.delete(jobId);
+  }
+  hydrate(records) {
+    this.clear();
+    for (const record of records) {
+      if (record.pinned)
+        this.pin(record.jobId, record.queue);
+      else
+        this.add(record.jobId, record.queue);
+    }
+  }
+  pinnedValues() {
+    return this.pinned.values();
+  }
+  has(jobId) {
+    return this.pinned.has(jobId) || this.recent.has(jobId);
+  }
+  delete(jobId) {
+    const wasPinned = this.pinned.delete(jobId);
+    const wasRecent = this.recent.delete(jobId);
+    if (wasRecent) {
+      this.recentTokens.delete(jobId);
+      this.compactRecentOrder();
+    }
+    this.owners.delete(jobId);
+    return wasRecent || wasPinned;
+  }
+  deleteForQueue(queue) {
+    const removed = [];
+    for (const [jobId, owner] of this.owners) {
+      if (owner !== queue)
+        continue;
+      if (this.delete(jobId))
+        removed.push(jobId);
+    }
+    return removed;
+  }
+  clear() {
+    this.recent.clear();
+    this.recentOrder = [];
+    this.recentOrderTokens = [];
+    this.recentTokens.clear();
+    this.recentOrderHead = 0;
+    this.nextRecentToken = 0;
+    this.pinned.clear();
+    this.owners.clear();
+  }
+  get size() {
+    return this.recent.size + this.pinned.size;
+  }
+  evictOldestRecent() {
+    while (this.recentOrderHead < this.recentOrder.length) {
+      const index = this.recentOrderHead++;
+      const oldest = this.recentOrder[index];
+      const token = this.recentOrderTokens[index];
+      if (this.recentTokens.get(oldest) !== token)
+        continue;
+      this.recent.delete(oldest);
+      this.recentTokens.delete(oldest);
+      this.owners.delete(oldest);
+      this.compactRecentOrder();
+      this.onRecentEvict?.(oldest);
+      return;
+    }
+  }
+  compactRecentOrder(force = false) {
+    const pending = this.recentOrder.length - this.recentOrderHead;
+    if (!force && this.recentOrderHead < this.maxRecent && pending < this.maxRecent * 2)
+      return;
+    const order = [];
+    const tokens = [];
+    for (let index = this.recentOrderHead;index < this.recentOrder.length; index++) {
+      const jobId = this.recentOrder[index];
+      const token = this.recentOrderTokens[index];
+      if (this.recentTokens.get(jobId) !== token)
+        continue;
+      const compactedToken = order.length;
+      order.push(jobId);
+      tokens.push(compactedToken);
+    }
+    this.recentTokens.clear();
+    for (let index = 0;index < order.length; index++) {
+      this.recentTokens.set(order[index], tokens[index]);
     }
+    this.recentOrder = order;
+    this.recentOrderTokens = tokens;
+    this.recentOrderHead = 0;
+    this.nextRecentToken = order.length;
   }
-  return true;
-}
-function assertWellFormedJobId(id, name = "job ID") {
-  if (!isWellFormedJobId(id))
-    throw new Error(`${name} must be well-formed Unicode`);
-}
-function jobId(id) {
-  return id;
-}
-function generateJobId() {
-  return Bun.randomUUIDv7();
 }
-function generateLockToken() {
-  return Bun.randomUUIDv7();
+function hasDependencyWaiters(shards, jobId) {
+  return shards.some((shard) => (shard.getJobsWaitingFor(jobId)?.size ?? 0) > 0);
 }
-// ../../src/domain/job/locks.ts
-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
-  };
+function commitRemovedCompletion(job, ctx, completedAt = Date.now()) {
+  const pinned = hasDependencyWaiters(ctx.shards, job.id);
+  ctx.storage?.commitRemovedCompletion(job, ctx.maxDependencyCompletions, pinned, completedAt);
+  if (pinned)
+    ctx.depCompletions?.pin(job.id, job.queue);
+  else
+    ctx.depCompletions?.add(job.id, job.queue);
 }
-function isLockExpired(lock, now = Date.now()) {
-  return now >= lock.expiresAt;
+function releaseDependencyCompletionPins(dependencyIds, ctx) {
+  const candidates = [...new Set(dependencyIds)].filter((id) => !hasDependencyWaiters(ctx.shards, id));
+  if (candidates.length === 0)
+    return;
+  if (ctx.storage) {
+    const records = ctx.storage.unpinDependencyCompletions(candidates, ctx.maxDependencyCompletions);
+    ctx.depCompletions?.hydrate(records);
+    return;
+  }
+  for (const id of candidates)
+    ctx.depCompletions?.unpin(id, true);
 }
-function renewLock(lock, newTtl, now = Date.now()) {
-  const ttl = newTtl ?? lock.ttl;
-  lock.expiresAt = now + ttl;
-  lock.lastRenewalAt = now;
-  lock.renewalCount++;
+function reconcileDependencyCompletionPins(ctx) {
+  const referenced = new Set;
+  for (const shard of ctx.shards) {
+    for (const dependencyId of shard.dependencyIndex.keys())
+      referenced.add(dependencyId);
+  }
+  if (ctx.storage) {
+    const records = ctx.storage.reconcileDependencyCompletionPins(referenced, ctx.maxDependencyCompletions);
+    ctx.depCompletions?.hydrate(records);
+    return;
+  }
+  for (const id of ctx.depCompletions?.pinnedValues() ?? []) {
+    if (!referenced.has(id))
+      ctx.depCompletions?.unpin(id, true);
+  }
 }
-// ../../src/domain/job/state.ts
-function normalizeStacktrace(lines, limit) {
-  if (!lines || lines.length === 0)
-    return null;
-  const out = [];
-  for (const line of lines) {
-    if (out.length >= limit)
+
+// ../../src/shared/serialization.ts
+function compareSqliteBinaryText(left, right) {
+  if (left === right)
+    return 0;
+  let leftIndex = 0;
+  let rightIndex = 0;
+  while (leftIndex < left.length && rightIndex < right.length) {
+    const leftPoint = left.codePointAt(leftIndex);
+    const rightPoint = right.codePointAt(rightIndex);
+    if (leftPoint === undefined || rightPoint === undefined)
       break;
-    if (typeof line !== "string")
-      continue;
-    const trimmed = line.trim();
-    if (trimmed)
-      out.push(trimmed);
+    if (leftPoint !== rightPoint)
+      return leftPoint - rightPoint;
+    leftIndex += leftPoint > 65535 ? 2 : 1;
+    rightIndex += rightPoint > 65535 ? 2 : 1;
   }
-  return out.length > 0 ? out : null;
-}
-function isReady(job, now = Date.now()) {
-  return job.runAt <= now;
+  return left.length - leftIndex - (right.length - rightIndex);
 }
-function isExpired(job, now = Date.now()) {
-  if (job.ttl === null)
-    return false;
-  return now > job.createdAt + job.ttl;
+
+// ../../src/application/completedCleanup.ts
+function memoryCandidates(queue, completedBefore, limit, ctx) {
+  return [...ctx.jobIndex].flatMap(([jobId, location]) => {
+    if (location.type !== "completed")
+      return [];
+    if (queue !== null && location.queueName !== queue)
+      return [];
+    if (ctx.dependencyResults.hasConsumers(jobId))
+      return [];
+    const job = ctx.completedJobsData.get(jobId);
+    const timestamp = job?.completedAt ?? job?.createdAt ?? 0;
+    return timestamp <= completedBefore ? [{ jobId, timestamp }] : [];
+  }).sort((left, right) => left.timestamp - right.timestamp || compareSqliteBinaryText(left.jobId, right.jobId)).slice(0, limit).map(({ jobId }) => ({ jobId, queue: ctx.jobIndex.get(jobId)?.queueName ?? "" }));
 }
-function calculateBackoff(job) {
-  const maxDelay = job.backoffConfig?.maxDelay ?? DEFAULT_MAX_BACKOFF;
-  if (job.backoffConfig) {
-    if (job.backoffConfig.type === "fixed") {
-      const base = job.backoffConfig.delay;
-      const jittered = base * (0.8 + Math.random() * 0.4);
-      return Math.min(jittered, maxDelay);
+function cleanCompletedJobs(queue, completedBefore, limit, ctx) {
+  const normalizedLimit = Number.isFinite(limit) ? Math.max(0, Math.trunc(limit)) : 0;
+  if (normalizedLimit === 0 || !Number.isFinite(completedBefore))
+    return [];
+  const removals = ctx.storage ? ctx.storage.cleanCompletedJobs(queue, completedBefore, normalizedLimit, (jobId) => ctx.dependencyResults.hasConsumers(jobId)) : memoryCandidates(queue, completedBefore, normalizedLimit, ctx);
+  for (const { jobId, queue: ownerQueue } of removals) {
+    const location = ctx.jobIndex.get(jobId);
+    const ownsCurrentCompletion = location?.type === "completed" && location.queueName === ownerQueue;
+    const hasNoCurrentGeneration = location === undefined;
+    const resultOwner = ctx.jobResultQueues?.get(jobId);
+    if (resultOwner === ownerQueue || resultOwner === undefined && ownsCurrentCompletion) {
+      ctx.jobResults?.delete(jobId);
+      ctx.jobResultQueues?.delete(jobId);
     }
-    const base = job.backoffConfig.delay * Math.pow(2, job.attempts);
-    const jittered = base * (0.5 + Math.random());
-    return Math.min(jittered, maxDelay);
-  }
-  const base = job.backoff * Math.pow(2, job.attempts);
-  const jittered = base * (0.5 + Math.random());
-  return Math.min(jittered, maxDelay);
-}
-function canRetry(job) {
-  return job.attempts < job.maxAttempts;
-}
-// ../../src/application/dependencyProcessor.ts
-function dependencyReadyState(job, now) {
-  if (job.runAt > now)
-    return "delayed";
-  return job.priority > 0 ? "prioritized" : "waiting";
-}
-function checkpointDependencyPromotion(job, state, now, storage) {
-  if (job.timeline.at(-1)?.state !== state && job.timeline.length < MAX_TIMELINE_ENTRIES) {
-    job.timeline.push({ state, timestamp: now });
-  }
-  storage?.updateFlowParentResolution(job, state);
-}
-async function processPendingDependencies(ctx) {
-  if (ctx.pendingDepChecks.size === 0)
-    return;
-  const completedIds = Array.from(ctx.pendingDepChecks);
-  const completedNow = new Set(completedIds);
-  ctx.pendingDepChecks.clear();
-  const jobsToCheckByShard = new Map;
-  const releasedDependencyIds = new Set;
-  for (const completedId of completedIds) {
-    for (let i = 0;i < SHARD_COUNT; i++) {
-      const waitingJobIds = ctx.shards[i].getJobsWaitingFor(completedId);
-      if (waitingJobIds && waitingJobIds.size > 0) {
-        let shardJobs = jobsToCheckByShard.get(i);
-        if (!shardJobs) {
-          shardJobs = new Set;
-          jobsToCheckByShard.set(i, shardJobs);
-        }
-        for (const jobId of waitingJobIds) {
-          shardJobs.add(jobId);
-        }
-      }
+    const logOwner = ctx.jobLogQueues?.get(jobId);
+    if (logOwner === ownerQueue || logOwner === undefined && ownsCurrentCompletion) {
+      ctx.jobLogs?.delete(jobId);
+      ctx.jobLogQueues?.delete(jobId);
     }
+    if (!hasNoCurrentGeneration && !ownsCurrentCompletion)
+      continue;
+    ctx.completedJobs.delete(jobId);
+    ctx.completedJobsData.delete(jobId);
+    ctx.jobIndex.delete(jobId);
+    ctx.dependencyResults.releaseConsumer(jobId);
   }
-  await Promise.all(Array.from(jobsToCheckByShard.entries()).map(async ([i, jobIdsToCheck]) => {
-    await withWriteLock(ctx.shardLocks[i], () => {
-      const shard = ctx.shards[i];
-      const jobsToPromote = [];
-      for (const jobId of jobIdsToCheck) {
-        const job = shard.waitingDeps.get(jobId);
-        if (job?.dependsOn.every((dep) => completedNow.has(dep) || ctx.completedJobs.has(dep) || (ctx.depCompletions?.has(dep) ?? false))) {
-          jobsToPromote.push(job);
-        }
-      }
-      if (jobsToPromote.length > 0) {
-        promoteJobsToQueue(jobsToPromote, shard, ctx, i, releasedDependencyIds);
-      }
-    });
-  }));
-  releaseDependencyCompletionPins(releasedDependencyIds, ctx);
+  return removals.map(({ jobId }) => jobId);
 }
-function promoteJobsToQueue(jobsToPromote, shard, ctx, shardIdx, releasedDependencyIds) {
-  const now = Date.now();
-  for (const job of jobsToPromote) {
-    if (shard.waitingDeps.has(job.id)) {
-      const state = dependencyReadyState(job, now);
-      checkpointDependencyPromotion(job, state, now, ctx.storage);
-      shard.waitingDeps.delete(job.id);
-      shard.unregisterDependencies(job.id, job.dependsOn);
-      for (const dependencyId of job.dependsOn)
-        releasedDependencyIds.add(dependencyId);
-      shard.getQueue(job.queue).push(job);
-      const isDelayed = state === "delayed";
-      shard.incrementQueued(job.id, isDelayed, job.createdAt, job.queue, job.runAt);
-      ctx.jobIndex.set(job.id, { type: "queue", shardIdx, queueName: job.queue });
-    }
+
+// ../../src/application/emptyQueueCleanup.ts
+function collectOccupiedQueues(ctx) {
+  const occupied = new Set;
+  for (const [jobId, location] of ctx.jobIndex) {
+    if (location.type !== "processing")
+      continue;
+    occupied.add(location.queueName);
+    const processingJob = ctx.processingShards[location.shardIdx]?.get(jobId);
+    if (processingJob)
+      occupied.add(processingJob.queue);
   }
-  if (jobsToPromote.length > 0) {
-    const promotedByQueue = new Map;
-    for (const job of jobsToPromote) {
-      promotedByQueue.set(job.queue, (promotedByQueue.get(job.queue) ?? 0) + 1);
-    }
-    for (const [queue, count] of promotedByQueue)
-      shard.notifyBatch(queue, count);
-    for (const job of jobsToPromote) {
-      ctx.dashboardEmit?.("job:dependencies-resolved", { jobId: String(job.id), queue: job.queue });
-    }
+  for (const processing of ctx.processingShards) {
+    for (const job of processing.values())
+      occupied.add(job.queue);
   }
-}
-
-// ../../src/domain/types/dlq.ts
-var DLQ_RETRY_STATE = Symbol("bunqueue.dlqRetryState");
-function getDlqRetryState(job) {
-  return job[DLQ_RETRY_STATE] ?? null;
-}
-function setDlqRetryState(job, state) {
-  if (state === null) {
-    delete job[DLQ_RETRY_STATE];
-    return;
+  for (const shard of ctx.shards) {
+    for (const job of shard.waitingDeps.values())
+      occupied.add(job.queue);
+    for (const job of shard.waitingChildren.values())
+      occupied.add(job.queue);
   }
-  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
-  };
-}
-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);
-}
-function retainDlqRetryState(job, entry) {
-  setDlqRetryState(job, {
-    enteredAt: entry.enteredAt,
-    expiresAt: entry.expiresAt,
-    attempts: [...entry.attempts],
-    retryCount: entry.retryCount,
-    lastRetryAt: entry.lastRetryAt,
-    nextRetryAt: entry.nextRetryAt
-  });
+  for (const [queue, count] of ctx.pendingQueueAdmissions) {
+    if (count > 0)
+      occupied.add(queue);
+  }
+  return occupied;
 }
-var DEFAULT_DLQ_CONFIG = {
-  autoRetry: false,
-  autoRetryInterval: 60 * 60 * 1000,
-  maxAutoRetries: 3,
-  maxAge: 7 * 24 * 60 * 60 * 1000,
-  maxEntries: 1e4
-};
-function createDlqEntry(job, reason, error, config = DEFAULT_DLQ_CONFIG, now = Date.now()) {
-  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: alreadyEntered ? retained.enteredAt : now,
-    reason,
-    error,
-    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
-  };
+function collectConfiguredQueues(ctx) {
+  const configured = new Set;
+  for (const shard of ctx.shards) {
+    for (const queue of shard.getConfiguredQueueNames())
+      configured.add(queue);
+  }
+  return configured;
 }
-function isDlqEntryExpired(entry, now = Date.now()) {
-  return entry.expiresAt !== null && now >= entry.expiresAt;
+function collectBufferedCompletedQueues(ctx) {
+  const queues = new Set;
+  for (const job of ctx.storage?.getBufferedJobs() ?? []) {
+    if (job.completedAt === null)
+      continue;
+    const location = ctx.jobIndex.get(job.id);
+    if (location && (location.type !== "completed" || location.queueName !== job.queue))
+      continue;
+    queues.add(job.queue);
+  }
+  return queues;
 }
-function canAutoRetry(entry, config, now = Date.now()) {
-  if (!config.autoRetry)
-    return false;
-  if (entry.retryCount >= config.maxAutoRetries)
-    return false;
-  if (entry.nextRetryAt === null)
-    return false;
-  return now >= entry.nextRetryAt;
+function collectCompletedCounts(ctx, registered) {
+  if (ctx.storage)
+    return ctx.storage.countCompletedJobsByQueue(registered);
+  const registeredSet = new Set(registered);
+  const counts = new Map;
+  for (const [jobId, location] of ctx.jobIndex) {
+    if (location.type !== "completed" || !registeredSet.has(location.queueName) || !ctx.completedJobs.has(jobId)) {
+      continue;
+    }
+    counts.set(location.queueName, (counts.get(location.queueName) ?? 0) + 1);
+  }
+  return counts;
 }
-function scheduleNextRetry(entry, config) {
-  const now = Date.now();
-  entry.retryCount++;
-  entry.lastRetryAt = now;
-  if (entry.retryCount < config.maxAutoRetries) {
-    const backoffMultiplier = Math.pow(2, entry.retryCount - 1);
-    entry.nextRetryAt = now + config.autoRetryInterval * backoffMultiplier;
-  } else {
-    entry.nextRetryAt = null;
+function cleanEmptyQueues(ctx) {
+  const registered = Array.from(ctx.queueNamesCache);
+  const completedCounts = collectCompletedCounts(ctx, registered);
+  const bufferedCompletedQueues = collectBufferedCompletedQueues(ctx);
+  const occupied = collectOccupiedQueues(ctx);
+  const configured = collectConfiguredQueues(ctx);
+  const removed = [];
+  for (const queueName of registered) {
+    const shard = ctx.shards[shardIndex(queueName)];
+    const hasLiveRuntime = (shard.queues.get(queueName)?.size ?? 0) > 0 || shard.getDlqCount(queueName) > 0 || occupied.has(queueName);
+    if (hasLiveRuntime)
+      continue;
+    shard.queues.delete(queueName);
+    shard.clearEmptyGroupRuntime(queueName);
+    if ((completedCounts.get(queueName) ?? 0) > 0 || bufferedCompletedQueues.has(queueName) || configured.has(queueName)) {
+      continue;
+    }
+    ctx.storage?.deleteQueueState(queueName);
+    ctx.storage?.deleteGroupState(queueName);
+    ctx.unregisterQueueName(queueName);
+    shard.obliterate(queueName);
+    removed.push(queueName);
   }
+  for (const shard of ctx.shards)
+    shard.cleanOrphanedTemporalEntries();
+  for (const queue of removed)
+    ctx.dashboardEmit?.("queue:removed", { queue });
 }
 
-// ../../src/domain/types/stall.ts
-var DEFAULT_STALL_CONFIG = {
-  enabled: true,
-  stallInterval: 30000,
-  maxStalls: 3,
-  gracePeriod: 5000
-};
-function checkStall(job, config = DEFAULT_STALL_CONFIG, now = Date.now()) {
-  if (job.startedAt === null) {
-    return {
-      isStalled: false,
-      stalledFor: 0,
-      shouldMoveToDlq: false,
-      newStallCount: job.stallCount
-    };
+// ../../src/application/cleanupTasks.ts
+async function cleanup(ctx) {
+  const now = Date.now();
+  const retention = ctx.config.completedRetentionMs;
+  if (retention !== null && retention !== undefined) {
+    const removed = cleanCompletedJobs(null, now - retention, 1000, ctx);
+    if (removed.length > 0) {
+      ctx.dashboardEmit?.("cleanup:completed-removed", { count: removed.length });
+    }
   }
-  if (now - job.startedAt < config.gracePeriod) {
-    return {
-      isStalled: false,
-      stalledFor: 0,
-      shouldMoveToDlq: false,
-      newStallCount: job.stallCount
-    };
+  for (let i = 0;i < SHARD_COUNT; i++) {
+    ctx.shards[i].refreshDelayedCount(now);
   }
-  const stallInterval = job.stallTimeout ?? config.stallInterval;
-  const stalledFor = now - job.lastHeartbeat;
-  const isStalled = stalledFor > stallInterval;
-  if (!isStalled) {
-    return {
-      isStalled: false,
-      stalledFor,
-      shouldMoveToDlq: false,
-      newStallCount: job.stallCount
-    };
+  for (let i = 0;i < SHARD_COUNT; i++) {
+    for (const q of ctx.shards[i].queues.values()) {
+      if (q.needsCompaction(0.2)) {
+        q.compact();
+      }
+    }
   }
-  const newStallCount = job.stallCount + 1;
-  const shouldMoveToDlq = newStallCount >= config.maxStalls;
-  return {
-    isStalled: true,
-    stalledFor,
-    shouldMoveToDlq,
-    newStallCount
-  };
+  await recoverOrphanedProcessingEntries(ctx, now);
+  await cleanStaleWaitingDependencies(ctx, now);
+  cleanUniqueKeysAndGroups(ctx, now);
+  cleanStalledCandidates(ctx);
+  await cleanOrphanedJobIndex(ctx);
+  cleanOrphanedJobLocks(ctx);
+  pruneEndedClientDeliveries(ctx);
+  cleanEmptyQueues(ctx);
 }
-function getStallAction(job, config = DEFAULT_STALL_CONFIG, now = Date.now()) {
-  const result = checkStall(job, config, now);
-  if (!result.isStalled) {
-    return "keep" /* Keep */;
-  }
-  if (result.shouldMoveToDlq) {
-    return "move_to_dlq" /* MoveToDlq */;
+async function cleanStaleWaitingDependencies(ctx, now) {
+  const depTimeout = 60 * 60 * 1000;
+  for (let i = 0;i < SHARD_COUNT; i++) {
+    const shard = ctx.shards[i];
+    const staleIds = [];
+    for (const [_id, job] of shard.waitingDeps) {
+      if (now - job.createdAt > depTimeout) {
+        staleIds.push(job.id);
+      }
+    }
+    if (staleIds.length === 0)
+      continue;
+    const removed = await withWriteLock(ctx.shardLocks[i], () => {
+      let count = 0;
+      const released = [];
+      for (const id of staleIds) {
+        const job = shard.waitingDeps.get(id);
+        if (!job || now - job.createdAt <= depTimeout)
+          continue;
+        ctx.storage?.deleteJob(job.id);
+        shard.waitingDeps.delete(job.id);
+        shard.unregisterDependencies(job.id, job.dependsOn);
+        released.push(...job.dependsOn);
+        if (job.uniqueKey && shard.getUniqueKeyEntry(job.queue, job.uniqueKey)?.jobId === job.id) {
+          shard.releaseUniqueKeyIfOwned(job.queue, job.uniqueKey, job.id);
+        }
+        if (job.customId && ctx.customIdMap.get(job.customId) === job.id) {
+          ctx.customIdMap.delete(job.customId);
+        }
+        ctx.dependencyResults?.releaseConsumer(job.id);
+        ctx.jobIndex.delete(job.id);
+        count++;
+      }
+      return { count, released };
+    });
+    releaseDependencyCompletionPins(removed.released, ctx);
+    if (removed.count > 0) {
+      ctx.dashboardEmit?.("cleanup:stale-deps-removed", { count: removed.count });
+    }
   }
-  return "retry" /* Retry */;
-}
-function incrementStallCount(job) {
-  job.stallCount++;
-  return job.stallCount;
 }
-
-// ../../src/domain/types/queue.ts
-function createQueueState(name) {
-  return {
-    name,
-    paused: false,
-    rateLimit: null,
-    rateLimitDuration: null,
-    rateLimitExpiresAt: null,
-    concurrencyLimit: null,
-    activeCount: 0
-  };
+function cleanUniqueKeysAndGroups(ctx, now) {
+  for (let i = 0;i < SHARD_COUNT; i++) {
+    const shard = ctx.shards[i];
+    shard.cleanExpiredGroupWindows(now);
+    shard.cleanExpiredUniqueKeys();
+    for (const [_queueName, keys] of shard.uniqueKeys) {
+      if (keys.size > 1000) {
+        const toRemove = Math.floor(keys.size / 2);
+        const iter = keys.keys();
+        for (let j = 0;j < toRemove; j++) {
+          const { value, done } = iter.next();
+          if (done)
+            break;
+          keys.delete(value);
+        }
+      }
+    }
+  }
 }
-
-class RateLimiter {
-  capacity;
-  refillRate;
-  tokens;
-  lastRefill;
-  constructor(capacity, refillRate = capacity) {
-    this.capacity = capacity;
-    this.refillRate = refillRate;
-    this.tokens = capacity;
-    this.lastRefill = Date.now();
+function cleanStalledCandidates(ctx) {
+  for (const jobId of ctx.stalledCandidates) {
+    const loc = ctx.jobIndex.get(jobId);
+    if (loc?.type !== "processing") {
+      ctx.stalledCandidates.delete(jobId);
+    }
   }
-  tryAcquire() {
-    this.refill();
-    if (this.tokens >= 1) {
-      this.tokens -= 1;
-      return true;
+}
+async function cleanOrphanedJobIndex(ctx) {
+  if (ctx.jobIndex.size <= 1e5)
+    return;
+  const processingCandidates = new Map;
+  const queueCandidates = new Map;
+  for (const [jobId, loc] of ctx.jobIndex) {
+    if (loc.type === "processing") {
+      const procIdx = processingShardIndex(jobId);
+      let list = processingCandidates.get(procIdx);
+      if (!list) {
+        list = [];
+        processingCandidates.set(procIdx, list);
+      }
+      list.push(jobId);
+    } else if (loc.type === "queue") {
+      let list = queueCandidates.get(loc.shardIdx);
+      if (!list) {
+        list = [];
+        queueCandidates.set(loc.shardIdx, list);
+      }
+      list.push({ jobId, queueName: loc.queueName });
     }
-    return false;
   }
-  refill() {
-    const now = Date.now();
-    const elapsed = (now - this.lastRefill) / 1000;
-    const tokensToAdd = elapsed * this.refillRate;
-    this.tokens = Math.min(this.capacity, this.tokens + tokensToAdd);
-    this.lastRefill = now;
+  for (const [procIdx, candidates] of processingCandidates) {
+    await withWriteLock(ctx.processingLocks[procIdx], () => {
+      for (const jobId of candidates) {
+        if (!ctx.processingShards[procIdx].has(jobId)) {
+          ctx.jobIndex.delete(jobId);
+        }
+      }
+    });
   }
-  getTokens() {
-    this.refill();
-    return this.tokens;
+  for (const [shardIdx, candidates] of queueCandidates) {
+    await withWriteLock(ctx.shardLocks[shardIdx], () => {
+      const shard = ctx.shards[shardIdx];
+      for (const { jobId, queueName } of candidates) {
+        if (!shard.getQueue(queueName).has(jobId)) {
+          ctx.jobIndex.delete(jobId);
+        }
+      }
+    });
   }
-  getTtl(maxJobs) {
-    const tokens = this.getTokens();
-    const consumed = this.capacity - tokens;
-    if (maxJobs !== undefined && consumed < maxJobs)
-      return 0;
-    if (tokens >= 1 || this.refillRate <= 0)
-      return 0;
-    return Math.ceil((1 - tokens) / this.refillRate * 1000);
+}
+function cleanOrphanedJobLocks(ctx) {
+  for (const jobId of ctx.jobLocks.keys()) {
+    const loc = ctx.jobIndex.get(jobId);
+    if (loc?.type !== "processing") {
+      ctx.jobLocks.delete(jobId);
+    }
   }
 }
 
-class ConcurrencyLimiter {
-  limit;
-  active = 0;
-  constructor(limit) {
-    this.limit = limit;
+// ../../src/application/dependencyProcessor.ts
+function dependencyReadyState(job, now) {
+  if (job.runAt > now)
+    return "delayed";
+  return job.priority > 0 ? "prioritized" : "waiting";
+}
+function checkpointDependencyPromotion(job, state, now, storage) {
+  if (job.timeline.at(-1)?.state !== state && job.timeline.length < MAX_TIMELINE_ENTRIES) {
+    job.timeline.push({ state, timestamp: now });
   }
-  tryAcquire() {
-    if (this.active < this.limit) {
-      this.active += 1;
-      return true;
+  storage?.updateFlowParentResolution(job, state);
+}
+async function processPendingDependencies(ctx) {
+  if (ctx.pendingDepChecks.size === 0)
+    return;
+  const completedIds = Array.from(ctx.pendingDepChecks);
+  const completedNow = new Set(completedIds);
+  ctx.pendingDepChecks.clear();
+  const jobsToCheckByShard = new Map;
+  const releasedDependencyIds = new Set;
+  for (const completedId of completedIds) {
+    for (let i = 0;i < SHARD_COUNT; i++) {
+      const waitingJobIds = ctx.shards[i].getJobsWaitingFor(completedId);
+      if (waitingJobIds && waitingJobIds.size > 0) {
+        let shardJobs = jobsToCheckByShard.get(i);
+        if (!shardJobs) {
+          shardJobs = new Set;
+          jobsToCheckByShard.set(i, shardJobs);
+        }
+        for (const jobId of waitingJobIds) {
+          shardJobs.add(jobId);
+        }
+      }
     }
-    return false;
   }
-  release() {
-    if (this.active > 0) {
-      this.active -= 1;
+  await Promise.all(Array.from(jobsToCheckByShard.entries()).map(async ([i, jobIdsToCheck]) => {
+    await withWriteLock(ctx.shardLocks[i], () => {
+      const shard = ctx.shards[i];
+      const jobsToPromote = [];
+      for (const jobId of jobIdsToCheck) {
+        const job = shard.waitingDeps.get(jobId);
+        if (job?.dependsOn.every((dep) => completedNow.has(dep) || ctx.completedJobs.has(dep) || (ctx.depCompletions?.has(dep) ?? false))) {
+          jobsToPromote.push(job);
+        }
+      }
+      if (jobsToPromote.length > 0) {
+        promoteJobsToQueue(jobsToPromote, shard, ctx, i, releasedDependencyIds);
+      }
+    });
+  }));
+  releaseDependencyCompletionPins(releasedDependencyIds, ctx);
+}
+function promoteJobsToQueue(jobsToPromote, shard, ctx, shardIdx, releasedDependencyIds) {
+  const now = Date.now();
+  for (const job of jobsToPromote) {
+    if (shard.waitingDeps.has(job.id)) {
+      const state = dependencyReadyState(job, now);
+      checkpointDependencyPromotion(job, state, now, ctx.storage);
+      shard.waitingDeps.delete(job.id);
+      shard.unregisterDependencies(job.id, job.dependsOn);
+      for (const dependencyId of job.dependsOn)
+        releasedDependencyIds.add(dependencyId);
+      shard.getQueue(job.queue).push(job);
+      const isDelayed = state === "delayed";
+      shard.incrementQueued(job.id, isDelayed, job.createdAt, job.queue, job.runAt);
+      ctx.jobIndex.set(job.id, { type: "queue", shardIdx, queueName: job.queue });
     }
   }
-  getActive() {
-    return this.active;
-  }
-  getLimit() {
-    return this.limit;
-  }
-  setLimit(limit) {
-    this.limit = limit;
+  if (jobsToPromote.length > 0) {
+    const promotedByQueue = new Map;
+    for (const job of jobsToPromote) {
+      promotedByQueue.set(job.queue, (promotedByQueue.get(job.queue) ?? 0) + 1);
+    }
+    for (const [queue, count] of promotedByQueue)
+      shard.notifyBatch(queue, count);
+    for (const job of jobsToPromote) {
+      ctx.dashboardEmit?.("job:dependencies-resolved", { jobId: String(job.id), queue: job.queue });
+    }
   }
 }
 
@@ -1273,16 +1613,10 @@ function createLock(jobId, owner, ctx, ttl = DEFAULT_LOCK_TTL) {
   const existing = ctx.jobLocks.get(jobId);
   if (existing) {
     const job = ctx.processingShards[loc.shardIdx].get(jobId);
-    const isNewGeneration = job?.startedAt !== null && job?.startedAt !== undefined && job.startedAt > existing.createdAt;
-    if (!isNewGeneration)
+    if (!job || !isLeaseFromEarlierGeneration(job, existing))
       return null;
     ctx.jobLocks.delete(jobId);
-    for (const [clientId, jobs] of ctx.clientJobs) {
-      if (!jobs.delete(jobId))
-        continue;
-      if (jobs.size === 0)
-        ctx.clientJobs.delete(clientId);
-    }
+    detachClientJob(jobId, ctx);
   }
   const lock = createJobLock(jobId, owner, ttl);
   ctx.jobLocks.set(jobId, lock);
@@ -1327,42 +1661,29 @@ function renewJobLockBatch(items, ctx) {
   return renewed;
 }
 function releaseLock(jobId, ctx, token) {
-  const lock = ctx.jobLocks.get(jobId);
-  if (!lock)
-    return true;
-  if (token && lock.token !== token) {
-    return false;
-  }
-  ctx.jobLocks.delete(jobId);
-  return true;
-}
-function getLockInfo(jobId, ctx) {
-  return ctx.jobLocks.get(jobId) ?? null;
-}
-// ../../src/application/clientTracking.ts
-function registerClientJob(clientId, jobId, ctx) {
-  let jobs = ctx.clientJobs.get(clientId);
-  if (!jobs) {
-    jobs = new Set;
-    ctx.clientJobs.set(clientId, jobs);
-  }
-  jobs.add(jobId);
-}
-function unregisterClientJob(clientId, jobId, ctx) {
-  if (!clientId)
-    return;
-  const jobs = ctx.clientJobs.get(clientId);
-  if (jobs) {
-    jobs.delete(jobId);
-    if (jobs.size === 0) {
-      ctx.clientJobs.delete(clientId);
-    }
+  const lock = ctx.jobLocks.get(jobId);
+  if (!lock)
+    return true;
+  if (token && lock.token !== token) {
+    return false;
   }
+  ctx.jobLocks.delete(jobId);
+  return true;
+}
+function getLockInfo(jobId, ctx) {
+  return ctx.jobLocks.get(jobId) ?? null;
+}
+// ../../src/application/clientTracking.ts
+function isReleasable(clientId, jobId, ctx) {
+  if (!ownsCurrentDelivery(clientId, jobId, ctx))
+    return false;
+  const lock = ctx.jobLocks.get(jobId);
+  return !(lock && lock.renewalCount > 0);
 }
 async function releaseClientJobs(clientId, ctx) {
   const jobs = ctx.clientJobs.get(clientId);
   if (!jobs || jobs.size === 0) {
-    ctx.clientJobs.delete(clientId);
+    dropClient(clientId, ctx);
     return 0;
   }
   const jobsToRelease = [];
@@ -1370,8 +1691,7 @@ async function releaseClientJobs(clientId, ctx) {
     const loc = ctx.jobIndex.get(jobId);
     if (loc?.type !== "processing")
       continue;
-    const lock = ctx.jobLocks.get(jobId);
-    if (lock && lock.renewalCount > 0)
+    if (!isReleasable(clientId, jobId, ctx))
       continue;
     const procIdx = loc.shardIdx;
     const job = ctx.processingShards[procIdx].get(jobId);
@@ -1384,7 +1704,7 @@ async function releaseClientJobs(clientId, ctx) {
     });
   }
   if (jobsToRelease.length === 0) {
-    ctx.clientJobs.delete(clientId);
+    dropClient(clientId, ctx);
     return 0;
   }
   const byProcShard = new Map;
@@ -1414,7 +1734,7 @@ async function releaseClientJobs(clientId, ctx) {
           await withWriteLock(ctx.processingLocks[procIdx], () => {
             for (const { jobId } of shardItems) {
               const job = ctx.processingShards[procIdx].get(jobId);
-              if (!job)
+              if (!job || !isReleasable(clientId, jobId, ctx))
                 continue;
               released += releaseJobToQueue({ jobId, job, procIdx, queueShardIdx, ctx, now });
             }
@@ -1424,17 +1744,19 @@ async function releaseClientJobs(clientId, ctx) {
     }
     return released;
   } finally {
-    ctx.clientJobs.delete(clientId);
+    dropClient(clientId, ctx);
   }
 }
 function forceReleaseClientJobs(clientId, ctx) {
   const jobs = ctx.clientJobs.get(clientId);
   if (!jobs || jobs.size === 0) {
-    ctx.clientJobs.delete(clientId);
+    dropClient(clientId, ctx);
     return 0;
   }
   let touched = 0;
   for (const jobId of jobs) {
+    if (!ownsCurrentDelivery(clientId, jobId, ctx))
+      continue;
     ctx.jobLocks.delete(jobId);
     const loc = ctx.jobIndex.get(jobId);
     if (loc?.type !== "processing")
@@ -1447,7 +1769,7 @@ function forceReleaseClientJobs(clientId, ctx) {
     ctx.timeoutScheduler.cancel(jobId);
     touched++;
   }
-  ctx.clientJobs.delete(clientId);
+  dropClient(clientId, ctx);
   return touched;
 }
 function releaseJobToQueue(opts) {
@@ -1456,6 +1778,7 @@ function releaseJobToQueue(opts) {
   ctx.processingShards[procIdx].delete(jobId);
   ctx.timeoutScheduler.cancel(jobId);
   ctx.jobLocks.delete(jobId);
+  detachClientJob(jobId, ctx);
   shard.releaseJobResources(job.queue, job.uniqueKey, job.groupId, job.id);
   if (job.uniqueKey?.startsWith("cron:")) {
     ctx.jobIndex.delete(jobId);
@@ -1479,7 +1802,7 @@ async function checkExpiredLocks(ctx) {
     if (isLockExpired(lock, now)) {
       const procIdx = processingShardIndex(jobId);
       const job = ctx.processingShards[procIdx].get(jobId);
-      if (job) {
+      if (job && !isLeaseFromEarlierGeneration(job, lock)) {
         const shardIdx = shardIndex(job.queue);
         expired.push({ jobId, lock, procIdx, shardIdx, job });
       } else {
@@ -1510,7 +1833,7 @@ async function checkExpiredLocks(ctx) {
           for (const { jobId, lock, job } of items) {
             const currentJob = ctx.processingShards[procIdx].get(jobId);
             const currentLock = ctx.jobLocks.get(jobId);
-            if (currentJob !== job || currentLock !== lock || !isLockExpired(currentLock, Date.now())) {
+            if (currentJob !== job || currentLock !== lock || !isLockExpired(currentLock, Date.now()) || isLeaseFromEarlierGeneration(currentJob, currentLock)) {
               continue;
             }
             processExpiredLockInner(jobId, lock, job, shardIdx, procIdx, ctx, now);
@@ -1525,6 +1848,7 @@ function processExpiredLockInner(jobId, lock, job, shardIdx, procIdx, ctx, now)
   const queue = shard.getQueue(job.queue);
   ctx.processingShards[procIdx].delete(jobId);
   ctx.timeoutScheduler.cancel(jobId);
+  detachClientJob(jobId, ctx);
   if (job.uniqueKey?.startsWith("cron:")) {
     ctx.retiredCronLeaseTokens.set(jobId, lock.token);
     shard.releaseJobResources(job.queue, job.uniqueKey, job.groupId, job.id);
@@ -1752,239 +2076,6 @@ function checkStorageSize(ctx) {
   }
 }
 
-// ../../src/shared/logger.ts
-var LOG_LEVEL_PRIORITY = {
-  debug: 0,
-  info: 1,
-  warn: 2,
-  error: 3
-};
-
-class Logger {
-  component;
-  static jsonMode = false;
-  static level = "info";
-  constructor(component) {
-    this.component = component;
-  }
-  static enableJsonMode() {
-    Logger.jsonMode = true;
-  }
-  static disableJsonMode() {
-    Logger.jsonMode = false;
-  }
-  static setLevel(level) {
-    Logger.level = level;
-  }
-  debug(message, data) {
-    this.log("debug", message, data);
-  }
-  debugToStderr(message, data) {
-    this.log("debug", message, data, true);
-  }
-  info(message, data) {
-    this.log("info", message, data);
-  }
-  infoToStderr(message, data) {
-    this.log("info", message, data, true);
-  }
-  warn(message, data) {
-    this.log("warn", message, data);
-  }
-  error(message, data) {
-    this.log("error", message, data);
-  }
-  log(level, message, data, forceStderr = false) {
-    if (LOG_LEVEL_PRIORITY[level] < LOG_LEVEL_PRIORITY[Logger.level])
-      return;
-    if (Logger.jsonMode) {
-      const entry = {
-        timestamp: new Date().toISOString(),
-        level,
-        component: this.component,
-        message,
-        ...data && { data }
-      };
-      if (forceStderr)
-        console.error(JSON.stringify(entry));
-      else
-        console.log(JSON.stringify(entry));
-    } else {
-      const prefix = `[${this.component}]`;
-      const dataStr = data ? ` ${JSON.stringify(data)}` : "";
-      switch (level) {
-        case "debug":
-          if (forceStderr)
-            console.error(`${prefix} ${message}${dataStr}`);
-          else
-            console.debug(`${prefix} ${message}${dataStr}`);
-          break;
-        case "info":
-          if (forceStderr)
-            console.error(`${prefix} ${message}${dataStr}`);
-          else
-            console.log(`${prefix} ${message}${dataStr}`);
-          break;
-        case "warn":
-          console.warn(`${prefix} ${message}${dataStr}`);
-          break;
-        case "error":
-          console.error(`${prefix} ${message}${dataStr}`);
-          break;
-      }
-    }
-  }
-}
-function createLogger(component) {
-  return new Logger(component);
-}
-var serverLog = createLogger("Server");
-var tcpLog = createLogger("TCP");
-var httpLog = createLogger("HTTP");
-var wsLog = createLogger("WS");
-var cronLog = createLogger("Cron");
-var statsLog = createLogger("Stats");
-var storageLog = createLogger("Storage");
-var queueLog = createLogger("Queue");
-var webhookLog = createLogger("Webhook");
-var backupLog = createLogger("Backup");
-
-// ../../src/application/stallDetection.ts
-function checkStalledJobs(ctx) {
-  const now = Date.now();
-  const confirmedStalled = [];
-  for (const jobId of ctx.stalledCandidates) {
-    const procIdx = processingShardIndex(jobId);
-    const job = ctx.processingShards[procIdx].get(jobId);
-    if (!job) {
-      ctx.stalledCandidates.delete(jobId);
-      continue;
-    }
-    const stallConfig = ctx.shards[shardIndex(job.queue)].getStallConfig(job.queue);
-    if (!stallConfig.enabled) {
-      ctx.stalledCandidates.delete(jobId);
-      continue;
-    }
-    const action = getStallAction(job, stallConfig, now);
-    if (action !== "keep" /* Keep */) {
-      confirmedStalled.push({ job, action });
-    }
-    ctx.stalledCandidates.delete(jobId);
-  }
-  for (let i = 0;i < SHARD_COUNT; i++) {
-    const procShard = ctx.processingShards[i];
-    for (const [jobId, job] of procShard) {
-      const stallConfig = ctx.shards[shardIndex(job.queue)].getStallConfig(job.queue);
-      if (!stallConfig.enabled)
-        continue;
-      const action = getStallAction(job, stallConfig, now);
-      if (action !== "keep" /* Keep */) {
-        ctx.stalledCandidates.add(jobId);
-      }
-    }
-  }
-  for (const { job, action } of confirmedStalled) {
-    handleStalledJob(job, action, ctx).catch((err) => {
-      queueLog.error("Failed to handle stalled job", {
-        jobId: String(job.id),
-        error: String(err)
-      });
-    });
-  }
-}
-async function handleStalledJob(job, action, ctx) {
-  const idx = shardIndex(job.queue);
-  const procIdx = processingShardIndex(job.id);
-  let handled = false;
-  let handledAction = action;
-  await withWriteLock(ctx.shardLocks[idx], async () => {
-    await withWriteLock(ctx.processingLocks[procIdx], () => {
-      if (!ctx.processingShards[procIdx].has(job.id)) {
-        return;
-      }
-      const shard = ctx.shards[idx];
-      const attemptsExhausted = job.attempts + 1 >= job.maxAttempts;
-      if (action === "move_to_dlq" /* MoveToDlq */ || attemptsExhausted) {
-        handledAction = "move_to_dlq" /* MoveToDlq */;
-        moveStalliedJobToDlq(job, ctx, shard, procIdx, attemptsExhausted);
-      } else {
-        retryStalliedJob(job, ctx, shard, procIdx, idx);
-      }
-      handled = true;
-    });
-  });
-  if (handled) {
-    ctx.dashboardEmit?.("job:stalled", {
-      jobId: String(job.id),
-      queue: job.queue,
-      stallCount: job.stallCount,
-      action: handledAction
-    });
-    ctx.eventsManager.broadcast({
-      eventType: "stalled" /* Stalled */,
-      queue: job.queue,
-      jobId: job.id,
-      timestamp: Date.now(),
-      data: { stallCount: job.stallCount, action: handledAction }
-    });
-    ctx.webhookManager.trigger("stalled", String(job.id), job.queue, {
-      data: { stallCount: job.stallCount, action: handledAction }
-    });
-  }
-}
-function moveStalliedJobToDlq(job, ctx, shard, procIdx, attemptsExhausted) {
-  ctx.processingShards[procIdx].delete(job.id);
-  ctx.timeoutScheduler.cancel(job.id);
-  shard.releaseJobResources(job.queue, job.uniqueKey, job.groupId, job.id);
-  if (job.uniqueKey?.startsWith("cron:")) {
-    ctx.jobIndex.delete(job.id);
-    ctx.storage?.deleteJob(job.id);
-    return;
-  }
-  incrementStallCount(job);
-  job.attempts++;
-  job.startedAt = null;
-  job.lastHeartbeat = Date.now();
-  const entry = shard.addToDlq(job, attemptsExhausted ? "max_attempts_exceeded" /* MaxAttemptsExceeded */ : "stalled" /* Stalled */, attemptsExhausted ? `Job stalled at max attempts (${job.maxAttempts})` : `Job stalled ${job.stallCount} times`);
-  ctx.jobIndex.set(job.id, { type: "dlq", queueName: job.queue });
-  ctx.storage?.saveDlqEntry(entry);
-  ctx.storage?.deleteJob(job.id);
-}
-function retryStalliedJob(job, ctx, shard, procIdx, idx) {
-  if (job.uniqueKey?.startsWith("cron:")) {
-    ctx.processingShards[procIdx].delete(job.id);
-    ctx.timeoutScheduler.cancel(job.id);
-    shard.releaseJobResources(job.queue, job.uniqueKey, job.groupId, job.id);
-    ctx.jobIndex.delete(job.id);
-    ctx.storage?.deleteJob(job.id);
-    return;
-  }
-  incrementStallCount(job);
-  job.attempts++;
-  const stallNow = Date.now();
-  recordJobFailureAttempt(job, "stalled" /* Stalled */, "stalled", stallNow);
-  job.startedAt = null;
-  job.runAt = stallNow + calculateBackoff(job);
-  job.lastHeartbeat = stallNow;
-  if (job.timeline.length < MAX_TIMELINE_ENTRIES) {
-    job.timeline.push({
-      state: "failed",
-      timestamp: stallNow,
-      error: "stalled",
-      attempt: job.attempts
-    });
-    job.timeline.push({ state: "waiting", timestamp: stallNow, attempt: job.attempts + 1 });
-  }
-  ctx.processingShards[procIdx].delete(job.id);
-  ctx.timeoutScheduler.cancel(job.id);
-  shard.releaseJobResources(job.queue, job.uniqueKey, job.groupId, job.id);
-  shard.getQueue(job.queue).push(job);
-  const isDelayed = job.runAt > Date.now();
-  shard.incrementQueued(job.id, isDelayed, job.createdAt, job.queue, job.runAt);
-  ctx.jobIndex.set(job.id, { type: "queue", shardIdx: idx, queueName: job.queue });
-  ctx.storage?.updateForRetry(job);
-}
-
 // ../../src/application/taskErrorTracking.ts
 var MAX_CONSECUTIVE_FAILURES = 5;
 var taskErrors = {
@@ -2407,6 +2498,7 @@ function getLockContext(ctx) {
     jobLocks: ctx.jobLocks,
     retiredCronLeaseTokens: ctx.retiredCronLeaseTokens,
     clientJobs: ctx.clientJobs,
+    clientJobOwners: ctx.clientJobOwners,
     processingShards: ctx.processingShards,
     processingLocks: ctx.processingLocks,
     shards: ctx.shards,
@@ -3665,7 +3757,7 @@ var latencyTracker = new LatencyTracker;
 // ../../package.json
 var package_default = {
   name: "bunqueue",
-  version: "2.9.6",
+  version: "2.9.7",
   description: "High-performance job queue for Bun and AI agents. Memory or one-file SQLite, optional PostgreSQL 15\u201318 multi-broker persistence, cron, retries, DLQ, and MCP.",
   keywords: [
     "agentic",
@@ -4279,12 +4371,7 @@ function isStorageDegraded(status) {
 // ../../src/application/operations/jobClaim.ts
 function releaseClaimedJobOwnership(jobId, ctx) {
   ctx.jobLocks.delete(jobId);
-  for (const [clientId, jobs] of ctx.clientJobs) {
-    if (!jobs.delete(jobId))
-      continue;
-    if (jobs.size === 0)
-      ctx.clientJobs.delete(clientId);
-  }
+  detachClientJob(jobId, ctx);
 }
 
 // ../../src/application/operations/jobMoveOperations.ts
@@ -7042,9 +7129,10 @@ function validateOptions(input) {
     if (input.backoff.type !== "fixed" && input.backoff.type !== "exponential") {
       throw new Error("backoff.type must be 'fixed' or 'exponential'");
     }
-    numeric(input.backoff.delay, "backoff.delay", 0, 24 * 60 * 60 * 1000);
+    numeric(input.backoff.delay, "backoff.delay", 0, MAX_BACKOFF_DELAY);
+    numeric(input.backoff.maxDelay, "backoff.maxDelay", 0, MAX_BACKOFF_DELAY);
   } else {
-    numeric(input.backoff, "backoff", 0, 24 * 60 * 60 * 1000);
+    numeric(input.backoff, "backoff", 0, MAX_BACKOFF_DELAY);
   }
   for (const name of BOOLEAN_OPTIONS) {
     const value = input[name];
@@ -13832,6 +13920,7 @@ class ContextFactory {
       jobLocks: this.deps.jobLocks,
       retiredCronLeaseTokens: this.deps.retiredCronLeaseTokens,
       clientJobs: this.deps.clientJobs,
+      clientJobOwners: this.deps.clientJobOwners,
       processingShards: this.deps.processingShards,
       processingLocks: this.deps.processingLocks,
       shards: this.deps.shards,
@@ -13865,6 +13954,7 @@ class ContextFactory {
       jobLocks: this.deps.jobLocks,
       retiredCronLeaseTokens: this.deps.retiredCronLeaseTokens,
       clientJobs: this.deps.clientJobs,
+      clientJobOwners: this.deps.clientJobOwners,
       stalledCandidates: this.deps.stalledCandidates,
       pendingDepChecks: this.deps.pendingDepChecks,
       pendingQueueAdmissions: this.deps.pendingQueueAdmissions,
@@ -13988,6 +14078,7 @@ class ContextFactory {
       jobIndex: this.deps.jobIndex,
       jobLocks: this.deps.jobLocks,
       clientJobs: this.deps.clientJobs,
+      clientJobOwners: this.deps.clientJobOwners,
       dependencyResults: this.deps.dependencyResults,
       customIdMap: this.deps.customIdMap,
       depCompletions: this.deps.depCompletions,
@@ -14434,6 +14525,7 @@ function createContextDependencies(state) {
     jobLogQueues: state.jobLogQueues,
     jobLocks: state.jobLocks,
     clientJobs: state.clientJobs,
+    clientJobOwners: state.clientJobOwners,
     stalledCandidates: state.stalledCandidates,
     pendingDepChecks: state.pendingDepChecks,
     pendingQueueAdmissions: state.pendingQueueAdmissions,
@@ -14502,6 +14594,7 @@ class QueueManagerState {
   depFlushRunning = false;
   jobLocks = new Map;
   clientJobs = new Map;
+  clientJobOwners = new Map;
   repeatChain = new Map;
   failedChildrenValues = new Map;
   ignoredChildrenFailures = new Map;
@@ -14688,7 +14781,7 @@ class QueueManagerDelivery extends QueueManagerState {
     if (location?.type !== "processing")
       return;
     const job = this.processingShards[location.shardIdx].get(jobId);
-    if (!job || job.startedAt !== null && job.startedAt > lock.createdAt) {
+    if (!job || isLeaseFromEarlierGeneration(job, lock)) {
       throw new Error(`Invalid or expired lock token for job ${jobId}`);
     }
   }
@@ -14700,7 +14793,7 @@ class QueueManagerDelivery extends QueueManagerState {
     if (lock?.token !== token)
       return false;
     const job = this.processingShards[location.shardIdx].get(jobId);
-    return !(job && job.startedAt !== null && job.startedAt > lock.createdAt);
+    return !(job && isLeaseFromEarlierGeneration(job, lock));
   }
   isStallRetried(jobId) {
     const location = this.jobIndex.get(jobId);
@@ -14942,11 +15035,7 @@ class QueueManagerAck extends QueueManagerDelivery {
     if (lock)
       this.retiredTimeoutLeaseTokens.set(lock.token, generation);
     releaseLock(job.id, this.contextFactory.getLockContext(), lock?.token);
-    for (const [clientId, jobs] of this.clientJobs) {
-      jobs.delete(job.id);
-      if (jobs.size === 0)
-        this.clientJobs.delete(clientId);
-    }
+    detachClientJob(job.id, { clientJobs: this.clientJobs, clientJobOwners: this.clientJobOwners });
   }
   async failWithOptions(jobId, error, token, options, enforceLease = true) {
     try {
@@ -15228,11 +15317,13 @@ class QueueManagerControl extends QueueManagerQueries {
         toDrop.add(jobId);
       }
     }
+    const ownership = { clientJobs: this.clientJobs, clientJobOwners: this.clientJobOwners };
     for (const jobId of toDrop) {
       const location = this.jobIndex.get(jobId);
       if (location?.type === "processing") {
         this.processingShards[location.shardIdx]?.delete(jobId);
       }
+      detachClientJob(jobId, ownership);
       this.timeoutScheduler.cancel(jobId);
       this.jobIndex.delete(jobId);
       this.completedJobs.delete(jobId);
@@ -16344,6 +16435,7 @@ class QueueManagerLifecycle extends QueueManagerDependencies {
     this.jobLocks.clear();
     this.stalledCandidates.clear();
     this.clientJobs.clear();
+    this.clientJobOwners.clear();
     this.repeatChain.clear();
     this.failedChildrenValues.clear();
     this.ignoredChildrenFailures.clear();