@holo-js/queue 0.2.5 → 0.3.0

package/dist/config.mjs

@@ -0,0 +1,32 @@
+import {
+  DEFAULT_DATABASE_QUEUE_TABLE,
+  DEFAULT_FAILED_JOBS_CONNECTION,
+  DEFAULT_FAILED_JOBS_TABLE,
+  DEFAULT_QUEUE_BLOCK_FOR,
+  DEFAULT_QUEUE_CONNECTION,
+  DEFAULT_QUEUE_NAME,
+  DEFAULT_QUEUE_RETRY_AFTER,
+  DEFAULT_QUEUE_SLEEP,
+  DEFAULT_REDIS_DB,
+  DEFAULT_REDIS_HOST,
+  DEFAULT_REDIS_PORT,
+  holoQueueDefaults,
+  normalizeQueueConfig,
+  queueInternals
+} from "./chunk-5MPOVBVE.mjs";
+export {
+  DEFAULT_DATABASE_QUEUE_TABLE,
+  DEFAULT_FAILED_JOBS_CONNECTION,
+  DEFAULT_FAILED_JOBS_TABLE,
+  DEFAULT_QUEUE_BLOCK_FOR,
+  DEFAULT_QUEUE_CONNECTION,
+  DEFAULT_QUEUE_NAME,
+  DEFAULT_QUEUE_RETRY_AFTER,
+  DEFAULT_QUEUE_SLEEP,
+  DEFAULT_REDIS_DB,
+  DEFAULT_REDIS_HOST,
+  DEFAULT_REDIS_PORT,
+  holoQueueDefaults,
+  normalizeQueueConfig,
+  queueInternals
+};

package/dist/index.d.ts

@@ -1,375 +1,5 @@
-type QueueJsonPrimitive = string | number | boolean | null;
-type QueueJsonValue = QueueJsonPrimitive | readonly QueueJsonValue[] | {
-    readonly [key: string]: QueueJsonValue;
-};
-type QueueJobDispatcher = <TPayload extends QueueJsonValue>(jobName: string, payload: TPayload) => QueuePendingDispatch<TPayload>;
-type QueueJobSyncDispatcher = <TPayload extends QueueJsonValue, TResult>(jobName: string, payload: TPayload) => Promise<TResult>;
-declare function setQueueJobDispatcher(dispatcher: QueueJobDispatcher): void;
-declare function setQueueJobSyncDispatcher(dispatcher: QueueJobSyncDispatcher): void;
-declare function setQueueJobDefinitionName(definition: object, name: string): void;
-declare function deleteQueueJobDefinitionName(name: string): void;
-declare function clearQueueJobDefinitionNames(): void;
-declare function resolveQueueJobDefinitionName(definition: object): string;
-declare function dispatchDefinedQueueJob<TPayload extends QueueJsonValue>(definition: object, payload: TPayload): QueuePendingDispatch<TPayload>;
-declare function dispatchDefinedQueueJobSync<TPayload extends QueueJsonValue, TResult>(definition: object, payload: TPayload): Promise<TResult>;
-declare function normalizeOptionalString(value: string | undefined, label: string): string | undefined;
-declare function normalizeOptionalInteger(value: number | undefined, label: string, options?: {
-    minimum?: number;
-}): number | undefined;
-declare function normalizeBackoff(value: number | readonly number[] | undefined): number | readonly number[] | undefined;
-declare function normalizeOptionalHook<THandler extends (...args: never[]) => unknown>(value: THandler | undefined, label: string): THandler | undefined;
-interface QueueJobContext {
-    readonly jobId: string;
-    readonly jobName: string;
-    readonly connection: string;
-    readonly queue: string;
-    readonly attempt: number;
-    readonly maxAttempts: number;
-    release(delaySeconds?: number): Promise<void>;
-    fail(error: Error): Promise<void>;
-}
-interface QueueJobCompletedHook<TPayload extends QueueJsonValue = QueueJsonValue, TResult = unknown> {
-    (payload: TPayload, result: TResult, context: QueueJobContext): void | Promise<void>;
-}
-interface QueueJobFailedHook<TPayload extends QueueJsonValue = QueueJsonValue> {
-    (payload: TPayload, error: Error, context: QueueJobContext): void | Promise<void>;
-}
-interface QueueJobDefinition<TPayload extends QueueJsonValue = QueueJsonValue, TResult = unknown> {
-    readonly connection?: string;
-    readonly queue?: string;
-    readonly tries?: number;
-    readonly backoff?: number | readonly number[];
-    readonly timeout?: number;
-    readonly onCompleted?: QueueJobCompletedHook<TPayload, TResult>;
-    readonly onFailed?: QueueJobFailedHook<TPayload>;
-    handle(payload: TPayload, context: QueueJobContext): Promise<TResult> | TResult;
-}
-interface DefinedQueueJobDefinition<TPayload extends QueueJsonValue = QueueJsonValue, TResult = unknown> extends QueueJobDefinition<TPayload, TResult> {
-    dispatch(payload: TPayload): QueuePendingDispatch<TPayload>;
-    dispatchSync(payload: TPayload): Promise<TResult>;
-}
-interface QueueJobEnvelope<TPayload extends QueueJsonValue = QueueJsonValue> {
-    readonly id: string;
-    readonly name: string;
-    readonly connection: string;
-    readonly queue: string;
-    readonly payload: TPayload;
-    readonly attempts: number;
-    readonly maxAttempts: number;
-    readonly availableAt?: number;
-    readonly createdAt: number;
-}
-type QueueDelayValue = number | Date;
-interface QueueDispatchOptions {
-    readonly connection?: string;
-    readonly queue?: string;
-    readonly delay?: QueueDelayValue;
-}
-interface QueueDispatchResult {
-    readonly jobId: string;
-    readonly connection: string;
-    readonly queue: string;
-    readonly synchronous: boolean;
-}
-interface QueueDispatchCompletedHook {
-    (result: QueueDispatchResult): void | Promise<void>;
-}
-interface QueueDispatchFailedHook {
-    (error: unknown): void | Promise<void>;
-}
-interface QueueDriverDispatchResult<TResult = unknown> {
-    readonly jobId: string;
-    readonly synchronous: boolean;
-    readonly result?: TResult;
-}
-interface QueueRegisteredJob<TPayload extends QueueJsonValue = QueueJsonValue, TResult = unknown> {
-    readonly name: string;
-    readonly sourcePath?: string;
-    readonly definition: QueueJobDefinition<TPayload, TResult>;
-}
-interface HoloQueueJobRegistry {
-}
-type KnownQueueJobName = Extract<keyof HoloQueueJobRegistry, string>;
-type DynamicQueueJobName<TJobName extends string> = [KnownQueueJobName] extends [never] ? TJobName : TJobName extends KnownQueueJobName ? never : KnownQueueJobName extends TJobName ? never : TJobName;
-type ResolveRegisteredQueueJobDefinition<TJobName extends string> = TJobName extends KnownQueueJobName ? HoloQueueJobRegistry[TJobName] extends QueueJobDefinition<infer TPayload, infer TResult> ? QueueJobDefinition<TPayload, TResult> : QueueJobDefinition : QueueJobDefinition;
-type ExportedQueueJobDefinition<TValue> = TValue extends QueueJobDefinition<infer TPayload, infer TResult> ? QueueJobDefinition<TPayload, TResult> : QueueJobDefinition;
-type QueuePayloadFor<TJobName extends string> = ResolveRegisteredQueueJobDefinition<TJobName> extends QueueJobDefinition<infer TPayload, infer _TResult> ? TPayload : QueueJsonValue;
-type QueueResultFor<TJobName extends string> = ResolveRegisteredQueueJobDefinition<TJobName> extends QueueJobDefinition<infer _TPayload, infer TResult> ? TResult : unknown;
-interface RegisterQueueJobOptions {
-    readonly name?: string;
-    readonly sourcePath?: string;
-    readonly replaceExisting?: boolean;
-}
-type RegisterableQueueJobDefinition<TPayload extends QueueJsonValue = QueueJsonValue, TResult = unknown> = QueueJobDefinition<TPayload, TResult>;
-interface QueuePendingDispatch<TPayload extends QueueJsonValue = QueueJsonValue> extends PromiseLike<QueueDispatchResult> {
-    onConnection(name: string): QueuePendingDispatch<TPayload>;
-    onQueue(name: string): QueuePendingDispatch<TPayload>;
-    delay(value: QueueDelayValue): QueuePendingDispatch<TPayload>;
-    onComplete(callback: QueueDispatchCompletedHook): QueuePendingDispatch<TPayload>;
-    onFailed(callback: QueueDispatchFailedHook): QueuePendingDispatch<TPayload>;
-    then<TResult1 = QueueDispatchResult, TResult2 = never>(onfulfilled?: ((value: QueueDispatchResult) => TResult1 | PromiseLike<TResult1>) | null, onrejected?: ((reason: unknown) => TResult2 | PromiseLike<TResult2>) | null): Promise<TResult1 | TResult2>;
-    catch<TResult = never>(onrejected?: ((reason: unknown) => TResult | PromiseLike<TResult>) | null): Promise<QueueDispatchResult | TResult>;
-    finally(onfinally?: (() => void) | null): Promise<QueueDispatchResult>;
-    dispatch(): Promise<QueueDispatchResult>;
-}
-interface QueueConnectionFacade {
-    readonly name: string;
-    dispatch<TJobName extends KnownQueueJobName>(jobName: TJobName, payload: QueuePayloadFor<TJobName>, options?: QueueDispatchOptions): QueuePendingDispatch<QueuePayloadFor<TJobName>>;
-    dispatch<TPayload extends QueueJsonValue = QueueJsonValue, const TJobName extends string = string>(jobName: TJobName & DynamicQueueJobName<TJobName>, payload: TPayload, options?: QueueDispatchOptions): QueuePendingDispatch<TPayload>;
-    dispatchSync<TJobName extends KnownQueueJobName>(jobName: TJobName, payload: QueuePayloadFor<TJobName>): Promise<QueueResultFor<TJobName>>;
-    dispatchSync<TPayload extends QueueJsonValue = QueueJsonValue, TResult = unknown, const TJobName extends string = string>(jobName: TJobName & DynamicQueueJobName<TJobName>, payload: TPayload): Promise<TResult>;
-}
-interface QueueEnqueueResult {
-    readonly jobId: string;
-}
-interface QueueReserveInput {
-    readonly queueNames: readonly string[];
-    readonly workerId: string;
-}
-interface QueueReservedJob<TPayload extends QueueJsonValue = QueueJsonValue> {
-    readonly reservationId: string;
-    readonly envelope: QueueJobEnvelope<TPayload>;
-    readonly reservedAt: number;
-}
-interface QueueReleaseOptions {
-    readonly delaySeconds?: number;
-}
-interface QueueClearInput {
-    readonly queueNames?: readonly string[];
-}
-interface QueueJobContextOverrides {
-    readonly maxAttempts?: number;
-    shouldSkipLifecycleHooks?(): boolean;
-    release?(delaySeconds?: number): Promise<void>;
-    fail?(error: Error): Promise<void>;
-}
-interface QueueDriverFactoryContext {
-    execute<TPayload extends QueueJsonValue = QueueJsonValue, TResult = unknown>(job: QueueJobEnvelope<TPayload>): Promise<TResult>;
-}
-interface QueueDriverBase {
-    readonly name: string;
-    readonly driver: NormalizedQueueConnectionConfig['driver'];
-    readonly mode: 'sync' | 'async';
-    dispatch<TPayload extends QueueJsonValue = QueueJsonValue, TResult = unknown>(job: QueueJobEnvelope<TPayload>): Promise<QueueDriverDispatchResult<TResult>>;
-    clear(input?: QueueClearInput): Promise<number>;
-    close(): Promise<void>;
-}
-interface QueueAsyncDriver extends QueueDriverBase {
-    readonly mode: 'async';
-    reserve<TPayload extends QueueJsonValue = QueueJsonValue>(input: QueueReserveInput): Promise<QueueReservedJob<TPayload> | null>;
-    acknowledge(job: QueueReservedJob): Promise<void>;
-    release(job: QueueReservedJob, options?: QueueReleaseOptions): Promise<void>;
-    delete(job: QueueReservedJob): Promise<void>;
-}
-interface QueueSyncDriver extends QueueDriverBase {
-    readonly mode: 'sync';
-}
-type QueueDriver = QueueSyncDriver | QueueAsyncDriver;
-interface QueueDriverFactory<TConfig extends NormalizedQueueConnectionConfig = NormalizedQueueConnectionConfig> {
-    readonly driver: TConfig['driver'];
-    create(connection: TConfig, context: QueueDriverFactoryContext): QueueDriver;
-}
-interface QueueRuntimeBinding {
-    readonly config: NormalizedHoloQueueConfig;
-    readonly drivers: ReadonlyMap<string, QueueDriver>;
-}
-interface QueueWorkerOptions {
-    readonly connection?: string;
-    readonly queueNames?: readonly string[];
-    readonly once?: boolean;
-    readonly stopWhenEmpty?: boolean;
-    readonly sleep?: number;
-    readonly tries?: number;
-    readonly timeout?: number;
-    readonly maxJobs?: number;
-    readonly maxTime?: number;
-    readonly workerId?: string;
-    readonly shouldStop?: () => boolean | Promise<boolean>;
-    readonly sleepFn?: (milliseconds: number) => Promise<void>;
-}
-interface QueueWorkerJobEvent {
-    readonly jobId: string;
-    readonly jobName: string;
-    readonly connection: string;
-    readonly queue: string;
-    readonly attempt: number;
-    readonly maxAttempts: number;
-}
-interface QueueWorkerHooks {
-    onJobProcessed?(event: QueueWorkerJobEvent): void | Promise<void>;
-    onJobReleased?(event: QueueWorkerJobEvent & {
-        readonly delaySeconds?: number;
-        readonly error?: Error;
-    }): void | Promise<void>;
-    onJobFailed?(event: QueueWorkerJobEvent & {
-        readonly error: Error;
-    }): void | Promise<void>;
-    onIdle?(): void | Promise<void>;
-}
-interface QueueWorkerRunOptions extends QueueWorkerOptions, QueueWorkerHooks {
-}
-interface QueueWorkerResult {
-    readonly processed: number;
-    readonly released: number;
-    readonly failed: number;
-    readonly stoppedBecause: 'once' | 'empty' | 'max-jobs' | 'max-time' | 'signal';
-}
-interface QueueFailedJobRecord<TPayload extends QueueJsonValue = QueueJsonValue> {
-    readonly id: string;
-    readonly jobId: string;
-    readonly job: QueueJobEnvelope<TPayload>;
-    readonly exception: string;
-    readonly failedAt: number;
-}
-interface QueueFailedJobStore {
-    persistFailedJob(reserved: QueueReservedJob, error: Error): Promise<QueueFailedJobRecord | null>;
-    listFailedJobs(): Promise<readonly QueueFailedJobRecord[]>;
-    retryFailedJobs(identifier: 'all' | string, retry: (record: QueueFailedJobRecord) => Promise<void>): Promise<number>;
-    forgetFailedJob(id: string): Promise<boolean>;
-    flushFailedJobs(): Promise<number>;
-}
-declare function isQueueJobDefinition(value: unknown): value is QueueJobDefinition;
-declare function normalizeQueueJobDefinition<TPayload extends QueueJsonValue, TResult, TJob extends QueueJobDefinition<TPayload, TResult>>(job: TJob): TJob;
-declare function defineJob<TPayload extends QueueJsonValue, TResult = unknown>(job: QueueJobDefinition<TPayload, TResult>): DefinedQueueJobDefinition<TPayload, TResult>;
-interface QueueFailedStoreConfig {
-    readonly driver?: 'database';
-    readonly connection?: string;
-    readonly table?: string;
-}
-interface QueueRedisConnectionConfig {
-    readonly driver: 'redis';
-    readonly connection?: string;
-    readonly queue?: string;
-    readonly retryAfter?: number | string;
-    readonly blockFor?: number | string;
-    readonly redis?: {
-        readonly url?: string;
-        readonly clusters?: readonly {
-            readonly url?: string;
-            readonly host?: string;
-            readonly port?: number | string;
-        }[];
-        readonly host?: string;
-        readonly port?: number | string;
-        readonly password?: string;
-        readonly username?: string;
-        readonly db?: number | string;
-    };
-}
-interface QueueDatabaseConnectionConfig {
-    readonly driver: 'database';
-    readonly queue?: string;
-    readonly retryAfter?: number | string;
-    readonly sleep?: number | string;
-    readonly connection?: string;
-    readonly table?: string;
-}
-interface QueueSyncConnectionConfig {
-    readonly driver: 'sync';
-    readonly queue?: string;
-}
-type QueueConnectionConfig = QueueSyncConnectionConfig | QueueRedisConnectionConfig | QueueDatabaseConnectionConfig;
-interface HoloQueueConfig {
-    readonly default?: string;
-    readonly failed?: false | QueueFailedStoreConfig;
-    readonly connections?: Readonly<Record<string, QueueConnectionConfig>>;
-}
-interface NormalizedQueueFailedStoreConfig {
-    readonly driver: 'database';
-    readonly connection: string;
-    readonly table: string;
-}
-interface NormalizedQueueSyncConnectionConfig {
-    readonly name: string;
-    readonly driver: 'sync';
-    readonly queue: string;
-}
-interface NormalizedQueueRedisConnectionConfig {
-    readonly name: string;
-    readonly driver: 'redis';
-    readonly connection: string;
-    readonly queue: string;
-    readonly retryAfter: number;
-    readonly blockFor: number;
-    readonly redis: {
-        readonly url?: string;
-        readonly clusters?: readonly {
-            readonly url?: string;
-            readonly host: string;
-            readonly port: number;
-        }[];
-        readonly host: string;
-        readonly port: number;
-        readonly password?: string;
-        readonly username?: string;
-        readonly db: number;
-    };
-}
-interface QueueSharedRedisConnectionConfig {
-    readonly name: string;
-    readonly url?: string;
-    readonly clusters?: readonly {
-        readonly url?: string;
-        readonly host: string;
-        readonly port: number;
-    }[];
-    readonly host: string;
-    readonly port: number;
-    readonly password?: string;
-    readonly username?: string;
-    readonly db: number;
-}
-interface QueueSharedRedisConfig {
-    readonly default: string;
-    readonly connections: Readonly<Record<string, QueueSharedRedisConnectionConfig>>;
-}
-interface NormalizedQueueDatabaseConnectionConfig {
-    readonly name: string;
-    readonly driver: 'database';
-    readonly queue: string;
-    readonly retryAfter: number;
-    readonly sleep: number;
-    readonly connection: string;
-    readonly table: string;
-}
-type NormalizedQueueConnectionConfig = NormalizedQueueSyncConnectionConfig | NormalizedQueueRedisConnectionConfig | NormalizedQueueDatabaseConnectionConfig;
-interface NormalizedHoloQueueConfig {
-    readonly default: string;
-    readonly failed: false | NormalizedQueueFailedStoreConfig;
-    readonly connections: Readonly<Record<string, NormalizedQueueConnectionConfig>>;
-}
-declare const queueJobInternals: {
-    clearQueueJobDefinitionNames: typeof clearQueueJobDefinitionNames;
-    deleteQueueJobDefinitionName: typeof deleteQueueJobDefinitionName;
-    dispatchDefinedQueueJob: typeof dispatchDefinedQueueJob;
-    dispatchDefinedQueueJobSync: typeof dispatchDefinedQueueJobSync;
-    normalizeQueueJobDefinition: typeof normalizeQueueJobDefinition;
-    normalizeBackoff: typeof normalizeBackoff;
-    normalizeOptionalHook: typeof normalizeOptionalHook;
-    normalizeOptionalInteger: typeof normalizeOptionalInteger;
-    normalizeOptionalString: typeof normalizeOptionalString;
-    resolveQueueJobDefinitionName: typeof resolveQueueJobDefinitionName;
-    setQueueJobDefinitionName: typeof setQueueJobDefinitionName;
-    setQueueJobDispatcher: typeof setQueueJobDispatcher;
-    setQueueJobSyncDispatcher: typeof setQueueJobSyncDispatcher;
-};
-
-declare const DEFAULT_QUEUE_CONNECTION = "sync";
-declare const DEFAULT_QUEUE_NAME = "default";
-declare const DEFAULT_QUEUE_RETRY_AFTER = 90;
-declare const DEFAULT_QUEUE_BLOCK_FOR = 5;
-declare const DEFAULT_QUEUE_SLEEP = 1;
-declare const DEFAULT_FAILED_JOBS_CONNECTION = "default";
-declare const DEFAULT_FAILED_JOBS_TABLE = "failed_jobs";
-declare const DEFAULT_DATABASE_QUEUE_TABLE = "jobs";
-declare function parseInteger(value: number | string | undefined, fallback: number, label: string, options?: {
-    minimum?: number;
-}): number;
-declare function normalizeQueueConfig(config?: HoloQueueConfig, redisConfig?: QueueSharedRedisConfig): NormalizedHoloQueueConfig;
-declare const holoQueueDefaults: Readonly<NormalizedHoloQueueConfig>;
-declare const queueInternals: {
-    parseInteger: typeof parseInteger;
-};
+import { Q as QueueRegisteredJob, a as QueueJsonValue, R as RegisterableQueueJobDefinition, b as RegisterQueueJobOptions, c as QueueDriverFactory, N as NormalizedQueueSyncConnectionConfig, d as QueueSyncDriver, e as QueueDriverFactoryContext, f as QueueJobEnvelope, g as QueueDriverDispatchResult, h as QueueConnectionFacade, H as HoloQueueJobRegistry, i as QueuePayloadFor, j as QueueDispatchOptions, k as QueuePendingDispatch, l as QueueResultFor, m as HoloQueueConfig, n as NormalizedHoloQueueConfig, o as QueueSharedRedisConfig, p as QueueFailedJobStore, q as QueueRuntimeBinding, r as QueueDriver, s as QueueJobContextOverrides, t as QueueJobContext, u as QueueDispatchResult, v as QueueDelayValue, w as NormalizedQueueConnectionConfig, x as QueueFailedJobRecord, y as QueueReservedJob, z as QueueClearInput, A as QueueWorkerJobEvent, B as QueueAsyncDriver, C as QueueWorkerRunOptions, D as QueueJobDefinition, E as QueueWorkerOptions, F as QueueWorkerResult } from './config-Bleufve4.js';
+export { G as DEFAULT_DATABASE_QUEUE_TABLE, I as DEFAULT_FAILED_JOBS_CONNECTION, J as DEFAULT_FAILED_JOBS_TABLE, K as DEFAULT_QUEUE_BLOCK_FOR, L as DEFAULT_QUEUE_CONNECTION, M as DEFAULT_QUEUE_NAME, O as DEFAULT_QUEUE_RETRY_AFTER, P as DEFAULT_QUEUE_SLEEP, S as DefinedQueueJobDefinition, T as ExportedQueueJobDefinition, U as NormalizedQueueDatabaseConnectionConfig, V as NormalizedQueueFailedStoreConfig, W as NormalizedQueuePluginConnectionConfig, X as NormalizedQueueRedisConnectionConfig, Y as QueueConnectionConfig, Z as QueueDatabaseConnectionConfig, _ as QueueDispatchCompletedHook, $ as QueueDispatchFailedHook, a0 as QueueEnqueueResult, a1 as QueueFailedStoreConfig, a2 as QueuePluginConnectionConfig, a3 as QueueRedisConnectionConfig, a4 as QueueReleaseOptions, a5 as QueueReserveInput, a6 as QueueSharedRedisConnectionConfig, a7 as QueueSyncConnectionConfig, a8 as QueueWorkerHooks, a9 as defineJob, aa as holoQueueDefaults, ab as isQueueJobDefinition, ac as normalizeQueueConfig, ad as normalizeQueueJobDefinition, ae as queueInternals, af as queueJobInternals } from './config-Bleufve4.js';
 
 declare function deriveJobNameFromSourcePath(sourcePath: string): string;
 declare function registerQueueJob<TPayload extends QueueJsonValue, TResult>(definition: RegisterableQueueJobDefinition<TPayload, TResult>, options?: RegisterQueueJobOptions): QueueRegisteredJob<TPayload, TResult>;
@@ -385,67 +15,6 @@ declare const queueRegistryInternals: {
     deriveJobNameFromSourcePath: typeof deriveJobNameFromSourcePath;
 };
 
-type RedisDriverModule = {
-    redisQueueDriverFactory: QueueDriverFactory<NormalizedQueueRedisConnectionConfig>;
-};
-type RedisQueuedEnvelope = QueueJobEnvelope<QueueJsonValue>;
-declare function loadRedisDriverModule(): Promise<RedisDriverModule>;
-declare function normalizeRedisErrorMessage(error: unknown): string;
-declare function isQueueEnvelope(value: unknown): value is RedisQueuedEnvelope;
-type RedisConnectionOptions = {
-    url?: string;
-    clusters?: readonly {
-        readonly url?: string;
-        readonly host: string;
-        readonly port: number;
-    }[];
-    host?: string;
-    port?: number;
-    path?: string;
-    username?: string;
-    password?: string;
-    db: number;
-    maxRetriesPerRequest: null;
-};
-declare function toRedisSocketPath(value: string): string;
-declare function resolveBullConnectionOptions(connection: NormalizedQueueRedisConnectionConfig): RedisConnectionOptions;
-declare class RedisQueueDriverError extends Error {
-    constructor(connectionName: string, action: string, cause: unknown);
-}
-declare function wrapRedisError(connectionName: string, action: string, error: unknown): RedisQueueDriverError;
-declare function resolveAttempts(job: {
-    attemptsStarted?: number;
-    attemptsMade?: number;
-}): number;
-declare class RedisQueueDriver implements QueueAsyncDriver {
-    private readonly connection;
-    private readonly context;
-    readonly name: string;
-    readonly driver: "redis";
-    readonly mode: "async";
-    private driverInstance?;
-    private pending?;
-    constructor(connection: NormalizedQueueRedisConnectionConfig, context: QueueDriverFactoryContext);
-    private resolveDriver;
-    dispatch<TPayload extends QueueJsonValue = QueueJsonValue, TResult = unknown>(job: QueueJobEnvelope<TPayload>): Promise<QueueDriverDispatchResult<TResult>>;
-    reserve<TPayload extends QueueJsonValue = QueueJsonValue>(input: Parameters<QueueAsyncDriver['reserve']>[0]): Promise<QueueReservedJob<TPayload> | null>;
-    acknowledge(job: QueueReservedJob): Promise<void>;
-    release(job: QueueReservedJob, options?: QueueReleaseOptions): Promise<void>;
-    delete(job: QueueReservedJob): Promise<void>;
-    clear(input?: Parameters<QueueAsyncDriver['clear']>[0]): Promise<number>;
-    close(): Promise<void>;
-}
-declare const redisQueueDriverFactory: QueueDriverFactory<NormalizedQueueRedisConnectionConfig>;
-declare const redisQueueDriverInternals: {
-    isQueueEnvelope: typeof isQueueEnvelope;
-    loadRedisDriverModule: typeof loadRedisDriverModule;
-    normalizeRedisErrorMessage: typeof normalizeRedisErrorMessage;
-    resolveAttempts: typeof resolveAttempts;
-    resolveBullConnectionOptions: typeof resolveBullConnectionOptions;
-    toRedisSocketPath: typeof toRedisSocketPath;
-    wrapRedisError: typeof wrapRedisError;
-};
-
 declare class SyncQueueDriver implements QueueSyncDriver {
     readonly name: string;
     readonly driver: "sync";
@@ -497,6 +66,7 @@ declare function executeRegisteredQueueJobFailedHook<TPayload extends QueueJsonV
 declare function dispatchThroughDriver(driver: QueueDriver, envelope: QueueJobEnvelope): Promise<Awaited<ReturnType<QueueDriver['dispatch']>>>;
 declare function createQueueDriverFactoryContext(): QueueDriverFactoryContext;
 declare function resolveDriverFactory(state: RuntimeQueueState, connection: NormalizedQueueConnectionConfig): QueueDriverFactory;
+declare function loadQueuePluginDrivers(projectRoot?: string, pluginNames?: readonly string[]): Promise<void>;
 declare function resolveConnectionDriver(connectionName?: string): QueueDriver;
 declare function resolveSyncExecutionDriver(): QueueDriver;
 declare function createJobEnvelope<TPayload extends QueueJsonValue>(jobName: string, payload: TPayload, options: QueueDispatchOptions): QueueJobEnvelope<TPayload>;
@@ -550,6 +120,9 @@ declare const queueRuntimeInternals: {
 };
 declare function closeQueueDrivers(drivers: Iterable<QueueDriver>): Promise<void>;
 
+declare function loadQueuePluginDriverFactories(projectRoot?: string, pluginNames?: readonly string[]): Promise<readonly QueueDriverFactory[]>;
+declare function resetQueuePluginDriverFactories(): void;
+
 declare function normalizeFailedStoreErrorMessage(error: unknown): string;
 declare class QueueFailedStoreError extends Error {
     constructor(action: string, cause: unknown);
@@ -629,4 +202,4 @@ declare const queueWorkerInternals: {
 
 declare function defineQueueConfig<TConfig extends HoloQueueConfig>(config: TConfig): Readonly<TConfig>;
 
-export { DEFAULT_DATABASE_QUEUE_TABLE, DEFAULT_FAILED_JOBS_CONNECTION, DEFAULT_FAILED_JOBS_TABLE, DEFAULT_QUEUE_BLOCK_FOR, DEFAULT_QUEUE_CONNECTION, DEFAULT_QUEUE_NAME, DEFAULT_QUEUE_RETRY_AFTER, DEFAULT_QUEUE_SLEEP, type DefinedQueueJobDefinition, type ExportedQueueJobDefinition, type HoloQueueConfig, type HoloQueueJobRegistry, type NormalizedHoloQueueConfig, type NormalizedQueueConnectionConfig, type NormalizedQueueDatabaseConnectionConfig, type NormalizedQueueFailedStoreConfig, type NormalizedQueueRedisConnectionConfig, type NormalizedQueueSyncConnectionConfig, Queue, type QueueAsyncDriver, type QueueClearInput, type QueueConnectionConfig, type QueueConnectionFacade, type QueueDatabaseConnectionConfig, type QueueDelayValue, type QueueDispatchCompletedHook, type QueueDispatchFailedHook, type QueueDispatchOptions, type QueueDispatchResult, type QueueDriver, type QueueDriverDispatchResult, type QueueDriverFactory, type QueueDriverFactoryContext, type QueueEnqueueResult, type QueueFailedJobRecord, type QueueFailedJobStore, type QueueFailedStoreConfig, QueueFailedStoreError, type QueueJobContext, type QueueJobContextOverrides, type QueueJobDefinition, type QueueJobEnvelope, type QueueJsonValue, type QueuePayloadFor, type QueuePendingDispatch, type QueueRedisConnectionConfig, type QueueRegisteredJob, type QueueReleaseOptions, QueueReleaseUnsupportedError, type QueueReserveInput, type QueueReservedJob, type QueueResultFor, type QueueRuntimeBinding, type QueueSharedRedisConfig, type QueueSharedRedisConnectionConfig, type QueueSyncConnectionConfig, type QueueSyncDriver, type QueueWorkerHooks, type QueueWorkerJobEvent, type QueueWorkerOptions, type QueueWorkerResult, type QueueWorkerRunOptions, QueueWorkerTimeoutError, QueueWorkerUnsupportedDriverError, RedisQueueDriver, RedisQueueDriverError, type RegisterQueueJobOptions, type RegisterableQueueJobDefinition, clearQueueConnection, configureQueueRuntime, defineJob, defineQueueConfig, dispatch, dispatchSync, flushFailedQueueJobs, forgetFailedQueueJob, getQueueRuntime, getRegisteredQueueJob, holoQueueDefaults, isQueueJobDefinition, listFailedQueueJobs, listRegisteredQueueJobs, normalizeQueueConfig, normalizeQueueJobDefinition, persistFailedQueueJob, queueFailedInternals, queueInternals, queueJobInternals, queueRegistryInternals, queueRuntimeInternals, queueWorkerInternals, redisQueueDriverFactory, redisQueueDriverInternals, registerQueueJob, registerQueueJobs, resetQueueRegistry, resetQueueRuntime, retryFailedQueueJobs, runQueueWorker, shutdownQueueRuntime, syncQueueDriverFactory, syncQueueDriverInternals, unregisterQueueJob, useQueueConnection };
+export { HoloQueueConfig, HoloQueueJobRegistry, NormalizedHoloQueueConfig, NormalizedQueueConnectionConfig, NormalizedQueueSyncConnectionConfig, Queue, QueueAsyncDriver, QueueClearInput, QueueConnectionFacade, QueueDelayValue, QueueDispatchOptions, QueueDispatchResult, QueueDriver, QueueDriverDispatchResult, QueueDriverFactory, QueueDriverFactoryContext, QueueFailedJobRecord, QueueFailedJobStore, QueueFailedStoreError, QueueJobContext, QueueJobContextOverrides, QueueJobDefinition, QueueJobEnvelope, QueueJsonValue, QueuePayloadFor, QueuePendingDispatch, QueueRegisteredJob, QueueReleaseUnsupportedError, QueueReservedJob, QueueResultFor, QueueRuntimeBinding, QueueSharedRedisConfig, QueueSyncDriver, QueueWorkerJobEvent, QueueWorkerOptions, QueueWorkerResult, QueueWorkerRunOptions, QueueWorkerTimeoutError, QueueWorkerUnsupportedDriverError, RegisterQueueJobOptions, RegisterableQueueJobDefinition, clearQueueConnection, configureQueueRuntime, defineQueueConfig, dispatch, dispatchSync, flushFailedQueueJobs, forgetFailedQueueJob, getQueueRuntime, getRegisteredQueueJob, listFailedQueueJobs, listRegisteredQueueJobs, loadQueuePluginDriverFactories, loadQueuePluginDrivers, persistFailedQueueJob, queueFailedInternals, queueRegistryInternals, queueRuntimeInternals, queueWorkerInternals, registerQueueJob, registerQueueJobs, resetQueuePluginDriverFactories, resetQueueRegistry, resetQueueRuntime, retryFailedQueueJobs, runQueueWorker, shutdownQueueRuntime, syncQueueDriverFactory, syncQueueDriverInternals, unregisterQueueJob, useQueueConnection };