@trigger.dev/redis-worker 4.5.8 → 4.5.10

package/dist/index.d.cts

@@ -1,295 +1,293 @@
-import { Callback, Result, RedisOptions, Redis } from '@internal/redis';
-import { Logger } from '@trigger.dev/core/logger';
-import { z } from 'zod';
-import { Tracer, Meter, Attributes, Span, Context, Counter, Histogram, ObservableGauge, SpanKind } from '@internal/tracing';
-import { RetryOptions as RetryOptions$1 } from '@trigger.dev/core/v3/schemas';
-
+import { Callback, Redis, RedisOptions, Result } from "@internal/redis";
+import { Logger } from "@trigger.dev/core/logger";
+import { z } from "zod";
+import { Attributes, Context, Counter, Histogram, Meter, ObservableGauge, Span, SpanKind, Tracer } from "@internal/tracing";
+import { RetryOptions as RetryOptions$1 } from "@trigger.dev/core/v3/schemas";
+//#region src/queue.d.ts
 interface MessageCatalogSchema {
-    [key: string]: z.ZodFirstPartySchemaTypes | z.ZodDiscriminatedUnion<any, any>;
+  [key: string]: z.ZodFirstPartySchemaTypes | z.ZodDiscriminatedUnion<any, any>;
 }
 type MessageCatalogKey<TMessageCatalog extends MessageCatalogSchema> = keyof TMessageCatalog;
 type MessageCatalogValue<TMessageCatalog extends MessageCatalogSchema, TKey extends MessageCatalogKey<TMessageCatalog>> = z.infer<TMessageCatalog[TKey]>;
 type AnyMessageCatalog = MessageCatalogSchema;
 type QueueItem<TMessageCatalog extends MessageCatalogSchema> = {
-    id: string;
-    job: MessageCatalogKey<TMessageCatalog>;
-    item: MessageCatalogValue<TMessageCatalog, MessageCatalogKey<TMessageCatalog>>;
-    visibilityTimeoutMs: number;
-    attempt: number;
-    timestamp: Date;
-    deduplicationKey?: string;
+  id: string;
+  job: MessageCatalogKey<TMessageCatalog>;
+  item: MessageCatalogValue<TMessageCatalog, MessageCatalogKey<TMessageCatalog>>;
+  visibilityTimeoutMs: number;
+  attempt: number;
+  timestamp: Date;
+  deduplicationKey?: string;
 };
 type AnyQueueItem = {
-    id: string;
-    job: string;
-    item: any;
-    visibilityTimeoutMs: number;
-    attempt: number;
-    timestamp: Date;
-    deduplicationKey?: string;
+  id: string;
+  job: string;
+  item: any;
+  visibilityTimeoutMs: number;
+  attempt: number;
+  timestamp: Date;
+  deduplicationKey?: string;
 };
 declare class SimpleQueue<TMessageCatalog extends MessageCatalogSchema> {
-    #private;
+  #private;
+  name: string;
+  private redis;
+  private schema;
+  private logger;
+  constructor({ name, schema, redisOptions, logger }: {
     name: string;
-    private redis;
-    private schema;
-    private logger;
-    constructor({ name, schema, redisOptions, logger, }: {
-        name: string;
-        schema: TMessageCatalog;
-        redisOptions: RedisOptions;
-        logger?: Logger;
-    });
-    cancel(cancellationKey: string): Promise<void>;
-    enqueue({ id, job, item, attempt, availableAt, visibilityTimeoutMs, cancellationKey, }: {
-        id?: string;
-        job: MessageCatalogKey<TMessageCatalog>;
-        item: MessageCatalogValue<TMessageCatalog, MessageCatalogKey<TMessageCatalog>>;
-        attempt?: number;
-        availableAt?: Date;
-        visibilityTimeoutMs: number;
-        cancellationKey?: string;
-    }): Promise<void>;
-    enqueueOnce({ id, job, item, attempt, availableAt, visibilityTimeoutMs, }: {
-        id: string;
-        job: MessageCatalogKey<TMessageCatalog>;
-        item: MessageCatalogValue<TMessageCatalog, MessageCatalogKey<TMessageCatalog>>;
-        attempt?: number;
-        availableAt?: Date;
-        visibilityTimeoutMs: number;
-    }): Promise<boolean>;
-    dequeue(count?: number): Promise<Array<QueueItem<TMessageCatalog>>>;
-    ack(id: string, deduplicationKey?: string): Promise<void>;
-    reschedule(id: string, availableAt: Date): Promise<void>;
-    size({ includeFuture }?: {
-        includeFuture?: boolean;
-    }): Promise<number>;
-    /**
-     * Age (in ms) of the oldest *overdue* message — the oldest item whose scheduled
-     * time has already passed (score <= now). Returns 0 when the queue is empty or
-     * only holds future/delayed or in-flight (future-scored) items.
-     *
-     * Resolves the candidate against the `items` hash so orphaned `queue` entries
-     * (a member whose payload is missing — the same stale state `dequeueItems`
-     * cleans up) don't report a phantom stall for work that can't be dequeued. The
-     * Lua scans due items oldest-first and returns the first score whose payload
-     * still exists.
-     *
-     * This is the generic stall signal: it stays at 0 while a queue drains healthily
-     * and rises only when due work sits undrained (poison block, dead consumer,
-     * backpressure).
-     */
-    oldestMessageAge(): Promise<number>;
-    getJob(id: string): Promise<QueueItem<TMessageCatalog> | null>;
-    moveToDeadLetterQueue(id: string, errorMessage: string): Promise<void>;
-    sizeOfDeadLetterQueue(): Promise<number>;
-    redriveFromDeadLetterQueue(id: string): Promise<void>;
-    close(): Promise<void>;
+    schema: TMessageCatalog;
+    redisOptions: RedisOptions;
+    logger?: Logger;
+  });
+  cancel(cancellationKey: string): Promise<void>;
+  enqueue({ id, job, item, attempt, availableAt, visibilityTimeoutMs, cancellationKey }: {
+    id?: string;
+    job: MessageCatalogKey<TMessageCatalog>;
+    item: MessageCatalogValue<TMessageCatalog, MessageCatalogKey<TMessageCatalog>>;
+    attempt?: number;
+    availableAt?: Date;
+    visibilityTimeoutMs: number;
+    cancellationKey?: string;
+  }): Promise<void>;
+  enqueueOnce({ id, job, item, attempt, availableAt, visibilityTimeoutMs }: {
+    id: string;
+    job: MessageCatalogKey<TMessageCatalog>;
+    item: MessageCatalogValue<TMessageCatalog, MessageCatalogKey<TMessageCatalog>>;
+    attempt?: number;
+    availableAt?: Date;
+    visibilityTimeoutMs: number;
+  }): Promise<boolean>;
+  dequeue(count?: number): Promise<Array<QueueItem<TMessageCatalog>>>;
+  ack(id: string, deduplicationKey?: string): Promise<void>;
+  reschedule(id: string, availableAt: Date): Promise<void>;
+  size({ includeFuture }?: {
+    includeFuture?: boolean;
+  }): Promise<number>;
+  /**
+   * Age (in ms) of the oldest *overdue* message — the oldest item whose scheduled
+   * time has already passed (score <= now). Returns 0 when the queue is empty or
+   * only holds future/delayed or in-flight (future-scored) items.
+   *
+   * Resolves the candidate against the `items` hash so orphaned `queue` entries
+   * (a member whose payload is missing — the same stale state `dequeueItems`
+   * cleans up) don't report a phantom stall for work that can't be dequeued. The
+   * Lua scans due items oldest-first and returns the first score whose payload
+   * still exists.
+   *
+   * This is the generic stall signal: it stays at 0 while a queue drains healthily
+   * and rises only when due work sits undrained (poison block, dead consumer,
+   * backpressure).
+   */
+  oldestMessageAge(): Promise<number>;
+  getJob(id: string): Promise<QueueItem<TMessageCatalog> | null>;
+  moveToDeadLetterQueue(id: string, errorMessage: string): Promise<void>;
+  sizeOfDeadLetterQueue(): Promise<number>;
+  redriveFromDeadLetterQueue(id: string): Promise<void>;
+  close(): Promise<void>;
 }
 declare module "@internal/redis" {
-    interface RedisCommander<Context> {
-        enqueueItem(queue: string, items: string, id: string, score: number, serializedItem: string, callback?: Callback<number>): Result<number, Context>;
-        enqueueItemWithCancellationKey(queue: string, items: string, cancellationKey: string, id: string, score: number, serializedItem: string, callback?: Callback<number>): Result<number, Context>;
-        dequeueItems(queue: string, items: string, now: number, count: number, callback?: Callback<Array<[string, string, string]>>): Result<Array<[string, string, string]>, Context>;
-        ackItem(queue: string, items: string, id: string, deduplicationKey: string, callback?: Callback<number>): Result<number, Context>;
-        redriveFromDeadLetterQueue(queue: string, items: string, dlq: string, dlqItems: string, id: string, callback?: Callback<number>): Result<number, Context>;
-        moveToDeadLetterQueue(queue: string, items: string, dlq: string, dlqItems: string, id: string, errorMessage: string, callback?: Callback<number>): Result<number, Context>;
-        enqueueItemOnce(queue: string, items: string, id: string, score: number, serializedItem: string, callback?: Callback<number>): Result<number, Context>;
-        getJob(queue: string, items: string, id: string, callback?: Callback<[string, string, string] | null>): Result<[string, string, string] | null, Context>;
-        getOldestDueScore(queue: string, items: string, now: number, callback?: Callback<string | number>): Result<string | number, Context>;
-    }
-}
-
+  interface RedisCommander<Context> {
+    enqueueItem(queue: string, items: string, id: string, score: number, serializedItem: string, callback?: Callback<number>): Result<number, Context>;
+    enqueueItemWithCancellationKey(queue: string, items: string, cancellationKey: string, id: string, score: number, serializedItem: string, callback?: Callback<number>): Result<number, Context>;
+    dequeueItems(queue: string, items: string, now: number, count: number, callback?: Callback<Array<[string, string, string]>>): Result<Array<[string, string, string]>, Context>;
+    ackItem(queue: string, items: string, id: string, deduplicationKey: string, callback?: Callback<number>): Result<number, Context>;
+    redriveFromDeadLetterQueue(queue: string, items: string, dlq: string, dlqItems: string, id: string, callback?: Callback<number>): Result<number, Context>;
+    moveToDeadLetterQueue(queue: string, items: string, dlq: string, dlqItems: string, id: string, errorMessage: string, callback?: Callback<number>): Result<number, Context>;
+    enqueueItemOnce(queue: string, items: string, id: string, score: number, serializedItem: string, callback?: Callback<number>): Result<number, Context>;
+    getJob(queue: string, items: string, id: string, callback?: Callback<[string, string, string] | null>): Result<[string, string, string] | null, Context>;
+    getOldestDueScore(queue: string, items: string, now: number, callback?: Callback<string | number>): Result<string | number, Context>;
+  }
+}
+//#endregion
+//#region src/worker.d.ts
 declare const CronSchema: z.ZodObject<{
-    cron: z.ZodString;
-    lastTimestamp: z.ZodOptional<z.ZodNumber>;
-    timestamp: z.ZodNumber;
+  cron: z.ZodString;
+  lastTimestamp: z.ZodOptional<z.ZodNumber>;
+  timestamp: z.ZodNumber;
 }, "strip", z.ZodTypeAny, {
-    timestamp: number;
-    cron: string;
-    lastTimestamp?: number | undefined;
+  cron: string;
+  lastTimestamp?: number | undefined;
+  timestamp: number;
 }, {
-    timestamp: number;
-    cron: string;
-    lastTimestamp?: number | undefined;
+  cron: string;
+  lastTimestamp?: number | undefined;
+  timestamp: number;
 }>;
 type CronSchema = z.infer<typeof CronSchema>;
 type BatchConfig = {
-    maxSize: number;
-    maxWaitMs: number;
+  maxSize: number;
+  maxWaitMs: number;
 };
 type WorkerCatalog = {
-    [key: string]: {
-        schema: z.ZodFirstPartySchemaTypes | z.ZodDiscriminatedUnion<any, any>;
-        visibilityTimeoutMs: number;
-        retry?: RetryOptions$1;
-        cron?: string;
-        jitterInMs?: number;
-        /** Defaults to true. If false, errors will not be logged. */
-        logErrors?: boolean;
-        /** When set, items are accumulated and delivered in batches to the handler. */
-        batch?: BatchConfig;
-    };
-};
-type QueueCatalogFromWorkerCatalog<Catalog extends WorkerCatalog> = {
-    [K in keyof Catalog]: Catalog[K]["schema"];
+  [key: string]: {
+    schema: z.ZodFirstPartySchemaTypes | z.ZodDiscriminatedUnion<any, any>;
+    visibilityTimeoutMs: number;
+    retry?: RetryOptions$1;
+    cron?: string;
+    jitterInMs?: number;
+    /** Defaults to true. If false, errors will not be logged. */
+    logErrors?: boolean;
+    /** When set, items are accumulated and delivered in batches to the handler. */
+    batch?: BatchConfig;
+  };
 };
+type QueueCatalogFromWorkerCatalog<Catalog extends WorkerCatalog> = { [K in keyof Catalog]: Catalog[K]["schema"]; };
 type JobHandlerParams<Catalog extends WorkerCatalog, K extends keyof Catalog> = {
-    id: string;
-    payload: z.infer<Catalog[K]["schema"]>;
-    visibilityTimeoutMs: number;
-    attempt: number;
-    deduplicationKey?: string;
+  id: string;
+  payload: z.infer<Catalog[K]["schema"]>;
+  visibilityTimeoutMs: number;
+  attempt: number;
+  deduplicationKey?: string;
 };
 type JobHandler<Catalog extends WorkerCatalog, K extends keyof Catalog> = (params: JobHandlerParams<Catalog, K>) => Promise<void>;
 type JobHandlerFor<Catalog extends WorkerCatalog, K extends keyof Catalog> = Catalog[K] extends {
-    batch: BatchConfig;
+  batch: BatchConfig;
 } ? (items: Array<JobHandlerParams<Catalog, K>>) => Promise<void> : (params: JobHandlerParams<Catalog, K>) => Promise<void>;
 type WorkerConcurrencyOptions = {
-    workers?: number;
-    tasksPerWorker?: number;
-    limit?: number;
+  workers?: number;
+  tasksPerWorker?: number;
+  limit?: number;
 };
 type WorkerOptions<TCatalog extends WorkerCatalog> = {
-    name: string;
-    redisOptions: RedisOptions;
-    catalog: TCatalog;
-    jobs: {
-        [K in keyof TCatalog]: JobHandlerFor<TCatalog, K>;
-    };
-    concurrency?: WorkerConcurrencyOptions;
-    pollIntervalMs?: number;
-    immediatePollIntervalMs?: number;
-    shutdownTimeoutMs?: number;
-    logger?: Logger;
-    tracer?: Tracer;
-    meter?: Meter;
+  name: string;
+  redisOptions: RedisOptions;
+  catalog: TCatalog;
+  jobs: { [K in keyof TCatalog]: JobHandlerFor<TCatalog, K>; };
+  concurrency?: WorkerConcurrencyOptions;
+  pollIntervalMs?: number;
+  immediatePollIntervalMs?: number;
+  shutdownTimeoutMs?: number;
+  logger?: Logger;
+  tracer?: Tracer;
+  meter?: Meter;
 };
 declare class Worker<TCatalog extends WorkerCatalog> {
-    #private;
-    private options;
-    private subscriber;
-    private tracer;
-    private meter;
-    private metrics;
-    queue: SimpleQueue<QueueCatalogFromWorkerCatalog<TCatalog>>;
-    private jobs;
-    private logger;
-    private workerLoops;
-    private isShuttingDown;
-    private concurrency;
-    private shutdownTimeoutMs;
-    private limiters;
-    private batchAccumulators;
-    constructor(options: WorkerOptions<TCatalog>);
-    start(): this;
-    /**
-     * Enqueues a job for processing.
-     * @param options - The enqueue options.
-     * @param options.id - Optional unique identifier for the job. If not provided, one will be generated. It prevents duplication.
-     * @param options.job - The job type from the worker catalog.
-     * @param options.payload - The job payload that matches the schema defined in the catalog.
-     * @param options.visibilityTimeoutMs - Optional visibility timeout in milliseconds. Defaults to value from catalog.
-     * @param options.availableAt - Optional date when the job should become available for processing. Defaults to now.
-     * @returns A promise that resolves when the job is enqueued.
-     */
-    enqueue<K extends keyof TCatalog>({ id, job, payload, visibilityTimeoutMs, availableAt, cancellationKey, }: {
-        id?: string;
-        job: K;
-        payload: z.infer<TCatalog[K]["schema"]>;
-        visibilityTimeoutMs?: number;
-        availableAt?: Date;
-        cancellationKey?: string;
-    }): Promise<void>;
-    /**
-     * Enqueues a job for processing once. If the job is already in the queue, it will be ignored.
-     * @param options - The enqueue options.
-     * @param options.id - Required unique identifier for the job.
-     * @param options.job - The job type from the worker catalog.
-     * @param options.payload - The job payload that matches the schema defined in the catalog.
-     * @param options.visibilityTimeoutMs - Optional visibility timeout in milliseconds. Defaults to value from catalog.
-     * @param options.availableAt - Optional date when the job should become available for processing. Defaults to now.
-     * @returns A promise that resolves when the job is enqueued.
-     */
-    enqueueOnce<K extends keyof TCatalog>({ id, job, payload, visibilityTimeoutMs, availableAt, }: {
-        id: string;
-        job: K;
-        payload: z.infer<TCatalog[K]["schema"]>;
-        visibilityTimeoutMs?: number;
-        availableAt?: Date;
-    }): Promise<boolean>;
-    /**
-     * Reschedules an existing job to a new available date.
-     * If the job isn't in the queue, it will be ignored.
-     */
-    reschedule(id: string, availableAt: Date): Promise<void>;
-    /**
-     * Cancels a job before it's enqueued.
-     * @param cancellationKey - The cancellation key to cancel.
-     * @returns A promise that resolves when the job is cancelled.
-     *
-     * Any jobs enqueued with the same cancellation key will be not be enqueued.
-     */
-    cancel(cancellationKey: string): Promise<void>;
-    ack(id: string): Promise<void>;
-    getJob(id: string): Promise<QueueItem<QueueCatalogFromWorkerCatalog<TCatalog>> | null>;
-    /**
-     * Returns true if the given job type has batch config in the catalog.
-     */
-    private isBatchJob;
-    /**
-     * Returns the batch config for a job type, or undefined if not batch-enabled.
-     */
-    private getBatchConfig;
-    /**
-     * The max dequeue count: the largest batch maxSize across catalog entries,
-     * falling back to tasksPerWorker for non-batch catalogs.
-     */
-    private get maxDequeueCount();
-    /**
-     * The main loop that each worker runs. It repeatedly polls for items,
-     * processes them, and then waits before the next iteration.
-     */
-    private runWorkerLoop;
-    /**
-     * Adds an item to the batch accumulator for its job type.
-     */
-    private addToAccumulator;
-    /**
-     * Flushes any batch accumulators that have exceeded their maxWaitMs.
-     */
-    private flushTimedOutBatches;
-    /**
-     * Flushes all batch accumulators (used during shutdown).
-     */
-    private flushAllBatches;
-    /**
-     * Flushes the batch accumulator for a specific job type.
-     * Removes items from the accumulator and submits them to the limiter as a single batch.
-     */
-    private flushBatch;
-    /**
-     * Processes a batch of items for a batch-enabled job type.
-     */
-    private processBatch;
-    /**
-     * Processes a single item.
-     */
-    private processItem;
-    private withHistogram;
-    private static delay;
-    private setupCron;
-    private enqueueCronJob;
-    private rescheduleCronJob;
-    private calculateNextScheduledAt;
-    private timestampIdentifier;
-    private setupSubscriber;
-    private handleRedriveMessage;
-    private setupShutdownHandlers;
-    private shutdown;
-    stop(): Promise<void>;
-}
-
+  #private;
+  private options;
+  private subscriber;
+  private tracer;
+  private meter;
+  private metrics;
+  queue: SimpleQueue<QueueCatalogFromWorkerCatalog<TCatalog>>;
+  private jobs;
+  private logger;
+  private workerLoops;
+  private isShuttingDown;
+  private concurrency;
+  private shutdownTimeoutMs;
+  private limiters;
+  private batchAccumulators;
+  constructor(options: WorkerOptions<TCatalog>);
+  start(): this;
+  /**
+   * Enqueues a job for processing.
+   * @param options - The enqueue options.
+   * @param options.id - Optional unique identifier for the job. If not provided, one will be generated. It prevents duplication.
+   * @param options.job - The job type from the worker catalog.
+   * @param options.payload - The job payload that matches the schema defined in the catalog.
+   * @param options.visibilityTimeoutMs - Optional visibility timeout in milliseconds. Defaults to value from catalog.
+   * @param options.availableAt - Optional date when the job should become available for processing. Defaults to now.
+   * @returns A promise that resolves when the job is enqueued.
+   */
+  enqueue<K extends keyof TCatalog>({ id, job, payload, visibilityTimeoutMs, availableAt, cancellationKey }: {
+    id?: string;
+    job: K;
+    payload: z.infer<TCatalog[K]["schema"]>;
+    visibilityTimeoutMs?: number;
+    availableAt?: Date;
+    cancellationKey?: string;
+  }): Promise<void>;
+  /**
+   * Enqueues a job for processing once. If the job is already in the queue, it will be ignored.
+   * @param options - The enqueue options.
+   * @param options.id - Required unique identifier for the job.
+   * @param options.job - The job type from the worker catalog.
+   * @param options.payload - The job payload that matches the schema defined in the catalog.
+   * @param options.visibilityTimeoutMs - Optional visibility timeout in milliseconds. Defaults to value from catalog.
+   * @param options.availableAt - Optional date when the job should become available for processing. Defaults to now.
+   * @returns A promise that resolves when the job is enqueued.
+   */
+  enqueueOnce<K extends keyof TCatalog>({ id, job, payload, visibilityTimeoutMs, availableAt }: {
+    id: string;
+    job: K;
+    payload: z.infer<TCatalog[K]["schema"]>;
+    visibilityTimeoutMs?: number;
+    availableAt?: Date;
+  }): Promise<boolean>;
+  /**
+   * Reschedules an existing job to a new available date.
+   * If the job isn't in the queue, it will be ignored.
+   */
+  reschedule(id: string, availableAt: Date): Promise<void>;
+  /**
+   * Cancels a job before it's enqueued.
+   * @param cancellationKey - The cancellation key to cancel.
+   * @returns A promise that resolves when the job is cancelled.
+   *
+   * Any jobs enqueued with the same cancellation key will be not be enqueued.
+   */
+  cancel(cancellationKey: string): Promise<void>;
+  ack(id: string): Promise<void>;
+  getJob(id: string): Promise<QueueItem<QueueCatalogFromWorkerCatalog<TCatalog>> | null>;
+  /**
+   * Returns true if the given job type has batch config in the catalog.
+   */
+  private isBatchJob;
+  /**
+   * Returns the batch config for a job type, or undefined if not batch-enabled.
+   */
+  private getBatchConfig;
+  /**
+   * The max dequeue count: the largest batch maxSize across catalog entries,
+   * falling back to tasksPerWorker for non-batch catalogs.
+   */
+  private get maxDequeueCount();
+  /**
+   * The main loop that each worker runs. It repeatedly polls for items,
+   * processes them, and then waits before the next iteration.
+   */
+  private runWorkerLoop;
+  /**
+   * Adds an item to the batch accumulator for its job type.
+   */
+  private addToAccumulator;
+  /**
+   * Flushes any batch accumulators that have exceeded their maxWaitMs.
+   */
+  private flushTimedOutBatches;
+  /**
+   * Flushes all batch accumulators (used during shutdown).
+   */
+  private flushAllBatches;
+  /**
+   * Flushes the batch accumulator for a specific job type.
+   * Removes items from the accumulator and submits them to the limiter as a single batch.
+   */
+  private flushBatch;
+  /**
+   * Processes a batch of items for a batch-enabled job type.
+   */
+  private processBatch;
+  /**
+   * Processes a single item.
+   */
+  private processItem;
+  private withHistogram;
+  private static delay;
+  private setupCron;
+  private enqueueCronJob;
+  private rescheduleCronJob;
+  private calculateNextScheduledAt;
+  private timestampIdentifier;
+  private setupSubscriber;
+  private handleRedriveMessage;
+  private setupShutdownHandlers;
+  private shutdown;
+  stop(): Promise<void>;
+}
+//#endregion
+//#region src/utils.d.ts
 /**
  * Check if an error is an AbortError.
  *
@@ -298,24 +296,25 @@ declare class Worker<TCatalog extends WorkerCatalog> {
  * - Native Node.js AbortError from timers/promises (sets .name)
  */
 declare function isAbortError(error: unknown): boolean;
-
+//#endregion
+//#region src/fair-queue/retry.d.ts
 /**
  * RetryStrategy interface for pluggable retry logic.
  */
 interface RetryStrategy {
-    /**
-     * Calculate the next retry delay in milliseconds.
-     * Return null to indicate the message should be sent to DLQ.
-     *
-     * @param attempt - Current attempt number (1-indexed)
-     * @param error - Optional error from the failed attempt
-     * @returns Delay in milliseconds, or null to send to DLQ
-     */
-    getNextDelay(attempt: number, error?: Error): number | null;
-    /**
-     * Maximum number of attempts before moving to DLQ.
-     */
-    maxAttempts: number;
+  /**
+   * Calculate the next retry delay in milliseconds.
+   * Return null to indicate the message should be sent to DLQ.
+   *
+   * @param attempt - Current attempt number (1-indexed)
+   * @param error - Optional error from the failed attempt
+   * @returns Delay in milliseconds, or null to send to DLQ
+   */
+  getNextDelay(attempt: number, error?: Error): number | null;
+  /**
+   * Maximum number of attempts before moving to DLQ.
+   */
+  maxAttempts: number;
 }
 /**
  * Exponential backoff retry strategy.
@@ -323,10 +322,10 @@ interface RetryStrategy {
  * Uses the same algorithm as @trigger.dev/core's calculateNextRetryDelay.
  */
 declare class ExponentialBackoffRetry implements RetryStrategy {
-    readonly maxAttempts: number;
-    private options;
-    constructor(options?: Partial<RetryOptions$1>);
-    getNextDelay(attempt: number, _error?: Error): number | null;
+  readonly maxAttempts: number;
+  private options;
+  constructor(options?: Partial<RetryOptions$1>);
+  getNextDelay(attempt: number, _error?: Error): number | null;
 }
 /**
  * Fixed delay retry strategy.
@@ -334,13 +333,13 @@ declare class ExponentialBackoffRetry implements RetryStrategy {
  * Always waits the same amount of time between retries.
  */
 declare class FixedDelayRetry implements RetryStrategy {
-    readonly maxAttempts: number;
-    private delayMs;
-    constructor(options: {
-        maxAttempts: number;
-        delayMs: number;
-    });
-    getNextDelay(attempt: number, _error?: Error): number | null;
+  readonly maxAttempts: number;
+  private delayMs;
+  constructor(options: {
+    maxAttempts: number;
+    delayMs: number;
+  });
+  getNextDelay(attempt: number, _error?: Error): number | null;
 }
 /**
  * Linear backoff retry strategy.
@@ -348,15 +347,15 @@ declare class FixedDelayRetry implements RetryStrategy {
  * Delay increases linearly with each attempt.
  */
 declare class LinearBackoffRetry implements RetryStrategy {
-    readonly maxAttempts: number;
-    private baseDelayMs;
-    private maxDelayMs;
-    constructor(options: {
-        maxAttempts: number;
-        baseDelayMs: number;
-        maxDelayMs?: number;
-    });
-    getNextDelay(attempt: number, _error?: Error): number | null;
+  readonly maxAttempts: number;
+  private baseDelayMs;
+  private maxDelayMs;
+  constructor(options: {
+    maxAttempts: number;
+    baseDelayMs: number;
+    maxDelayMs?: number;
+  });
+  getNextDelay(attempt: number, _error?: Error): number | null;
 }
 /**
  * No retry strategy.
@@ -364,8 +363,8 @@ declare class LinearBackoffRetry implements RetryStrategy {
  * Messages go directly to DLQ on first failure.
  */
 declare class NoRetry implements RetryStrategy {
-    readonly maxAttempts = 1;
-    getNextDelay(_attempt: number, _error?: Error): number | null;
+  readonly maxAttempts = 1;
+  getNextDelay(_attempt: number, _error?: Error): number | null;
 }
 /**
  * Immediate retry strategy.
@@ -373,21 +372,21 @@ declare class NoRetry implements RetryStrategy {
  * Retries immediately without any delay.
  */
 declare class ImmediateRetry implements RetryStrategy {
-    readonly maxAttempts: number;
-    constructor(maxAttempts: number);
-    getNextDelay(attempt: number, _error?: Error): number | null;
+  readonly maxAttempts: number;
+  constructor(maxAttempts: number);
+  getNextDelay(attempt: number, _error?: Error): number | null;
 }
 /**
  * Custom retry strategy that uses a user-provided function.
  */
 declare class CustomRetry implements RetryStrategy {
-    readonly maxAttempts: number;
-    private calculateDelay;
-    constructor(options: {
-        maxAttempts: number;
-        calculateDelay: (attempt: number, error?: Error) => number | null;
-    });
-    getNextDelay(attempt: number, error?: Error): number | null;
+  readonly maxAttempts: number;
+  private calculateDelay;
+  constructor(options: {
+    maxAttempts: number;
+    calculateDelay: (attempt: number, error?: Error) => number | null;
+  });
+  getNextDelay(attempt: number, error?: Error): number | null;
 }
 /**
  * Default retry options matching @trigger.dev/core defaults.
@@ -397,258 +396,259 @@ declare const defaultRetryOptions: RetryOptions$1;
  * Create an exponential backoff retry strategy with default options.
  */
 declare function createDefaultRetryStrategy(): RetryStrategy;
-
+//#endregion
+//#region src/fair-queue/types.d.ts
 /**
  * Interface for a global rate limiter that limits processing across all consumers.
  * When configured, consumers will check this before processing each message.
  */
 interface GlobalRateLimiter {
-    /**
-     * Check if processing is allowed under the rate limit.
-     * @returns Object with allowed flag and optional resetAt timestamp (ms since epoch)
-     */
-    limit(): Promise<{
-        allowed: boolean;
-        resetAt?: number;
-    }>;
+  /**
+   * Check if processing is allowed under the rate limit.
+   * @returns Object with allowed flag and optional resetAt timestamp (ms since epoch)
+   */
+  limit(): Promise<{
+    allowed: boolean;
+    resetAt?: number;
+  }>;
 }
 /**
  * Descriptor for a queue in the fair queue system.
  * Contains all the metadata needed to identify and route a queue.
  */
 interface QueueDescriptor {
-    /** Unique queue identifier */
-    id: string;
-    /** Tenant this queue belongs to */
-    tenantId: string;
-    /** Additional metadata for concurrency group extraction */
-    metadata: Record<string, unknown>;
+  /** Unique queue identifier */
+  id: string;
+  /** Tenant this queue belongs to */
+  tenantId: string;
+  /** Additional metadata for concurrency group extraction */
+  metadata: Record<string, unknown>;
 }
 /**
  * A message in the queue with its metadata.
  */
 interface QueueMessage<TPayload = unknown> {
-    /** Unique message identifier */
-    id: string;
-    /** The queue this message belongs to */
-    queueId: string;
-    /** Message payload */
-    payload: TPayload;
-    /** Timestamp when message was enqueued */
-    timestamp: number;
-    /** Current attempt number (1-indexed, for retries) */
-    attempt: number;
-    /** Optional metadata */
-    metadata?: Record<string, unknown>;
+  /** Unique message identifier */
+  id: string;
+  /** The queue this message belongs to */
+  queueId: string;
+  /** Message payload */
+  payload: TPayload;
+  /** Timestamp when message was enqueued */
+  timestamp: number;
+  /** Current attempt number (1-indexed, for retries) */
+  attempt: number;
+  /** Optional metadata */
+  metadata?: Record<string, unknown>;
 }
 /**
  * Internal message format stored in Redis.
  * Includes additional fields for tracking and routing.
  */
 interface StoredMessage<TPayload = unknown> {
-    /** Message ID */
-    id: string;
-    /** Queue ID */
-    queueId: string;
-    /** Tenant ID */
-    tenantId: string;
-    /** Message payload */
-    payload: TPayload;
-    /** Timestamp when enqueued */
-    timestamp: number;
-    /** Current attempt number */
-    attempt: number;
-    /** Worker queue to route to */
-    workerQueue?: string;
-    /** Additional metadata */
-    metadata?: Record<string, unknown>;
+  /** Message ID */
+  id: string;
+  /** Queue ID */
+  queueId: string;
+  /** Tenant ID */
+  tenantId: string;
+  /** Message payload */
+  payload: TPayload;
+  /** Timestamp when enqueued */
+  timestamp: number;
+  /** Current attempt number */
+  attempt: number;
+  /** Worker queue to route to */
+  workerQueue?: string;
+  /** Additional metadata */
+  metadata?: Record<string, unknown>;
 }
 /**
  * Queue with its score (oldest message timestamp) from the master queue.
  */
 interface QueueWithScore {
-    /** Queue identifier */
-    queueId: string;
-    /** Score (typically oldest message timestamp) */
-    score: number;
-    /** Tenant ID extracted from queue */
-    tenantId: string;
+  /** Queue identifier */
+  queueId: string;
+  /** Score (typically oldest message timestamp) */
+  score: number;
+  /** Tenant ID extracted from queue */
+  tenantId: string;
 }
 /**
  * Configuration for a concurrency group.
  * Allows defining arbitrary levels of concurrency (tenant, org, project, etc.)
  */
 interface ConcurrencyGroupConfig {
-    /** Group name (e.g., "tenant", "organization", "project") */
-    name: string;
-    /** Extract the group ID from a queue descriptor */
-    extractGroupId: (queue: QueueDescriptor) => string;
-    /** Get the concurrency limit for a specific group ID */
-    getLimit: (groupId: string) => Promise<number>;
-    /** Default limit if not specified */
-    defaultLimit: number;
+  /** Group name (e.g., "tenant", "organization", "project") */
+  name: string;
+  /** Extract the group ID from a queue descriptor */
+  extractGroupId: (queue: QueueDescriptor) => string;
+  /** Get the concurrency limit for a specific group ID */
+  getLimit: (groupId: string) => Promise<number>;
+  /** Default limit if not specified */
+  defaultLimit: number;
 }
 /**
  * Current concurrency state for a group.
  */
 interface ConcurrencyState {
-    /** Group name */
-    groupName: string;
-    /** Group ID */
-    groupId: string;
-    /** Current active count */
-    current: number;
-    /** Configured limit */
-    limit: number;
+  /** Group name */
+  groupName: string;
+  /** Group ID */
+  groupId: string;
+  /** Current active count */
+  current: number;
+  /** Configured limit */
+  limit: number;
 }
 /**
  * Result of a concurrency check.
  */
 interface ConcurrencyCheckResult {
-    /** Whether processing is allowed */
-    allowed: boolean;
-    /** If not allowed, which group is blocking */
-    blockedBy?: ConcurrencyState;
+  /** Whether processing is allowed */
+  allowed: boolean;
+  /** If not allowed, which group is blocking */
+  blockedBy?: ConcurrencyState;
 }
 /**
  * Information about a reclaimed message from visibility timeout.
  * Used to release concurrency after a message is returned to the queue.
  */
 interface ReclaimedMessageInfo {
-    /** Message ID */
-    messageId: string;
-    /** Queue ID */
-    queueId: string;
-    /** Tenant ID for concurrency release */
-    tenantId: string;
-    /** Additional metadata for concurrency group extraction */
-    metadata?: Record<string, unknown>;
+  /** Message ID */
+  messageId: string;
+  /** Queue ID */
+  queueId: string;
+  /** Tenant ID for concurrency release */
+  tenantId: string;
+  /** Additional metadata for concurrency group extraction */
+  metadata?: Record<string, unknown>;
 }
 /**
  * Queues grouped by tenant for the scheduler.
  */
 interface TenantQueues {
-    /** Tenant identifier */
-    tenantId: string;
-    /** Queue IDs belonging to this tenant, in priority order */
-    queues: string[];
+  /** Tenant identifier */
+  tenantId: string;
+  /** Queue IDs belonging to this tenant, in priority order */
+  queues: string[];
 }
 /**
  * Context provided to the scheduler for making decisions.
  */
 interface SchedulerContext {
-    /** Get current concurrency for a group */
-    getCurrentConcurrency(groupName: string, groupId: string): Promise<number>;
-    /** Get concurrency limit for a group */
-    getConcurrencyLimit(groupName: string, groupId: string): Promise<number>;
-    /** Check if a group is at capacity */
-    isAtCapacity(groupName: string, groupId: string): Promise<boolean>;
-    /** Get queue descriptor by ID */
-    getQueueDescriptor(queueId: string): QueueDescriptor;
+  /** Get current concurrency for a group */
+  getCurrentConcurrency(groupName: string, groupId: string): Promise<number>;
+  /** Get concurrency limit for a group */
+  getConcurrencyLimit(groupName: string, groupId: string): Promise<number>;
+  /** Check if a group is at capacity */
+  isAtCapacity(groupName: string, groupId: string): Promise<boolean>;
+  /** Get queue descriptor by ID */
+  getQueueDescriptor(queueId: string): QueueDescriptor;
 }
 /**
  * Extended context for two-level dispatch scheduling.
  */
 interface DispatchSchedulerContext extends SchedulerContext {
-    /** Get queues for a specific tenant from the per-tenant queue index (Level 2) */
-    getQueuesForTenant(tenantId: string, limit?: number): Promise<QueueWithScore[]>;
+  /** Get queues for a specific tenant from the per-tenant queue index (Level 2) */
+  getQueuesForTenant(tenantId: string, limit?: number): Promise<QueueWithScore[]>;
 }
 /**
  * Pluggable scheduler interface for fair queue selection.
  */
 interface FairScheduler {
-    /**
-     * Select queues for processing from a master queue shard.
-     * Returns queues grouped by tenant, ordered by the fairness algorithm.
-     *
-     * @param masterQueueShard - The master queue shard key
-     * @param consumerId - The consumer making the request
-     * @param context - Context for concurrency checks
-     * @returns Queues grouped by tenant in priority order
-     */
-    selectQueues(masterQueueShard: string, consumerId: string, context: SchedulerContext): Promise<TenantQueues[]>;
-    /**
-     * Select queues using the two-level tenant dispatch index.
-     * Level 1: reads tenantIds from dispatch shard.
-     * Level 2: reads queueIds from per-tenant index.
-     * Optional - falls back to selectQueues with flat queue list if not implemented.
-     */
-    selectQueuesFromDispatch?(dispatchShardKey: string, consumerId: string, context: DispatchSchedulerContext): Promise<TenantQueues[]>;
-    /**
-     * Called after processing a message to update scheduler state.
-     * Optional - not all schedulers need to track state.
-     */
-    recordProcessed?(tenantId: string, queueId: string): Promise<void>;
-    /**
-     * Called after processing multiple messages to update scheduler state.
-     * Batch variant for efficiency - reduces Redis calls when processing multiple messages.
-     * Optional - falls back to calling recordProcessed multiple times if not implemented.
-     */
-    recordProcessedBatch?(tenantId: string, queueId: string, count: number): Promise<void>;
-    /**
-     * Initialize the scheduler (called once on startup).
-     */
-    initialize?(): Promise<void>;
-    /**
-     * Cleanup scheduler resources.
-     */
-    close?(): Promise<void>;
+  /**
+   * Select queues for processing from a master queue shard.
+   * Returns queues grouped by tenant, ordered by the fairness algorithm.
+   *
+   * @param masterQueueShard - The master queue shard key
+   * @param consumerId - The consumer making the request
+   * @param context - Context for concurrency checks
+   * @returns Queues grouped by tenant in priority order
+   */
+  selectQueues(masterQueueShard: string, consumerId: string, context: SchedulerContext): Promise<TenantQueues[]>;
+  /**
+   * Select queues using the two-level tenant dispatch index.
+   * Level 1: reads tenantIds from dispatch shard.
+   * Level 2: reads queueIds from per-tenant index.
+   * Optional - falls back to selectQueues with flat queue list if not implemented.
+   */
+  selectQueuesFromDispatch?(dispatchShardKey: string, consumerId: string, context: DispatchSchedulerContext): Promise<TenantQueues[]>;
+  /**
+   * Called after processing a message to update scheduler state.
+   * Optional - not all schedulers need to track state.
+   */
+  recordProcessed?(tenantId: string, queueId: string): Promise<void>;
+  /**
+   * Called after processing multiple messages to update scheduler state.
+   * Batch variant for efficiency - reduces Redis calls when processing multiple messages.
+   * Optional - falls back to calling recordProcessed multiple times if not implemented.
+   */
+  recordProcessedBatch?(tenantId: string, queueId: string, count: number): Promise<void>;
+  /**
+   * Initialize the scheduler (called once on startup).
+   */
+  initialize?(): Promise<void>;
+  /**
+   * Cleanup scheduler resources.
+   */
+  close?(): Promise<void>;
 }
 /**
  * An in-flight message being processed.
  */
 interface InFlightMessage<TPayload = unknown> {
-    /** Message ID */
-    messageId: string;
-    /** Queue ID */
-    queueId: string;
-    /** Message payload */
-    payload: TPayload;
-    /** When visibility timeout expires */
-    deadline: number;
-    /** Consumer that claimed this message */
-    consumerId: string;
+  /** Message ID */
+  messageId: string;
+  /** Queue ID */
+  queueId: string;
+  /** Message payload */
+  payload: TPayload;
+  /** When visibility timeout expires */
+  deadline: number;
+  /** Consumer that claimed this message */
+  consumerId: string;
 }
 /**
  * Result of claiming a message.
  */
 interface ClaimResult<TPayload = unknown> {
-    /** Whether the claim was successful */
-    claimed: boolean;
-    /** The claimed message if successful */
-    message?: InFlightMessage<TPayload>;
+  /** Whether the claim was successful */
+  claimed: boolean;
+  /** The claimed message if successful */
+  message?: InFlightMessage<TPayload>;
 }
 /**
  * Interface for generating Redis keys for the fair queue system.
  * Implementations can customize key prefixes and structures.
  */
 interface FairQueueKeyProducer {
-    /** Get the master queue key for a shard */
-    masterQueueKey(shardId: number): string;
-    /** Get the queue key for storing messages */
-    queueKey(queueId: string): string;
-    /** Get the queue items hash key */
-    queueItemsKey(queueId: string): string;
-    /** Get the concurrency set key for a group */
-    concurrencyKey(groupName: string, groupId: string): string;
-    /** Get the in-flight sorted set key for a shard */
-    inflightKey(shardId: number): string;
-    /** Get the in-flight message data hash key */
-    inflightDataKey(shardId: number): string;
-    /** Get the worker queue key for a consumer */
-    workerQueueKey(consumerId: string): string;
-    /** Get the dead letter queue key for a tenant */
-    deadLetterQueueKey(tenantId: string): string;
-    /** Get the dead letter queue data hash key for a tenant */
-    deadLetterQueueDataKey(tenantId: string): string;
-    /** Get the dispatch index key for a shard (Level 1: tenantIds with capacity) */
-    dispatchKey(shardId: number): string;
-    /** Get the per-tenant queue index key (Level 2: queueIds for a tenant) */
-    tenantQueueIndexKey(tenantId: string): string;
-    /** Extract tenant ID from a queue ID */
-    extractTenantId(queueId: string): string;
-    /** Extract a specific group ID from a queue ID */
-    extractGroupId(groupName: string, queueId: string): string;
+  /** Get the master queue key for a shard */
+  masterQueueKey(shardId: number): string;
+  /** Get the queue key for storing messages */
+  queueKey(queueId: string): string;
+  /** Get the queue items hash key */
+  queueItemsKey(queueId: string): string;
+  /** Get the concurrency set key for a group */
+  concurrencyKey(groupName: string, groupId: string): string;
+  /** Get the in-flight sorted set key for a shard */
+  inflightKey(shardId: number): string;
+  /** Get the in-flight message data hash key */
+  inflightDataKey(shardId: number): string;
+  /** Get the worker queue key for a consumer */
+  workerQueueKey(consumerId: string): string;
+  /** Get the dead letter queue key for a tenant */
+  deadLetterQueueKey(tenantId: string): string;
+  /** Get the dead letter queue data hash key for a tenant */
+  deadLetterQueueDataKey(tenantId: string): string;
+  /** Get the dispatch index key for a shard (Level 1: tenantIds with capacity) */
+  dispatchKey(shardId: number): string;
+  /** Get the per-tenant queue index key (Level 2: queueIds for a tenant) */
+  tenantQueueIndexKey(tenantId: string): string;
+  /** Extract tenant ID from a queue ID */
+  extractTenantId(queueId: string): string;
+  /** Extract a specific group ID from a queue ID */
+  extractGroupId(groupName: string, queueId: string): string;
 }
 /**
  * Worker queue configuration options.
@@ -656,33 +656,33 @@ interface FairQueueKeyProducer {
  * and external consumers are responsible for consuming from those queues.
  */
 interface WorkerQueueOptions<TPayload = unknown> {
-    /**
-     * Function to resolve which worker queue a message should go to.
-     * This is called during the claim-and-push phase to determine the target queue.
-     */
-    resolveWorkerQueue: (message: StoredMessage<TPayload>) => string;
+  /**
+   * Function to resolve which worker queue a message should go to.
+   * This is called during the claim-and-push phase to determine the target queue.
+   */
+  resolveWorkerQueue: (message: StoredMessage<TPayload>) => string;
 }
 /**
  * Retry and dead letter queue configuration.
  */
 interface RetryOptions {
-    /** Retry strategy for failed messages */
-    strategy: RetryStrategy;
-    /** Whether to enable dead letter queue (default: true) */
-    deadLetterQueue?: boolean;
+  /** Retry strategy for failed messages */
+  strategy: RetryStrategy;
+  /** Whether to enable dead letter queue (default: true) */
+  deadLetterQueue?: boolean;
 }
 /**
  * Queue cooloff configuration to avoid repeatedly polling concurrency-limited queues.
  */
 interface CooloffOptions {
-    /** Whether cooloff is enabled (default: true) */
-    enabled?: boolean;
-    /** Number of consecutive empty dequeues before entering cooloff (default: 10) */
-    threshold?: number;
-    /** Duration of cooloff period in milliseconds (default: 10000) */
-    periodMs?: number;
-    /** Maximum number of cooloff state entries before triggering cleanup (default: 1000) */
-    maxStatesSize?: number;
+  /** Whether cooloff is enabled (default: true) */
+  enabled?: boolean;
+  /** Number of consecutive empty dequeues before entering cooloff (default: 10) */
+  threshold?: number;
+  /** Duration of cooloff period in milliseconds (default: 10000) */
+  periodMs?: number;
+  /** Maximum number of cooloff state entries before triggering cleanup (default: 1000) */
+  maxStatesSize?: number;
 }
 /**
  * Options for creating a FairQueue instance.
@@ -690,90 +690,90 @@ interface CooloffOptions {
  * @typeParam TPayloadSchema - Zod schema for message payload validation
  */
 interface FairQueueOptions<TPayloadSchema extends z.ZodTypeAny = z.ZodUnknown> {
-    /** Redis connection options */
-    redis: RedisOptions;
-    /** Key producer for Redis keys */
-    keys: FairQueueKeyProducer;
-    /** Scheduler for fair queue selection */
-    scheduler: FairScheduler;
-    /** Zod schema for message payload validation */
-    payloadSchema?: TPayloadSchema;
-    /** Whether to validate payloads on enqueue (default: false) */
-    validateOnEnqueue?: boolean;
-    /** Number of master queue shards (default: 1) */
-    shardCount?: number;
-    /** Concurrency group configurations */
-    concurrencyGroups?: ConcurrencyGroupConfig[];
-    /**
-     * Worker queue configuration.
-     * FairQueue routes messages to worker queues; external consumers handle consumption.
-     */
-    workerQueue: WorkerQueueOptions<z.infer<TPayloadSchema>>;
-    /** Retry and dead letter queue configuration */
-    retry?: RetryOptions;
-    /** Visibility timeout in milliseconds (default: 30000) */
-    visibilityTimeoutMs?: number;
-    /** Heartbeat interval in milliseconds (default: visibilityTimeoutMs / 3) */
-    heartbeatIntervalMs?: number;
-    /** Interval for reclaiming timed-out messages (default: 5000) */
-    reclaimIntervalMs?: number;
-    /** Number of consumer loops to run (default: 1) */
-    consumerCount?: number;
-    /** Interval between consumer iterations in milliseconds (default: 100) */
-    consumerIntervalMs?: number;
-    /** Whether to start consumers on initialization (default: true) */
-    startConsumers?: boolean;
-    /** Maximum number of messages to claim in a single batch operation (default: 10) */
-    batchClaimSize?: number;
-    /** Maximum iterations before starting a new trace span (default: 500) */
-    consumerTraceMaxIterations?: number;
-    /** Maximum seconds before starting a new trace span (default: 60) */
-    consumerTraceTimeoutSeconds?: number;
-    /** Queue cooloff configuration */
-    cooloff?: CooloffOptions;
-    /** Logger instance */
-    logger?: Logger;
-    /** OpenTelemetry tracer */
-    tracer?: Tracer;
-    /** OpenTelemetry meter */
-    meter?: Meter;
-    /** Name for metrics/tracing (default: "fairqueue") */
-    name?: string;
-    /**
-     * Maximum number of items allowed in a worker queue before claiming pauses.
-     * When set, the claim phase checks worker queue depth and skips claiming if
-     * the queue is at or above this limit. This prevents unbounded worker queue
-     * growth which could cause visibility timeouts (claimed messages have a
-     * visibility timeout that ticks while they sit in the worker queue).
-     * Requires `workerQueueDepthCheckId` to know which queue to check.
-     * Disabled by default (0 = no limit).
-     */
-    workerQueueMaxDepth?: number;
-    /**
-     * The worker queue ID to check depth against when workerQueueMaxDepth is set.
-     * Required when workerQueueMaxDepth > 0 and the system uses a single shared worker queue.
-     * If not set, depth checking is disabled even if workerQueueMaxDepth is set.
-     */
-    workerQueueDepthCheckId?: string;
+  /** Redis connection options */
+  redis: RedisOptions;
+  /** Key producer for Redis keys */
+  keys: FairQueueKeyProducer;
+  /** Scheduler for fair queue selection */
+  scheduler: FairScheduler;
+  /** Zod schema for message payload validation */
+  payloadSchema?: TPayloadSchema;
+  /** Whether to validate payloads on enqueue (default: false) */
+  validateOnEnqueue?: boolean;
+  /** Number of master queue shards (default: 1) */
+  shardCount?: number;
+  /** Concurrency group configurations */
+  concurrencyGroups?: ConcurrencyGroupConfig[];
+  /**
+   * Worker queue configuration.
+   * FairQueue routes messages to worker queues; external consumers handle consumption.
+   */
+  workerQueue: WorkerQueueOptions<z.infer<TPayloadSchema>>;
+  /** Retry and dead letter queue configuration */
+  retry?: RetryOptions;
+  /** Visibility timeout in milliseconds (default: 30000) */
+  visibilityTimeoutMs?: number;
+  /** Heartbeat interval in milliseconds (default: visibilityTimeoutMs / 3) */
+  heartbeatIntervalMs?: number;
+  /** Interval for reclaiming timed-out messages (default: 5000) */
+  reclaimIntervalMs?: number;
+  /** Number of consumer loops to run (default: 1) */
+  consumerCount?: number;
+  /** Interval between consumer iterations in milliseconds (default: 100) */
+  consumerIntervalMs?: number;
+  /** Whether to start consumers on initialization (default: true) */
+  startConsumers?: boolean;
+  /** Maximum number of messages to claim in a single batch operation (default: 10) */
+  batchClaimSize?: number;
+  /** Maximum iterations before starting a new trace span (default: 500) */
+  consumerTraceMaxIterations?: number;
+  /** Maximum seconds before starting a new trace span (default: 60) */
+  consumerTraceTimeoutSeconds?: number;
+  /** Queue cooloff configuration */
+  cooloff?: CooloffOptions;
+  /** Logger instance */
+  logger?: Logger;
+  /** OpenTelemetry tracer */
+  tracer?: Tracer;
+  /** OpenTelemetry meter */
+  meter?: Meter;
+  /** Name for metrics/tracing (default: "fairqueue") */
+  name?: string;
+  /**
+   * Maximum number of items allowed in a worker queue before claiming pauses.
+   * When set, the claim phase checks worker queue depth and skips claiming if
+   * the queue is at or above this limit. This prevents unbounded worker queue
+   * growth which could cause visibility timeouts (claimed messages have a
+   * visibility timeout that ticks while they sit in the worker queue).
+   * Requires `workerQueueDepthCheckId` to know which queue to check.
+   * Disabled by default (0 = no limit).
+   */
+  workerQueueMaxDepth?: number;
+  /**
+   * The worker queue ID to check depth against when workerQueueMaxDepth is set.
+   * Required when workerQueueMaxDepth > 0 and the system uses a single shared worker queue.
+   * If not set, depth checking is disabled even if workerQueueMaxDepth is set.
+   */
+  workerQueueDepthCheckId?: string;
 }
 /**
  * Context passed to the message handler.
  */
 interface MessageHandlerContext<TPayload = unknown> {
-    /** The message being processed */
-    message: QueueMessage<TPayload>;
-    /** Queue descriptor */
-    queue: QueueDescriptor;
-    /** Consumer ID processing this message */
-    consumerId: string;
-    /** Extend the visibility timeout */
-    heartbeat(): Promise<boolean>;
-    /** Mark message as successfully processed */
-    complete(): Promise<void>;
-    /** Release message back to the queue for retry */
-    release(): Promise<void>;
-    /** Mark message as failed (triggers retry or DLQ) */
-    fail(error?: Error): Promise<void>;
+  /** The message being processed */
+  message: QueueMessage<TPayload>;
+  /** Queue descriptor */
+  queue: QueueDescriptor;
+  /** Consumer ID processing this message */
+  consumerId: string;
+  /** Extend the visibility timeout */
+  heartbeat(): Promise<boolean>;
+  /** Mark message as successfully processed */
+  complete(): Promise<void>;
+  /** Release message back to the queue for retry */
+  release(): Promise<void>;
+  /** Mark message as failed (triggers retry or DLQ) */
+  fail(error?: Error): Promise<void>;
 }
 /**
  * Handler function for processing messages.
@@ -783,137 +783,138 @@ type MessageHandler<TPayload = unknown> = (context: MessageHandlerContext<TPaylo
  * A message in the dead letter queue.
  */
 interface DeadLetterMessage<TPayload = unknown> {
-    /** Message ID */
-    id: string;
-    /** Original queue ID */
-    queueId: string;
-    /** Tenant ID */
-    tenantId: string;
-    /** Message payload */
-    payload: TPayload;
-    /** Timestamp when moved to DLQ */
-    deadLetteredAt: number;
-    /** Number of attempts before DLQ */
-    attempts: number;
-    /** Last error message if available */
-    lastError?: string;
-    /** Original message timestamp */
-    originalTimestamp: number;
+  /** Message ID */
+  id: string;
+  /** Original queue ID */
+  queueId: string;
+  /** Tenant ID */
+  tenantId: string;
+  /** Message payload */
+  payload: TPayload;
+  /** Timestamp when moved to DLQ */
+  deadLetteredAt: number;
+  /** Number of attempts before DLQ */
+  attempts: number;
+  /** Last error message if available */
+  lastError?: string;
+  /** Original message timestamp */
+  originalTimestamp: number;
 }
 /**
  * Cooloff state for a queue.
  */
 type QueueCooloffState = {
-    tag: "normal";
-    consecutiveFailures: number;
+  tag: "normal";
+  consecutiveFailures: number;
 } | {
-    tag: "cooloff";
-    expiresAt: number;
+  tag: "cooloff";
+  expiresAt: number;
 };
 /**
  * Options for enqueueing a message.
  */
 interface EnqueueOptions<TPayload = unknown> {
-    /** Queue to add the message to */
-    queueId: string;
-    /** Tenant ID for the queue */
-    tenantId: string;
-    /** Message payload */
-    payload: TPayload;
-    /** Optional message ID (auto-generated if not provided) */
-    messageId?: string;
-    /** Optional timestamp (defaults to now) */
-    timestamp?: number;
-    /** Optional metadata for concurrency group extraction */
-    metadata?: Record<string, string>;
+  /** Queue to add the message to */
+  queueId: string;
+  /** Tenant ID for the queue */
+  tenantId: string;
+  /** Message payload */
+  payload: TPayload;
+  /** Optional message ID (auto-generated if not provided) */
+  messageId?: string;
+  /** Optional timestamp (defaults to now) */
+  timestamp?: number;
+  /** Optional metadata for concurrency group extraction */
+  metadata?: Record<string, string>;
 }
 /**
  * Options for enqueueing multiple messages.
  */
 interface EnqueueBatchOptions<TPayload = unknown> {
-    /** Queue to add messages to */
-    queueId: string;
-    /** Tenant ID for the queue */
-    tenantId: string;
-    /** Messages to enqueue */
-    messages: Array<{
-        payload: TPayload;
-        messageId?: string;
-        timestamp?: number;
-    }>;
-    /** Optional metadata for concurrency group extraction */
-    metadata?: Record<string, string>;
+  /** Queue to add messages to */
+  queueId: string;
+  /** Tenant ID for the queue */
+  tenantId: string;
+  /** Messages to enqueue */
+  messages: Array<{
+    payload: TPayload;
+    messageId?: string;
+    timestamp?: number;
+  }>;
+  /** Optional metadata for concurrency group extraction */
+  metadata?: Record<string, string>;
 }
 /**
  * Configuration for the Deficit Round Robin scheduler.
  */
 interface DRRSchedulerConfig {
-    /** Credits allocated per tenant per round */
-    quantum: number;
-    /** Maximum accumulated deficit (prevents starvation) */
-    maxDeficit: number;
-    /** Maximum queues to fetch from master queue (default: 1000) */
-    masterQueueLimit?: number;
-    /** Redis options for state storage */
-    redis: RedisOptions;
-    /** Key producer */
-    keys: FairQueueKeyProducer;
-    /** Optional logger */
-    logger?: {
-        debug: (message: string, context?: Record<string, unknown>) => void;
-        error: (message: string, context?: Record<string, unknown>) => void;
-    };
+  /** Credits allocated per tenant per round */
+  quantum: number;
+  /** Maximum accumulated deficit (prevents starvation) */
+  maxDeficit: number;
+  /** Maximum queues to fetch from master queue (default: 1000) */
+  masterQueueLimit?: number;
+  /** Redis options for state storage */
+  redis: RedisOptions;
+  /** Key producer */
+  keys: FairQueueKeyProducer;
+  /** Optional logger */
+  logger?: {
+    debug: (message: string, context?: Record<string, unknown>) => void;
+    error: (message: string, context?: Record<string, unknown>) => void;
+  };
 }
 /**
  * Bias configuration for weighted shuffle scheduler.
  */
 interface WeightedSchedulerBiases {
-    /**
-     * How much to bias towards tenants with higher concurrency limits.
-     * 0 = no bias, 1 = full bias based on limit differences
-     */
-    concurrencyLimitBias: number;
-    /**
-     * How much to bias towards tenants with more available capacity.
-     * 0 = no bias, 1 = full bias based on available capacity
-     */
-    availableCapacityBias: number;
-    /**
-     * Controls randomization of queue ordering within tenants.
-     * 0 = strict age-based ordering (oldest first)
-     * 1 = completely random ordering
-     * Values between 0-1 blend between age-based and random ordering
-     */
-    queueAgeRandomization: number;
+  /**
+   * How much to bias towards tenants with higher concurrency limits.
+   * 0 = no bias, 1 = full bias based on limit differences
+   */
+  concurrencyLimitBias: number;
+  /**
+   * How much to bias towards tenants with more available capacity.
+   * 0 = no bias, 1 = full bias based on available capacity
+   */
+  availableCapacityBias: number;
+  /**
+   * Controls randomization of queue ordering within tenants.
+   * 0 = strict age-based ordering (oldest first)
+   * 1 = completely random ordering
+   * Values between 0-1 blend between age-based and random ordering
+   */
+  queueAgeRandomization: number;
 }
 /**
  * Configuration for the weighted shuffle scheduler.
  */
 interface WeightedSchedulerConfig {
-    /** Redis options */
-    redis: RedisOptions;
-    /** Key producer */
-    keys: FairQueueKeyProducer;
-    /** Default tenant concurrency limit */
-    defaultTenantConcurrencyLimit?: number;
-    /** Maximum queues to consider from master queue */
-    masterQueueLimit?: number;
-    /** Bias configuration */
-    biases?: WeightedSchedulerBiases;
-    /** Number of iterations to reuse a snapshot */
-    reuseSnapshotCount?: number;
-    /** Maximum number of tenants to consider */
-    maximumTenantCount?: number;
-    /** Random seed for reproducibility */
-    seed?: string;
-    /** Optional tracer */
-    tracer?: Tracer;
-}
-
+  /** Redis options */
+  redis: RedisOptions;
+  /** Key producer */
+  keys: FairQueueKeyProducer;
+  /** Default tenant concurrency limit */
+  defaultTenantConcurrencyLimit?: number;
+  /** Maximum queues to consider from master queue */
+  masterQueueLimit?: number;
+  /** Bias configuration */
+  biases?: WeightedSchedulerBiases;
+  /** Number of iterations to reuse a snapshot */
+  reuseSnapshotCount?: number;
+  /** Maximum number of tenants to consider */
+  maximumTenantCount?: number;
+  /** Random seed for reproducibility */
+  seed?: string;
+  /** Optional tracer */
+  tracer?: Tracer;
+}
+//#endregion
+//#region src/fair-queue/concurrency.d.ts
 interface ConcurrencyManagerOptions {
-    redis: RedisOptions;
-    keys: FairQueueKeyProducer;
-    groups: ConcurrencyGroupConfig[];
+  redis: RedisOptions;
+  keys: FairQueueKeyProducer;
+  groups: ConcurrencyGroupConfig[];
 }
 /**
  * ConcurrencyManager handles multi-level concurrency tracking and limiting.
@@ -924,87 +925,88 @@ interface ConcurrencyManagerOptions {
  * - Efficient batch checking of all groups
  */
 declare class ConcurrencyManager {
-    #private;
-    private options;
-    private redis;
-    private keys;
-    private groups;
-    private groupsByName;
-    constructor(options: ConcurrencyManagerOptions);
-    /**
-     * Check if a message can be processed given all concurrency constraints.
-     * Checks all configured groups and returns the first one at capacity.
-     */
-    canProcess(queue: QueueDescriptor): Promise<ConcurrencyCheckResult>;
-    /**
-     * Reserve concurrency slots for a message across all groups.
-     * Atomic - either all groups are reserved or none.
-     *
-     * @returns true if reservation successful, false if any group is at capacity
-     */
-    reserve(queue: QueueDescriptor, messageId: string): Promise<boolean>;
-    /**
-     * Release concurrency slots for a message across all groups.
-     */
-    release(queue: QueueDescriptor, messageId: string): Promise<void>;
-    /**
-     * Release concurrency slots for multiple messages in a single pipeline.
-     * More efficient than calling release() multiple times.
-     */
-    releaseBatch(messages: Array<{
-        queue: QueueDescriptor;
-        messageId: string;
-    }>): Promise<void>;
-    /**
-     * Get current concurrency for a specific group.
-     */
-    getCurrentConcurrency(groupName: string, groupId: string): Promise<number>;
-    /**
-     * Get available capacity for a queue across all concurrency groups.
-     * Returns the minimum available capacity across all groups.
-     */
-    getAvailableCapacity(queue: QueueDescriptor): Promise<number>;
-    /**
-     * Get concurrency limit for a specific group.
-     */
-    getConcurrencyLimit(groupName: string, groupId: string): Promise<number>;
-    /**
-     * Check if a group is at capacity.
-     */
-    isAtCapacity(groupName: string, groupId: string): Promise<boolean>;
-    /**
-     * Get full state for a group.
-     */
-    getState(groupName: string, groupId: string): Promise<ConcurrencyState>;
-    /**
-     * Get all active message IDs for a group.
-     */
-    getActiveMessages(groupName: string, groupId: string): Promise<string[]>;
-    /**
-     * Force-clear concurrency for a group (use with caution).
-     * Useful for cleanup after crashes.
-     */
-    clearGroup(groupName: string, groupId: string): Promise<void>;
-    /**
-     * Remove a specific message from concurrency tracking.
-     * Useful for cleanup.
-     */
-    removeMessage(messageId: string, queue: QueueDescriptor): Promise<void>;
-    /**
-     * Get configured group names.
-     */
-    getGroupNames(): string[];
-    /**
-     * Close the Redis connection.
-     */
-    close(): Promise<void>;
+  #private;
+  private options;
+  private redis;
+  private keys;
+  private groups;
+  private groupsByName;
+  constructor(options: ConcurrencyManagerOptions);
+  /**
+   * Check if a message can be processed given all concurrency constraints.
+   * Checks all configured groups and returns the first one at capacity.
+   */
+  canProcess(queue: QueueDescriptor): Promise<ConcurrencyCheckResult>;
+  /**
+   * Reserve concurrency slots for a message across all groups.
+   * Atomic - either all groups are reserved or none.
+   *
+   * @returns true if reservation successful, false if any group is at capacity
+   */
+  reserve(queue: QueueDescriptor, messageId: string): Promise<boolean>;
+  /**
+   * Release concurrency slots for a message across all groups.
+   */
+  release(queue: QueueDescriptor, messageId: string): Promise<void>;
+  /**
+   * Release concurrency slots for multiple messages in a single pipeline.
+   * More efficient than calling release() multiple times.
+   */
+  releaseBatch(messages: Array<{
+    queue: QueueDescriptor;
+    messageId: string;
+  }>): Promise<void>;
+  /**
+   * Get current concurrency for a specific group.
+   */
+  getCurrentConcurrency(groupName: string, groupId: string): Promise<number>;
+  /**
+   * Get available capacity for a queue across all concurrency groups.
+   * Returns the minimum available capacity across all groups.
+   */
+  getAvailableCapacity(queue: QueueDescriptor): Promise<number>;
+  /**
+   * Get concurrency limit for a specific group.
+   */
+  getConcurrencyLimit(groupName: string, groupId: string): Promise<number>;
+  /**
+   * Check if a group is at capacity.
+   */
+  isAtCapacity(groupName: string, groupId: string): Promise<boolean>;
+  /**
+   * Get full state for a group.
+   */
+  getState(groupName: string, groupId: string): Promise<ConcurrencyState>;
+  /**
+   * Get all active message IDs for a group.
+   */
+  getActiveMessages(groupName: string, groupId: string): Promise<string[]>;
+  /**
+   * Force-clear concurrency for a group (use with caution).
+   * Useful for cleanup after crashes.
+   */
+  clearGroup(groupName: string, groupId: string): Promise<void>;
+  /**
+   * Remove a specific message from concurrency tracking.
+   * Useful for cleanup.
+   */
+  removeMessage(messageId: string, queue: QueueDescriptor): Promise<void>;
+  /**
+   * Get configured group names.
+   */
+  getGroupNames(): string[];
+  /**
+   * Close the Redis connection.
+   */
+  close(): Promise<void>;
 }
 declare module "@internal/redis" {
-    interface RedisCommander<Context> {
-        reserveConcurrency(numKeys: number, keys: string[], messageId: string, ...limits: string[]): Promise<number>;
-    }
+  interface RedisCommander<Context> {
+    reserveConcurrency(numKeys: number, keys: string[], messageId: string, ...limits: string[]): Promise<number>;
+  }
 }
-
+//#endregion
+//#region src/fair-queue/keyProducer.d.ts
 /**
  * Default key producer for the fair queue system.
  * Uses a configurable prefix and standard key structure.
@@ -1021,58 +1023,59 @@ declare module "@internal/redis" {
  * - Worker queue: {prefix}:worker:{consumerId}
  */
 declare class DefaultFairQueueKeyProducer implements FairQueueKeyProducer {
-    #private;
-    private readonly prefix;
-    private readonly separator;
-    constructor(options?: {
-        prefix?: string;
-        separator?: string;
-    });
-    masterQueueKey(shardId: number): string;
-    queueKey(queueId: string): string;
-    queueItemsKey(queueId: string): string;
-    concurrencyKey(groupName: string, groupId: string): string;
-    inflightKey(shardId: number): string;
-    inflightDataKey(shardId: number): string;
-    workerQueueKey(consumerId: string): string;
-    dispatchKey(shardId: number): string;
-    tenantQueueIndexKey(tenantId: string): string;
-    deadLetterQueueKey(tenantId: string): string;
-    deadLetterQueueDataKey(tenantId: string): string;
-    /**
-     * Extract tenant ID from a queue ID.
-     * Default implementation assumes queue IDs are formatted as: tenant:{tenantId}:...
-     * Override this method for custom queue ID formats.
-     */
-    extractTenantId(queueId: string): string;
-    /**
-     * Extract a group ID from a queue ID.
-     * Default implementation looks for pattern: {groupName}:{groupId}:...
-     * Override this method for custom queue ID formats.
-     */
-    extractGroupId(groupName: string, queueId: string): string;
+  #private;
+  private readonly prefix;
+  private readonly separator;
+  constructor(options?: {
+    prefix?: string;
+    separator?: string;
+  });
+  masterQueueKey(shardId: number): string;
+  queueKey(queueId: string): string;
+  queueItemsKey(queueId: string): string;
+  concurrencyKey(groupName: string, groupId: string): string;
+  inflightKey(shardId: number): string;
+  inflightDataKey(shardId: number): string;
+  workerQueueKey(consumerId: string): string;
+  dispatchKey(shardId: number): string;
+  tenantQueueIndexKey(tenantId: string): string;
+  deadLetterQueueKey(tenantId: string): string;
+  deadLetterQueueDataKey(tenantId: string): string;
+  /**
+   * Extract tenant ID from a queue ID.
+   * Default implementation assumes queue IDs are formatted as: tenant:{tenantId}:...
+   * Override this method for custom queue ID formats.
+   */
+  extractTenantId(queueId: string): string;
+  /**
+   * Extract a group ID from a queue ID.
+   * Default implementation looks for pattern: {groupName}:{groupId}:...
+   * Override this method for custom queue ID formats.
+   */
+  extractGroupId(groupName: string, queueId: string): string;
 }
 /**
  * Key producer with custom extraction logic via callbacks.
  * Useful when queue IDs don't follow a standard pattern.
  */
 declare class CallbackFairQueueKeyProducer extends DefaultFairQueueKeyProducer {
-    private readonly tenantExtractor;
-    private readonly groupExtractor;
-    constructor(options: {
-        prefix?: string;
-        separator?: string;
-        extractTenantId: (queueId: string) => string;
-        extractGroupId: (groupName: string, queueId: string) => string;
-    });
-    extractTenantId(queueId: string): string;
-    extractGroupId(groupName: string, queueId: string): string;
-}
-
+  private readonly tenantExtractor;
+  private readonly groupExtractor;
+  constructor(options: {
+    prefix?: string;
+    separator?: string;
+    extractTenantId: (queueId: string) => string;
+    extractGroupId: (groupName: string, queueId: string) => string;
+  });
+  extractTenantId(queueId: string): string;
+  extractGroupId(groupName: string, queueId: string): string;
+}
+//#endregion
+//#region src/fair-queue/masterQueue.d.ts
 interface MasterQueueOptions {
-    redis: RedisOptions;
-    keys: FairQueueKeyProducer;
-    shardCount: number;
+  redis: RedisOptions;
+  keys: FairQueueKeyProducer;
+  shardCount: number;
 }
 /**
  * Master queue manages the top-level queue of queues.
@@ -1083,141 +1086,143 @@ interface MasterQueueOptions {
  * - Queues scored by oldest message timestamp
  */
 declare class MasterQueue {
-    #private;
-    private options;
-    private redis;
-    private keys;
-    private shardCount;
-    constructor(options: MasterQueueOptions);
-    /**
-     * Get the shard ID for a queue.
-     * Uses consistent hashing based on queue ID.
-     */
-    getShardForQueue(queueId: string): number;
-    /**
-     * Add a queue to its master queue shard.
-     * Updates the score to the oldest message timestamp.
-     *
-     * @param queueId - The queue identifier
-     * @param oldestMessageTimestamp - Timestamp of the oldest message in the queue
-     */
-    addQueue(queueId: string, oldestMessageTimestamp: number): Promise<void>;
-    /**
-     * Update a queue's score in the master queue.
-     * This is typically called after dequeuing to update to the new oldest message.
-     *
-     * @param queueId - The queue identifier
-     * @param newOldestTimestamp - New timestamp of the oldest message
-     */
-    updateQueueScore(queueId: string, newOldestTimestamp: number): Promise<void>;
-    /**
-     * Remove a queue from its master queue shard.
-     * Called when a queue becomes empty.
-     *
-     * @param queueId - The queue identifier
-     */
-    removeQueue(queueId: string): Promise<void>;
-    /**
-     * Get queues from a shard, ordered by oldest message (lowest score first).
-     *
-     * @param shardId - The shard to query
-     * @param limit - Maximum number of queues to return (default: 1000)
-     * @param maxScore - Maximum score (timestamp) to include (default: now)
-     */
-    getQueuesFromShard(shardId: number, limit?: number, maxScore?: number): Promise<QueueWithScore[]>;
-    /**
-     * Get the number of queues in a shard.
-     */
-    getShardQueueCount(shardId: number): Promise<number>;
-    /**
-     * Get total queue count across all shards.
-     */
-    getTotalQueueCount(): Promise<number>;
-    /**
-     * Atomically add a queue to master queue only if queue has messages.
-     * Uses Lua script for atomicity.
-     *
-     * @param queueId - The queue identifier
-     * @param queueKey - The actual queue sorted set key
-     * @returns Whether the queue was added to the master queue
-     */
-    addQueueIfNotEmpty(queueId: string, queueKey: string): Promise<boolean>;
-    /**
-     * Atomically remove a queue from master queue only if queue is empty.
-     * Uses Lua script for atomicity.
-     *
-     * @param queueId - The queue identifier
-     * @param queueKey - The actual queue sorted set key
-     * @returns Whether the queue was removed from the master queue
-     */
-    removeQueueIfEmpty(queueId: string, queueKey: string): Promise<boolean>;
-    /**
-     * Close the Redis connection.
-     */
-    close(): Promise<void>;
+  #private;
+  private options;
+  private redis;
+  private keys;
+  private shardCount;
+  constructor(options: MasterQueueOptions);
+  /**
+   * Get the shard ID for a queue.
+   * Uses consistent hashing based on queue ID.
+   */
+  getShardForQueue(queueId: string): number;
+  /**
+   * Add a queue to its master queue shard.
+   * Updates the score to the oldest message timestamp.
+   *
+   * @param queueId - The queue identifier
+   * @param oldestMessageTimestamp - Timestamp of the oldest message in the queue
+   */
+  addQueue(queueId: string, oldestMessageTimestamp: number): Promise<void>;
+  /**
+   * Update a queue's score in the master queue.
+   * This is typically called after dequeuing to update to the new oldest message.
+   *
+   * @param queueId - The queue identifier
+   * @param newOldestTimestamp - New timestamp of the oldest message
+   */
+  updateQueueScore(queueId: string, newOldestTimestamp: number): Promise<void>;
+  /**
+   * Remove a queue from its master queue shard.
+   * Called when a queue becomes empty.
+   *
+   * @param queueId - The queue identifier
+   */
+  removeQueue(queueId: string): Promise<void>;
+  /**
+   * Get queues from a shard, ordered by oldest message (lowest score first).
+   *
+   * @param shardId - The shard to query
+   * @param limit - Maximum number of queues to return (default: 1000)
+   * @param maxScore - Maximum score (timestamp) to include (default: now)
+   */
+  getQueuesFromShard(shardId: number, limit?: number, maxScore?: number): Promise<QueueWithScore[]>;
+  /**
+   * Get the number of queues in a shard.
+   */
+  getShardQueueCount(shardId: number): Promise<number>;
+  /**
+   * Get total queue count across all shards.
+   */
+  getTotalQueueCount(): Promise<number>;
+  /**
+   * Atomically add a queue to master queue only if queue has messages.
+   * Uses Lua script for atomicity.
+   *
+   * @param queueId - The queue identifier
+   * @param queueKey - The actual queue sorted set key
+   * @returns Whether the queue was added to the master queue
+   */
+  addQueueIfNotEmpty(queueId: string, queueKey: string): Promise<boolean>;
+  /**
+   * Atomically remove a queue from master queue only if queue is empty.
+   * Uses Lua script for atomicity.
+   *
+   * @param queueId - The queue identifier
+   * @param queueKey - The actual queue sorted set key
+   * @returns Whether the queue was removed from the master queue
+   */
+  removeQueueIfEmpty(queueId: string, queueKey: string): Promise<boolean>;
+  /**
+   * Close the Redis connection.
+   */
+  close(): Promise<void>;
 }
 declare module "@internal/redis" {
-    interface RedisCommander<Context> {
-        addQueueIfNotEmpty(masterKey: string, queueKey: string, queueId: string): Promise<number>;
-        removeQueueIfEmpty(masterKey: string, queueKey: string, queueId: string): Promise<number>;
-    }
+  interface RedisCommander<Context> {
+    addQueueIfNotEmpty(masterKey: string, queueKey: string, queueId: string): Promise<number>;
+    removeQueueIfEmpty(masterKey: string, queueKey: string, queueId: string): Promise<number>;
+  }
 }
-
+//#endregion
+//#region src/fair-queue/scheduler.d.ts
 /**
  * Base class for scheduler implementations.
  * Provides common utilities and default implementations.
  */
 declare abstract class BaseScheduler implements FairScheduler {
-    /**
-     * Select queues for processing from a master queue shard.
-     * Must be implemented by subclasses.
-     */
-    abstract selectQueues(masterQueueShard: string, consumerId: string, context: SchedulerContext): Promise<TenantQueues[]>;
-    /**
-     * Called after processing a message to update scheduler state.
-     * Default implementation does nothing.
-     */
-    recordProcessed(_tenantId: string, _queueId: string): Promise<void>;
-    /**
-     * Called after processing multiple messages to update scheduler state.
-     * Batch variant for efficiency - reduces Redis calls when processing multiple messages.
-     * Default implementation does nothing.
-     */
-    recordProcessedBatch(_tenantId: string, _queueId: string, _count: number): Promise<void>;
-    /**
-     * Initialize the scheduler.
-     * Default implementation does nothing.
-     */
-    initialize(): Promise<void>;
-    /**
-     * Cleanup scheduler resources.
-     * Default implementation does nothing.
-     */
-    close(): Promise<void>;
-    /**
-     * Helper to group queues by tenant.
-     */
-    protected groupQueuesByTenant(queues: Array<{
-        queueId: string;
-        tenantId: string;
-    }>): Map<string, string[]>;
-    /**
-     * Helper to convert grouped queues to TenantQueues array.
-     */
-    protected toTenantQueuesArray(grouped: Map<string, string[]>): TenantQueues[];
-    /**
-     * Helper to filter out tenants at capacity.
-     */
-    protected filterAtCapacity(tenants: TenantQueues[], context: SchedulerContext, groupName?: string): Promise<TenantQueues[]>;
+  /**
+   * Select queues for processing from a master queue shard.
+   * Must be implemented by subclasses.
+   */
+  abstract selectQueues(masterQueueShard: string, consumerId: string, context: SchedulerContext): Promise<TenantQueues[]>;
+  /**
+   * Called after processing a message to update scheduler state.
+   * Default implementation does nothing.
+   */
+  recordProcessed(_tenantId: string, _queueId: string): Promise<void>;
+  /**
+   * Called after processing multiple messages to update scheduler state.
+   * Batch variant for efficiency - reduces Redis calls when processing multiple messages.
+   * Default implementation does nothing.
+   */
+  recordProcessedBatch(_tenantId: string, _queueId: string, _count: number): Promise<void>;
+  /**
+   * Initialize the scheduler.
+   * Default implementation does nothing.
+   */
+  initialize(): Promise<void>;
+  /**
+   * Cleanup scheduler resources.
+   * Default implementation does nothing.
+   */
+  close(): Promise<void>;
+  /**
+   * Helper to group queues by tenant.
+   */
+  protected groupQueuesByTenant(queues: Array<{
+    queueId: string;
+    tenantId: string;
+  }>): Map<string, string[]>;
+  /**
+   * Helper to convert grouped queues to TenantQueues array.
+   */
+  protected toTenantQueuesArray(grouped: Map<string, string[]>): TenantQueues[];
+  /**
+   * Helper to filter out tenants at capacity.
+   */
+  protected filterAtCapacity(tenants: TenantQueues[], context: SchedulerContext, groupName?: string): Promise<TenantQueues[]>;
 }
 /**
  * Simple noop scheduler that returns empty results.
  * Useful for testing or disabling scheduling.
  */
 declare class NoopScheduler extends BaseScheduler {
-    selectQueues(_masterQueueShard: string, _consumerId: string, _context: SchedulerContext): Promise<TenantQueues[]>;
+  selectQueues(_masterQueueShard: string, _consumerId: string, _context: SchedulerContext): Promise<TenantQueues[]>;
 }
-
+//#endregion
+//#region src/fair-queue/schedulers/drr.d.ts
 /**
  * Deficit Round Robin (DRR) Scheduler.
  *
@@ -1233,71 +1238,72 @@ declare class NoopScheduler extends BaseScheduler {
  * - Automatic deficit cleanup for inactive tenants
  */
 declare class DRRScheduler extends BaseScheduler {
-    #private;
-    private config;
-    private redis;
-    private keys;
-    private quantum;
-    private maxDeficit;
-    private masterQueueLimit;
-    private logger;
-    constructor(config: DRRSchedulerConfig);
-    /**
-     * Select queues for processing using DRR algorithm.
-     *
-     * Algorithm:
-     * 1. Get all queues from the master shard
-     * 2. Group by tenant
-     * 3. Filter out tenants at concurrency capacity
-     * 4. Add quantum to each tenant's deficit (atomically)
-     * 5. Select queues from tenants with deficit >= 1
-     * 6. Order tenants by deficit (highest first for fairness)
-     */
-    selectQueues(masterQueueShard: string, consumerId: string, context: SchedulerContext): Promise<TenantQueues[]>;
-    /**
-     * Select queues using the two-level tenant dispatch index.
-     *
-     * Algorithm:
-     * 1. ZRANGEBYSCORE on dispatch index (gets only tenants with queues - much smaller)
-     * 2. Add quantum to each tenant's deficit (atomically)
-     * 3. Check capacity as safety net (dispatch should only have tenants with capacity)
-     * 4. Select tenants with deficit >= 1, sorted by deficit (highest first)
-     * 5. For each tenant, fetch their queues from Level 2 index
-     */
-    selectQueuesFromDispatch(dispatchShardKey: string, consumerId: string, context: DispatchSchedulerContext): Promise<TenantQueues[]>;
-    /**
-     * Record that a message was processed from a tenant.
-     * Decrements the tenant's deficit.
-     */
-    recordProcessed(tenantId: string, _queueId: string): Promise<void>;
-    /**
-     * Record that multiple messages were processed from a tenant.
-     * Decrements the tenant's deficit by count atomically.
-     */
-    recordProcessedBatch(tenantId: string, _queueId: string, count: number): Promise<void>;
-    close(): Promise<void>;
-    /**
-     * Get the current deficit for a tenant.
-     */
-    getDeficit(tenantId: string): Promise<number>;
-    /**
-     * Reset deficit for a tenant.
-     * Used when a tenant has no more active queues.
-     */
-    resetDeficit(tenantId: string): Promise<void>;
-    /**
-     * Get all tenant deficits.
-     */
-    getAllDeficits(): Promise<Map<string, number>>;
+  #private;
+  private config;
+  private redis;
+  private keys;
+  private quantum;
+  private maxDeficit;
+  private masterQueueLimit;
+  private logger;
+  constructor(config: DRRSchedulerConfig);
+  /**
+   * Select queues for processing using DRR algorithm.
+   *
+   * Algorithm:
+   * 1. Get all queues from the master shard
+   * 2. Group by tenant
+   * 3. Filter out tenants at concurrency capacity
+   * 4. Add quantum to each tenant's deficit (atomically)
+   * 5. Select queues from tenants with deficit >= 1
+   * 6. Order tenants by deficit (highest first for fairness)
+   */
+  selectQueues(masterQueueShard: string, consumerId: string, context: SchedulerContext): Promise<TenantQueues[]>;
+  /**
+   * Select queues using the two-level tenant dispatch index.
+   *
+   * Algorithm:
+   * 1. ZRANGEBYSCORE on dispatch index (gets only tenants with queues - much smaller)
+   * 2. Add quantum to each tenant's deficit (atomically)
+   * 3. Check capacity as safety net (dispatch should only have tenants with capacity)
+   * 4. Select tenants with deficit >= 1, sorted by deficit (highest first)
+   * 5. For each tenant, fetch their queues from Level 2 index
+   */
+  selectQueuesFromDispatch(dispatchShardKey: string, consumerId: string, context: DispatchSchedulerContext): Promise<TenantQueues[]>;
+  /**
+   * Record that a message was processed from a tenant.
+   * Decrements the tenant's deficit.
+   */
+  recordProcessed(tenantId: string, _queueId: string): Promise<void>;
+  /**
+   * Record that multiple messages were processed from a tenant.
+   * Decrements the tenant's deficit by count atomically.
+   */
+  recordProcessedBatch(tenantId: string, _queueId: string, count: number): Promise<void>;
+  close(): Promise<void>;
+  /**
+   * Get the current deficit for a tenant.
+   */
+  getDeficit(tenantId: string): Promise<number>;
+  /**
+   * Reset deficit for a tenant.
+   * Used when a tenant has no more active queues.
+   */
+  resetDeficit(tenantId: string): Promise<void>;
+  /**
+   * Get all tenant deficits.
+   */
+  getAllDeficits(): Promise<Map<string, number>>;
 }
 declare module "@internal/redis" {
-    interface RedisCommander<Context> {
-        drrAddQuantum(deficitKey: string, quantum: string, maxDeficit: string, ...tenantIds: string[]): Promise<string[]>;
-        drrDecrementDeficit(deficitKey: string, tenantId: string): Promise<string>;
-        drrDecrementDeficitBatch(deficitKey: string, tenantId: string, count: string): Promise<string>;
-    }
-}
-
+  interface RedisCommander<Context> {
+    drrAddQuantum(deficitKey: string, quantum: string, maxDeficit: string, ...tenantIds: string[]): Promise<string[]>;
+    drrDecrementDeficit(deficitKey: string, tenantId: string): Promise<string>;
+    drrDecrementDeficitBatch(deficitKey: string, tenantId: string, count: string): Promise<string>;
+  }
+}
+//#endregion
+//#region src/fair-queue/schedulers/weighted.d.ts
 /**
  * Weighted Shuffle Scheduler.
  *
@@ -1312,27 +1318,28 @@ declare module "@internal/redis" {
  * - Maximum tenant count to limit iteration
  */
 declare class WeightedScheduler extends BaseScheduler {
-    #private;
-    private config;
-    private redis;
-    private keys;
-    private rng;
-    private biases;
-    private defaultTenantLimit;
-    private masterQueueLimit;
-    private reuseSnapshotCount;
-    private maximumTenantCount;
-    private snapshotCache;
-    constructor(config: WeightedSchedulerConfig);
-    selectQueues(masterQueueShard: string, consumerId: string, context: SchedulerContext): Promise<TenantQueues[]>;
-    close(): Promise<void>;
-}
-
+  #private;
+  private config;
+  private redis;
+  private keys;
+  private rng;
+  private biases;
+  private defaultTenantLimit;
+  private masterQueueLimit;
+  private reuseSnapshotCount;
+  private maximumTenantCount;
+  private snapshotCache;
+  constructor(config: WeightedSchedulerConfig);
+  selectQueues(masterQueueShard: string, consumerId: string, context: SchedulerContext): Promise<TenantQueues[]>;
+  close(): Promise<void>;
+}
+//#endregion
+//#region src/fair-queue/schedulers/roundRobin.d.ts
 interface RoundRobinSchedulerConfig {
-    redis: RedisOptions;
-    keys: FairQueueKeyProducer;
-    /** Maximum queues to fetch from master queue per iteration */
-    masterQueueLimit?: number;
+  redis: RedisOptions;
+  keys: FairQueueKeyProducer;
+  /** Maximum queues to fetch from master queue per iteration */
+  masterQueueLimit?: number;
 }
 /**
  * Round Robin Scheduler.
@@ -1346,65 +1353,66 @@ interface RoundRobinSchedulerConfig {
  * - No weighting or bias
  */
 declare class RoundRobinScheduler extends BaseScheduler {
-    #private;
-    private config;
-    private redis;
-    private keys;
-    private masterQueueLimit;
-    constructor(config: RoundRobinSchedulerConfig);
-    selectQueues(masterQueueShard: string, consumerId: string, context: SchedulerContext): Promise<TenantQueues[]>;
-    close(): Promise<void>;
-}
-
+  #private;
+  private config;
+  private redis;
+  private keys;
+  private masterQueueLimit;
+  constructor(config: RoundRobinSchedulerConfig);
+  selectQueues(masterQueueShard: string, consumerId: string, context: SchedulerContext): Promise<TenantQueues[]>;
+  close(): Promise<void>;
+}
+//#endregion
+//#region src/fair-queue/telemetry.d.ts
 /**
  * Semantic attributes for fair queue messaging operations.
  */
 declare const FairQueueAttributes: {
-    readonly QUEUE_ID: "fairqueue.queue_id";
-    readonly TENANT_ID: "fairqueue.tenant_id";
-    readonly MESSAGE_ID: "fairqueue.message_id";
-    readonly SHARD_ID: "fairqueue.shard_id";
-    readonly WORKER_QUEUE: "fairqueue.worker_queue";
-    readonly CONSUMER_ID: "fairqueue.consumer_id";
-    readonly ATTEMPT: "fairqueue.attempt";
-    readonly CONCURRENCY_GROUP: "fairqueue.concurrency_group";
-    readonly MESSAGE_COUNT: "fairqueue.message_count";
-    readonly RESULT: "fairqueue.result";
+  readonly QUEUE_ID: "fairqueue.queue_id";
+  readonly TENANT_ID: "fairqueue.tenant_id";
+  readonly MESSAGE_ID: "fairqueue.message_id";
+  readonly SHARD_ID: "fairqueue.shard_id";
+  readonly WORKER_QUEUE: "fairqueue.worker_queue";
+  readonly CONSUMER_ID: "fairqueue.consumer_id";
+  readonly ATTEMPT: "fairqueue.attempt";
+  readonly CONCURRENCY_GROUP: "fairqueue.concurrency_group";
+  readonly MESSAGE_COUNT: "fairqueue.message_count";
+  readonly RESULT: "fairqueue.result";
 };
 /**
  * Standard messaging semantic attributes.
  */
 declare const MessagingAttributes: {
-    readonly SYSTEM: "messaging.system";
-    readonly OPERATION: "messaging.operation";
-    readonly MESSAGE_ID: "messaging.message_id";
-    readonly DESTINATION_NAME: "messaging.destination.name";
+  readonly SYSTEM: "messaging.system";
+  readonly OPERATION: "messaging.operation";
+  readonly MESSAGE_ID: "messaging.message_id";
+  readonly DESTINATION_NAME: "messaging.destination.name";
 };
 /**
  * FairQueue metrics collection.
  */
 interface FairQueueMetrics {
-    messagesEnqueued: Counter;
-    messagesCompleted: Counter;
-    messagesFailed: Counter;
-    messagesRetried: Counter;
-    messagesToDLQ: Counter;
-    processingTime: Histogram;
-    queueTime: Histogram;
-    queueLength: ObservableGauge;
-    masterQueueLength: ObservableGauge;
-    dispatchLength: ObservableGauge;
-    inflightCount: ObservableGauge;
-    dlqLength: ObservableGauge;
+  messagesEnqueued: Counter;
+  messagesCompleted: Counter;
+  messagesFailed: Counter;
+  messagesRetried: Counter;
+  messagesToDLQ: Counter;
+  processingTime: Histogram;
+  queueTime: Histogram;
+  queueLength: ObservableGauge;
+  masterQueueLength: ObservableGauge;
+  dispatchLength: ObservableGauge;
+  inflightCount: ObservableGauge;
+  dlqLength: ObservableGauge;
 }
 /**
  * Options for creating FairQueue telemetry.
  */
 interface TelemetryOptions {
-    tracer?: Tracer;
-    meter?: Meter;
-    /** Custom name for metrics prefix */
-    name?: string;
+  tracer?: Tracer;
+  meter?: Meter;
+  /** Custom name for metrics prefix */
+  name?: string;
 }
 /**
  * Telemetry helper for FairQueue.
@@ -1415,139 +1423,139 @@ interface TelemetryOptions {
  * - Context propagation helpers
  */
 declare class FairQueueTelemetry {
-    #private;
-    private tracer?;
-    private meter?;
-    private metrics?;
-    private name;
-    constructor(options: TelemetryOptions);
-    /**
-     * Create a traced span for an operation.
-     * Returns the result of the function, or throws any error after recording it.
-     */
-    trace<T>(name: string, fn: (span: Span) => Promise<T>, options?: {
-        kind?: SpanKind;
-        attributes?: Attributes;
-    }): Promise<T>;
-    /**
-     * Synchronous version of trace.
-     */
-    traceSync<T>(name: string, fn: (span: Span) => T, options?: {
-        kind?: SpanKind;
-        attributes?: Attributes;
-    }): T;
-    /**
-     * Record a message enqueued.
-     */
-    recordEnqueue(attributes?: Attributes): void;
-    /**
-     * Record a batch of messages enqueued.
-     */
-    recordEnqueueBatch(count: number, attributes?: Attributes): void;
-    /**
-     * Record a message completed successfully.
-     */
-    recordComplete(attributes?: Attributes): void;
-    /**
-     * Record a message processing failure.
-     */
-    recordFailure(attributes?: Attributes): void;
-    /**
-     * Record a message retry.
-     */
-    recordRetry(attributes?: Attributes): void;
-    /**
-     * Record a message sent to DLQ.
-     */
-    recordDLQ(attributes?: Attributes): void;
-    /**
-     * Record message processing time.
-     *
-     * @param durationMs - Processing duration in milliseconds
-     */
-    recordProcessingTime(durationMs: number, attributes?: Attributes): void;
-    /**
-     * Record time a message spent waiting in queue.
-     *
-     * @param durationMs - Queue wait time in milliseconds
-     */
-    recordQueueTime(durationMs: number, attributes?: Attributes): void;
-    /**
-     * Register observable gauge callbacks.
-     * Call this after FairQueue is initialized to register the gauge callbacks.
-     */
-    registerGaugeCallbacks(callbacks: {
-        getQueueLength?: (queueId: string) => Promise<number>;
-        getMasterQueueLength?: (shardId: number) => Promise<number>;
-        getDispatchLength?: (shardId: number) => Promise<number>;
-        getInflightCount?: (shardId: number) => Promise<number>;
-        getDLQLength?: (tenantId: string) => Promise<number>;
-        shardCount?: number;
-        observedQueues?: string[];
-        observedTenants?: string[];
-    }): void;
-    /**
-     * Create standard attributes for a message operation (for spans/traces).
-     * Use this for span attributes where high cardinality is acceptable.
-     */
-    messageAttributes(params: {
-        queueId?: string;
-        tenantId?: string;
-        messageId?: string;
-        attempt?: number;
-        workerQueue?: string;
-        consumerId?: string;
-    }): Attributes;
-    /**
-     * Check if telemetry is enabled.
-     */
-    get isEnabled(): boolean;
-    /**
-     * Check if tracing is enabled.
-     */
-    get hasTracer(): boolean;
-    /**
-     * Check if metrics are enabled.
-     */
-    get hasMetrics(): boolean;
+  #private;
+  private tracer?;
+  private meter?;
+  private metrics?;
+  private name;
+  constructor(options: TelemetryOptions);
+  /**
+   * Create a traced span for an operation.
+   * Returns the result of the function, or throws any error after recording it.
+   */
+  trace<T>(name: string, fn: (span: Span) => Promise<T>, options?: {
+    kind?: SpanKind;
+    attributes?: Attributes;
+  }): Promise<T>;
+  /**
+   * Synchronous version of trace.
+   */
+  traceSync<T>(name: string, fn: (span: Span) => T, options?: {
+    kind?: SpanKind;
+    attributes?: Attributes;
+  }): T;
+  /**
+   * Record a message enqueued.
+   */
+  recordEnqueue(attributes?: Attributes): void;
+  /**
+   * Record a batch of messages enqueued.
+   */
+  recordEnqueueBatch(count: number, attributes?: Attributes): void;
+  /**
+   * Record a message completed successfully.
+   */
+  recordComplete(attributes?: Attributes): void;
+  /**
+   * Record a message processing failure.
+   */
+  recordFailure(attributes?: Attributes): void;
+  /**
+   * Record a message retry.
+   */
+  recordRetry(attributes?: Attributes): void;
+  /**
+   * Record a message sent to DLQ.
+   */
+  recordDLQ(attributes?: Attributes): void;
+  /**
+   * Record message processing time.
+   *
+   * @param durationMs - Processing duration in milliseconds
+   */
+  recordProcessingTime(durationMs: number, attributes?: Attributes): void;
+  /**
+   * Record time a message spent waiting in queue.
+   *
+   * @param durationMs - Queue wait time in milliseconds
+   */
+  recordQueueTime(durationMs: number, attributes?: Attributes): void;
+  /**
+   * Register observable gauge callbacks.
+   * Call this after FairQueue is initialized to register the gauge callbacks.
+   */
+  registerGaugeCallbacks(callbacks: {
+    getQueueLength?: (queueId: string) => Promise<number>;
+    getMasterQueueLength?: (shardId: number) => Promise<number>;
+    getDispatchLength?: (shardId: number) => Promise<number>;
+    getInflightCount?: (shardId: number) => Promise<number>;
+    getDLQLength?: (tenantId: string) => Promise<number>;
+    shardCount?: number;
+    observedQueues?: string[];
+    observedTenants?: string[];
+  }): void;
+  /**
+   * Create standard attributes for a message operation (for spans/traces).
+   * Use this for span attributes where high cardinality is acceptable.
+   */
+  messageAttributes(params: {
+    queueId?: string;
+    tenantId?: string;
+    messageId?: string;
+    attempt?: number;
+    workerQueue?: string;
+    consumerId?: string;
+  }): Attributes;
+  /**
+   * Check if telemetry is enabled.
+   */
+  get isEnabled(): boolean;
+  /**
+   * Check if tracing is enabled.
+   */
+  get hasTracer(): boolean;
+  /**
+   * Check if metrics are enabled.
+   */
+  get hasMetrics(): boolean;
 }
 /**
  * State for tracking a consumer loop's batched span.
  */
 interface ConsumerLoopState {
-    /** Countdown of iterations before starting a new span */
-    perTraceCountdown: number;
-    /** When the current trace started */
-    traceStartedAt: Date;
-    /** The current batched span */
-    currentSpan?: Span;
-    /** The context for the current batched span */
-    currentSpanContext?: Context;
-    /** Number of iterations in the current span */
-    iterationsCount: number;
-    /** Total iterations across all spans */
-    totalIterationsCount: number;
-    /** Running duration in milliseconds for the current span */
-    runningDurationInMs: number;
-    /** Stats counters for the current span */
-    stats: Record<string, number>;
-    /** Flag to force span end on next iteration */
-    endSpanInNextIteration: boolean;
+  /** Countdown of iterations before starting a new span */
+  perTraceCountdown: number;
+  /** When the current trace started */
+  traceStartedAt: Date;
+  /** The current batched span */
+  currentSpan?: Span;
+  /** The context for the current batched span */
+  currentSpanContext?: Context;
+  /** Number of iterations in the current span */
+  iterationsCount: number;
+  /** Total iterations across all spans */
+  totalIterationsCount: number;
+  /** Running duration in milliseconds for the current span */
+  runningDurationInMs: number;
+  /** Stats counters for the current span */
+  stats: Record<string, number>;
+  /** Flag to force span end on next iteration */
+  endSpanInNextIteration: boolean;
 }
 /**
  * Configuration for the BatchedSpanManager.
  */
 interface BatchedSpanManagerOptions {
-    /** The tracer to use for creating spans */
-    tracer?: Tracer;
-    /** Name prefix for spans */
-    name: string;
-    /** Maximum iterations before rotating the span */
-    maxIterations: number;
-    /** Maximum seconds before rotating the span */
-    timeoutSeconds: number;
-    /** Optional callback to get dynamic attributes when starting a new batched span */
-    getDynamicAttributes?: () => Attributes;
+  /** The tracer to use for creating spans */
+  tracer?: Tracer;
+  /** Name prefix for spans */
+  name: string;
+  /** Maximum iterations before rotating the span */
+  maxIterations: number;
+  /** Maximum seconds before rotating the span */
+  timeoutSeconds: number;
+  /** Optional callback to get dynamic attributes when starting a new batched span */
+  getDynamicAttributes?: () => Attributes;
 }
 /**
  * Manages batched spans for consumer loops.
@@ -1556,71 +1564,72 @@ interface BatchedSpanManagerOptions {
  * reducing the volume of spans while maintaining observability.
  */
 declare class BatchedSpanManager {
-    private tracer?;
-    private name;
-    private maxIterations;
-    private timeoutSeconds;
-    private loopStates;
-    private getDynamicAttributes?;
-    constructor(options: BatchedSpanManagerOptions);
-    /**
-     * Initialize state for a consumer loop.
-     */
-    initializeLoop(loopId: string): void;
-    /**
-     * Get the state for a consumer loop.
-     */
-    getState(loopId: string): ConsumerLoopState | undefined;
-    /**
-     * Increment a stat counter for a loop.
-     */
-    incrementStat(loopId: string, statName: string, value?: number): void;
-    /**
-     * Mark that the span should end on the next iteration.
-     */
-    markForRotation(loopId: string): void;
-    /**
-     * Check if the span should be rotated (ended and a new one started).
-     */
-    shouldRotate(loopId: string): boolean;
-    /**
-     * End the current span for a loop and record stats.
-     */
-    endCurrentSpan(loopId: string): void;
-    /**
-     * Start a new batched span for a loop.
-     */
-    startNewSpan(loopId: string, attributes?: Attributes): void;
-    /**
-     * Execute a function within the batched span context.
-     * Automatically handles span rotation and iteration tracking.
-     */
-    withBatchedSpan<T>(loopId: string, fn: (span: Span) => Promise<T>, options?: {
-        iterationSpanName?: string;
-        attributes?: Attributes;
-    }): Promise<T>;
-    /**
-     * Clean up state for a loop when it's stopped.
-     */
-    cleanup(loopId: string): void;
-    /**
-     * Clean up all loop states.
-     */
-    cleanupAll(): void;
+  private tracer?;
+  private name;
+  private maxIterations;
+  private timeoutSeconds;
+  private loopStates;
+  private getDynamicAttributes?;
+  constructor(options: BatchedSpanManagerOptions);
+  /**
+   * Initialize state for a consumer loop.
+   */
+  initializeLoop(loopId: string): void;
+  /**
+   * Get the state for a consumer loop.
+   */
+  getState(loopId: string): ConsumerLoopState | undefined;
+  /**
+   * Increment a stat counter for a loop.
+   */
+  incrementStat(loopId: string, statName: string, value?: number): void;
+  /**
+   * Mark that the span should end on the next iteration.
+   */
+  markForRotation(loopId: string): void;
+  /**
+   * Check if the span should be rotated (ended and a new one started).
+   */
+  shouldRotate(loopId: string): boolean;
+  /**
+   * End the current span for a loop and record stats.
+   */
+  endCurrentSpan(loopId: string): void;
+  /**
+   * Start a new batched span for a loop.
+   */
+  startNewSpan(loopId: string, attributes?: Attributes): void;
+  /**
+   * Execute a function within the batched span context.
+   * Automatically handles span rotation and iteration tracking.
+   */
+  withBatchedSpan<T>(loopId: string, fn: (span: Span) => Promise<T>, options?: {
+    iterationSpanName?: string;
+    attributes?: Attributes;
+  }): Promise<T>;
+  /**
+   * Clean up state for a loop when it's stopped.
+   */
+  cleanup(loopId: string): void;
+  /**
+   * Clean up all loop states.
+   */
+  cleanupAll(): void;
 }
 /**
  * No-op telemetry instance for when telemetry is disabled.
  */
 declare const noopTelemetry: FairQueueTelemetry;
-
+//#endregion
+//#region src/fair-queue/tenantDispatch.d.ts
 interface TenantDispatchOptions {
-    redis: RedisOptions;
-    keys: FairQueueKeyProducer;
-    shardCount: number;
+  redis: RedisOptions;
+  keys: FairQueueKeyProducer;
+  shardCount: number;
 }
 interface TenantWithScore {
-    tenantId: string;
-    score: number;
+  tenantId: string;
+  score: number;
 }
 /**
  * TenantDispatch manages the two-level tenant dispatch index.
@@ -1638,67 +1647,68 @@ interface TenantWithScore {
  * queue backlog so the scheduler iterates tenants (not queues) at Level 1.
  */
 declare class TenantDispatch {
-    private options;
-    private redis;
-    private keys;
-    private shardCount;
-    constructor(options: TenantDispatchOptions);
-    /**
-     * Get the dispatch shard ID for a tenant.
-     * Uses jump consistent hash on the tenant ID so each tenant
-     * always maps to exactly one dispatch shard.
-     */
-    getShardForTenant(tenantId: string): number;
-    /**
-     * Get eligible tenants from a dispatch shard (Level 1).
-     * Returns tenants ordered by oldest message (lowest score first).
-     */
-    getTenantsFromShard(shardId: number, limit?: number, maxScore?: number): Promise<TenantWithScore[]>;
-    /**
-     * Get queues for a specific tenant (Level 2).
-     * Returns queues ordered by oldest message (lowest score first).
-     */
-    getQueuesForTenant(tenantId: string, limit?: number, maxScore?: number): Promise<QueueWithScore[]>;
-    /**
-     * Get the number of tenants in a dispatch shard.
-     */
-    getShardTenantCount(shardId: number): Promise<number>;
-    /**
-     * Get total tenant count across all dispatch shards.
-     * Note: tenants may appear in multiple shards, so this may overcount.
-     */
-    getTotalTenantCount(): Promise<number>;
-    /**
-     * Get the number of queues for a tenant.
-     */
-    getTenantQueueCount(tenantId: string): Promise<number>;
-    /**
-     * Remove a tenant from a specific dispatch shard.
-     */
-    removeTenantFromShard(shardId: number, tenantId: string): Promise<void>;
-    /**
-     * Add a tenant to a dispatch shard with the given score.
-     */
-    addTenantToShard(shardId: number, tenantId: string, score: number): Promise<void>;
-    /**
-     * Remove a queue from a tenant's queue index.
-     */
-    removeQueueFromTenant(tenantId: string, queueId: string): Promise<void>;
-    /**
-     * Close the Redis connection.
-     */
-    close(): Promise<void>;
-}
-
+  private options;
+  private redis;
+  private keys;
+  private shardCount;
+  constructor(options: TenantDispatchOptions);
+  /**
+   * Get the dispatch shard ID for a tenant.
+   * Uses jump consistent hash on the tenant ID so each tenant
+   * always maps to exactly one dispatch shard.
+   */
+  getShardForTenant(tenantId: string): number;
+  /**
+   * Get eligible tenants from a dispatch shard (Level 1).
+   * Returns tenants ordered by oldest message (lowest score first).
+   */
+  getTenantsFromShard(shardId: number, limit?: number, maxScore?: number): Promise<TenantWithScore[]>;
+  /**
+   * Get queues for a specific tenant (Level 2).
+   * Returns queues ordered by oldest message (lowest score first).
+   */
+  getQueuesForTenant(tenantId: string, limit?: number, maxScore?: number): Promise<QueueWithScore[]>;
+  /**
+   * Get the number of tenants in a dispatch shard.
+   */
+  getShardTenantCount(shardId: number): Promise<number>;
+  /**
+   * Get total tenant count across all dispatch shards.
+   * Note: tenants may appear in multiple shards, so this may overcount.
+   */
+  getTotalTenantCount(): Promise<number>;
+  /**
+   * Get the number of queues for a tenant.
+   */
+  getTenantQueueCount(tenantId: string): Promise<number>;
+  /**
+   * Remove a tenant from a specific dispatch shard.
+   */
+  removeTenantFromShard(shardId: number, tenantId: string): Promise<void>;
+  /**
+   * Add a tenant to a dispatch shard with the given score.
+   */
+  addTenantToShard(shardId: number, tenantId: string, score: number): Promise<void>;
+  /**
+   * Remove a queue from a tenant's queue index.
+   */
+  removeQueueFromTenant(tenantId: string, queueId: string): Promise<void>;
+  /**
+   * Close the Redis connection.
+   */
+  close(): Promise<void>;
+}
+//#endregion
+//#region src/fair-queue/visibility.d.ts
 interface VisibilityManagerOptions {
-    redis: RedisOptions;
-    keys: FairQueueKeyProducer;
-    shardCount: number;
-    defaultTimeoutMs: number;
-    logger?: {
-        debug: (message: string, context?: Record<string, unknown>) => void;
-        error: (message: string, context?: Record<string, unknown>) => void;
-    };
+  redis: RedisOptions;
+  keys: FairQueueKeyProducer;
+  shardCount: number;
+  defaultTimeoutMs: number;
+  logger?: {
+    debug: (message: string, context?: Record<string, unknown>) => void;
+    error: (message: string, context?: Record<string, unknown>) => void;
+  };
 }
 /**
  * VisibilityManager handles message visibility timeouts for safe message processing.
@@ -1714,140 +1724,141 @@ interface VisibilityManagerOptions {
  * - In-flight data hash: field = messageId, value = JSON message data
  */
 declare class VisibilityManager {
-    #private;
-    private options;
-    private redis;
-    private keys;
-    private shardCount;
-    private defaultTimeoutMs;
-    private logger;
-    constructor(options: VisibilityManagerOptions);
-    /**
-     * Claim a message for processing.
-     * Moves the message from its queue to the in-flight set with a visibility timeout.
-     *
-     * @param queueId - The queue to claim from
-     * @param queueKey - The Redis key for the queue sorted set
-     * @param queueItemsKey - The Redis key for the queue items hash
-     * @param consumerId - ID of the consumer claiming the message
-     * @param timeoutMs - Visibility timeout in milliseconds
-     * @returns Claim result with the message if successful
-     */
-    claim<TPayload = unknown>(queueId: string, queueKey: string, queueItemsKey: string, consumerId: string, timeoutMs?: number): Promise<ClaimResult<TPayload>>;
-    /**
-     * Claim multiple messages for processing (batch claim).
-     * Moves up to maxCount messages from the queue to the in-flight set.
-     *
-     * @param queueId - The queue to claim from
-     * @param queueKey - The Redis key for the queue sorted set
-     * @param queueItemsKey - The Redis key for the queue items hash
-     * @param consumerId - ID of the consumer claiming the messages
-     * @param maxCount - Maximum number of messages to claim
-     * @param timeoutMs - Visibility timeout in milliseconds
-     * @returns Array of claimed messages
-     */
-    claimBatch<TPayload = unknown>(queueId: string, queueKey: string, queueItemsKey: string, consumerId: string, maxCount: number, timeoutMs?: number): Promise<Array<InFlightMessage<TPayload>>>;
-    /**
-     * Extend the visibility timeout for a message (heartbeat).
-     *
-     * @param messageId - The message ID
-     * @param queueId - The queue ID
-     * @param extendMs - Additional milliseconds to add to the deadline
-     * @returns true if the heartbeat was successful
-     */
-    heartbeat(messageId: string, queueId: string, extendMs: number): Promise<boolean>;
-    /**
-     * Mark a message as successfully processed.
-     * Removes the message from in-flight tracking.
-     *
-     * @param messageId - The message ID
-     * @param queueId - The queue ID
-     */
-    complete(messageId: string, queueId: string): Promise<void>;
-    /**
-     * Release a message back to its queue.
-     * Used when processing fails or consumer wants to retry later.
-     *
-     * @param messageId - The message ID
-     * @param queueId - The queue ID
-     * @param queueKey - The Redis key for the queue
-     * @param queueItemsKey - The Redis key for the queue items hash
-     * @param tenantQueueIndexKey - The Redis key for the tenant queue index (Level 2)
-     * @param dispatchKey - The Redis key for the dispatch index (Level 1)
-     * @param tenantId - The tenant ID
-     * @param score - Optional score for the message (defaults to now)
-     */
-    release<_TPayload = unknown>(messageId: string, queueId: string, queueKey: string, queueItemsKey: string, tenantQueueIndexKey: string, dispatchKey: string, tenantId: string, score?: number, updatedData?: string): Promise<void>;
-    /**
-     * Release multiple messages back to their queue in a single operation.
-     * Used when processing fails or consumer wants to retry later.
-     * All messages must belong to the same queue.
-     *
-     * @param messages - Array of messages to release (must all have same queueId)
-     * @param queueId - The queue ID
-     * @param queueKey - The Redis key for the queue
-     * @param queueItemsKey - The Redis key for the queue items hash
-     * @param tenantQueueIndexKey - The Redis key for the tenant queue index (Level 2)
-     * @param dispatchKey - The Redis key for the dispatch index (Level 1)
-     * @param tenantId - The tenant ID
-     * @param score - Optional score for the messages (defaults to now)
-     */
-    releaseBatch(messages: Array<{
-        messageId: string;
-    }>, queueId: string, queueKey: string, queueItemsKey: string, tenantQueueIndexKey: string, dispatchKey: string, tenantId: string, score?: number): Promise<void>;
-    /**
-     * Reclaim timed-out messages from a shard.
-     * Returns messages to their original queues.
-     *
-     * @param shardId - The shard to check
-     * @param getQueueKeys - Function to get queue keys for a queue ID
-     * @returns Array of reclaimed message info for concurrency release
-     */
-    reclaimTimedOut(shardId: number, getQueueKeys: (queueId: string) => {
-        queueKey: string;
-        queueItemsKey: string;
-        tenantQueueIndexKey: string;
-        dispatchKey: string;
-        tenantId: string;
-    }): Promise<ReclaimedMessageInfo[]>;
-    /**
-     * Get all in-flight messages for a shard.
-     */
-    getInflightMessages(shardId: number): Promise<Array<{
-        messageId: string;
-        queueId: string;
-        deadline: number;
-    }>>;
-    /**
-     * Get count of in-flight messages for a shard.
-     */
-    getInflightCount(shardId: number): Promise<number>;
-    /**
-     * Get total in-flight count across all shards.
-     */
-    getTotalInflightCount(): Promise<number>;
-    /**
-     * Close the Redis connection.
-     */
-    close(): Promise<void>;
+  #private;
+  private options;
+  private redis;
+  private keys;
+  private shardCount;
+  private defaultTimeoutMs;
+  private logger;
+  constructor(options: VisibilityManagerOptions);
+  /**
+   * Claim a message for processing.
+   * Moves the message from its queue to the in-flight set with a visibility timeout.
+   *
+   * @param queueId - The queue to claim from
+   * @param queueKey - The Redis key for the queue sorted set
+   * @param queueItemsKey - The Redis key for the queue items hash
+   * @param consumerId - ID of the consumer claiming the message
+   * @param timeoutMs - Visibility timeout in milliseconds
+   * @returns Claim result with the message if successful
+   */
+  claim<TPayload = unknown>(queueId: string, queueKey: string, queueItemsKey: string, consumerId: string, timeoutMs?: number): Promise<ClaimResult<TPayload>>;
+  /**
+   * Claim multiple messages for processing (batch claim).
+   * Moves up to maxCount messages from the queue to the in-flight set.
+   *
+   * @param queueId - The queue to claim from
+   * @param queueKey - The Redis key for the queue sorted set
+   * @param queueItemsKey - The Redis key for the queue items hash
+   * @param consumerId - ID of the consumer claiming the messages
+   * @param maxCount - Maximum number of messages to claim
+   * @param timeoutMs - Visibility timeout in milliseconds
+   * @returns Array of claimed messages
+   */
+  claimBatch<TPayload = unknown>(queueId: string, queueKey: string, queueItemsKey: string, consumerId: string, maxCount: number, timeoutMs?: number): Promise<Array<InFlightMessage<TPayload>>>;
+  /**
+   * Extend the visibility timeout for a message (heartbeat).
+   *
+   * @param messageId - The message ID
+   * @param queueId - The queue ID
+   * @param extendMs - Additional milliseconds to add to the deadline
+   * @returns true if the heartbeat was successful
+   */
+  heartbeat(messageId: string, queueId: string, extendMs: number): Promise<boolean>;
+  /**
+   * Mark a message as successfully processed.
+   * Removes the message from in-flight tracking.
+   *
+   * @param messageId - The message ID
+   * @param queueId - The queue ID
+   */
+  complete(messageId: string, queueId: string): Promise<void>;
+  /**
+   * Release a message back to its queue.
+   * Used when processing fails or consumer wants to retry later.
+   *
+   * @param messageId - The message ID
+   * @param queueId - The queue ID
+   * @param queueKey - The Redis key for the queue
+   * @param queueItemsKey - The Redis key for the queue items hash
+   * @param tenantQueueIndexKey - The Redis key for the tenant queue index (Level 2)
+   * @param dispatchKey - The Redis key for the dispatch index (Level 1)
+   * @param tenantId - The tenant ID
+   * @param score - Optional score for the message (defaults to now)
+   */
+  release<_TPayload = unknown>(messageId: string, queueId: string, queueKey: string, queueItemsKey: string, tenantQueueIndexKey: string, dispatchKey: string, tenantId: string, score?: number, updatedData?: string): Promise<void>;
+  /**
+   * Release multiple messages back to their queue in a single operation.
+   * Used when processing fails or consumer wants to retry later.
+   * All messages must belong to the same queue.
+   *
+   * @param messages - Array of messages to release (must all have same queueId)
+   * @param queueId - The queue ID
+   * @param queueKey - The Redis key for the queue
+   * @param queueItemsKey - The Redis key for the queue items hash
+   * @param tenantQueueIndexKey - The Redis key for the tenant queue index (Level 2)
+   * @param dispatchKey - The Redis key for the dispatch index (Level 1)
+   * @param tenantId - The tenant ID
+   * @param score - Optional score for the messages (defaults to now)
+   */
+  releaseBatch(messages: Array<{
+    messageId: string;
+  }>, queueId: string, queueKey: string, queueItemsKey: string, tenantQueueIndexKey: string, dispatchKey: string, tenantId: string, score?: number): Promise<void>;
+  /**
+   * Reclaim timed-out messages from a shard.
+   * Returns messages to their original queues.
+   *
+   * @param shardId - The shard to check
+   * @param getQueueKeys - Function to get queue keys for a queue ID
+   * @returns Array of reclaimed message info for concurrency release
+   */
+  reclaimTimedOut(shardId: number, getQueueKeys: (queueId: string) => {
+    queueKey: string;
+    queueItemsKey: string;
+    tenantQueueIndexKey: string;
+    dispatchKey: string;
+    tenantId: string;
+  }): Promise<ReclaimedMessageInfo[]>;
+  /**
+   * Get all in-flight messages for a shard.
+   */
+  getInflightMessages(shardId: number): Promise<Array<{
+    messageId: string;
+    queueId: string;
+    deadline: number;
+  }>>;
+  /**
+   * Get count of in-flight messages for a shard.
+   */
+  getInflightCount(shardId: number): Promise<number>;
+  /**
+   * Get total in-flight count across all shards.
+   */
+  getTotalInflightCount(): Promise<number>;
+  /**
+   * Close the Redis connection.
+   */
+  close(): Promise<void>;
 }
 declare module "@internal/redis" {
-    interface RedisCommander<Context> {
-        claimMessage(queueKey: string, queueItemsKey: string, inflightKey: string, inflightDataKey: string, queueId: string, consumerId: string, deadline: string): Promise<[string, string] | null>;
-        claimMessageBatch(queueKey: string, queueItemsKey: string, inflightKey: string, inflightDataKey: string, queueId: string, deadline: string, maxCount: string): Promise<string[]>;
-        releaseMessage(inflightKey: string, inflightDataKey: string, queueKey: string, queueItemsKey: string, tenantQueueIndexKey: string, dispatchKey: string, member: string, messageId: string, score: string, queueId: string, updatedData: string, tenantId: string): Promise<number>;
-        releaseMessageBatch(inflightKey: string, inflightDataKey: string, queueKey: string, queueItemsKey: string, tenantQueueIndexKey: string, dispatchKey: string, score: string, queueId: string, tenantId: string, ...membersAndMessageIds: string[]): Promise<number>;
-        heartbeatMessage(inflightKey: string, member: string, newDeadline: string): Promise<number>;
-    }
-}
-
+  interface RedisCommander<Context> {
+    claimMessage(queueKey: string, queueItemsKey: string, inflightKey: string, inflightDataKey: string, queueId: string, consumerId: string, deadline: string): Promise<[string, string] | null>;
+    claimMessageBatch(queueKey: string, queueItemsKey: string, inflightKey: string, inflightDataKey: string, queueId: string, deadline: string, maxCount: string): Promise<string[]>;
+    releaseMessage(inflightKey: string, inflightDataKey: string, queueKey: string, queueItemsKey: string, tenantQueueIndexKey: string, dispatchKey: string, member: string, messageId: string, score: string, queueId: string, updatedData: string, tenantId: string): Promise<number>;
+    releaseMessageBatch(inflightKey: string, inflightDataKey: string, queueKey: string, queueItemsKey: string, tenantQueueIndexKey: string, dispatchKey: string, score: string, queueId: string, tenantId: string, ...membersAndMessageIds: string[]): Promise<number>;
+    heartbeatMessage(inflightKey: string, member: string, newDeadline: string): Promise<number>;
+  }
+}
+//#endregion
+//#region src/fair-queue/workerQueue.d.ts
 interface WorkerQueueManagerOptions {
-    redis: RedisOptions;
-    keys: FairQueueKeyProducer;
-    logger?: {
-        debug: (message: string, context?: Record<string, unknown>) => void;
-        error: (message: string, context?: Record<string, unknown>) => void;
-    };
+  redis: RedisOptions;
+  keys: FairQueueKeyProducer;
+  logger?: {
+    debug: (message: string, context?: Record<string, unknown>) => void;
+    error: (message: string, context?: Record<string, unknown>) => void;
+  };
 }
 /**
  * WorkerQueueManager handles the intermediate worker queue layer.
@@ -1863,85 +1874,86 @@ interface WorkerQueueManagerOptions {
  * 3. Worker queue consumer does blocking pop to receive message
  */
 declare class WorkerQueueManager {
-    #private;
-    private options;
-    private redis;
-    private keys;
-    private logger;
-    constructor(options: WorkerQueueManagerOptions);
-    /**
-     * Push a message key to a worker queue.
-     * Called after claiming a message from the message queue.
-     *
-     * @param workerQueueId - The worker queue identifier
-     * @param messageKey - The message key to push (typically "messageId:queueId")
-     */
-    push(workerQueueId: string, messageKey: string): Promise<void>;
-    /**
-     * Push multiple message keys to a worker queue.
-     *
-     * @param workerQueueId - The worker queue identifier
-     * @param messageKeys - The message keys to push
-     */
-    pushBatch(workerQueueId: string, messageKeys: string[]): Promise<void>;
-    /**
-     * Blocking pop from a worker queue.
-     * Waits until a message is available or timeout expires.
-     *
-     * @param workerQueueId - The worker queue identifier
-     * @param timeoutSeconds - Maximum time to wait (0 = wait forever)
-     * @param signal - Optional abort signal to cancel waiting
-     * @returns The message key, or null if timeout
-     */
-    blockingPop(workerQueueId: string, timeoutSeconds: number, signal?: AbortSignal): Promise<string | null>;
-    /**
-     * Non-blocking pop from a worker queue.
-     *
-     * @param workerQueueId - The worker queue identifier
-     * @returns The message key and queue length, or null if empty
-     */
-    pop(workerQueueId: string): Promise<{
-        messageKey: string;
-        queueLength: number;
-    } | null>;
-    /**
-     * Get the current length of a worker queue.
-     */
-    getLength(workerQueueId: string): Promise<number>;
-    /**
-     * Peek at all messages in a worker queue without removing them.
-     * Useful for debugging and tests.
-     */
-    peek(workerQueueId: string): Promise<string[]>;
-    /**
-     * Remove a specific message from the worker queue.
-     * Used when a message needs to be removed without processing.
-     *
-     * @param workerQueueId - The worker queue identifier
-     * @param messageKey - The message key to remove
-     * @returns Number of removed items
-     */
-    remove(workerQueueId: string, messageKey: string): Promise<number>;
-    /**
-     * Clear all messages from a worker queue.
-     */
-    clear(workerQueueId: string): Promise<void>;
-    /**
-     * Close the Redis connection.
-     */
-    close(): Promise<void>;
-    /**
-     * Register custom commands on an external Redis client.
-     * Use this when initializing FairQueue with worker queues.
-     */
-    registerCommands(redis: Redis): void;
+  #private;
+  private options;
+  private redis;
+  private keys;
+  private logger;
+  constructor(options: WorkerQueueManagerOptions);
+  /**
+   * Push a message key to a worker queue.
+   * Called after claiming a message from the message queue.
+   *
+   * @param workerQueueId - The worker queue identifier
+   * @param messageKey - The message key to push (typically "messageId:queueId")
+   */
+  push(workerQueueId: string, messageKey: string): Promise<void>;
+  /**
+   * Push multiple message keys to a worker queue.
+   *
+   * @param workerQueueId - The worker queue identifier
+   * @param messageKeys - The message keys to push
+   */
+  pushBatch(workerQueueId: string, messageKeys: string[]): Promise<void>;
+  /**
+   * Blocking pop from a worker queue.
+   * Waits until a message is available or timeout expires.
+   *
+   * @param workerQueueId - The worker queue identifier
+   * @param timeoutSeconds - Maximum time to wait (0 = wait forever)
+   * @param signal - Optional abort signal to cancel waiting
+   * @returns The message key, or null if timeout
+   */
+  blockingPop(workerQueueId: string, timeoutSeconds: number, signal?: AbortSignal): Promise<string | null>;
+  /**
+   * Non-blocking pop from a worker queue.
+   *
+   * @param workerQueueId - The worker queue identifier
+   * @returns The message key and queue length, or null if empty
+   */
+  pop(workerQueueId: string): Promise<{
+    messageKey: string;
+    queueLength: number;
+  } | null>;
+  /**
+   * Get the current length of a worker queue.
+   */
+  getLength(workerQueueId: string): Promise<number>;
+  /**
+   * Peek at all messages in a worker queue without removing them.
+   * Useful for debugging and tests.
+   */
+  peek(workerQueueId: string): Promise<string[]>;
+  /**
+   * Remove a specific message from the worker queue.
+   * Used when a message needs to be removed without processing.
+   *
+   * @param workerQueueId - The worker queue identifier
+   * @param messageKey - The message key to remove
+   * @returns Number of removed items
+   */
+  remove(workerQueueId: string, messageKey: string): Promise<number>;
+  /**
+   * Clear all messages from a worker queue.
+   */
+  clear(workerQueueId: string): Promise<void>;
+  /**
+   * Close the Redis connection.
+   */
+  close(): Promise<void>;
+  /**
+   * Register custom commands on an external Redis client.
+   * Use this when initializing FairQueue with worker queues.
+   */
+  registerCommands(redis: Redis): void;
 }
 declare module "@internal/redis" {
-    interface RedisCommander<Context> {
-        popWithLength(workerQueueKey: string): Promise<[string, string] | null>;
-    }
+  interface RedisCommander<Context> {
+    popWithLength(workerQueueKey: string): Promise<[string, string] | null>;
+  }
 }
-
+//#endregion
+//#region src/fair-queue/index.d.ts
 /**
  * FairQueue is the main orchestrator for fair queue message routing.
  *
@@ -1961,463 +1973,466 @@ declare module "@internal/redis" {
  * @typeParam TPayloadSchema - Zod schema for message payload validation
  */
 declare class FairQueue<TPayloadSchema extends z.ZodTypeAny = z.ZodUnknown> {
-    #private;
-    private options;
-    private redis;
-    private keys;
-    private scheduler;
-    private masterQueue;
-    private concurrencyManager?;
-    private visibilityManager;
-    private workerQueueManager;
-    private telemetry;
-    private logger;
-    private payloadSchema?;
-    private validateOnEnqueue;
-    private retryStrategy?;
-    private deadLetterQueueEnabled;
-    private shardCount;
-    private consumerCount;
-    private consumerIntervalMs;
-    private visibilityTimeoutMs;
-    private heartbeatIntervalMs;
-    private reclaimIntervalMs;
-    private workerQueueResolver;
-    private batchClaimSize;
-    private cooloffEnabled;
-    private cooloffThreshold;
-    private cooloffPeriodMs;
-    private maxCooloffStatesSize;
-    private queueCooloffStates;
-    private workerQueueMaxDepth;
-    private workerQueueDepthCheckId?;
-    private consumerTraceMaxIterations;
-    private consumerTraceTimeoutSeconds;
-    private batchedSpanManager;
-    private isRunning;
-    private abortController;
-    private masterQueueConsumerLoops;
-    private reclaimLoop?;
-    private queueDescriptorCache;
-    private tenantDispatch;
-    constructor(options: FairQueueOptions<TPayloadSchema>);
-    /**
-     * Register observable gauge callbacks for telemetry.
-     * Call this after FairQueue is created to enable gauge metrics.
-     *
-     * @param options.observedTenants - List of tenant IDs to observe for DLQ metrics
-     */
-    registerTelemetryGauges(options?: {
-        observedTenants?: string[];
-    }): void;
-    /**
-     * Enqueue a single message to a queue.
-     */
-    enqueue(options: EnqueueOptions<z.infer<TPayloadSchema>>): Promise<string>;
-    /**
-     * Enqueue multiple messages to a queue.
-     */
-    enqueueBatch(options: EnqueueBatchOptions<z.infer<TPayloadSchema>>): Promise<string[]>;
-    /**
-     * Get messages from the dead letter queue for a tenant.
-     */
-    getDeadLetterMessages(tenantId: string, limit?: number): Promise<DeadLetterMessage<z.infer<TPayloadSchema>>[]>;
-    /**
-     * Redrive a message from DLQ back to its original queue.
-     */
-    redriveMessage(tenantId: string, messageId: string): Promise<boolean>;
-    /**
-     * Redrive all messages from DLQ back to their original queues.
-     */
-    redriveAll(tenantId: string): Promise<number>;
-    /**
-     * Purge all messages from a tenant's DLQ.
-     */
-    purgeDeadLetterQueue(tenantId: string): Promise<number>;
-    /**
-     * Get the number of messages in a tenant's DLQ.
-     */
-    getDeadLetterQueueLength(tenantId: string): Promise<number>;
-    /**
-     * Get the size of the in-memory queue descriptor cache.
-     * This cache stores metadata for queues that have been enqueued.
-     * The cache is cleaned up when queues are fully processed.
-     */
-    getQueueDescriptorCacheSize(): number;
-    /**
-     * Get the size of the in-memory cooloff states cache.
-     * This cache tracks queues that are in cooloff due to repeated failures.
-     * The cache is cleaned up when queues are fully processed or cooloff expires.
-     */
-    getQueueCooloffStatesSize(): number;
-    /**
-     * Get all in-memory cache sizes for monitoring.
-     * Useful for adding as span attributes.
-     */
-    getCacheSizes(): {
-        descriptorCacheSize: number;
-        cooloffStatesSize: number;
-    };
-    /**
-     * Start the master queue consumer loops and reclaim loop.
-     * FairQueue claims messages and pushes them to worker queues.
-     * External consumers are responsible for consuming from worker queues.
-     */
-    start(): void;
-    /**
-     * Stop the consumer loops gracefully.
-     */
-    stop(): Promise<void>;
-    /**
-     * Close all resources.
-     */
-    close(): Promise<void>;
-    /**
-     * Get the number of messages in a queue.
-     */
-    getQueueLength(queueId: string): Promise<number>;
-    /**
-     * Get total tenant count across dispatch shards plus any legacy queues still draining.
-     */
-    getTotalQueueCount(): Promise<number>;
-    /**
-     * Get total in-flight message count.
-     */
-    getTotalInflightCount(): Promise<number>;
-    /**
-     * Get the shard ID for a queue.
-     */
-    getShardForQueue(queueId: string): number;
-    /**
-     * Get message data from in-flight storage.
-     * External consumers use this to retrieve the stored message after popping from worker queue.
-     *
-     * @param messageId - The ID of the message
-     * @param queueId - The queue ID the message belongs to
-     * @returns The stored message or null if not found
-     */
-    getMessageData(messageId: string, queueId: string): Promise<StoredMessage<z.infer<TPayloadSchema>> | null>;
-    /**
-     * Extend the visibility timeout for a message.
-     * External consumers should call this periodically during long-running processing.
-     *
-     * @param messageId - The ID of the message
-     * @param queueId - The queue ID the message belongs to
-     * @returns true if heartbeat was successful
-     */
-    heartbeatMessage(messageId: string, queueId: string): Promise<boolean>;
-    /**
-     * Mark a message as successfully processed.
-     * This removes the message from in-flight and releases concurrency.
-     *
-     * @param messageId - The ID of the message
-     * @param queueId - The queue ID the message belongs to
-     */
-    completeMessage(messageId: string, queueId: string): Promise<void>;
-    /**
-     * Release a message back to the queue for processing by another consumer.
-     * The message is placed at the back of the queue.
-     *
-     * @param messageId - The ID of the message
-     * @param queueId - The queue ID the message belongs to
-     */
-    releaseMessage(messageId: string, queueId: string): Promise<void>;
-    /**
-     * Mark a message as failed. This will trigger retry logic if configured,
-     * or move the message to the dead letter queue.
-     *
-     * @param messageId - The ID of the message
-     * @param queueId - The queue ID the message belongs to
-     * @param error - Optional error that caused the failure
-     */
-    failMessage(messageId: string, queueId: string, error?: Error): Promise<void>;
+  #private;
+  private options;
+  private redis;
+  private keys;
+  private scheduler;
+  private masterQueue;
+  private concurrencyManager?;
+  private visibilityManager;
+  private workerQueueManager;
+  private telemetry;
+  private logger;
+  private payloadSchema?;
+  private validateOnEnqueue;
+  private retryStrategy?;
+  private deadLetterQueueEnabled;
+  private shardCount;
+  private consumerCount;
+  private consumerIntervalMs;
+  private visibilityTimeoutMs;
+  private heartbeatIntervalMs;
+  private reclaimIntervalMs;
+  private workerQueueResolver;
+  private batchClaimSize;
+  private cooloffEnabled;
+  private cooloffThreshold;
+  private cooloffPeriodMs;
+  private maxCooloffStatesSize;
+  private queueCooloffStates;
+  private workerQueueMaxDepth;
+  private workerQueueDepthCheckId?;
+  private consumerTraceMaxIterations;
+  private consumerTraceTimeoutSeconds;
+  private batchedSpanManager;
+  private isRunning;
+  private abortController;
+  private masterQueueConsumerLoops;
+  private reclaimLoop?;
+  private queueDescriptorCache;
+  private tenantDispatch;
+  constructor(options: FairQueueOptions<TPayloadSchema>);
+  /**
+   * Register observable gauge callbacks for telemetry.
+   * Call this after FairQueue is created to enable gauge metrics.
+   *
+   * @param options.observedTenants - List of tenant IDs to observe for DLQ metrics
+   */
+  registerTelemetryGauges(options?: {
+    observedTenants?: string[];
+  }): void;
+  /**
+   * Enqueue a single message to a queue.
+   */
+  enqueue(options: EnqueueOptions<z.infer<TPayloadSchema>>): Promise<string>;
+  /**
+   * Enqueue multiple messages to a queue.
+   */
+  enqueueBatch(options: EnqueueBatchOptions<z.infer<TPayloadSchema>>): Promise<string[]>;
+  /**
+   * Get messages from the dead letter queue for a tenant.
+   */
+  getDeadLetterMessages(tenantId: string, limit?: number): Promise<DeadLetterMessage<z.infer<TPayloadSchema>>[]>;
+  /**
+   * Redrive a message from DLQ back to its original queue.
+   */
+  redriveMessage(tenantId: string, messageId: string): Promise<boolean>;
+  /**
+   * Redrive all messages from DLQ back to their original queues.
+   */
+  redriveAll(tenantId: string): Promise<number>;
+  /**
+   * Purge all messages from a tenant's DLQ.
+   */
+  purgeDeadLetterQueue(tenantId: string): Promise<number>;
+  /**
+   * Get the number of messages in a tenant's DLQ.
+   */
+  getDeadLetterQueueLength(tenantId: string): Promise<number>;
+  /**
+   * Get the size of the in-memory queue descriptor cache.
+   * This cache stores metadata for queues that have been enqueued.
+   * The cache is cleaned up when queues are fully processed.
+   */
+  getQueueDescriptorCacheSize(): number;
+  /**
+   * Get the size of the in-memory cooloff states cache.
+   * This cache tracks queues that are in cooloff due to repeated failures.
+   * The cache is cleaned up when queues are fully processed or cooloff expires.
+   */
+  getQueueCooloffStatesSize(): number;
+  /**
+   * Get all in-memory cache sizes for monitoring.
+   * Useful for adding as span attributes.
+   */
+  getCacheSizes(): {
+    descriptorCacheSize: number;
+    cooloffStatesSize: number;
+  };
+  /**
+   * Start the master queue consumer loops and reclaim loop.
+   * FairQueue claims messages and pushes them to worker queues.
+   * External consumers are responsible for consuming from worker queues.
+   */
+  start(): void;
+  /**
+   * Stop the consumer loops gracefully.
+   */
+  stop(): Promise<void>;
+  /**
+   * Close all resources.
+   */
+  close(): Promise<void>;
+  /**
+   * Get the number of messages in a queue.
+   */
+  getQueueLength(queueId: string): Promise<number>;
+  /**
+   * Get total tenant count across dispatch shards plus any legacy queues still draining.
+   */
+  getTotalQueueCount(): Promise<number>;
+  /**
+   * Get total in-flight message count.
+   */
+  getTotalInflightCount(): Promise<number>;
+  /**
+   * Get the shard ID for a queue.
+   */
+  getShardForQueue(queueId: string): number;
+  /**
+   * Get message data from in-flight storage.
+   * External consumers use this to retrieve the stored message after popping from worker queue.
+   *
+   * @param messageId - The ID of the message
+   * @param queueId - The queue ID the message belongs to
+   * @returns The stored message or null if not found
+   */
+  getMessageData(messageId: string, queueId: string): Promise<StoredMessage<z.infer<TPayloadSchema>> | null>;
+  /**
+   * Extend the visibility timeout for a message.
+   * External consumers should call this periodically during long-running processing.
+   *
+   * @param messageId - The ID of the message
+   * @param queueId - The queue ID the message belongs to
+   * @returns true if heartbeat was successful
+   */
+  heartbeatMessage(messageId: string, queueId: string): Promise<boolean>;
+  /**
+   * Mark a message as successfully processed.
+   * This removes the message from in-flight and releases concurrency.
+   *
+   * @param messageId - The ID of the message
+   * @param queueId - The queue ID the message belongs to
+   */
+  completeMessage(messageId: string, queueId: string): Promise<void>;
+  /**
+   * Release a message back to the queue for processing by another consumer.
+   * The message is placed at the back of the queue.
+   *
+   * @param messageId - The ID of the message
+   * @param queueId - The queue ID the message belongs to
+   */
+  releaseMessage(messageId: string, queueId: string): Promise<void>;
+  /**
+   * Mark a message as failed. This will trigger retry logic if configured,
+   * or move the message to the dead letter queue.
+   *
+   * @param messageId - The ID of the message
+   * @param queueId - The queue ID the message belongs to
+   * @param error - Optional error that caused the failure
+   */
+  failMessage(messageId: string, queueId: string, error?: Error): Promise<void>;
 }
 declare module "@internal/redis" {
-    interface RedisCommander<Context> {
-        enqueueMessageAtomic(queueKey: string, queueItemsKey: string, masterQueueKey: string, queueId: string, messageId: string, timestamp: string, payload: string): Promise<number>;
-        enqueueBatchAtomic(queueKey: string, queueItemsKey: string, masterQueueKey: string, queueId: string, ...args: string[]): Promise<number>;
-        updateMasterQueueIfEmpty(masterQueueKey: string, queueKey: string, queueId: string): Promise<number>;
-        enqueueMessageAtomicV2(queueKey: string, queueItemsKey: string, tenantQueueIndexKey: string, dispatchKey: string, queueId: string, messageId: string, timestamp: string, payload: string, tenantId: string): Promise<number>;
-        enqueueBatchAtomicV2(queueKey: string, queueItemsKey: string, tenantQueueIndexKey: string, dispatchKey: string, queueId: string, tenantId: string, ...args: string[]): Promise<number>;
-        updateDispatchIndexes(queueKey: string, tenantQueueIndexKey: string, dispatchKey: string, queueId: string, tenantId: string): Promise<number>;
-    }
-}
-
+  interface RedisCommander<Context> {
+    enqueueMessageAtomic(queueKey: string, queueItemsKey: string, masterQueueKey: string, queueId: string, messageId: string, timestamp: string, payload: string): Promise<number>;
+    enqueueBatchAtomic(queueKey: string, queueItemsKey: string, masterQueueKey: string, queueId: string, ...args: string[]): Promise<number>;
+    updateMasterQueueIfEmpty(masterQueueKey: string, queueKey: string, queueId: string): Promise<number>;
+    enqueueMessageAtomicV2(queueKey: string, queueItemsKey: string, tenantQueueIndexKey: string, dispatchKey: string, queueId: string, messageId: string, timestamp: string, payload: string, tenantId: string): Promise<number>;
+    enqueueBatchAtomicV2(queueKey: string, queueItemsKey: string, tenantQueueIndexKey: string, dispatchKey: string, queueId: string, tenantId: string, ...args: string[]): Promise<number>;
+    updateDispatchIndexes(queueKey: string, tenantQueueIndexKey: string, dispatchKey: string, queueId: string, tenantId: string): Promise<number>;
+  }
+}
+//#endregion
+//#region src/mollifier/schemas.d.ts
 declare const BufferEntryStatus: z.ZodEnum<["QUEUED", "DRAINING", "FAILED"]>;
 type BufferEntryStatus = z.infer<typeof BufferEntryStatus>;
 declare const BufferEntryError: z.ZodObject<{
-    code: z.ZodString;
-    message: z.ZodString;
+  code: z.ZodString;
+  message: z.ZodString;
 }, "strip", z.ZodTypeAny, {
-    message: string;
-    code: string;
+  code: string;
+  message: string;
 }, {
-    message: string;
-    code: string;
+  code: string;
+  message: string;
 }>;
 type BufferEntryError = z.infer<typeof BufferEntryError>;
 declare const BufferEntrySchema: z.ZodObject<{
-    runId: z.ZodString;
-    envId: z.ZodString;
-    orgId: z.ZodString;
-    payload: z.ZodString;
-    status: z.ZodEnum<["QUEUED", "DRAINING", "FAILED"]>;
-    attempts: z.ZodEffects<z.ZodString, number, string>;
-    createdAt: z.ZodEffects<z.ZodString, Date, string>;
-    createdAtMicros: z.ZodDefault<z.ZodEffects<z.ZodString, number, string>>;
-    materialised: z.ZodDefault<z.ZodEffects<z.ZodUnion<[z.ZodLiteral<"true">, z.ZodLiteral<"false">]>, boolean, "true" | "false">>;
-    idempotencyLookupKey: z.ZodDefault<z.ZodOptional<z.ZodString>>;
-    metadataVersion: z.ZodDefault<z.ZodEffects<z.ZodString, number, string>>;
-    lastError: z.ZodOptional<z.ZodEffects<z.ZodString, {
-        message: string;
-        code: string;
-    }, string>>;
+  runId: z.ZodString;
+  envId: z.ZodString;
+  orgId: z.ZodString;
+  payload: z.ZodString;
+  status: z.ZodEnum<["QUEUED", "DRAINING", "FAILED"]>;
+  attempts: z.ZodEffects<z.ZodString, number, string>;
+  createdAt: z.ZodEffects<z.ZodString, Date, string>;
+  createdAtMicros: z.ZodDefault<z.ZodEffects<z.ZodString, number, string>>;
+  materialised: z.ZodDefault<z.ZodEffects<z.ZodUnion<[z.ZodLiteral<"true">, z.ZodLiteral<"false">]>, boolean, "false" | "true">>;
+  idempotencyLookupKey: z.ZodDefault<z.ZodOptional<z.ZodString>>;
+  metadataVersion: z.ZodDefault<z.ZodEffects<z.ZodString, number, string>>;
+  lastError: z.ZodOptional<z.ZodEffects<z.ZodString, {
+    code: string;
+    message: string;
+  }, string>>;
 }, "strip", z.ZodTypeAny, {
-    status: "QUEUED" | "FAILED" | "DRAINING";
-    payload: string;
-    createdAt: Date;
-    runId: string;
-    attempts: number;
-    envId: string;
-    orgId: string;
-    createdAtMicros: number;
-    materialised: boolean;
-    idempotencyLookupKey: string;
-    metadataVersion: number;
-    lastError?: {
-        message: string;
-        code: string;
-    } | undefined;
+  runId: string;
+  envId: string;
+  orgId: string;
+  payload: string;
+  status: "DRAINING" | "FAILED" | "QUEUED";
+  attempts: number;
+  createdAt: Date;
+  createdAtMicros: number;
+  materialised: boolean;
+  idempotencyLookupKey: string;
+  metadataVersion: number;
+  lastError?: {
+    code: string;
+    message: string;
+  } | undefined;
 }, {
-    status: "QUEUED" | "FAILED" | "DRAINING";
-    payload: string;
-    createdAt: string;
-    runId: string;
-    attempts: string;
-    envId: string;
-    orgId: string;
-    createdAtMicros?: string | undefined;
-    materialised?: "true" | "false" | undefined;
-    idempotencyLookupKey?: string | undefined;
-    metadataVersion?: string | undefined;
-    lastError?: string | undefined;
+  runId: string;
+  envId: string;
+  orgId: string;
+  payload: string;
+  status: "DRAINING" | "FAILED" | "QUEUED";
+  attempts: string;
+  createdAt: string;
+  createdAtMicros?: string | undefined;
+  materialised?: "false" | "true" | undefined;
+  idempotencyLookupKey?: string | undefined;
+  metadataVersion?: string | undefined;
+  lastError?: string | undefined;
 }>;
 type BufferEntry = z.infer<typeof BufferEntrySchema>;
 declare function serialiseSnapshot(snapshot: unknown): string;
 declare function deserialiseSnapshot<T = unknown>(serialised: string): T;
-
+//#endregion
+//#region src/mollifier/buffer.d.ts
 type MollifierBufferOptions = {
-    redisOptions: RedisOptions;
-    logger?: Logger;
-    ackGraceTtlSeconds?: number;
-    maxRetriesPerRequest?: number;
-    reconnectStepMs?: number;
-    reconnectMaxMs?: number;
+  redisOptions: RedisOptions;
+  logger?: Logger;
+  ackGraceTtlSeconds?: number;
+  maxRetriesPerRequest?: number;
+  reconnectStepMs?: number;
+  reconnectMaxMs?: number;
 };
 type SnapshotPatch = {
-    type: "append_tags";
-    tags: string[];
-    maxTags?: number;
+  type: "append_tags";
+  tags: string[];
+  maxTags?: number;
 } | {
-    type: "set_metadata";
-    metadata: string;
-    metadataType: string;
+  type: "set_metadata";
+  metadata: string;
+  metadataType: string;
 } | {
-    type: "set_delay";
-    delayUntil: string;
+  type: "set_delay";
+  delayUntil: string;
 } | {
-    type: "mark_cancelled";
-    cancelledAt: string;
-    cancelReason?: string;
+  type: "mark_cancelled";
+  cancelledAt: string;
+  cancelReason?: string;
 };
 type MutateSnapshotResult = "applied_to_snapshot" | "not_found" | "busy" | "limit_exceeded";
 type CasSetMetadataResult = {
-    kind: "applied";
-    newVersion: number;
+  kind: "applied";
+  newVersion: number;
 } | {
-    kind: "version_conflict";
-    currentVersion: number;
+  kind: "version_conflict";
+  currentVersion: number;
 } | {
-    kind: "not_found";
+  kind: "not_found";
 } | {
-    kind: "busy";
+  kind: "busy";
 };
 type AcceptResult = {
-    kind: "accepted";
+  kind: "accepted";
 } | {
-    kind: "duplicate_run_id";
+  kind: "duplicate_run_id";
 } | {
-    kind: "duplicate_idempotency";
-    existingRunId: string;
+  kind: "duplicate_idempotency";
+  existingRunId: string;
 };
 type IdempotencyLookupInput = {
-    envId: string;
-    taskIdentifier: string;
-    idempotencyKey: string;
+  envId: string;
+  taskIdentifier: string;
+  idempotencyKey: string;
 };
 declare function idempotencyLookupKeyFor(input: IdempotencyLookupInput): string;
 declare function makeIdempotencyClaimKey(input: IdempotencyLookupInput): string;
 type IdempotencyClaimResult = {
-    kind: "claimed";
+  kind: "claimed";
 } | {
-    kind: "pending";
+  kind: "pending";
 } | {
-    kind: "resolved";
-    runId: string;
+  kind: "resolved";
+  runId: string;
 };
 declare class MollifierBuffer {
-    #private;
-    private readonly redis;
-    private readonly logger;
-    private readonly ackGraceTtlSeconds;
-    constructor(options: MollifierBufferOptions);
-    accept(input: {
-        runId: string;
-        envId: string;
-        orgId: string;
-        payload: string;
-        idempotencyKey?: string;
-        taskIdentifier?: string;
-    }): Promise<AcceptResult>;
-    pop(envId: string): Promise<BufferEntry | null>;
-    getEntry(runId: string): Promise<BufferEntry | null>;
-    listOrgs(): Promise<string[]>;
-    listEnvsForOrg(orgId: string): Promise<string[]>;
-    listEntriesForEnv(envId: string, maxCount: number): Promise<BufferEntry[]>;
-    mutateSnapshot(runId: string, patch: SnapshotPatch): Promise<MutateSnapshotResult>;
-    casSetMetadata(input: {
-        runId: string;
-        expectedVersion: number;
-        newMetadata: string;
-        newMetadataType: string;
-    }): Promise<CasSetMetadataResult>;
-    claimIdempotency(input: IdempotencyLookupInput & {
-        token: string;
-        ttlSeconds: number;
-    }): Promise<IdempotencyClaimResult>;
-    publishClaim(input: IdempotencyLookupInput & {
-        token: string;
-        runId: string;
-        ttlSeconds: number;
-    }): Promise<boolean>;
-    releaseClaim(input: IdempotencyLookupInput & {
-        token: string;
-    }): Promise<void>;
-    resetResolvedClaim(input: IdempotencyLookupInput & {
-        expectedRunId: string;
-    }): Promise<boolean>;
-    readClaim(input: IdempotencyLookupInput): Promise<IdempotencyClaimResult | null>;
-    lookupIdempotency(input: IdempotencyLookupInput): Promise<string | null>;
-    resetIdempotency(input: IdempotencyLookupInput): Promise<{
-        clearedRunId: string | null;
-    }>;
-    ack(runId: string): Promise<void>;
-    requeue(runId: string): Promise<void>;
-    fail(runId: string, error: {
-        code: string;
-        message: string;
-    }): Promise<boolean>;
-    getDrainingCount(): Promise<number>;
-    listStaleDraining(olderThanMs: number, limit: number): Promise<string[]>;
-    getEntryTtlSeconds(runId: string): Promise<number>;
-    evaluateTrip(envId: string, options: {
-        windowMs: number;
-        threshold: number;
-        holdMs: number;
-    }): Promise<{
-        tripped: boolean;
-        count: number;
-    }>;
-    close(): Promise<void>;
-}
-declare module "@internal/redis" {
-    interface RedisCommander<Context> {
-        acceptMollifierEntry(entryKey: string, queueKey: string, orgsKey: string, runId: string, envId: string, orgId: string, payload: string, createdAt: string, createdAtMicros: string, orgEnvsPrefix: string, idempotencyLookupKey: string, entryPrefix: string, callback?: Callback<number | string>): Result<number | string, Context>;
-        popAndMarkDraining(queueKey: string, orgsKey: string, drainingSetKey: string, entryPrefix: string, envId: string, orgEnvsPrefix: string, callback?: Callback<string | null>): Result<string | null, Context>;
-        requeueMollifierEntry(entryKey: string, orgsKey: string, drainingSetKey: string, queuePrefix: string, runId: string, orgEnvsPrefix: string, callback?: Callback<number>): Result<number, Context>;
-        mutateMollifierSnapshot(entryKey: string, patchJson: string, callback?: Callback<string>): Result<string, Context>;
-        casSetMollifierMetadata(entryKey: string, expectedVersion: string, newMetadata: string, newMetadataType: string, callback?: Callback<string>): Result<string, Context>;
-        resetMollifierIdempotency(lookupKey: string, entryPrefix: string, claimKey: string, callback?: Callback<string>): Result<string, Context>;
-        claimMollifierIdempotency(claimKey: string, pendingMarker: string, pendingPrefix: string, ttlSeconds: string, callback?: Callback<string>): Result<string, Context>;
-        publishMollifierClaim(claimKey: string, ownerMarker: string, runId: string, ttlSeconds: string, callback?: Callback<number>): Result<number, Context>;
-        releaseMollifierClaim(claimKey: string, ownerMarker: string, callback?: Callback<number>): Result<number, Context>;
-        ackMollifierEntry(entryKey: string, drainingSetKey: string, graceTtlSeconds: string, runId: string, callback?: Callback<number>): Result<number, Context>;
-        failMollifierEntry(entryKey: string, drainingSetKey: string, errorPayload: string, runId: string, callback?: Callback<number>): Result<number, Context>;
-        delMollifierKeyIfEquals(key: string, expected: string, callback?: Callback<number>): Result<number, Context>;
-        mollifierEvaluateTrip(rateKey: string, trippedKey: string, windowMs: string, threshold: string, holdMs: string, callback?: Callback<[number, number]>): Result<[number, number], Context>;
-    }
-}
-
-type MollifierDrainerHandler<TPayload> = (input: {
+  #private;
+  private readonly redis;
+  private readonly logger;
+  private readonly ackGraceTtlSeconds;
+  constructor(options: MollifierBufferOptions);
+  accept(input: {
     runId: string;
     envId: string;
     orgId: string;
-    payload: TPayload;
-    attempts: number;
-    createdAt: Date;
+    payload: string;
+    idempotencyKey?: string;
+    taskIdentifier?: string;
+  }): Promise<AcceptResult>;
+  pop(envId: string): Promise<BufferEntry | null>;
+  getEntry(runId: string): Promise<BufferEntry | null>;
+  listOrgs(): Promise<string[]>;
+  listEnvsForOrg(orgId: string): Promise<string[]>;
+  listEntriesForEnv(envId: string, maxCount: number): Promise<BufferEntry[]>;
+  mutateSnapshot(runId: string, patch: SnapshotPatch): Promise<MutateSnapshotResult>;
+  casSetMetadata(input: {
+    runId: string;
+    expectedVersion: number;
+    newMetadata: string;
+    newMetadataType: string;
+  }): Promise<CasSetMetadataResult>;
+  claimIdempotency(input: IdempotencyLookupInput & {
+    token: string;
+    ttlSeconds: number;
+  }): Promise<IdempotencyClaimResult>;
+  publishClaim(input: IdempotencyLookupInput & {
+    token: string;
+    runId: string;
+    ttlSeconds: number;
+  }): Promise<boolean>;
+  releaseClaim(input: IdempotencyLookupInput & {
+    token: string;
+  }): Promise<void>;
+  resetResolvedClaim(input: IdempotencyLookupInput & {
+    expectedRunId: string;
+  }): Promise<boolean>;
+  readClaim(input: IdempotencyLookupInput): Promise<IdempotencyClaimResult | null>;
+  lookupIdempotency(input: IdempotencyLookupInput): Promise<string | null>;
+  resetIdempotency(input: IdempotencyLookupInput): Promise<{
+    clearedRunId: string | null;
+  }>;
+  ack(runId: string): Promise<void>;
+  requeue(runId: string): Promise<void>;
+  fail(runId: string, error: {
+    code: string;
+    message: string;
+  }): Promise<boolean>;
+  getDrainingCount(): Promise<number>;
+  listStaleDraining(olderThanMs: number, limit: number): Promise<string[]>;
+  getEntryTtlSeconds(runId: string): Promise<number>;
+  evaluateTrip(envId: string, options: {
+    windowMs: number;
+    threshold: number;
+    holdMs: number;
+  }): Promise<{
+    tripped: boolean;
+    count: number;
+  }>;
+  close(): Promise<void>;
+}
+declare module "@internal/redis" {
+  interface RedisCommander<Context> {
+    acceptMollifierEntry(entryKey: string, queueKey: string, orgsKey: string, runId: string, envId: string, orgId: string, payload: string, createdAt: string, createdAtMicros: string, orgEnvsPrefix: string, idempotencyLookupKey: string, entryPrefix: string, callback?: Callback<number | string>): Result<number | string, Context>;
+    popAndMarkDraining(queueKey: string, orgsKey: string, drainingSetKey: string, entryPrefix: string, envId: string, orgEnvsPrefix: string, callback?: Callback<string | null>): Result<string | null, Context>;
+    requeueMollifierEntry(entryKey: string, orgsKey: string, drainingSetKey: string, queuePrefix: string, runId: string, orgEnvsPrefix: string, callback?: Callback<number>): Result<number, Context>;
+    mutateMollifierSnapshot(entryKey: string, patchJson: string, callback?: Callback<string>): Result<string, Context>;
+    casSetMollifierMetadata(entryKey: string, expectedVersion: string, newMetadata: string, newMetadataType: string, callback?: Callback<string>): Result<string, Context>;
+    resetMollifierIdempotency(lookupKey: string, entryPrefix: string, claimKey: string, callback?: Callback<string>): Result<string, Context>;
+    claimMollifierIdempotency(claimKey: string, pendingMarker: string, pendingPrefix: string, ttlSeconds: string, callback?: Callback<string>): Result<string, Context>;
+    publishMollifierClaim(claimKey: string, ownerMarker: string, runId: string, ttlSeconds: string, callback?: Callback<number>): Result<number, Context>;
+    releaseMollifierClaim(claimKey: string, ownerMarker: string, callback?: Callback<number>): Result<number, Context>;
+    ackMollifierEntry(entryKey: string, drainingSetKey: string, graceTtlSeconds: string, runId: string, callback?: Callback<number>): Result<number, Context>;
+    failMollifierEntry(entryKey: string, drainingSetKey: string, errorPayload: string, runId: string, callback?: Callback<number>): Result<number, Context>;
+    delMollifierKeyIfEquals(key: string, expected: string, callback?: Callback<number>): Result<number, Context>;
+    mollifierEvaluateTrip(rateKey: string, trippedKey: string, windowMs: string, threshold: string, holdMs: string, callback?: Callback<[number, number]>): Result<[number, number], Context>;
+  }
+}
+//#endregion
+//#region src/mollifier/drainer.d.ts
+type MollifierDrainerHandler<TPayload> = (input: {
+  runId: string;
+  envId: string;
+  orgId: string;
+  payload: TPayload;
+  attempts: number;
+  createdAt: Date;
 }) => Promise<void>;
 type MollifierDrainerTerminalFailureCause = "non-retryable" | "max-attempts-exhausted";
 type MollifierDrainerTerminalFailureHandler<TPayload> = (input: {
-    runId: string;
-    envId: string;
-    orgId: string;
-    payload: TPayload;
-    attempts: number;
-    createdAt: Date;
-    error: {
-        code: string;
-        message: string;
-    };
-    cause: MollifierDrainerTerminalFailureCause;
+  runId: string;
+  envId: string;
+  orgId: string;
+  payload: TPayload;
+  attempts: number;
+  createdAt: Date;
+  error: {
+    code: string;
+    message: string;
+  };
+  cause: MollifierDrainerTerminalFailureCause;
 }) => Promise<void>;
 type MollifierDrainerOptions<TPayload> = {
-    buffer: MollifierBuffer;
-    handler: MollifierDrainerHandler<TPayload>;
-    onTerminalFailure?: MollifierDrainerTerminalFailureHandler<TPayload>;
-    concurrency: number;
-    maxAttempts: number;
-    isRetryable: (err: unknown) => boolean;
-    pollIntervalMs?: number;
-    maxOrgsPerTick?: number;
-    drainBatchSize?: number;
-    maxBackoffMs?: number;
-    backoffFloorMs?: number;
-    logger?: Logger;
+  buffer: MollifierBuffer;
+  handler: MollifierDrainerHandler<TPayload>;
+  onTerminalFailure?: MollifierDrainerTerminalFailureHandler<TPayload>;
+  concurrency: number;
+  maxAttempts: number;
+  isRetryable: (err: unknown) => boolean;
+  pollIntervalMs?: number;
+  maxOrgsPerTick?: number;
+  drainBatchSize?: number;
+  maxBackoffMs?: number;
+  backoffFloorMs?: number;
+  logger?: Logger;
 };
 type DrainResult = {
-    drained: number;
-    failed: number;
+  drained: number;
+  failed: number;
 };
 declare class MollifierDrainer<TPayload = unknown> {
-    private readonly buffer;
-    private readonly handler;
-    private readonly onTerminalFailure?;
-    private readonly maxAttempts;
-    private readonly isRetryable;
-    private readonly pollIntervalMs;
-    private readonly maxOrgsPerTick;
-    private readonly drainBatchSize;
-    private readonly concurrency;
-    private readonly maxBackoffMs;
-    private readonly backoffFloorMs;
-    private readonly logger;
-    private orgCursor;
-    private perOrgEnvCursors;
-    private isRunning;
-    private stopping;
-    private loopPromise;
-    constructor(options: MollifierDrainerOptions<TPayload>);
-    runOnce(): Promise<DrainResult>;
-    start(): void;
-    stop(options?: {
-        timeoutMs?: number;
-    }): Promise<void>;
-    private loop;
-    private backoffMs;
-    private delay;
-    private takeOrgSlice;
-    private pickEnvForOrg;
-    private processEntry;
-}
-
-export { type AcceptResult, type AnyMessageCatalog, type AnyQueueItem, BaseScheduler, type BatchConfig, BatchedSpanManager, type BatchedSpanManagerOptions, type BufferEntry, BufferEntryError, BufferEntrySchema, BufferEntryStatus, CallbackFairQueueKeyProducer, type CasSetMetadataResult, type ClaimResult, type ConcurrencyCheckResult, type ConcurrencyGroupConfig, ConcurrencyManager, type ConcurrencyManagerOptions, type ConcurrencyState, type ConsumerLoopState, type CooloffOptions, CronSchema, CustomRetry, DRRScheduler, type DRRSchedulerConfig, type DeadLetterMessage, DefaultFairQueueKeyProducer, type DispatchSchedulerContext, type DrainResult, type EnqueueBatchOptions, type EnqueueOptions, ExponentialBackoffRetry, FairQueue, FairQueueAttributes, type FairQueueKeyProducer, type FairQueueMetrics, type FairQueueOptions, FairQueueTelemetry, type FairScheduler, FixedDelayRetry, type GlobalRateLimiter, type IdempotencyClaimResult, type IdempotencyLookupInput, ImmediateRetry, type InFlightMessage, type JobHandler, type JobHandlerParams, LinearBackoffRetry, MasterQueue, type MasterQueueOptions, type MessageCatalogKey, type MessageCatalogSchema, type MessageCatalogValue, type MessageHandler, type MessageHandlerContext, MessagingAttributes, MollifierBuffer, type MollifierBufferOptions, MollifierDrainer, type MollifierDrainerHandler, type MollifierDrainerOptions, type MollifierDrainerTerminalFailureCause, type MollifierDrainerTerminalFailureHandler, type MutateSnapshotResult, NoRetry, NoopScheduler, type QueueCooloffState, type QueueDescriptor, type QueueItem, type QueueMessage, type QueueWithScore, type ReclaimedMessageInfo, type RetryOptions, type RetryStrategy, RoundRobinScheduler, type SchedulerContext, SimpleQueue, type SnapshotPatch, type StoredMessage, type TelemetryOptions, TenantDispatch, type TenantDispatchOptions, type TenantQueues, type TenantWithScore, VisibilityManager, type VisibilityManagerOptions, WeightedScheduler, type WeightedSchedulerBiases, type WeightedSchedulerConfig, Worker, type WorkerCatalog, type WorkerConcurrencyOptions, WorkerQueueManager, type WorkerQueueManagerOptions, type WorkerQueueOptions, createDefaultRetryStrategy, defaultRetryOptions, deserialiseSnapshot, idempotencyLookupKeyFor, isAbortError, makeIdempotencyClaimKey, noopTelemetry, serialiseSnapshot };
+  private readonly buffer;
+  private readonly handler;
+  private readonly onTerminalFailure?;
+  private readonly maxAttempts;
+  private readonly isRetryable;
+  private readonly pollIntervalMs;
+  private readonly maxOrgsPerTick;
+  private readonly drainBatchSize;
+  private readonly concurrency;
+  private readonly maxBackoffMs;
+  private readonly backoffFloorMs;
+  private readonly logger;
+  private orgCursor;
+  private perOrgEnvCursors;
+  private isRunning;
+  private stopping;
+  private loopPromise;
+  constructor(options: MollifierDrainerOptions<TPayload>);
+  runOnce(): Promise<DrainResult>;
+  start(): void;
+  stop(options?: {
+    timeoutMs?: number;
+  }): Promise<void>;
+  private loop;
+  private backoffMs;
+  private delay;
+  private takeOrgSlice;
+  private pickEnvForOrg;
+  private processEntry;
+}
+//#endregion
+export { type AcceptResult, AnyMessageCatalog, AnyQueueItem, BaseScheduler, BatchConfig, BatchedSpanManager, BatchedSpanManagerOptions, type BufferEntry, BufferEntryError, BufferEntrySchema, BufferEntryStatus, CallbackFairQueueKeyProducer, type CasSetMetadataResult, ClaimResult, ConcurrencyCheckResult, ConcurrencyGroupConfig, ConcurrencyManager, ConcurrencyManagerOptions, ConcurrencyState, ConsumerLoopState, CooloffOptions, CronSchema, CustomRetry, DRRScheduler, DRRSchedulerConfig, DeadLetterMessage, DefaultFairQueueKeyProducer, DispatchSchedulerContext, type DrainResult, EnqueueBatchOptions, EnqueueOptions, ExponentialBackoffRetry, FairQueue, FairQueueAttributes, FairQueueKeyProducer, FairQueueMetrics, FairQueueOptions, FairQueueTelemetry, FairScheduler, FixedDelayRetry, GlobalRateLimiter, type IdempotencyClaimResult, type IdempotencyLookupInput, ImmediateRetry, InFlightMessage, JobHandler, JobHandlerParams, LinearBackoffRetry, MasterQueue, MasterQueueOptions, MessageCatalogKey, MessageCatalogSchema, MessageCatalogValue, MessageHandler, MessageHandlerContext, MessagingAttributes, MollifierBuffer, type MollifierBufferOptions, MollifierDrainer, type MollifierDrainerHandler, type MollifierDrainerOptions, type MollifierDrainerTerminalFailureCause, type MollifierDrainerTerminalFailureHandler, type MutateSnapshotResult, NoRetry, NoopScheduler, QueueCooloffState, QueueDescriptor, QueueItem, QueueMessage, QueueWithScore, ReclaimedMessageInfo, RetryOptions, RetryStrategy, RoundRobinScheduler, SchedulerContext, SimpleQueue, type SnapshotPatch, StoredMessage, TelemetryOptions, TenantDispatch, TenantDispatchOptions, TenantQueues, TenantWithScore, VisibilityManager, VisibilityManagerOptions, WeightedScheduler, WeightedSchedulerBiases, WeightedSchedulerConfig, Worker, WorkerCatalog, WorkerConcurrencyOptions, WorkerQueueManager, WorkerQueueManagerOptions, WorkerQueueOptions, createDefaultRetryStrategy, defaultRetryOptions, deserialiseSnapshot, idempotencyLookupKeyFor, isAbortError, makeIdempotencyClaimKey, noopTelemetry, serialiseSnapshot };