@zintrust/workers 0.1.29 → 0.1.30

package/dist/ui/router/ui.js

@@ -1,8 +1,59 @@
-import { Logger, MIME_TYPES, NodeSingletons, Router } from '@zintrust/core';
+import { Cloudflare, Logger, MIME_TYPES, NodeSingletons, Router, detectRuntime, } from '@zintrust/core';
+import { INDEX_HTML, MAIN_JS, STYLES_CSS, ZINTRUST_SVG } from './EmbeddedAssets';
+const isCloudflare = detectRuntime().isCloudflare;
+const safeFileUrlToPath = (url) => {
+    if (typeof url !== 'string' || url.trim() === '')
+        return '';
+    try {
+        return NodeSingletons.url.fileURLToPath(url);
+    }
+    catch {
+        return '';
+    }
+};
+const safeCwd = () => {
+    try {
+        const cwd = NodeSingletons.process?.cwd?.();
+        if (typeof cwd === 'string' && cwd.trim() !== '')
+            return cwd;
+    }
+    catch {
+        // ignore
+    }
+    return '';
+};
+const getAssetsBinding = () => Cloudflare.getAssetsBinding();
+const fetchAssetText = async (assetPath) => {
+    const assets = getAssetsBinding();
+    if (!assets)
+        return '';
+    const url = new URL(assetPath, 'http://assets');
+    const response = await assets.fetch(url);
+    if (!response.ok)
+        return '';
+    return response.text();
+};
+const fetchAssetBytes = async (assetPath) => {
+    const assets = getAssetsBinding();
+    if (!assets)
+        return null;
+    const url = new URL(assetPath, 'http://assets');
+    const response = await assets.fetch(url);
+    if (!response.ok)
+        return null;
+    const buffer = await response.arrayBuffer();
+    return new Uint8Array(buffer);
+};
 export const uiResolver = async (uiBasePath) => {
     // Resolve base path for UI assets
     // const __filename = NodeSingletons.url.fileURLToPath(import.meta.url);
     // const __dirname = NodeSingletons.path.dirname(__filename);
+    const assetHtml = await fetchAssetText('/workers/index.html');
+    if (assetHtml !== '')
+        return assetHtml;
+    if (isCloudflare) {
+        return Buffer.from(INDEX_HTML, 'base64').toString('utf-8');
+    }
     const uiPath = NodeSingletons.path.resolve(uiBasePath, 'workers/index.html');
     const html = await NodeSingletons.fs.readFile(uiPath, 'utf8');
     return html;
@@ -30,14 +81,58 @@ const getUiBase = () => {
     // Resolve base path for UI assets
     if (uiBasePath.length > 0)
         return uiBasePath;
-    const __filename = NodeSingletons.url.fileURLToPath(import.meta.url);
-    const __dirname = NodeSingletons.path.dirname(__filename);
-    uiBasePath = NodeSingletons.path.resolve(__dirname, '../');
+    const __filename = safeFileUrlToPath(import.meta.url);
+    if (__filename !== '') {
+        const __dirname = NodeSingletons.path.dirname(__filename);
+        uiBasePath = NodeSingletons.path.resolve(__dirname, '../');
+        return uiBasePath;
+    }
+    const cwd = safeCwd();
+    if (cwd !== '') {
+        uiBasePath = NodeSingletons.path.resolve(cwd, 'packages', 'workers', 'src', 'ui');
+        return uiBasePath;
+    }
+    uiBasePath = '';
     return uiBasePath;
 };
 const serveStaticFile = async (req, res) => {
     try {
         const filePath = req.getPath();
+        const assetBytes = await fetchAssetBytes(filePath);
+        if (assetBytes) {
+            const mimeType = getMimeType(filePath);
+            res.setHeader('Content-Type', mimeType);
+            res.setHeader('Cache-Control', 'public, max-age=3600'); // 1 hour cache
+            res.send(Buffer.from(assetBytes));
+            return;
+        }
+        if (isCloudflare) {
+            const normalizedPath = filePath.replace(/^\//, '');
+            if (normalizedPath === 'workers/styles.css') {
+                const mimeType = MIME_TYPES.CSS;
+                res.setHeader('Content-Type', mimeType);
+                res.setHeader('Cache-Control', 'public, max-age=3600');
+                res.send(Buffer.from(STYLES_CSS, 'base64'));
+                return;
+            }
+            if (normalizedPath === 'workers/main.js') {
+                const mimeType = MIME_TYPES.JS;
+                res.setHeader('Content-Type', mimeType);
+                res.setHeader('Cache-Control', 'public, max-age=3600');
+                res.send(Buffer.from(MAIN_JS, 'base64'));
+                return;
+            }
+            if (normalizedPath === 'workers/zintrust.svg') {
+                const mimeType = MIME_TYPES.SVG;
+                res.setHeader('Content-Type', mimeType);
+                res.setHeader('Cache-Control', 'public, max-age=3600');
+                res.send(Buffer.from(ZINTRUST_SVG, 'base64'));
+                return;
+            }
+            res.setStatus(404);
+            res.send(Buffer.from('Not Found'));
+            return;
+        }
         const fullPath = NodeSingletons.path.resolve(getUiBase(), filePath.replace(/^\//, ''));
         // Security check - prevent directory traversal
         if (!fullPath.startsWith(uiBasePath)) {
@@ -74,6 +169,7 @@ export const registerStaticAssets = (router, middleware) => {
         // Serve workers CSS and JS files
         Router.get(r, '/styles.css', serveStaticFile);
         Router.get(r, '/main.js', serveStaticFile);
+        Router.get(r, '/zintrust.svg', serveStaticFile);
         Router.get(r, '/:filename', serveStaticFile);
         Router.get(r, '/integration/:filename', serveStaticFile);
         // Serve components CSS files

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zintrust/workers",
-  "version": "0.1.29",
+  "version": "0.1.30",
   "private": false,
   "type": "module",
   "main": "./dist/index.js",
@@ -22,22 +22,26 @@
       "types": "./dist/ResourceMonitor.d.ts",
       "default": "./dist/ResourceMonitor.js"
     },
-    "./WorkerFactory": {
-      "types": "./dist/WorkerFactory.d.ts",
-      "default": "./dist/WorkerFactory.js"
+    "./telemetry": {
+      "types": "./telemetry/dist/index.d.ts",
+      "default": "./telemetry/dist/index.js"
+    },
+    "./telemetry/*": {
+      "types": "./telemetry/dist/*.d.ts",
+      "default": "./telemetry/dist/*.js"
     }
   },
   "engines": {
     "node": ">=20.0.0"
   },
   "peerDependencies": {
-    "@zintrust/core": "^0.1.34"
+    "@zintrust/core": "file:../../dist"
   },
   "publishConfig": {
     "access": "public"
   },
   "scripts": {
-    "build": "npm --prefix ../queue-redis run -s build && npm --prefix ../queue-monitor run -s build && tsc -p tsconfig.json",
+    "build": "tsc -p tsconfig.json",
     "prepublishOnly": "npm run build"
   },
   "dependencies": {

package/src/AnomalyDetection.ts

@@ -194,6 +194,15 @@ export const AnomalyDetection = Object.freeze({
     Logger.info(`Anomaly detection configured for ${config.workerName}`);
   },
 
+  /**
+   * Cleanup anomaly models for a worker
+   */
+  cleanup(workerName: string): void {
+    configs.delete(workerName);
+    models.delete(workerName);
+    Logger.debug(`Anomaly detection cleanup completed for ${workerName}`);
+  },
+
   /**
    * Train baseline model
    */

package/src/CanaryController.ts

@@ -174,7 +174,16 @@ const incrementTraffic = (workerName: string): void => {
 
     // eslint-disable-next-line no-restricted-syntax
     const timer = setTimeout(() => {
-      CanaryController.complete(workerName);
+      try {
+        CanaryController.complete(workerName);
+      } catch (error) {
+        Logger.error('Error during canary completion callback', error);
+      } finally {
+        const current = canaryTimers.get(`${workerName}:complete`);
+        if (current === timer) {
+          canaryTimers.delete(`${workerName}:complete`);
+        }
+      }
     }, config.monitoringDuration * 1000);
 
     canaryTimers.set(`${workerName}:complete`, timer);
@@ -188,7 +197,16 @@ const incrementTraffic = (workerName: string): void => {
 
     // eslint-disable-next-line no-restricted-syntax
     const timer = setTimeout(() => {
-      incrementTraffic(workerName);
+      try {
+        incrementTraffic(workerName);
+      } catch (error) {
+        Logger.error('Error during canary increment callback', error);
+      } finally {
+        const current = canaryTimers.get(workerName);
+        if (current === timer) {
+          canaryTimers.delete(workerName);
+        }
+      }
     }, config.incrementInterval * 1000);
 
     canaryTimers.set(workerName, timer);
@@ -201,7 +219,7 @@ const appendHistory = (
 ): void => {
   deployment.history.push(entry);
   if (deployment.history.length > MAX_HISTORY) {
-    deployment.history.shift();
+    deployment.history.splice(0, deployment.history.length - MAX_HISTORY);
   }
 };
 
@@ -269,7 +287,16 @@ export const CanaryController = Object.freeze({
 
     // eslint-disable-next-line no-restricted-syntax
     const timer = setTimeout(() => {
-      incrementTraffic(workerName);
+      try {
+        incrementTraffic(workerName);
+      } catch (error) {
+        Logger.error('Error during canary start callback', error);
+      } finally {
+        const current = canaryTimers.get(workerName);
+        if (current === timer) {
+          canaryTimers.delete(workerName);
+        }
+      }
     }, config.monitoringDuration * 1000);
 
     canaryTimers.set(workerName, timer);
@@ -314,7 +341,16 @@ export const CanaryController = Object.freeze({
 
     // eslint-disable-next-line no-restricted-syntax
     const timer = setTimeout(() => {
-      incrementTraffic(workerName);
+      try {
+        incrementTraffic(workerName);
+      } catch (error) {
+        Logger.error('Error during canary resume callback', error);
+      } finally {
+        const current = canaryTimers.get(workerName);
+        if (current === timer) {
+          canaryTimers.delete(workerName);
+        }
+      }
     }, deployment.config.incrementInterval * 1000);
 
     canaryTimers.set(workerName, timer);

package/src/ChaosEngineering.ts

@@ -61,6 +61,18 @@ type ExperimentRecord = {
 };
 
 const experiments = new Map<string, ExperimentRecord>();
+const EXPERIMENT_RETENTION_MS = 24 * 60 * 60 * 1000;
+
+const cleanupExpiredExperiments = (): void => {
+  const cutoff = Date.now() - EXPERIMENT_RETENTION_MS;
+  for (const [id, record] of experiments.entries()) {
+    if (record.status.state !== 'completed') continue;
+    const endedAt = record.status.endedAt?.getTime() ?? 0;
+    if (endedAt > 0 && endedAt < cutoff) {
+      experiments.delete(id);
+    }
+  }
+};
 
 const getTargetWorkers = (config: IChaosExperiment): string[] => {
   const candidates = config.target.workers ?? WorkerRegistry.listRunning();
@@ -224,6 +236,8 @@ export const ChaosEngineering = Object.freeze({
       id: experimentId,
       duration: record.config.duration,
     });
+
+    cleanupExpiredExperiments();
   },
 
   /**

package/src/ClusterLock.ts

@@ -5,6 +5,7 @@
  */
 
 import {
+  Cloudflare,
   ErrorFactory,
   Logger,
   createRedisConnection,
@@ -39,8 +40,20 @@ export type AuditLogEntry = {
   success: boolean;
 };
 
-// Generate unique instance ID for this process
-const INSTANCE_ID = `worker-${process.pid}-${Date.now()}-${generateUuid()}`;
+let INSTANCE_ID = '';
+
+const createInstanceId = (): string => {
+  const workers = Cloudflare.getWorkersEnv() !== null;
+  const pid = typeof process !== 'undefined' && typeof process.pid === 'number' ? process.pid : 0;
+  const prefix = workers ? 'worker-cf' : 'worker';
+  return `${prefix}-${pid}-${Date.now()}-${generateUuid()}`;
+};
+
+const getInstanceId = (): string => {
+  if (INSTANCE_ID !== '') return INSTANCE_ID;
+  INSTANCE_ID = createInstanceId();
+  return INSTANCE_ID;
+};
 
 // Redis key prefixes
 const LOCK_PREFIX = 'worker:lock:';
@@ -94,7 +107,7 @@ const extendLockTTL = async (client: IORedis, lockKey: string, ttl: number): Pro
   const redisKey = getLockKey(lockKey);
   const value = await client.get(redisKey);
 
-  if (value === null || value !== INSTANCE_ID) {
+  if (value === null || value !== getInstanceId()) {
     return false; // Lock not held by this instance
   }
 
@@ -132,7 +145,7 @@ const startHeartbeat = (client: IORedis): void => {
                 timestamp: now,
                 operation: 'extend',
                 lockKey,
-                instanceId: INSTANCE_ID,
+                instanceId: getInstanceId(),
                 success: true,
               });
             } else {
@@ -178,7 +191,7 @@ export const ClusterLock = Object.freeze({
     redisClient = createRedisConnection(config);
     startHeartbeat(redisClient);
 
-    Logger.info('ClusterLock initialized', { instanceId: INSTANCE_ID });
+    Logger.info('ClusterLock initialized', { instanceId: getInstanceId() });
   },
 
   /**
@@ -197,14 +210,14 @@ export const ClusterLock = Object.freeze({
 
     try {
       // Try to acquire lock using SET NX EX (set if not exists with expiry)
-      const result = await redisClient.set(redisKey, INSTANCE_ID, 'EX', ttl, 'NX');
+      const result = await redisClient.set(redisKey, getInstanceId(), 'EX', ttl, 'NX');
 
       const success = result === 'OK';
 
       if (success) {
         const lockInfo: LockInfo = {
           lockKey,
-          instanceId: INSTANCE_ID,
+          instanceId: getInstanceId(),
           acquiredAt: now,
           expiresAt: new Date(now.getTime() + ttl * 1000),
           region,
@@ -224,7 +237,7 @@ export const ClusterLock = Object.freeze({
           timestamp: now,
           operation: 'acquire',
           lockKey,
-          instanceId: INSTANCE_ID,
+          instanceId: getInstanceId(),
           userId,
           success: true,
         });
@@ -235,7 +248,7 @@ export const ClusterLock = Object.freeze({
           timestamp: now,
           operation: 'acquire',
           lockKey,
-          instanceId: INSTANCE_ID,
+          instanceId: getInstanceId(),
           userId,
           success: false,
         });

package/src/DeadLetterQueue.ts

@@ -70,9 +70,14 @@ export type DLQStats = {
   retentionViolations: number;
 };
 
-// Redis key prefixes
-const DLQ_PREFIX = 'worker:dlq:';
-const AUDIT_PREFIX = 'worker:dlq:audit:';
+// Redis key prefixes - using workers package prefix system
+const getDLQPrefix = (): string => {
+  return 'worker:dlq:';
+};
+
+const getAuditPrefix = (): string => {
+  return 'worker:dlq:audit:';
+};
 
 // Internal state
 let redisClient: IORedis | null = null;
@@ -83,14 +88,14 @@ let cleanupInterval: NodeJS.Timeout | null = null;
  * Helper: Get DLQ key
  */
 const getDLQKey = (queueName: string): string => {
-  return `${DLQ_PREFIX}${queueName}`;
+  return `${getDLQPrefix()}${queueName}`;
 };
 
 /**
  * Helper: Get audit key
  */
 const getAuditKey = (failedJobId: string): string => {
-  return `${AUDIT_PREFIX}${failedJobId}`;
+  return `${getAuditPrefix()}${failedJobId}`;
 };
 
 /**
@@ -184,7 +189,7 @@ const cleanupOldEntries = async (): Promise<number> => {
   try {
     const cutoffTimestamp = Date.now() - policy.autoDeleteAfterDays * 24 * 60 * 60 * 1000;
     // Find all DLQ keys
-    const pattern = `${DLQ_PREFIX}*`;
+    const pattern = `${getDLQPrefix()}*`;
     const keys = await client.keys(pattern);
 
     const cleanedCounts = await Promise.all(
@@ -587,12 +592,12 @@ export const DeadLetterQueue = Object.freeze({
 
     try {
       const client = redisClient;
-      const pattern = `${DLQ_PREFIX}*`;
+      const pattern = `${getDLQPrefix()}*`;
       const keys = await client.keys(pattern);
 
       const entriesByQueue = await Promise.all(
         keys.map(async (key) => {
-          const queueName = key.replace(DLQ_PREFIX, '');
+          const queueName = key.replace(getDLQPrefix(), '');
           const entries = await client.zrange(key, 0, -1);
           return {
             queueName,

package/src/MultiQueueWorker.ts

@@ -50,12 +50,12 @@ const multiQueueWorkers = new Map<
 /**
  * Helper: Create worker for a queue
  */
-const createQueueWorker = (
+const createQueueWorker = async (
   workerName: string,
   queueConfig: QueueConfig,
   processor: MultiQueueWorkerConfig['processor']
-): Worker => {
-  const queue = PriorityQueue.getQueueInstance(queueConfig.name);
+): Promise<Worker> => {
+  const queue = await PriorityQueue.getQueueInstance(queueConfig.name);
   const connection = queue.opts.connection;
 
   const workerOptions: WorkerOptions = {
@@ -138,7 +138,7 @@ export const MultiQueueWorker = Object.freeze({
   /**
    * Create multi-queue worker
    */
-  create(config: MultiQueueWorkerConfig): void {
+  async create(config: MultiQueueWorkerConfig): Promise<void> {
     if (multiQueueWorkers.has(config.workerName)) {
       throw ErrorFactory.createWorkerError(
         `Multi-queue worker "${config.workerName}" already exists`
@@ -151,9 +151,16 @@ export const MultiQueueWorker = Object.freeze({
     // Sort queues by priority (higher first)
     const sortedQueues = [...config.queues].sort((a, b) => b.priority - a.priority);
 
-    // Create workers for each queue
-    for (const queueConfig of sortedQueues) {
-      const worker = createQueueWorker(config.workerName, queueConfig, config.processor);
+    // Create workers for each queue in parallel
+    const workerPromises = sortedQueues.map(async (queueConfig) => {
+      const worker = await createQueueWorker(config.workerName, queueConfig, config.processor);
+      return { queueConfig, worker };
+    });
+
+    const workerResults = await Promise.all(workerPromises);
+
+    // Store workers and stats
+    for (const { queueConfig, worker } of workerResults) {
       workers.set(queueConfig.name, worker);
       stats.set(queueConfig.name, initializeQueueStats(queueConfig.name, queueConfig.enabled));
     }
@@ -322,7 +329,7 @@ export const MultiQueueWorker = Object.freeze({
     // Update worker concurrency (requires restart in BullMQ)
     await worker.close();
 
-    const newWorker = createQueueWorker(workerName, queueConfig, mqw.config.processor);
+    const newWorker = await createQueueWorker(workerName, queueConfig, mqw.config.processor);
     mqw.workers.set(queueName, newWorker);
 
     Logger.info(`Queue concurrency updated: ${queueName}`, { workerName, concurrency });

package/src/PriorityQueue.ts

@@ -4,7 +4,7 @@
  * Sealed namespace for immutability
  */
 
-import { ErrorFactory, Logger, NodeSingletons, type RedisConfig } from '@zintrust/core';
+import { ErrorFactory, Logger, type RedisConfig } from '@zintrust/core';
 import type { Queue } from 'bullmq';
 
 export type PriorityLevel = 'critical' | 'high' | 'normal' | 'low';
@@ -55,15 +55,14 @@ const PRIORITY_VALUES: Record<PriorityLevel, number> = {
 
 type QueueRedisModule = typeof import('@zintrust/queue-redis');
 
-const require = NodeSingletons.module.createRequire(import.meta.url);
 let queueRedisModule: QueueRedisModule | undefined;
 let hasWarnedMissingQueueRedis = false;
 
-const loadQueueRedisModule = (): QueueRedisModule | undefined => {
+const loadQueueRedisModule = async (): Promise<QueueRedisModule | undefined> => {
   if (queueRedisModule) return queueRedisModule;
 
   try {
-    queueRedisModule = require('@zintrust/queue-redis') as QueueRedisModule;
+    queueRedisModule = (await import('@zintrust/queue-redis')) as QueueRedisModule;
     return queueRedisModule;
   } catch (error) {
     if (!hasWarnedMissingQueueRedis) {
@@ -80,8 +79,8 @@ const loadQueueRedisModule = (): QueueRedisModule | undefined => {
 /**
  * Helper: Get or create queue via shared driver
  */
-const getQueue = (queueName: string): Queue => {
-  const queueRedis = loadQueueRedisModule();
+const getQueue = async (queueName: string): Promise<Queue> => {
+  const queueRedis = await loadQueueRedisModule();
   if (!queueRedis) {
     throw ErrorFactory.createWorkerError(
       'Optional package "@zintrust/queue-redis" is required for PriorityQueue. Install it to use queue features.'
@@ -170,7 +169,7 @@ export const PriorityQueue = Object.freeze({
     data: T,
     options: PriorityJobOptions
   ): Promise<string> {
-    const queue = getQueue(queueName);
+    const queue = await getQueue(queueName);
     const jobOptions = buildJobOptions(options);
 
     try {
@@ -206,7 +205,7 @@ export const PriorityQueue = Object.freeze({
       options: PriorityJobOptions;
     }>
   ): Promise<string[]> {
-    const queue = getQueue(queueName);
+    const queue = await getQueue(queueName);
 
     try {
       const bulkJobs = jobs.map((job) => ({
@@ -237,7 +236,7 @@ export const PriorityQueue = Object.freeze({
    * Get job by ID
    */
   async getJob(queueName: string, jobId: string) {
-    const queue = getQueue(queueName);
+    const queue = await getQueue(queueName);
     return queue.getJob(jobId);
   },
 
@@ -245,7 +244,7 @@ export const PriorityQueue = Object.freeze({
    * Remove a job
    */
   async removeJob(queueName: string, jobId: string): Promise<void> {
-    const queue = getQueue(queueName);
+    const queue = await getQueue(queueName);
     const job = await queue.getJob(jobId);
 
     if (job) {
@@ -258,7 +257,7 @@ export const PriorityQueue = Object.freeze({
    * Pause a queue
    */
   async pause(queueName: string): Promise<void> {
-    const queue = getQueue(queueName);
+    const queue = await getQueue(queueName);
     await queue.pause();
     Logger.info(`Paused queue "${queueName}"`);
   },
@@ -267,7 +266,7 @@ export const PriorityQueue = Object.freeze({
    * Resume a queue
    */
   async resume(queueName: string): Promise<void> {
-    const queue = getQueue(queueName);
+    const queue = await getQueue(queueName);
     await queue.resume();
     Logger.info(`Resumed queue "${queueName}"`);
   },
@@ -276,7 +275,7 @@ export const PriorityQueue = Object.freeze({
    * Get queue information
    */
   async getQueueInfo(queueName: string): Promise<QueueInfo> {
-    const queue = getQueue(queueName);
+    const queue = await getQueue(queueName);
     const isPaused = await queue.isPaused();
     const jobCounts = await queue.getJobCounts();
 
@@ -297,8 +296,8 @@ export const PriorityQueue = Object.freeze({
   /**
    * Get all queue names
    */
-  getQueueNames(): string[] {
-    const queueRedis = loadQueueRedisModule();
+  async getQueueNames(): Promise<string[]> {
+    const queueRedis = await loadQueueRedisModule();
     if (!queueRedis) return [];
     return queueRedis.BullMQRedisQueue.getQueueNames();
   },
@@ -307,7 +306,7 @@ export const PriorityQueue = Object.freeze({
    * Drain queue (remove all jobs)
    */
   async drain(queueName: string, delayed = false): Promise<void> {
-    const queue = getQueue(queueName);
+    const queue = await getQueue(queueName);
     await queue.drain(delayed);
     Logger.info(`Drained queue "${queueName}"`, { delayed });
   },
@@ -321,7 +320,7 @@ export const PriorityQueue = Object.freeze({
     limit: number,
     type: 'completed' | 'failed' | 'delayed' | 'wait' | 'active' | 'paused' = 'completed'
   ): Promise<string[]> {
-    const queue = getQueue(queueName);
+    const queue = await getQueue(queueName);
     const jobs = await queue.clean(grace, limit, type);
 
     Logger.info(`Cleaned ${jobs.length} ${type} jobs from queue "${queueName}"`);
@@ -333,9 +332,9 @@ export const PriorityQueue = Object.freeze({
    * Obliterate queue (remove all data including queue itself)
    */
   async obliterate(queueName: string, force = false): Promise<void> {
-    const queue = getQueue(queueName);
+    const queue = await getQueue(queueName);
     await queue.obliterate({ force });
-    const queueRedis = loadQueueRedisModule();
+    const queueRedis = await loadQueueRedisModule();
     if (queueRedis) {
       await queueRedis.BullMQRedisQueue.closeQueue(queueName);
     }
@@ -360,7 +359,7 @@ export const PriorityQueue = Object.freeze({
   /**
    * Get queue instance (internal use)
    */
-  getQueueInstance(queueName: string): Queue {
+  getQueueInstance(queueName: string): Promise<Queue> {
     return getQueue(queueName);
   },
 
@@ -368,7 +367,7 @@ export const PriorityQueue = Object.freeze({
    * Close a queue
    */
   async closeQueue(queueName: string): Promise<void> {
-    const queueRedis = loadQueueRedisModule();
+    const queueRedis = await loadQueueRedisModule();
     if (!queueRedis) return;
     await queueRedis.BullMQRedisQueue.closeQueue(queueName);
     Logger.info(`Closed queue "${queueName}"`);
@@ -379,7 +378,7 @@ export const PriorityQueue = Object.freeze({
    */
   async shutdown(): Promise<void> {
     Logger.info('PriorityQueue shutting down via BullMQRedisQueue...');
-    const queueRedis = loadQueueRedisModule();
+    const queueRedis = await loadQueueRedisModule();
     if (!queueRedis) return;
     await queueRedis.BullMQRedisQueue.shutdown();
     Logger.info('PriorityQueue shutdown complete');