@trigger.dev/redis-worker 4.5.0 → 4.5.2

package/dist/index.d.ts

@@ -910,6 +910,101 @@ interface WeightedSchedulerConfig {
     tracer?: Tracer;
 }
 
+interface ConcurrencyManagerOptions {
+    redis: RedisOptions;
+    keys: FairQueueKeyProducer;
+    groups: ConcurrencyGroupConfig[];
+}
+/**
+ * ConcurrencyManager handles multi-level concurrency tracking and limiting.
+ *
+ * Features:
+ * - Multiple concurrent concurrency groups (tenant, org, project, etc.)
+ * - Atomic reserve/release operations using Lua scripts
+ * - 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>;
+}
+declare module "@internal/redis" {
+    interface RedisCommander<Context> {
+        reserveConcurrency(numKeys: number, keys: string[], messageId: string, ...limits: string[]): Promise<number>;
+    }
+}
+
 /**
  * Default key producer for the fair queue system.
  * Uses a configurable prefix and standard key structure.
@@ -1059,359 +1154,12 @@ declare class MasterQueue {
     /**
      * 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 ConcurrencyManagerOptions {
-    redis: RedisOptions;
-    keys: FairQueueKeyProducer;
-    groups: ConcurrencyGroupConfig[];
-}
-/**
- * ConcurrencyManager handles multi-level concurrency tracking and limiting.
- *
- * Features:
- * - Multiple concurrent concurrency groups (tenant, org, project, etc.)
- * - Atomic reserve/release operations using Lua scripts
- * - 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>;
-}
-declare module "@internal/redis" {
-    interface RedisCommander<Context> {
-        reserveConcurrency(numKeys: number, keys: string[], messageId: string, ...limits: string[]): Promise<number>;
-    }
-}
-
-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;
-    };
-}
-/**
- * VisibilityManager handles message visibility timeouts for safe message processing.
- *
- * Features:
- * - Claim messages with visibility timeout
- * - Heartbeat to extend timeout
- * - Automatic reclaim of timed-out messages
- * - Per-shard in-flight tracking
- *
- * Data structures:
- * - In-flight sorted set: score = deadline timestamp, member = "{messageId}:{queueId}"
- * - 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>;
-}
-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 WorkerQueueManagerOptions {
-    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.
- *
- * This provides:
- * - Low-latency message delivery via blocking pop (BLPOP)
- * - Routing of messages to specific workers/consumers
- * - Efficient waiting without polling
- *
- * Flow:
- * 1. Master queue consumer claims message from message queue
- * 2. Message key is pushed to worker queue
- * 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;
+    close(): Promise<void>;
 }
 declare module "@internal/redis" {
     interface RedisCommander<Context> {
-        popWithLength(workerQueueKey: string): Promise<[string, string] | null>;
+        addQueueIfNotEmpty(masterKey: string, queueKey: string, queueId: string): Promise<number>;
+        removeQueueIfEmpty(masterKey: string, queueKey: string, queueId: string): Promise<number>;
     }
 }
 
@@ -1942,6 +1690,258 @@ declare class TenantDispatch {
     close(): Promise<void>;
 }
 
+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;
+    };
+}
+/**
+ * VisibilityManager handles message visibility timeouts for safe message processing.
+ *
+ * Features:
+ * - Claim messages with visibility timeout
+ * - Heartbeat to extend timeout
+ * - Automatic reclaim of timed-out messages
+ * - Per-shard in-flight tracking
+ *
+ * Data structures:
+ * - In-flight sorted set: score = deadline timestamp, member = "{messageId}:{queueId}"
+ * - 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>;
+}
+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 WorkerQueueManagerOptions {
+    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.
+ *
+ * This provides:
+ * - Low-latency message delivery via blocking pop (BLPOP)
+ * - Routing of messages to specific workers/consumers
+ * - Efficient waiting without polling
+ *
+ * Flow:
+ * 1. Master queue consumer claims message from message queue
+ * 2. Message key is pushed to worker queue
+ * 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;
+}
+declare module "@internal/redis" {
+    interface RedisCommander<Context> {
+        popWithLength(workerQueueKey: string): Promise<[string, string] | null>;
+    }
+}
+
 /**
  * FairQueue is the main orchestrator for fair queue message routing.
  *