@zintrust/queue-monitor 2.0.0 → 2.0.1

package/dist/api/workerClient.d.ts

@@ -0,0 +1,20 @@
+type WorkerApiResponse<T> = {
+    ok: boolean;
+    error?: string;
+} & T;
+export declare const WorkerClient: Readonly<{
+    listWorkers(): Promise<string[]>;
+    getWorker(name: string): Promise<unknown>;
+    getStatus(name: string): Promise<unknown>;
+    getHealth(name: string): Promise<unknown>;
+    startWorker(name: string): Promise<WorkerApiResponse<{
+        message?: string;
+    }>>;
+    stopWorker(name: string): Promise<WorkerApiResponse<{
+        message?: string;
+    }>>;
+    restartWorker(name: string): Promise<WorkerApiResponse<{
+        message?: string;
+    }>>;
+}>;
+export {};

package/dist/api/workerClient.js

@@ -0,0 +1,45 @@
+import { ErrorFactory, Logger } from '@zintrust/core';
+import { WorkerConfig } from '../config/workerConfig.js';
+const requestJson = async (path, options = {}) => {
+    const baseUrl = WorkerConfig.getWorkerBaseUrl();
+    const url = `${baseUrl}${path}`;
+    const response = await fetch(url, {
+        ...options,
+        headers: {
+            'Content-Type': 'application/json',
+            ...options.headers,
+        },
+    });
+    if (!response.ok) {
+        Logger.error('Worker API request failed', { url, status: response.status });
+        throw ErrorFactory.createWorkerError(`Worker API request failed (${response.status})`);
+    }
+    return (await response.json());
+};
+export const WorkerClient = Object.freeze({
+    async listWorkers() {
+        const response = await requestJson('/api/workers');
+        return response.workers ?? [];
+    },
+    async getWorker(name) {
+        const response = await requestJson(`/api/workers/${name}`);
+        return response.worker;
+    },
+    async getStatus(name) {
+        const response = await requestJson(`/api/workers/${name}/status`);
+        return response.status;
+    },
+    async getHealth(name) {
+        const response = await requestJson(`/api/workers/${name}/health`);
+        return response.health;
+    },
+    async startWorker(name) {
+        return requestJson(`/api/workers/${name}/start`, { method: 'POST' });
+    },
+    async stopWorker(name) {
+        return requestJson(`/api/workers/${name}/stop`, { method: 'POST' });
+    },
+    async restartWorker(name) {
+        return requestJson(`/api/workers/${name}/restart`, { method: 'POST' });
+    },
+});

package/dist/build-manifest.json

@@ -1,15 +1,15 @@
 {
   "name": "@zintrust/queue-monitor",
   "version": "2.0.0",
-  "buildDate": "2026-05-20T20:03:20.173Z",
+  "buildDate": "2026-05-22T14:51:47.293Z",
   "buildEnvironment": {
-    "node": "v20.20.2",
-    "platform": "linux",
-    "arch": "x64"
+    "node": "v22.22.1",
+    "platform": "darwin",
+    "arch": "arm64"
   },
   "git": {
-    "commit": "be96835b",
-    "branch": "master"
+    "commit": "3c553e92",
+    "branch": "release"
   },
   "package": {
     "engines": {
@@ -40,6 +40,34 @@
       "size": 8928,
       "sha256": "fc408db720d5883821b169eabce66944295068cd6f2338f1884493c299f0a0f1"
     },
+    "api/workerClient.d.ts": {
+      "size": 597,
+      "sha256": "1d712bfa9127aa2df4f1fbd0efbb6d84069e1888ed73aca5542a41eee865d4bb"
+    },
+    "api/workerClient.js": {
+      "size": 1629,
+      "sha256": "60f993a42f4a9dd5000b01dae3b0f105a8f4348da8433a735b5cc1929a8f64ce"
+    },
+    "build-manifest.json": {
+      "size": 4136,
+      "sha256": "382a0dce0ff1c6077eece1a71780eb91726048370dc6a61fe9a80c1212917082"
+    },
+    "config/queueMonitor.d.ts": {
+      "size": 407,
+      "sha256": "4541f47e64c8ede1bfd8fc0cb7edb76c4e885311b28b1f51c9be7639e5d87eca"
+    },
+    "config/queueMonitor.js": {
+      "size": 689,
+      "sha256": "0b95e6b65d4b6ffdd69788cdfd19e0e76400a39ad69dce018d8827a3b298e419"
+    },
+    "config/workerConfig.d.ts": {
+      "size": 86,
+      "sha256": "b669205d50c8844455a2d9b34a54f48a71118eb6ac99bad5372683ab666f5a22"
+    },
+    "config/workerConfig.js": {
+      "size": 628,
+      "sha256": "ca1c6dbaa751893f0e6b7c8a7fd41a80f7d5e8fc9aaaa4877ca12821bb25f56f"
+    },
     "connection.d.ts": {
       "size": 285,
       "sha256": "02b8d856e6b905f10ac01fabe7c44560530878c0ec73924889e1d159018d317a"
@@ -48,6 +76,14 @@
       "size": 171,
       "sha256": "a4d2967491dc471a75c163f81b5c7199f9e3b34c7c958b65d5bc6bb11798fc6f"
     },
+    "dashboard-index.d.ts": {
+      "size": 180,
+      "sha256": "f78b4a0a83566640eca154f92d3f858ec41deb2521a500939ee3f0e58ee5db86"
+    },
+    "dashboard-index.js": {
+      "size": 183,
+      "sha256": "9d7c7fc63fe2919de0584d3f3d0ef74166d834af0a68caca2fe6fe64340652b9"
+    },
     "dashboard-ui.d.ts": {
       "size": 219,
       "sha256": "5140191207b5620500ac5e1edacefed65956a1ad88739695d545ea7d2b405243"
@@ -56,6 +92,14 @@
       "size": 53927,
       "sha256": "71bab126f20aea1165ee3aa3c82e896ebd89b1f1a815ef2716cd884b846ab34f"
     },
+    "driver-index.d.ts": {
+      "size": 280,
+      "sha256": "71a4dc5d823391fe16e966069aae8e6704d5c2d64aaceb447e138fdde7023690"
+    },
+    "driver-index.js": {
+      "size": 184,
+      "sha256": "fb91df973acd13a88cca443e50ecdd34944c66e1a1d48333f63099079a00f3c9"
+    },
     "driver.d.ts": {
       "size": 1102,
       "sha256": "70b74e7a0489da3a5545dfd8458ab5b4def1f3733c291a782c033fed0afd0bcf"
@@ -70,7 +114,15 @@
     },
     "index.js": {
       "size": 14399,
-      "sha256": "18b28ec7b731fd8a68c05c008cbecfb59427c8bc157da938976b45c1adb117ad"
+      "sha256": "150a5729d3250b7351a1282ce74d923ee6e0f43bee85deed86ad843f664521c4"
+    },
+    "metrics-index.d.ts": {
+      "size": 233,
+      "sha256": "993ffe832f2914a81c81364f7b6d5c7247cd16da9bb9feb04caf8d770c14f9ec"
+    },
+    "metrics-index.js": {
+      "size": 171,
+      "sha256": "53e858995605858b819f2c48c701e3b8f7d028ec51c1b4814c46284c7fb3989e"
     },
     "metrics.d.ts": {
       "size": 910,
@@ -80,6 +132,22 @@
       "size": 3472,
       "sha256": "fab0e6d62ed694dcf57904a68b683280e4063c2fdcf97c60fdf5d933ae2b8f4f"
     },
+    "routes/workers.d.ts": {
+      "size": 477,
+      "sha256": "cfcc3527c47d1a796a3ced2d4777b339dd767f7feb3ecc66c5ce0a91d8ff1bc8"
+    },
+    "routes/workers.js": {
+      "size": 901,
+      "sha256": "1ec48c0becc8c0628b1780fb400e957c5fe50da79f73112436c33ecde7d7d574"
+    },
+    "runtime-index.d.ts": {
+      "size": 2209,
+      "sha256": "e5d5c3475a7caec57f9e1a61bffb11038858e2c3f7be03e04ca28b8295e878fc"
+    },
+    "runtime-index.js": {
+      "size": 8759,
+      "sha256": "9c08789ef9e4da7cfcf431cd369808f9baa088381e58ada3daa5e91f6e034e5d"
+    },
     "worker.d.ts": {
       "size": 332,
       "sha256": "97cddbc991c6e6724950090cd92f06671932ab848c16dd94a030d9fba3fbae26"
@@ -87,6 +155,14 @@
     "worker.js": {
       "size": 1233,
       "sha256": "da26c1b80da7473e1644a4e0f8d814097ce0adff14e36037164f9ae5855e656a"
+    },
+    "workers-ui.d.ts": {
+      "size": 214,
+      "sha256": "4f5fd3bbd077d0dee2cc6c73d2c736fc52119b0d3a5f4a1878a4f3d3d3edf299"
+    },
+    "workers-ui.js": {
+      "size": 24928,
+      "sha256": "ba2c5cbf890fe875cc5336c76bd29b146089bc8ba3a70de4a2c383f395f9be73"
     }
   }
 }

package/dist/config/queueMonitor.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Queue Monitor Configuration (default override)
+ *
+ * Keep this file declarative:
+ * - Core owns env parsing/default logic.
+ * - Projects can override config by editing values below.
+ */
+declare const _default: {
+    enabled: boolean;
+    basePath: string;
+    middleware: string[];
+    redis: {
+        host: string;
+        port: number;
+        password: string;
+    };
+};
+export default _default;

package/dist/config/queueMonitor.js

@@ -0,0 +1,21 @@
+import { Env } from '@zintrust/core';
+/**
+ * Queue Monitor Configuration (default override)
+ *
+ * Keep this file declarative:
+ * - Core owns env parsing/default logic.
+ * - Projects can override config by editing values below.
+ */
+export default {
+    enabled: Env.getBool('QUEUE_MONITOR_ENABLED', true),
+    basePath: Env.get('QUEUE_MONITOR_BASE_PATH', '/queue-monitor'),
+    middleware: Env.get('QUEUE_MONITOR_MIDDLEWARE', 'auth')
+        .split(',')
+        .map((m) => m.trim())
+        .filter((m) => m.length > 0),
+    redis: {
+        host: Env.get('REDIS_HOST', 'localhost'),
+        port: Env.getInt('REDIS_PORT', 6379),
+        password: Env.get('REDIS_PASSWORD', ''),
+    },
+};

package/dist/config/workerConfig.d.ts

@@ -0,0 +1,3 @@
+export declare const WorkerConfig: Readonly<{
+    getWorkerBaseUrl: () => string;
+}>;

package/dist/config/workerConfig.js

@@ -0,0 +1,19 @@
+import { Env } from '@zintrust/core';
+const normalizeBaseUrl = (value) => {
+    let end = value.length;
+    while (end > 0 && value.charAt(end - 1) === '/') {
+        end--;
+    }
+    return value.slice(0, end);
+};
+const withHttpScheme = (value) => value.startsWith('http://') || value.startsWith('https://') ? value : `http://${value}`;
+const resolveWorkerApiUrl = () => {
+    const workerApiUrl = Env.get('WORKER_API_URL');
+    if (workerApiUrl) {
+        return normalizeBaseUrl(withHttpScheme(workerApiUrl));
+    }
+    return '';
+};
+export const WorkerConfig = Object.freeze({
+    getWorkerBaseUrl: resolveWorkerApiUrl,
+});

package/dist/dashboard-index.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Queue Monitor Dashboard UI - Non-runtime entrypoint
+ * Contains the dashboard UI components for development/admin use
+ */
+export { getDashboardHtml } from './dashboard-ui';

package/dist/dashboard-index.js

@@ -0,0 +1,5 @@
+/**
+ * Queue Monitor Dashboard UI - Non-runtime entrypoint
+ * Contains the dashboard UI components for development/admin use
+ */
+export { getDashboardHtml } from './dashboard-ui';

package/dist/driver-index.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Queue Monitor Driver - Runtime-only entrypoint
+ * Contains only the core queue driver functionality for production Workers
+ */
+export type { JobPayload, JobCounts, RetrySnapshot, RetryJobResult, QueueDriver } from './driver';
+export { createBullMQDriver } from './driver';

package/dist/driver-index.js

@@ -0,0 +1,5 @@
+/**
+ * Queue Monitor Driver - Runtime-only entrypoint
+ * Contains only the core queue driver functionality for production Workers
+ */
+export { createBullMQDriver } from './driver';

package/dist/metrics-index.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Queue Monitor Metrics - Runtime-only entrypoint
+ * Contains only the metrics functionality for production Workers
+ */
+export type { JobStatus, JobSummary, Metrics } from './metrics';
+export { createMetrics } from './metrics';

package/dist/metrics-index.js

@@ -0,0 +1,5 @@
+/**
+ * Queue Monitor Metrics - Runtime-only entrypoint
+ * Contains only the metrics functionality for production Workers
+ */
+export { createMetrics } from './metrics';

package/dist/routes/workers.d.ts

@@ -0,0 +1,10 @@
+import { type IRouter } from '@zintrust/core';
+import { type WorkerUiOptions } from '../workers-ui';
+type RouteOptions = {
+    middleware?: ReadonlyArray<string>;
+} | undefined;
+export declare const registerWorkerUiRoutes: (router: IRouter, options: WorkerUiOptions, routeOptions: RouteOptions) => void;
+declare const _default: Readonly<{
+    registerWorkerUiRoutes: (router: IRouter, options: WorkerUiOptions, routeOptions: RouteOptions) => void;
+}>;
+export default _default;

package/dist/routes/workers.js

@@ -0,0 +1,20 @@
+import { Router } from '@zintrust/core';
+import { WorkerConfig } from '../config/workerConfig.js';
+import { getWorkersHtml } from '../workers-ui.js';
+const registerWorkerUiPage = (router, options, routeOptions) => {
+    const handler = (_req, res) => {
+        res.html(getWorkersHtml({
+            basePath: options.basePath,
+            apiBaseUrl: WorkerConfig.getWorkerBaseUrl(),
+            autoRefresh: options.autoRefresh,
+            refreshIntervalMs: options.refreshIntervalMs,
+        }));
+    };
+    Router.get(router, `${options.basePath}/workers`, handler, routeOptions);
+    Router.get(router, '/workers', handler, routeOptions);
+    Router.get(router, '/workers/', handler, routeOptions);
+};
+export const registerWorkerUiRoutes = (router, options, routeOptions) => {
+    registerWorkerUiPage(router, options, routeOptions);
+};
+export default Object.freeze({ registerWorkerUiRoutes });

package/dist/runtime-index.d.ts

@@ -0,0 +1,74 @@
+/**
+ * Queue Monitor - Runtime-only entrypoint for production Workers
+ * Excludes dashboard UI components that are not needed for runtime
+ */
+import { type RedisConfig } from './connection';
+import { type QueueDriver } from './driver';
+import { type Metrics } from './metrics';
+export type { JobPayload } from './driver';
+export { createMetrics, type JobStatus, type JobSummary, type Metrics } from './metrics';
+export { createWorker as createQueueWorker, type QueueWorker } from './worker';
+export type QueueMonitorConfig = {
+    enabled?: boolean;
+    basePath?: string;
+    middleware?: ReadonlyArray<string>;
+    autoRefresh?: boolean;
+    refreshIntervalMs?: number;
+    redis?: RedisConfig;
+    knownQueues?: ReadonlyArray<string> | (() => Promise<ReadonlyArray<string>> | ReadonlyArray<string>);
+};
+export type QueueCounts = {
+    waiting: number;
+    active: number;
+    completed: number;
+    failed: number;
+    delayed: number;
+    paused: number;
+};
+export type QueueMonitorSnapshot = {
+    status: 'ok';
+    startedAt: string;
+    queues: Array<{
+        name: string;
+        counts: QueueCounts;
+    }>;
+};
+export type LockSummary = {
+    key: string;
+    ttl?: number;
+    expires?: string;
+};
+export type LockMetrics = {
+    active: number;
+    attempts: number;
+    acquired: number;
+    collisions: number;
+    collisionRate: number;
+};
+export type LockHistogramBucket = {
+    label: string;
+    count: number;
+};
+export type LockAnalytics = {
+    locks: LockSummary[];
+    metrics: LockMetrics;
+    histogram: LockHistogramBucket[];
+};
+export type QueueMonitorApi = {
+    getSnapshot: () => Promise<QueueMonitorSnapshot>;
+    getLocks: (pattern?: string) => Promise<LockAnalytics>;
+    driver: QueueDriver;
+    metrics: Metrics;
+    close: () => Promise<void>;
+};
+export declare const QueueMonitor: Readonly<{
+    create(config: QueueMonitorConfig): QueueMonitorApi;
+}>;
+export default QueueMonitor;
+export { createBullMQDriver } from './driver';
+/**
+ * Package version and build metadata
+ * Available at runtime for debugging and health checks
+ */
+export declare const _ZINTRUST_QUEUE_MONITOR_VERSION = "0.1.0";
+export declare const _ZINTRUST_QUEUE_MONITOR_BUILD_DATE = "__BUILD_DATE__";

package/dist/runtime-index.js

@@ -0,0 +1,234 @@
+/**
+ * Queue Monitor - Runtime-only entrypoint for production Workers
+ * Excludes dashboard UI components that are not needed for runtime
+ */
+import { isNonEmptyString, Logger, queueConfig, resolveLockPrefix, ShutdownTrace, } from '@zintrust/core';
+import { createRedisConnection } from './connection';
+import { createBullMQDriver } from './driver';
+import { createMetrics } from './metrics';
+export { createMetrics } from './metrics';
+export { createWorker as createQueueWorker } from './worker';
+const DEFAULTS = {
+    enabled: true,
+    basePath: '/queue-monitor',
+    middleware: [],
+    autoRefresh: true,
+    refreshIntervalMs: 5000,
+};
+const METRICS_KEYS = {
+    attempts: 'metrics:attempts',
+    acquired: 'metrics:acquired',
+    collisions: 'metrics:collisions',
+};
+const HISTOGRAM_BUCKETS = [
+    { label: '<30s', max: 30_000 },
+    { label: '30s-2m', max: 120_000 },
+    { label: '2-10m', max: 600_000 },
+    { label: '10-60m', max: 3_600_000 },
+    { label: '>60m', min: 3_600_000 },
+];
+const MAX_LOCK_KEYS = 10_000;
+function normalizeQueueNames(queueNames) {
+    return Array.from(new Set(queueNames
+        .filter((queueName) => typeof queueName === 'string' && isNonEmptyString(queueName))
+        .map((name) => name.trim())))
+        .filter((name) => name.length > 0)
+        .sort((left, right) => left.localeCompare(right));
+}
+async function resolveKnownQueues(knownQueues) {
+    if (typeof knownQueues === 'function') {
+        return normalizeQueueNames(await knownQueues());
+    }
+    if (Array.isArray(knownQueues)) {
+        return normalizeQueueNames(knownQueues);
+    }
+    return [];
+}
+// Helper function to scan lock keys with pagination
+const scanLockKeys = async (client, searchPattern, maxKeys) => {
+    const keys = [];
+    let cursor = '0';
+    do {
+        // Redis scan must be sequential
+        // eslint-disable-next-line no-await-in-loop
+        const [nextCursor, batch] = await client.scan(cursor, 'MATCH', searchPattern, 'COUNT', '200');
+        cursor = nextCursor;
+        keys.push(...batch);
+        if (keys.length >= maxKeys) {
+            Logger.warn('Lock scan limit reached', {
+                pattern: searchPattern,
+                keysFound: keys.length,
+            });
+            break;
+        }
+    } while (cursor !== '0');
+    return keys;
+};
+// Helper function to get TTL statuses for keys
+const getLockStatuses = async (client, keys) => {
+    return Promise.all(keys.map((key) => client.pttl(key)));
+};
+// Helper function to build lock objects from keys and statuses
+const buildLockObjects = (keys, statuses, prefixLock) => {
+    return keys.map((key, index) => {
+        const ttl = statuses[index];
+        const exists = typeof ttl === 'number' && ttl > 0;
+        return {
+            key: key.replace(prefixLock, ''),
+            ttl: exists ? ttl : undefined,
+            expires: exists ? new Date(Date.now() + ttl).toISOString() : undefined,
+        };
+    });
+};
+// Helper function to calculate lock metrics
+const calculateLockMetrics = async (client, prefixLock) => {
+    const metricsKeys = [
+        `${prefixLock}${METRICS_KEYS.attempts}`,
+        `${prefixLock}${METRICS_KEYS.acquired}`,
+        `${prefixLock}${METRICS_KEYS.collisions}`,
+    ];
+    const [attemptsRaw, acquiredRaw, collisionsRaw] = await client.mget(...metricsKeys);
+    const parseMetric = (value) => Number.isFinite(Number(value)) ? Number(value) : 0;
+    const attempts = parseMetric(attemptsRaw);
+    const acquired = parseMetric(acquiredRaw);
+    const collisions = parseMetric(collisionsRaw);
+    const collisionRate = attempts > 0 ? collisions / attempts : 0;
+    return { attempts, acquired, collisions, collisionRate };
+};
+// Helper function to build histogram from locks
+const buildLockHistogram = (locks) => {
+    const histogram = HISTOGRAM_BUCKETS.map((bucket) => ({
+        label: bucket.label,
+        count: 0,
+    }));
+    locks.forEach((lock) => {
+        if (typeof lock.ttl !== 'number')
+            return;
+        const ttl = lock.ttl;
+        const idx = HISTOGRAM_BUCKETS.findIndex((bucket) => {
+            if (typeof bucket.min === 'number')
+                return ttl >= bucket.min;
+            if (typeof bucket.max === 'number')
+                return ttl < bucket.max;
+            return false;
+        });
+        if (idx >= 0)
+            histogram[idx].count += 1;
+    });
+    return histogram;
+};
+function createGetLocks(redisConfig) {
+    return async (pattern = '*') => {
+        const client = createRedisConnection(redisConfig, 3, { subsystem: 'queue-monitor-locks' });
+        const prefix_lock = resolveLockPrefix();
+        const searchPattern = `${prefix_lock}${pattern}`;
+        try {
+            // Scan for lock keys
+            const keys = await scanLockKeys(client, searchPattern, MAX_LOCK_KEYS);
+            // Get TTL statuses
+            const statuses = await getLockStatuses(client, keys);
+            // Build lock objects
+            const locks = buildLockObjects(keys, statuses, prefix_lock);
+            // Calculate metrics
+            const metrics = await calculateLockMetrics(client, prefix_lock);
+            // Build histogram
+            const histogram = buildLockHistogram(locks);
+            return {
+                locks,
+                metrics: {
+                    active: locks.length,
+                    ...metrics,
+                },
+                histogram,
+            };
+        }
+        finally {
+            if (typeof client.quit === 'function') {
+                await client.quit();
+            }
+            else if (typeof client.disconnect === 'function') {
+                client.disconnect();
+            }
+        }
+    };
+}
+function buildSettings(config) {
+    return {
+        enabled: config.enabled ?? DEFAULTS.enabled,
+        basePath: config.basePath ?? DEFAULTS.basePath,
+        middleware: config.middleware ?? DEFAULTS.middleware,
+        autoRefresh: config.autoRefresh ?? DEFAULTS.autoRefresh,
+        refreshIntervalMs: typeof config.refreshIntervalMs === 'number' && Number.isFinite(config.refreshIntervalMs)
+            ? Math.max(1000, Math.floor(config.refreshIntervalMs))
+            : DEFAULTS.refreshIntervalMs,
+    };
+}
+function createGetSnapshot(driver, startedAt, knownQueues) {
+    return async () => {
+        const [discoveredQueues, persistedQueues] = await Promise.all([
+            driver.getQueues(),
+            resolveKnownQueues(knownQueues),
+        ]);
+        const queues = Array.from(new Set([...persistedQueues, ...discoveredQueues])).sort((left, right) => left.localeCompare(right));
+        const stats = await Promise.all(queues.map(async (name) => {
+            const counts = await driver.getJobCounts(name);
+            return { name, counts: counts };
+        }));
+        return {
+            status: 'ok',
+            startedAt,
+            queues: stats,
+        };
+    };
+}
+export const QueueMonitor = Object.freeze({
+    create(config) {
+        const settings = buildSettings(config);
+        let redisConfig;
+        if (config?.redis) {
+            redisConfig = config?.redis;
+        }
+        else {
+            redisConfig = {
+                host: queueConfig.drivers.redis.host,
+                port: queueConfig.drivers.redis.port,
+                password: queueConfig.drivers.redis.password ?? '',
+                db: queueConfig.drivers.redis.database,
+            };
+        }
+        const driver = createBullMQDriver(redisConfig);
+        const metrics = createMetrics(redisConfig);
+        const startedAt = new Date().toISOString();
+        ShutdownTrace.logHandles('queue-monitor.create', {
+            basePath: settings.basePath,
+            autoRefresh: settings.autoRefresh,
+            refreshIntervalMs: settings.refreshIntervalMs,
+        });
+        const getSnapshot = createGetSnapshot(driver, startedAt, config.knownQueues);
+        const getLocks = createGetLocks(redisConfig);
+        const close = async () => {
+            ShutdownTrace.logHandles('queue-monitor.close.start', {
+                basePath: settings.basePath,
+            });
+            await Promise.all([driver.close(), metrics.close()]);
+            ShutdownTrace.logHandles('queue-monitor.close.complete', {
+                basePath: settings.basePath,
+            });
+        };
+        return Object.freeze({
+            getSnapshot,
+            getLocks,
+            driver,
+            metrics,
+            close,
+        });
+    },
+});
+export default QueueMonitor;
+export { createBullMQDriver } from './driver';
+/**
+ * Package version and build metadata
+ * Available at runtime for debugging and health checks
+ */
+export const _ZINTRUST_QUEUE_MONITOR_VERSION = '0.1.0';
+export const _ZINTRUST_QUEUE_MONITOR_BUILD_DATE = '__BUILD_DATE__';

package/dist/workers-ui.d.ts

@@ -0,0 +1,7 @@
+export type WorkerUiOptions = {
+    basePath: string;
+    apiBaseUrl?: string;
+    autoRefresh: boolean;
+    refreshIntervalMs: number;
+};
+export declare const getWorkersHtml: (options: WorkerUiOptions) => string;