@holo-js/queue 0.2.6 → 0.3.1

package/dist/index.mjs

@@ -1,3 +1,17 @@
+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,
+  holoQueueDefaults,
+  normalizeQueueConfig,
+  queueInternals
+} from "./chunk-5MPOVBVE.mjs";
+
 // src/contracts.ts
 function getQueueJobDispatcher() {
   return globalThis.__holoQueueJobDispatcher__;
@@ -229,247 +243,6 @@ var queueJobInternals = {
   setQueueJobSyncDispatcher
 };
 
-// src/config.ts
-var DEFAULT_QUEUE_CONNECTION = "sync";
-var DEFAULT_QUEUE_NAME = "default";
-var DEFAULT_QUEUE_RETRY_AFTER = 90;
-var DEFAULT_QUEUE_BLOCK_FOR = 5;
-var DEFAULT_QUEUE_SLEEP = 1;
-var DEFAULT_FAILED_JOBS_CONNECTION = "default";
-var DEFAULT_FAILED_JOBS_TABLE = "failed_jobs";
-var DEFAULT_DATABASE_QUEUE_TABLE = "jobs";
-var DEFAULT_REDIS_HOST = "127.0.0.1";
-var DEFAULT_REDIS_PORT = 6379;
-var DEFAULT_REDIS_DB = 0;
-var DEFAULT_QUEUE_CONFIG = Object.freeze({
-  default: DEFAULT_QUEUE_CONNECTION,
-  failed: Object.freeze({
-    driver: "database",
-    connection: DEFAULT_FAILED_JOBS_CONNECTION,
-    table: DEFAULT_FAILED_JOBS_TABLE
-  }),
-  connections: Object.freeze({
-    [DEFAULT_QUEUE_CONNECTION]: Object.freeze({
-      name: DEFAULT_QUEUE_CONNECTION,
-      driver: "sync",
-      queue: DEFAULT_QUEUE_NAME
-    })
-  })
-});
-function parseInteger(value, fallback, label, options = {}) {
-  if (typeof value === "undefined") {
-    return fallback;
-  }
-  const normalized = typeof value === "number" ? value : value.trim();
-  if (typeof normalized === "string" && !/^[+-]?\d+$/.test(normalized)) {
-    throw new Error(`[Holo Queue] ${label} must be an integer.`);
-  }
-  const integer = typeof normalized === "number" ? normalized : Number(normalized);
-  if (!Number.isInteger(integer)) {
-    throw new Error(`[Holo Queue] ${label} must be an integer.`);
-  }
-  if (typeof options.minimum === "number" && integer < options.minimum) {
-    throw new Error(`[Holo Queue] ${label} must be greater than or equal to ${options.minimum}.`);
-  }
-  return integer;
-}
-function normalizeConnectionName(value, label) {
-  const normalized = value?.trim();
-  if (!normalized) {
-    throw new Error(`[Holo Queue] ${label} must be a non-empty string.`);
-  }
-  return normalized;
-}
-function normalizeQueueName(value) {
-  return value?.trim() || DEFAULT_QUEUE_NAME;
-}
-function normalizeOptionalRedisString(value) {
-  return value?.trim() || void 0;
-}
-function normalizeSyncConnection(name, config) {
-  return Object.freeze({
-    name,
-    driver: "sync",
-    queue: normalizeQueueName(config.queue)
-  });
-}
-function resolveSharedRedisConnection(redisConfig, connectionName) {
-  const resolvedConnection = redisConfig.connections[connectionName];
-  if (!resolvedConnection) {
-    const availableConnections = Object.keys(redisConfig.connections);
-    throw new Error(
-      `[Holo Queue] Queue Redis connection "${connectionName}" was not found in shared Redis config. Available connections: ${availableConnections.join(", ") || "(none)"}.`
-    );
-  }
-  return resolvedConnection;
-}
-function parseRedisDatabaseFromUrl(url, label) {
-  if (typeof url === "undefined") {
-    return void 0;
-  }
-  let parsed;
-  try {
-    parsed = new URL(url);
-  } catch (error) {
-    throw new Error(`[Holo Queue] ${label} is invalid: ${String(error)}`);
-  }
-  if (parsed.protocol !== "redis:" && parsed.protocol !== "rediss:") {
-    throw new Error(`[Holo Queue] ${label} is invalid: unsupported protocol "${parsed.protocol}".`);
-  }
-  const pathname = parsed.pathname.replace(/^\/+/, "");
-  if (!pathname) {
-    return void 0;
-  }
-  const [databaseSegment] = pathname.split("/");
-  if (!databaseSegment || !/^\d+$/.test(databaseSegment) || pathname !== databaseSegment) {
-    throw new Error(`[Holo Queue] ${label} must include at most one integer database path segment.`);
-  }
-  return Number(databaseSegment);
-}
-function normalizeRedisClusterNodes(connectionName, nodes) {
-  if (!nodes || nodes.length === 0) {
-    return void 0;
-  }
-  return Object.freeze(nodes.map((node, index) => {
-    const label = `queue connection "${connectionName}" redis cluster node ${index + 1}`;
-    const url = normalizeOptionalRedisString(node.url);
-    if (typeof url !== "undefined") {
-      const database = parseRedisDatabaseFromUrl(url, `${label} url`);
-      if (typeof database !== "undefined") {
-        throw new Error(`[Holo Queue] ${label} url cannot include a database path in cluster mode.`);
-      }
-    }
-    return Object.freeze({
-      ...typeof url === "undefined" ? {} : { url },
-      host: normalizeOptionalRedisString(node.host) ?? DEFAULT_REDIS_HOST,
-      port: parseInteger(node.port, DEFAULT_REDIS_PORT, `${label} port`, {
-        minimum: 1
-      })
-    });
-  }));
-}
-function normalizeRedisOptions(connectionName, base, overrides) {
-  const hasTargetOverride = typeof overrides?.url !== "undefined" || typeof overrides?.clusters !== "undefined" || typeof overrides?.host !== "undefined" || typeof overrides?.port !== "undefined";
-  const url = normalizeOptionalRedisString(overrides?.url) ?? (hasTargetOverride ? void 0 : base?.url);
-  const clusters = typeof overrides?.clusters === "undefined" ? hasTargetOverride ? void 0 : base?.clusters : normalizeRedisClusterNodes(connectionName, overrides.clusters);
-  const dbFromUrl = parseRedisDatabaseFromUrl(url, `queue connection "${connectionName}" redis url`);
-  const db = parseInteger(overrides?.db ?? base?.db ?? dbFromUrl, DEFAULT_REDIS_DB, `queue connection "${connectionName}" redis db`, {
-    minimum: 0
-  });
-  if (typeof clusters !== "undefined" && db !== 0) {
-    throw new Error(`[Holo Queue] queue connection "${connectionName}" cannot select redis.db=${db} in cluster mode; Redis Cluster only supports database 0.`);
-  }
-  return Object.freeze({
-    ...typeof url === "undefined" ? {} : { url },
-    ...typeof clusters === "undefined" ? {} : { clusters },
-    host: normalizeOptionalRedisString(overrides?.host) ?? base?.host ?? DEFAULT_REDIS_HOST,
-    port: parseInteger(overrides?.port ?? base?.port, DEFAULT_REDIS_PORT, `queue connection "${connectionName}" redis port`, {
-      minimum: 1
-    }),
-    password: normalizeOptionalRedisString(overrides?.password) ?? base?.password,
-    username: normalizeOptionalRedisString(overrides?.username) ?? base?.username,
-    db
-  });
-}
-function normalizeRedisConnection(name, config, redisConfig) {
-  const explicitConnectionName = config.connection?.trim();
-  const connectionName = explicitConnectionName || redisConfig?.default;
-  if (!connectionName && !config.redis) {
-    throw new Error(
-      `[Holo Queue] Queue Redis connection "${name}" requires a shared Redis config with a default connection or an explicit connection name.`
-    );
-  }
-  if (!redisConfig && !config.redis) {
-    throw new Error(
-      `[Holo Queue] Queue Redis connection "${name}" references shared Redis connection "${connectionName}" but no shared Redis config was provided.`
-    );
-  }
-  const resolvedRedisConnection = redisConfig && connectionName ? resolveSharedRedisConnection(redisConfig, connectionName) : void 0;
-  return Object.freeze({
-    name,
-    driver: "redis",
-    connection: resolvedRedisConnection?.name ?? connectionName ?? name,
-    queue: normalizeQueueName(config.queue),
-    retryAfter: parseInteger(config.retryAfter, DEFAULT_QUEUE_RETRY_AFTER, `queue connection "${name}" retryAfter`, {
-      minimum: 0
-    }),
-    blockFor: parseInteger(config.blockFor, DEFAULT_QUEUE_BLOCK_FOR, `queue connection "${name}" blockFor`, {
-      minimum: 0
-    }),
-    redis: normalizeRedisOptions(name, resolvedRedisConnection, config.redis)
-  });
-}
-function normalizeDatabaseConnection(name, config) {
-  return Object.freeze({
-    name,
-    driver: "database",
-    queue: normalizeQueueName(config.queue),
-    retryAfter: parseInteger(config.retryAfter, DEFAULT_QUEUE_RETRY_AFTER, `queue connection "${name}" retryAfter`, {
-      minimum: 0
-    }),
-    sleep: parseInteger(config.sleep, DEFAULT_QUEUE_SLEEP, `queue connection "${name}" sleep`, {
-      minimum: 0
-    }),
-    connection: config.connection?.trim() || DEFAULT_FAILED_JOBS_CONNECTION,
-    table: config.table?.trim() || DEFAULT_DATABASE_QUEUE_TABLE
-  });
-}
-function normalizeConnectionConfig(name, config, redisConfig) {
-  switch (config.driver) {
-    case "sync":
-      return normalizeSyncConnection(name, config);
-    case "redis":
-      return normalizeRedisConnection(name, config, redisConfig);
-    case "database":
-      return normalizeDatabaseConnection(name, config);
-    default:
-      throw new Error(`[Holo Queue] Unsupported queue driver "${String(config.driver)}" on connection "${name}".`);
-  }
-}
-function normalizeConnections(connections, redisConfig) {
-  if (!connections || Object.keys(connections).length === 0) {
-    return DEFAULT_QUEUE_CONFIG.connections;
-  }
-  const normalizedEntries = Object.entries(connections).map(([name, config]) => {
-    const normalizedName = normalizeConnectionName(name, "Queue connection name");
-    return [normalizedName, normalizeConnectionConfig(normalizedName, config, redisConfig)];
-  });
-  return Object.freeze(Object.fromEntries(normalizedEntries));
-}
-function normalizeFailedStore(config) {
-  if (config === false) {
-    return false;
-  }
-  const normalized = config ?? DEFAULT_QUEUE_CONFIG.failed;
-  if (normalized.driver && normalized.driver !== "database") {
-    throw new Error(`[Holo Queue] Unsupported failed job store driver "${normalized.driver}".`);
-  }
-  return Object.freeze({
-    driver: "database",
-    connection: normalized.connection?.trim() || DEFAULT_FAILED_JOBS_CONNECTION,
-    table: normalized.table?.trim() || DEFAULT_FAILED_JOBS_TABLE
-  });
-}
-function normalizeQueueConfig(config = {}, redisConfig) {
-  const connections = normalizeConnections(config.connections, redisConfig);
-  const connectionNames = Object.keys(connections);
-  const defaultConnection = config.default?.trim() || connectionNames[0];
-  if (!connections[defaultConnection]) {
-    throw new Error(
-      `[Holo Queue] default queue connection "${defaultConnection}" is not configured. Available connections: ${connectionNames.join(", ")}`
-    );
-  }
-  return Object.freeze({
-    default: defaultConnection,
-    failed: normalizeFailedStore(config.failed),
-    connections
-  });
-}
-var holoQueueDefaults = DEFAULT_QUEUE_CONFIG;
-var queueInternals = {
-  parseInteger
-};
-
 // src/registry.ts
 function toPosixPath(value) {
   return value.replaceAll("\\", "/");
@@ -544,149 +317,6 @@ var queueRegistryInternals = {
   deriveJobNameFromSourcePath
 };
 
-// src/drivers/redis.ts
-function isModuleNotFoundError(error) {
-  return !!error && typeof error === "object" && "code" in error && error.code === "ERR_MODULE_NOT_FOUND";
-}
-async function loadRedisDriverModule() {
-  try {
-    const specifier = "@holo-js/queue-redis";
-    return await import(
-      /* @vite-ignore */
-      specifier
-    );
-  } catch (error) {
-    if (isModuleNotFoundError(error)) {
-      throw new Error("[@holo-js/queue] Redis queue support requires @holo-js/queue-redis to be installed.", {
-        cause: error
-      });
-    }
-    throw error;
-  }
-}
-function normalizeRedisErrorMessage(error) {
-  if (error instanceof Error) {
-    return error.message;
-  }
-  return String(error);
-}
-function isRecord(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-function isQueueEnvelope(value) {
-  return isRecord(value) && typeof value.id === "string" && typeof value.name === "string" && typeof value.connection === "string" && typeof value.queue === "string" && "payload" in value && typeof value.attempts === "number" && Number.isInteger(value.attempts) && value.attempts >= 0 && typeof value.maxAttempts === "number" && Number.isInteger(value.maxAttempts) && value.maxAttempts >= 1 && typeof value.createdAt === "number" && Number.isFinite(value.createdAt) && (typeof value.availableAt === "undefined" || typeof value.availableAt === "number" && Number.isFinite(value.availableAt));
-}
-function isRedisSocketConnectionTarget(value) {
-  return value.startsWith("unix://") || value.startsWith("/");
-}
-function toRedisSocketPath(value) {
-  return value.startsWith("unix://") ? value.slice("unix://".length) : value;
-}
-function resolveBullConnectionOptions(connection) {
-  const redisHost = connection.redis.host;
-  return {
-    ...typeof connection.redis.url === "string" ? { url: connection.redis.url } : connection.redis.clusters && connection.redis.clusters.length > 0 ? { clusters: connection.redis.clusters } : typeof redisHost === "string" && isRedisSocketConnectionTarget(redisHost) ? { path: toRedisSocketPath(redisHost) } : {
-      host: redisHost,
-      port: connection.redis.port
-    },
-    username: connection.redis.username,
-    password: connection.redis.password,
-    db: connection.redis.db,
-    maxRetriesPerRequest: null
-  };
-}
-var RedisQueueDriverError = class extends Error {
-  constructor(connectionName, action, cause) {
-    super(
-      `[Holo Queue] Redis queue connection "${connectionName}" failed to ${action}: ${normalizeRedisErrorMessage(cause)}`,
-      { cause }
-    );
-    this.name = "RedisQueueDriverError";
-  }
-};
-function wrapRedisError(connectionName, action, error) {
-  if (error instanceof RedisQueueDriverError) {
-    return error;
-  }
-  return new RedisQueueDriverError(connectionName, action, error);
-}
-function resolveAttempts(job) {
-  const attemptsStarted = typeof job.attemptsStarted === "number" && Number.isInteger(job.attemptsStarted) ? job.attemptsStarted : 0;
-  const attemptsMade = typeof job.attemptsMade === "number" && Number.isInteger(job.attemptsMade) ? job.attemptsMade : 0;
-  return Math.max(
-    attemptsStarted > 0 ? attemptsStarted - 1 : 0,
-    attemptsMade,
-    0
-  );
-}
-var RedisQueueDriver = class {
-  constructor(connection, context) {
-    this.connection = connection;
-    this.context = context;
-    this.name = connection.name;
-  }
-  name;
-  driver = "redis";
-  mode = "async";
-  driverInstance;
-  pending;
-  async resolveDriver() {
-    if (this.driverInstance) {
-      return this.driverInstance;
-    }
-    this.pending ??= loadRedisDriverModule().then((module) => {
-      const driver = module.redisQueueDriverFactory.create(this.connection, this.context);
-      if (driver.mode !== "async") {
-        throw new Error("[Holo Queue] Redis queue driver must be async.");
-      }
-      this.driverInstance = driver;
-      return driver;
-    }).finally(() => {
-      this.pending = void 0;
-    });
-    return this.pending;
-  }
-  async dispatch(job) {
-    return (await this.resolveDriver()).dispatch(job);
-  }
-  async reserve(input) {
-    return (await this.resolveDriver()).reserve(input);
-  }
-  async acknowledge(job) {
-    await (await this.resolveDriver()).acknowledge(job);
-  }
-  async release(job, options) {
-    await (await this.resolveDriver()).release(job, options);
-  }
-  async delete(job) {
-    await (await this.resolveDriver()).delete(job);
-  }
-  async clear(input) {
-    return (await this.resolveDriver()).clear(input);
-  }
-  async close() {
-    if (!this.driverInstance && !this.pending) {
-      return;
-    }
-    await (await this.resolveDriver()).close();
-  }
-};
-var redisQueueDriverFactory = {
-  driver: "redis",
-  create(connection, context) {
-    return new RedisQueueDriver(connection, context);
-  }
-};
-var redisQueueDriverInternals = {
-  isQueueEnvelope,
-  loadRedisDriverModule,
-  normalizeRedisErrorMessage,
-  resolveAttempts,
-  resolveBullConnectionOptions,
-  toRedisSocketPath,
-  wrapRedisError
-};
-
 // src/drivers/sync.ts
 var SyncQueueDriver = class {
   name;
@@ -723,6 +353,57 @@ var syncQueueDriverInternals = {
 
 // src/runtime.ts
 import { randomUUID } from "crypto";
+
+// src/plugins.ts
+import { resolve } from "path";
+import {
+  loadHoloPluginContributionModules,
+  loadHoloPluginDefinitions
+} from "@holo-js/kernel";
+var loadedFactoriesByProjectRoot = /* @__PURE__ */ new Map();
+var failedLoadsByProjectRoot = /* @__PURE__ */ new Map();
+function isRecord(value) {
+  return !!value && typeof value === "object" && !Array.isArray(value);
+}
+function resolveQueueDriverFactory(moduleValue, packageName, driverName) {
+  const candidate = isRecord(moduleValue) && typeof moduleValue.default !== "undefined" ? moduleValue.default : isRecord(moduleValue) && typeof moduleValue.factory !== "undefined" ? moduleValue.factory : moduleValue;
+  if (!isRecord(candidate) || candidate.driver !== driverName || typeof candidate.create !== "function") {
+    throw new Error(`[@holo-js/queue] Plugin ${packageName} queue driver "${driverName}" must export a matching QueueDriverFactory.`);
+  }
+  return candidate;
+}
+async function loadQueuePluginDriverFactories(projectRoot = process.cwd(), pluginNames = []) {
+  const root = resolve(projectRoot);
+  const cacheKey = `${root}\0${[...pluginNames].sort().join("\0")}`;
+  const loadedFactories = loadedFactoriesByProjectRoot.get(cacheKey);
+  if (loadedFactories) {
+    return loadedFactories;
+  }
+  if (failedLoadsByProjectRoot.has(cacheKey)) {
+    throw failedLoadsByProjectRoot.get(cacheKey);
+  }
+  const plugins = await loadHoloPluginDefinitions(root, pluginNames);
+  const contributions = await loadHoloPluginContributionModules(root, plugins, "queue", "drivers");
+  let factories;
+  try {
+    factories = Object.freeze(contributions.map((contribution) => resolveQueueDriverFactory(
+      contribution.module,
+      contribution.plugin.packageName,
+      contribution.name
+    )));
+  } catch (error) {
+    failedLoadsByProjectRoot.set(cacheKey, error);
+    throw error;
+  }
+  loadedFactoriesByProjectRoot.set(cacheKey, factories);
+  return factories;
+}
+function resetQueuePluginDriverFactories() {
+  loadedFactoriesByProjectRoot.clear();
+  failedLoadsByProjectRoot.clear();
+}
+
+// src/runtime.ts
 var INLINE_SYNC_DRIVER_KEY = "__inline_sync__";
 var QueueReleaseUnsupportedError = class extends Error {
   constructor() {
@@ -775,14 +456,14 @@ function assertQueueJsonValue(value, path, state) {
 function validateQueuePayload(payload) {
   assertQueueJsonValue(payload, "payload", { seen: /* @__PURE__ */ new Set() });
 }
-function normalizeConnectionName2(name) {
+function normalizeConnectionName(name) {
   const normalized = name.trim();
   if (!normalized) {
     throw new Error("[Holo Queue] Queue connection names must be non-empty strings.");
   }
   return normalized;
 }
-function normalizeQueueName2(name) {
+function normalizeQueueName(name) {
   const normalized = name.trim();
   if (!normalized) {
     throw new Error("[Holo Queue] Queue names must be non-empty strings.");
@@ -824,7 +505,6 @@ function normalizeDelay(delay) {
 }
 function createDefaultDriverFactories() {
   return /* @__PURE__ */ new Map([
-    [redisQueueDriverFactory.driver, redisQueueDriverFactory],
     [syncQueueDriverFactory.driver, syncQueueDriverFactory]
   ]);
 }
@@ -868,7 +548,7 @@ function requireRegisteredQueueJob(jobName) {
   return registered;
 }
 function resolveConnectionConfig(config, requestedConnection) {
-  const connectionName = requestedConnection ? normalizeConnectionName2(requestedConnection) : config.default;
+  const connectionName = requestedConnection ? normalizeConnectionName(requestedConnection) : config.default;
   const connection = config.connections[connectionName];
   if (!connection) {
     throw new Error(
@@ -975,6 +655,29 @@ function resolveDriverFactory(state, connection) {
   }
   return factory;
 }
+async function clearCachedDriversForFactoryNames(state, driverNames) {
+  const staleDrivers = [];
+  for (const [connectionName, driver] of state.drivers.entries()) {
+    const connection = state.config.connections[connectionName];
+    const driverName = connection?.driver ?? driver.driver;
+    if (driverNames.has(driverName)) {
+      staleDrivers.push(driver);
+      state.drivers.delete(connectionName);
+    }
+  }
+  await closeQueueDrivers(staleDrivers);
+}
+async function loadQueuePluginDrivers(projectRoot = process.cwd(), pluginNames = []) {
+  const state = getQueueRuntimeState();
+  const loadedDriverNames = /* @__PURE__ */ new Set();
+  for (const factory of await loadQueuePluginDriverFactories(projectRoot, pluginNames)) {
+    state.driverFactories.set(factory.driver, factory);
+    loadedDriverNames.add(factory.driver);
+  }
+  if (loadedDriverNames.size > 0) {
+    await clearCachedDriversForFactoryNames(state, loadedDriverNames);
+  }
+}
 function resolveConnectionDriver(connectionName) {
   const state = getQueueRuntimeState();
   const connection = resolveConnectionConfig(state.config, connectionName);
@@ -1010,7 +713,7 @@ function createJobEnvelope(jobName, payload, options) {
     runtime.config,
     options.connection ?? registered.definition.connection
   );
-  const queue = normalizeQueueName2(options.queue ?? registered.definition.queue ?? connection.queue ?? DEFAULT_QUEUE_NAME);
+  const queue = normalizeQueueName(options.queue ?? registered.definition.queue ?? connection.queue ?? DEFAULT_QUEUE_NAME);
   return Object.freeze({
     id: randomUUID(),
     name: registered.name,
@@ -1054,13 +757,13 @@ var PendingQueueDispatch = class _PendingQueueDispatch {
   onConnection(name) {
     return new _PendingQueueDispatch(this.jobName, this.payload, {
       ...this.options,
-      connection: normalizeConnectionName2(name)
+      connection: normalizeConnectionName(name)
     }, this.completedHooks, this.failedHooks);
   }
   onQueue(name) {
     return new _PendingQueueDispatch(this.jobName, this.payload, {
       ...this.options,
-      queue: normalizeQueueName2(name)
+      queue: normalizeQueueName(name)
     }, this.completedHooks, this.failedHooks);
   }
   delay(value) {
@@ -1130,7 +833,7 @@ var PendingQueueDispatch = class _PendingQueueDispatch {
   }
 };
 function createQueueConnection(name) {
-  const resolvedName = name ? normalizeConnectionName2(name) : getQueueRuntimeState().config.default;
+  const resolvedName = name ? normalizeConnectionName(name) : getQueueRuntimeState().config.default;
   const dispatchViaConnection = ((jobName, payload, options = {}) => {
     return new PendingQueueDispatch(jobName, payload, {
       ...options,
@@ -1182,6 +885,7 @@ function resetQueueRuntime() {
   const state = getQueueRuntimeState();
   void closeQueueDrivers(state.drivers.values());
   resetQueueRuntimeState(state);
+  resetQueuePluginDriverFactories();
 }
 function getQueueRuntime() {
   return createQueueRuntimeBinding(getQueueRuntimeState());
@@ -1232,9 +936,9 @@ var queueRuntimeInternals = {
   executeRegisteredQueueJobFailedHook,
   getQueueRuntimeState,
   isPlainObject,
-  normalizeConnectionName: normalizeConnectionName2,
+  normalizeConnectionName,
   normalizeDelay,
-  normalizeQueueName: normalizeQueueName2,
+  normalizeQueueName,
   resolveConnectionConfig,
   resolveConnectionDriver,
   resolveDriverFactory,
@@ -1368,7 +1072,7 @@ var QueueWorkerTimeoutError = class extends Error {
   }
 };
 function sleep(milliseconds) {
-  return new Promise((resolve) => setTimeout(resolve, milliseconds));
+  return new Promise((resolve2) => setTimeout(resolve2, milliseconds));
 }
 function requireAsyncDriver(driver, connectionName) {
   if (driver.mode !== "async") {
@@ -1759,8 +1463,6 @@ export {
   QueueReleaseUnsupportedError,
   QueueWorkerTimeoutError,
   QueueWorkerUnsupportedDriverError,
-  RedisQueueDriver,
-  RedisQueueDriverError,
   clearQueueConnection,
   configureQueueRuntime,
   defineJob,
@@ -1775,6 +1477,8 @@ export {
   isQueueJobDefinition,
   listFailedQueueJobs,
   listRegisteredQueueJobs,
+  loadQueuePluginDriverFactories,
+  loadQueuePluginDrivers,
   normalizeQueueConfig,
   normalizeQueueJobDefinition,
   persistFailedQueueJob,
@@ -1784,10 +1488,9 @@ export {
   queueRegistryInternals,
   queueRuntimeInternals,
   queueWorkerInternals,
-  redisQueueDriverFactory,
-  redisQueueDriverInternals,
   registerQueueJob,
   registerQueueJobs,
+  resetQueuePluginDriverFactories,
   resetQueueRegistry,
   resetQueueRuntime,
   retryFailedQueueJobs,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@holo-js/queue",
-  "version": "0.2.6",
+  "version": "0.3.1",
   "description": "Holo-JS Framework - queue contracts and config helpers",
   "type": "module",
   "license": "MIT",
@@ -9,6 +9,11 @@
       "types": "./dist/index.d.ts",
       "import": "./dist/index.mjs",
       "default": "./dist/index.mjs"
+    },
+    "./config": {
+      "types": "./dist/config.d.ts",
+      "import": "./dist/config.mjs",
+      "default": "./dist/config.mjs"
     }
   },
   "main": "./dist/index.mjs",
@@ -22,16 +27,11 @@
     "typecheck": "tsc -p tsconfig.json --noEmit",
     "test": "vitest --run"
   },
-  "peerDependencies": {
-    "@holo-js/queue-redis": "^0.2.6"
-  },
-  "peerDependenciesMeta": {
-    "@holo-js/queue-redis": {
-      "optional": true
-    }
+  "dependencies": {
+    "@holo-js/config": "^0.3.1",
+    "@holo-js/kernel": "^0.3.1"
   },
   "devDependencies": {
-    "@holo-js/queue-redis": "^0.2.6",
     "@types/node": "^22.10.2",
     "tsup": "^8.3.5",
     "typescript": "^5.7.2",