@kronos-ts/messaging 0.3.1 → 0.5.0

package/src/sequencing-policy.ts

@@ -0,0 +1,55 @@
+import { qualifiedNameToString } from "@kronos-ts/common"
+import type { EventMessage } from "./message.js"
+
+/**
+ * Decides which ordered sequence an event belongs to.
+ *
+ * Events sharing a sequence identifier are processed in order; if one is
+ * dead-lettered, subsequent events in the same sequence are parked behind it
+ * (see {@link createDeadLetteringDelivery}). This is the minimal analog of
+ * Axon's `SequencingPolicy` — a plain function rather than a class hierarchy,
+ * because Kronos does not (yet) do segmented parallel processing where the
+ * policy would also drive segment assignment. When/if it does, this same type
+ * is the seam to extend.
+ */
+export type SequencingPolicy = (event: EventMessage) => string
+
+/**
+ * Sequences events by the value of a named tag, falling back to the event name
+ * when the tag is absent. The DCB/tag-world analog of Axon's
+ * `SequentialPerAggregatePolicy` (aggregate id → sequence).
+ *
+ * Prefer this — naming the tag explicitly — over relying on tag *order*.
+ *
+ * ```typescript
+ * trackingProcessor("balances")
+ *   .deadLetterQueue(dlq)
+ *   .sequencingPolicy(sequentialPerTag("accountId"))
+ * ```
+ */
+export function sequentialPerTag(tagKey: string): SequencingPolicy {
+  return (event) => {
+    const match = event.tags.find((t) => t.key === tagKey)
+    return match ? match.value : qualifiedNameToString(event.name)
+  }
+}
+
+/**
+ * Default policy: sequence by the first tag value, else the event name.
+ *
+ * Order-dependent on the tag list, so it is a reasonable default but a poor
+ * deliberate choice — prefer {@link sequentialPerTag} with an explicit key.
+ */
+export const defaultSequencingPolicy: SequencingPolicy = (event) => {
+  if (event.tags.length > 0) {
+    return event.tags[0]!.value
+  }
+  return qualifiedNameToString(event.name)
+}
+
+/**
+ * Full concurrency: every event is its own singleton sequence (keyed by the
+ * unique message identifier), so no two events ever block each other. Use when
+ * handlers carry no cross-event ordering requirement.
+ */
+export const fullConcurrencyPolicy: SequencingPolicy = (event) => event.identifier

package/src/streaming-event-processor.ts

@@ -5,6 +5,14 @@ import type { StreamableEventSource, MessageStream, SequencedEvent } from "./eve
 import type { UoWRunner } from "./unit-of-work.js"
 import { runInNewUoW } from "./unit-of-work.js"
 import type { TokenStore } from "./token-store.js"
+import type { SequencedDeadLetterQueue, EnqueuePolicy, DeadLetter } from "./dead-letter-queue.js"
+import type { SequencingPolicy } from "./sequencing-policy.js"
+import { createDeadLetteringDelivery } from "./dead-lettering-handler.js"
+import { type DeadLetterListener, noOpDeadLetterListener } from "./dead-letter-listener.js"
+import {
+  type DeadLetterReprocessor,
+  createDeadLetterReprocessor,
+} from "./dead-letter-reprocessor.js"
 import type { EventProcessingErrorHandler } from "./tracking-event-processor.js"
 import { loggingErrorHandler } from "./tracking-event-processor.js"
 import type { HandlerEnhancerDefinition } from "./handler-enhancer.js"
@@ -20,7 +28,8 @@ import { REPLAY_STATE_KEY } from "./replay-token.js"
 import { setResource, onPrepareCommit } from "./processing-state.js"
 import type { CommandBus } from "./command-bus.js"
 import type { QueryBus } from "./query-bus.js"
-import { STATE_MANAGER_KEY } from "@kronos-ts/eventsourcing"
+import { STATE_MANAGER_KEY, EVENT_SCHEDULER_KEY } from "@kronos-ts/eventsourcing"
+import type { EventScheduler } from "./event-scheduler.js"
 import { COMMAND_BUS_KEY } from "./send.js"
 import { QUERY_BUS_KEY } from "./emit-update.js"
 
@@ -55,6 +64,9 @@ export interface StreamingEventProcessor {
   start(): Promise<void>
   stop(): void
   resetTokens(startPosition?: bigint, resetContext?: unknown): Promise<void>
+  /** Replay parked dead letters back through the handlers (oldest matching
+   * sequence). No-op returning false when no DLQ is configured. */
+  reprocessDeadLetters(filter?: (sequenceId: string) => boolean): Promise<boolean>
   splitSegment(segmentId: number): Promise<boolean>
   mergeSegment(segmentId: number): Promise<boolean>
   releaseSegment(segmentId: number): Promise<void>
@@ -70,10 +82,30 @@ export interface StreamingEventProcessorOptions {
   commandBus?: CommandBus
   /** Query bus injected into ALS at handler-invocation entry (D-44). */
   queryBus?: QueryBus
+  /** Event scheduler injected into ALS at handler-invocation entry (read by schedule()). */
+  eventScheduler?: EventScheduler
   /** Optional per-event callback fired inside the UoW before handler invocation (e.g. monitoring). */
   onEventDelivery?: () => void
   unitOfWorkRunner?: UoWRunner
   tokenStore?: TokenStore
+  /**
+   * Dead letter queue for poison-pill handling. When set, a handler failure
+   * parks the event in the DLQ (per {@link enqueuePolicy}) and the batch
+   * commits so the token advances past it — instead of redelivering the batch
+   * forever. The enqueue runs inside the batch UnitOfWork, so it commits in the
+   * same transaction as the token update.
+   */
+  deadLetterQueue?: SequencedDeadLetterQueue
+  /** Decides whether a failed event is enqueued. Default: always enqueue. */
+  enqueuePolicy?: EnqueuePolicy
+  /** Decides each event's ordered sequence for the DLQ. Default: first tag value. */
+  sequencingPolicy?: SequencingPolicy
+  /** Observability hook for dead-letter lifecycle events. Default: no-op. */
+  deadLetterListener?: DeadLetterListener
+  /** When true, resetTokens() also clears this processor's DLQ (Axon allowReset). Default: false. */
+  resetClearsDeadLetters?: boolean
+  /** When set, automatically drains the DLQ on this interval (ms). Off by default. */
+  dlqRetryIntervalMs?: number
   batchSize?: number
   /** Delay before retrying after a batch failure, in ms. Backs off to avoid hot-looping a deterministic failure. */
   errorBackoffMs?: number
@@ -94,10 +126,17 @@ export function createStreamingEventProcessor(
     stateManager,
     commandBus,
     queryBus,
+    eventScheduler,
     onEventDelivery,
     unitOfWorkRunner = runInNewUoW,
     tokenStore,
-    batchSize = 100,
+    deadLetterQueue,
+    enqueuePolicy,
+    sequencingPolicy,
+    deadLetterListener = noOpDeadLetterListener(),
+    resetClearsDeadLetters = false,
+    dlqRetryIntervalMs,
+    batchSize = 1,
     errorBackoffMs = 1000,
     errorHandler = loggingErrorHandler(name),
     handlerEnhancer,
@@ -106,6 +145,31 @@ export function createStreamingEventProcessor(
 
   const segment = 0
 
+  // Option A: when a DLQ is configured, handler failures are caught and parked
+  // (not propagated), so the batch commits and the token advances past the
+  // poison pill. Built once; invoked inside the batch UnitOfWork by deliverEvent.
+  const deadLetterDelivery = deadLetterQueue
+    ? createDeadLetteringDelivery({
+        queue: deadLetterQueue,
+        policy: enqueuePolicy,
+        sequencingPolicy,
+        listener: deadLetterListener,
+      })
+    : undefined
+
+  // Reprocessor: replays a parked letter through the same handlers, with the
+  // same ALS resources as live delivery, so dependencies resolve identically.
+  const reprocessor: DeadLetterReprocessor | undefined = deadLetterQueue
+    ? createDeadLetterReprocessor({
+        queue: deadLetterQueue,
+        policy: enqueuePolicy,
+        unitOfWorkRunner,
+        listener: deadLetterListener,
+        replay: replayDeadLetter,
+      })
+    : undefined
+  let dlqRetryTimer: ReturnType<typeof setInterval> | null = null
+
   const handlerMap = new Map<string, Array<EventHandlerRegistration<any>>>()
   for (const reg of eventHandlers) {
     const eventName = qualifiedNameToString(reg.descriptor.name)
@@ -265,9 +329,18 @@ export function createStreamingEventProcessor(
     if (stateManager !== undefined) setResource(STATE_MANAGER_KEY, stateManager as any)
     if (commandBus !== undefined) setResource(COMMAND_BUS_KEY, commandBus)
     if (queryBus !== undefined) setResource(QUERY_BUS_KEY, queryBus)
+    if (eventScheduler !== undefined) setResource(EVENT_SCHEDULER_KEY, eventScheduler)
     // Optional per-event callback (e.g. monitoring hooks registered inside the UoW).
     if (onEventDelivery) onEventDelivery()
 
+    // DLQ path: park failures, keep the batch committable (Option A). The DLQ
+    // delivery enforces per-sequence ordering and never propagates, so the
+    // errorHandler / batch-redelivery path is bypassed while a DLQ is active.
+    if (deadLetterDelivery) {
+      await deadLetterDelivery.deliver(sequencedEvent, handlers)
+      return
+    }
+
     for (const reg of handlers) {
       try {
         await reg.handler({ ...event, sequence: sequencedEvent.sequence })
@@ -277,6 +350,28 @@ export function createStreamingEventProcessor(
     }
   }
 
+  // Replay a parked dead letter through the handlers, re-establishing the same
+  // ALS resources as live delivery. Throws on the first handler failure so the
+  // reprocessor can requeue the letter (delivery is at-least-once → handlers
+  // must be idempotent).
+  async function replayDeadLetter(letter: DeadLetter): Promise<void> {
+    const event = letter.message
+    const eventName = qualifiedNameToString(event.name)
+    const handlers = handlerMap.get(eventName)
+    if (!handlers || handlers.length === 0) return
+
+    if (stateManager !== undefined) setResource(STATE_MANAGER_KEY, stateManager as any)
+    if (commandBus !== undefined) setResource(COMMAND_BUS_KEY, commandBus)
+    if (queryBus !== undefined) setResource(QUERY_BUS_KEY, queryBus)
+    if (eventScheduler !== undefined) setResource(EVENT_SCHEDULER_KEY, eventScheduler)
+
+    const position =
+      typeof letter.diagnostics.position === "number" ? BigInt(letter.diagnostics.position) : 0n
+    for (const reg of handlers) {
+      await reg.handler({ ...event, sequence: position })
+    }
+  }
+
   function scheduleImmediate() {
     if (processTimer !== null) {
       clearTimeout(processTimer)
@@ -308,6 +403,13 @@ export function createStreamingEventProcessor(
       isRunning = true
       openStream()
       scheduleImmediate()
+      if (reprocessor && dlqRetryIntervalMs && dlqRetryIntervalMs > 0) {
+        dlqRetryTimer = setInterval(() => {
+          void reprocessor.reprocessAll().catch((err) => {
+            console.error(`Event processor "${name}": scheduled DLQ drain failed:`, err)
+          })
+        }, dlqRetryIntervalMs)
+      }
     },
 
     stop() {
@@ -316,12 +418,21 @@ export function createStreamingEventProcessor(
         clearTimeout(processTimer)
         processTimer = null
       }
+      if (dlqRetryTimer !== null) {
+        clearInterval(dlqRetryTimer)
+        dlqRetryTimer = null
+      }
       if (stream) {
         stream.close()
         stream = null
       }
     },
 
+    async reprocessDeadLetters(filter?: (sequenceId: string) => boolean) {
+      if (!reprocessor) return false
+      return reprocessor.reprocess(filter)
+    },
+
     async resetTokens(startPosition: bigint = 0n, resetContext?: unknown) {
       if (isRunning) {
         throw new Error(`Processor "${name}" must be stopped before resetting tokens`)
@@ -343,6 +454,12 @@ export function createStreamingEventProcessor(
         await tokenStore.store(name, segment, token)
       }
 
+      // Axon allowReset: only clear parked letters when opted in (a replay
+      // re-derives view state, making prior dead letters meaningless).
+      if (resetClearsDeadLetters && deadLetterQueue) {
+        await deadLetterQueue.clear()
+      }
+
       if (onReset) {
         await onReset()
       }

package/src/subscribing-event-processor.ts

@@ -11,7 +11,8 @@ import type { CommandBus } from "./command-bus.js"
 import type { QueryBus } from "./query-bus.js"
 import type { HandlerEnhancerDefinition } from "./handler-enhancer.js"
 import { setResource } from "./processing-state.js"
-import { STATE_MANAGER_KEY } from "@kronos-ts/eventsourcing"
+import { STATE_MANAGER_KEY, EVENT_SCHEDULER_KEY } from "@kronos-ts/eventsourcing"
+import type { EventScheduler } from "./event-scheduler.js"
 import { COMMAND_BUS_KEY } from "./send.js"
 import { QUERY_BUS_KEY } from "./emit-update.js"
 
@@ -27,6 +28,12 @@ export type { SubscribableEventSource } from "./event-bus.js"
  * - Processes events synchronously with the publisher
  * - Is suitable for in-memory projections that don't need persistence
  *
+ * It also does **not** support a dead-letter queue — deliberately. A DLQ exists
+ * to let a processor advance its token past a poison pill and reprocess later;
+ * a subscribing processor has no token and runs in the publisher's call stack,
+ * so a failure must surface to the publisher (via the error handler), not be
+ * silently parked. Use a tracking/streaming processor with `.deadLetterQueue()`
+ * when you need dead-lettering.
  */
 export interface SubscribingEventProcessor {
   readonly name: string
@@ -47,6 +54,8 @@ export interface SubscribingEventProcessorOptions {
   commandBus?: CommandBus
   /** Query bus injected into ALS at handler-invocation entry (D-44). */
   queryBus?: QueryBus
+  /** Event scheduler injected into ALS at handler-invocation entry (read by schedule()). */
+  eventScheduler?: EventScheduler
   /** Optional per-event callback fired inside the UoW before handler invocation (e.g. monitoring). */
   onEventDelivery?: () => void
   unitOfWorkRunner?: UoWRunner
@@ -77,6 +86,7 @@ export function createSubscribingEventProcessor(
     stateManager,
     commandBus,
     queryBus,
+    eventScheduler,
     onEventDelivery,
     unitOfWorkRunner = runInNewUoW,
     errorHandler = loggingErrorHandler(name),
@@ -130,6 +140,7 @@ export function createSubscribingEventProcessor(
     if (stateManager !== undefined) setResource(STATE_MANAGER_KEY, stateManager as any)
     if (commandBus !== undefined) setResource(COMMAND_BUS_KEY, commandBus)
     if (queryBus !== undefined) setResource(QUERY_BUS_KEY, queryBus)
+    if (eventScheduler !== undefined) setResource(EVENT_SCHEDULER_KEY, eventScheduler)
     // Optional per-event callback (e.g. monitoring hooks registered inside the UoW).
     if (onEventDelivery) onEventDelivery()
 

package/src/tracking-event-processor.ts

@@ -5,6 +5,14 @@ import type { StreamableEventSource, MessageStream, SequencedEvent } from "./eve
 import type { UoWRunner } from "./unit-of-work.js"
 import { runInNewUoW } from "./unit-of-work.js"
 import type { TokenStore } from "./token-store.js"
+import type { SequencedDeadLetterQueue, EnqueuePolicy, DeadLetter } from "./dead-letter-queue.js"
+import type { SequencingPolicy } from "./sequencing-policy.js"
+import { createDeadLetteringDelivery } from "./dead-lettering-handler.js"
+import { type DeadLetterListener, noOpDeadLetterListener } from "./dead-letter-listener.js"
+import {
+  type DeadLetterReprocessor,
+  createDeadLetterReprocessor,
+} from "./dead-letter-reprocessor.js"
 import type { TrackingToken } from "./tracking-token.js"
 import {
   globalSequenceToken,
@@ -18,7 +26,8 @@ import { setResource, onPrepareCommit } from "./processing-state.js"
 import type { HandlerEnhancerDefinition } from "./handler-enhancer.js"
 import type { CommandBus } from "./command-bus.js"
 import type { QueryBus } from "./query-bus.js"
-import { STATE_MANAGER_KEY } from "@kronos-ts/eventsourcing"
+import { STATE_MANAGER_KEY, EVENT_SCHEDULER_KEY } from "@kronos-ts/eventsourcing"
+import type { EventScheduler } from "./event-scheduler.js"
 import { COMMAND_BUS_KEY } from "./send.js"
 import { QUERY_BUS_KEY } from "./emit-update.js"
 
@@ -47,6 +56,12 @@ export interface TrackingEventProcessor {
    * The processor must be stopped before calling this.
    */
   resetTokens(startPosition?: bigint, resetContext?: unknown): Promise<void>
+  /**
+   * Replay parked dead letters back through the handlers (the oldest matching
+   * sequence). No-op returning false when no DLQ is configured. Safe to call
+   * whether or not the processor is running.
+   */
+  reprocessDeadLetters(filter?: (sequenceId: string) => boolean): Promise<boolean>
 }
 
 export interface TrackingEventProcessorOptions {
@@ -59,10 +74,30 @@ export interface TrackingEventProcessorOptions {
   commandBus?: CommandBus
   /** Query bus injected into ALS at handler-invocation entry (D-44). */
   queryBus?: QueryBus
+  /** Event scheduler injected into ALS at handler-invocation entry (read by schedule()). */
+  eventScheduler?: EventScheduler
   /** Optional per-event callback fired inside the UoW before handler invocation (e.g. monitoring). */
   onEventDelivery?: () => void
   unitOfWorkRunner?: UoWRunner
   tokenStore?: TokenStore
+  /**
+   * Dead letter queue for poison-pill handling. When set, a handler failure
+   * parks the event in the DLQ (per {@link enqueuePolicy}) and the batch
+   * commits so the token advances past it — instead of redelivering the batch
+   * forever. The enqueue runs inside the batch UnitOfWork, so it commits in the
+   * same transaction as the token update.
+   */
+  deadLetterQueue?: SequencedDeadLetterQueue
+  /** Decides whether a failed event is enqueued. Default: always enqueue. */
+  enqueuePolicy?: EnqueuePolicy
+  /** Decides each event's ordered sequence for the DLQ. Default: first tag value. */
+  sequencingPolicy?: SequencingPolicy
+  /** Observability hook for dead-letter lifecycle events. Default: no-op. */
+  deadLetterListener?: DeadLetterListener
+  /** When true, resetTokens() also clears this processor's DLQ (Axon allowReset). Default: false. */
+  resetClearsDeadLetters?: boolean
+  /** When set, automatically drains the DLQ on this interval (ms). Off by default. */
+  dlqRetryIntervalMs?: number
   /** Polling interval when no events are available (ms). Default: 500. */
   pollingIntervalMs?: number
   batchSize?: number
@@ -115,11 +150,18 @@ export function createTrackingEventProcessor(
     stateManager,
     commandBus,
     queryBus,
+    eventScheduler,
     onEventDelivery,
     unitOfWorkRunner = runInNewUoW,
     tokenStore,
+    deadLetterQueue,
+    enqueuePolicy,
+    sequencingPolicy,
+    deadLetterListener = noOpDeadLetterListener(),
+    resetClearsDeadLetters = false,
+    dlqRetryIntervalMs,
     pollingIntervalMs = 500,
-    batchSize = 100,
+    batchSize = 1,
     errorHandler = loggingErrorHandler(name),
     handlerEnhancer,
     onReset,
@@ -127,6 +169,31 @@ export function createTrackingEventProcessor(
 
   const segment = 0
 
+  // Option A: when a DLQ is configured, handler failures are caught and parked
+  // (not propagated), so the batch commits and the token advances past the
+  // poison pill. Built once; invoked inside the batch UnitOfWork by deliverEvent.
+  const deadLetterDelivery = deadLetterQueue
+    ? createDeadLetteringDelivery({
+        queue: deadLetterQueue,
+        policy: enqueuePolicy,
+        sequencingPolicy,
+        listener: deadLetterListener,
+      })
+    : undefined
+
+  // Reprocessor: replays a parked letter through the same handlers, with the
+  // same ALS resources as live delivery, so dependencies resolve identically.
+  const reprocessor: DeadLetterReprocessor | undefined = deadLetterQueue
+    ? createDeadLetterReprocessor({
+        queue: deadLetterQueue,
+        policy: enqueuePolicy,
+        unitOfWorkRunner,
+        listener: deadLetterListener,
+        replay: replayDeadLetter,
+      })
+    : undefined
+  let dlqRetryTimer: ReturnType<typeof setInterval> | null = null
+
   const handlerMap = new Map<string, Array<EventHandlerRegistration<any>>>()
   for (const reg of eventHandlers) {
     const eventName = qualifiedNameToString(reg.descriptor.name)
@@ -273,9 +340,18 @@ export function createTrackingEventProcessor(
     if (stateManager !== undefined) setResource(STATE_MANAGER_KEY, stateManager as any)
     if (commandBus !== undefined) setResource(COMMAND_BUS_KEY, commandBus)
     if (queryBus !== undefined) setResource(QUERY_BUS_KEY, queryBus)
+    if (eventScheduler !== undefined) setResource(EVENT_SCHEDULER_KEY, eventScheduler)
     // Optional per-event callback (e.g. monitoring hooks registered inside the UoW).
     if (onEventDelivery) onEventDelivery()
 
+    // DLQ path: park failures, keep the batch committable (Option A). The DLQ
+    // delivery enforces per-sequence ordering and never propagates, so the
+    // errorHandler / batch-redelivery path is bypassed while a DLQ is active.
+    if (deadLetterDelivery) {
+      await deadLetterDelivery.deliver(sequencedEvent, handlers)
+      return
+    }
+
     for (const reg of handlers) {
       try {
         await reg.handler({ ...event, sequence: sequencedEvent.sequence })
@@ -285,6 +361,28 @@ export function createTrackingEventProcessor(
     }
   }
 
+  // Replay a parked dead letter through the handlers, re-establishing the same
+  // ALS resources as live delivery. Throws on the first handler failure so the
+  // reprocessor can requeue the letter (delivery is at-least-once → handlers
+  // must be idempotent).
+  async function replayDeadLetter(letter: DeadLetter): Promise<void> {
+    const event = letter.message
+    const eventName = qualifiedNameToString(event.name)
+    const handlers = handlerMap.get(eventName)
+    if (!handlers || handlers.length === 0) return
+
+    if (stateManager !== undefined) setResource(STATE_MANAGER_KEY, stateManager as any)
+    if (commandBus !== undefined) setResource(COMMAND_BUS_KEY, commandBus)
+    if (queryBus !== undefined) setResource(QUERY_BUS_KEY, queryBus)
+    if (eventScheduler !== undefined) setResource(EVENT_SCHEDULER_KEY, eventScheduler)
+
+    const position =
+      typeof letter.diagnostics.position === "number" ? BigInt(letter.diagnostics.position) : 0n
+    for (const reg of handlers) {
+      await reg.handler({ ...event, sequence: position })
+    }
+  }
+
   function scheduleImmediate() {
     if (pollTimer !== null) {
       clearTimeout(pollTimer)
@@ -303,6 +401,15 @@ export function createTrackingEventProcessor(
       await initialize()
       isRunning = true
       poll()
+      // Optional scheduled DLQ drain — operators can also trigger reprocessing
+      // manually via reprocessDeadLetters().
+      if (reprocessor && dlqRetryIntervalMs && dlqRetryIntervalMs > 0) {
+        dlqRetryTimer = setInterval(() => {
+          void reprocessor.reprocessAll().catch((err) => {
+            console.error(`Event processor "${name}": scheduled DLQ drain failed:`, err)
+          })
+        }, dlqRetryIntervalMs)
+      }
     },
 
     stop() {
@@ -311,12 +418,21 @@ export function createTrackingEventProcessor(
         clearTimeout(pollTimer)
         pollTimer = null
       }
+      if (dlqRetryTimer !== null) {
+        clearInterval(dlqRetryTimer)
+        dlqRetryTimer = null
+      }
       if (stream) {
         stream.close()
         stream = null
       }
     },
 
+    async reprocessDeadLetters(filter?: (sequenceId: string) => boolean) {
+      if (!reprocessor) return false
+      return reprocessor.reprocess(filter)
+    },
+
     async resetTokens(startPosition: bigint = 0n, resetContext?: unknown) {
       if (isRunning) {
         throw new Error(`Processor "${name}" must be stopped before resetting tokens`)
@@ -338,6 +454,13 @@ export function createTrackingEventProcessor(
         await tokenStore.store(name, segment, token)
       }
 
+      // Axon allowReset: a replay re-derives view state from scratch, so stale
+      // dead letters from the prior run are meaningless. Only clear when opted
+      // in — otherwise parked letters survive a reset for manual handling.
+      if (resetClearsDeadLetters && deadLetterQueue) {
+        await deadLetterQueue.clear()
+      }
+
       if (onReset) {
         await onReset()
       }