@zintrust/workers 0.1.31 → 0.1.43

package/dist/createQueueWorker.js

@@ -1,55 +1,294 @@
-import { Logger, Queue } from '@zintrust/core';
+import * as Core from '@zintrust/core';
+import { Env, Logger, Queue } from '@zintrust/core';
+const RETRY_BASE_DELAY_MS = 1000;
+const RETRY_MAX_DELAY_MS = 30000;
+const getJobStateTracker = () => {
+    try {
+        return Core['JobStateTracker'];
+    }
+    catch {
+        return undefined;
+    }
+};
+const getJobHeartbeatStore = () => {
+    try {
+        return Core['JobHeartbeatStore'];
+    }
+    catch {
+        return undefined;
+    }
+};
+const getTimeoutManager = () => {
+    try {
+        return Core['TimeoutManager'];
+    }
+    catch {
+        return undefined;
+    }
+};
+const getEnvInt = (key, fallback) => {
+    const getter = Env.getInt;
+    if (typeof getter === 'function') {
+        return getter(key, fallback);
+    }
+    const raw = Env[key];
+    if (typeof raw === 'number' && Number.isFinite(raw))
+        return Math.floor(raw);
+    if (typeof raw === 'string' && raw.trim() !== '') {
+        const parsed = Number(raw);
+        if (Number.isFinite(parsed))
+            return Math.floor(parsed);
+    }
+    return fallback;
+};
+const resolveQueueJobTimeoutMs = () => {
+    const timeoutManager = getTimeoutManager();
+    const tm = (timeoutManager ?? {});
+    if (typeof tm.getQueueJobTimeoutMs === 'function') {
+        return tm.getQueueJobTimeoutMs();
+    }
+    return Math.max(1000, getEnvInt('QUEUE_JOB_TIMEOUT', 60) * 1000);
+};
+const runWithTimeout = async (operation, timeoutMs, operationName) => {
+    const timeoutManager = getTimeoutManager();
+    const tm = (timeoutManager ?? {});
+    if (typeof tm.withTimeout === 'function') {
+        return tm.withTimeout(operation, timeoutMs, operationName);
+    }
+    return operation();
+};
+const isTimeoutError = (error) => {
+    const timeoutManager = getTimeoutManager();
+    const tm = (timeoutManager ?? {});
+    if (typeof tm.isTimeoutError === 'function') {
+        return tm.isTimeoutError(error);
+    }
+    if (error instanceof Error) {
+        return error.message.toLowerCase().includes('timed out');
+    }
+    return false;
+};
+const normalizeAttempts = (value) => {
+    if (typeof value === 'number' && Number.isFinite(value) && value >= 0) {
+        return Math.floor(value);
+    }
+    return 0;
+};
+const getAttemptsFromMessage = (message) => {
+    const payloadAttempts = typeof message.payload === 'object' && message.payload !== null
+        ? normalizeAttempts(message.payload['attempts'])
+        : 0;
+    const messageAttempts = normalizeAttempts(message.attempts);
+    return Math.max(payloadAttempts, messageAttempts);
+};
+const getRetryDelayMs = (nextAttempts) => {
+    const exponentialDelay = Math.min(RETRY_BASE_DELAY_MS * 2 ** Math.max(0, nextAttempts - 1), RETRY_MAX_DELAY_MS);
+    const jitterMs = Math.floor(Math.random() * 250); // NOSONAR
+    return exponentialDelay + jitterMs;
+};
 const buildBaseLogFields = (message, getLogFields) => {
     return {
         messageId: message.id,
         ...getLogFields(message.payload),
     };
 };
-const createProcessOne = (options) => {
-    return async (queueName = options.defaultQueueName, driverName) => {
-        const message = await Queue.dequeue(queueName, driverName);
-        if (!message)
-            return false;
-        const baseLogFields = buildBaseLogFields(message, options.getLogFields);
-        // Check for delayed execution
-        const payload = message.payload;
-        const rawTimestamp = 'timestamp' in payload ? payload['timestamp'] : 0;
-        const timestamp = typeof rawTimestamp === 'number' ? rawTimestamp : 0;
-        if (timestamp > Date.now()) {
-            Logger.info(`${options.kindLabel} not due yet, re-queueing`, {
-                ...baseLogFields,
-                dueAt: new Date(timestamp).toISOString(),
+const getWorkerInstanceId = () => {
+    return typeof Env['WORKER_INSTANCE_ID'] === 'string'
+        ? String(Env['WORKER_INSTANCE_ID'])
+        : undefined;
+};
+const getTrackerApi = () => {
+    return (getJobStateTracker() ?? {}) ?? {};
+};
+const getHeartbeatStoreApi = () => {
+    return (getJobHeartbeatStore() ?? {}) ?? {};
+};
+const removeHeartbeatIfSupported = async (queueName, jobId) => {
+    const heartbeatStore = getHeartbeatStoreApi();
+    if (typeof heartbeatStore.remove === 'function') {
+        await heartbeatStore.remove(queueName, jobId);
+    }
+};
+const scheduleHeartbeatLoop = (trackerApi, queueName, jobId, workerInstanceId, heartbeatIntervalMs) => {
+    return setInterval(() => {
+        if (typeof trackerApi.heartbeat === 'function') {
+            void trackerApi.heartbeat({
+                queueName,
+                jobId,
+                workerInstanceId,
             });
-            // Re-queue original payload
-            await Queue.enqueue(queueName, message.payload, driverName);
-            await Queue.ack(queueName, message.id, driverName);
-            return false;
-        }
-        try {
-            Logger.info(`Processing queued ${options.kindLabel}`, baseLogFields);
-            await options.handle(message.payload);
-            await Queue.ack(queueName, message.id, driverName);
-            Logger.info(`${options.kindLabel} processed successfully`, baseLogFields);
-            return true;
         }
-        catch (error) {
-            const attempts = message.attempts ?? 0;
-            Logger.error(`Failed to process ${options.kindLabel}`, {
-                ...baseLogFields,
-                error,
-                attempts,
+        const heartbeatStore = getHeartbeatStoreApi();
+        if (typeof heartbeatStore.heartbeat === 'function') {
+            void heartbeatStore.heartbeat({
+                queueName,
+                jobId,
+                workerInstanceId,
+                intervalMs: heartbeatIntervalMs,
             });
-            if (attempts < options.maxAttempts) {
-                await Queue.enqueue(queueName, message.payload, driverName);
-                Logger.info(`${options.kindLabel} re-queued for retry`, {
-                    ...baseLogFields,
-                    attempts: attempts + 1,
-                });
-            }
-            await Queue.ack(queueName, message.id, driverName);
-            // We processed the message (even if it failed), so return true to continue processing
-            return true;
         }
+    }, heartbeatIntervalMs);
+};
+const checkAndRequeueIfNotDue = async (options, queueName, driverName, message, baseLogFields) => {
+    const payload = message.payload;
+    const rawTimestamp = 'timestamp' in payload ? payload['timestamp'] : 0;
+    const timestamp = typeof rawTimestamp === 'number' ? rawTimestamp : 0;
+    if (timestamp <= Date.now())
+        return false;
+    Logger.info(`${options.kindLabel} not due yet, re-queueing`, {
+        ...baseLogFields,
+        dueAt: new Date(timestamp).toISOString(),
+    });
+    await Queue.enqueue(queueName, message.payload, driverName);
+    await Queue.ack(queueName, message.id, driverName);
+    return true;
+};
+const onProcessSuccess = async (input) => {
+    await Queue.ack(input.queueName, input.message.id, input.driverName);
+    if (typeof input.trackerApi.completed === 'function') {
+        await input.trackerApi.completed({
+            queueName: input.queueName,
+            jobId: input.message.id,
+            processingTimeMs: Date.now() - input.startedAtMs,
+        });
+    }
+    await removeHeartbeatIfSupported(input.queueName, input.message.id);
+    Logger.info(`${input.options.kindLabel} processed successfully`, input.baseLogFields);
+    return true;
+};
+const onProcessFailure = async (input) => {
+    const attempts = getAttemptsFromMessage(input.message);
+    const nextAttempts = attempts + 1;
+    const isFinal = nextAttempts >= input.options.maxAttempts;
+    let retryAt;
+    Logger.error(`Failed to process ${input.options.kindLabel}`, {
+        ...input.baseLogFields,
+        error: input.error,
+        attempts: nextAttempts,
+    });
+    if (isTimeoutError(input.error) && typeof input.trackerApi.timedOut === 'function') {
+        await input.trackerApi.timedOut({
+            queueName: input.queueName,
+            jobId: input.message.id,
+            reason: `Worker processing exceeded timeout for ${input.options.kindLabel}`,
+            error: input.error,
+        });
+    }
+    if (nextAttempts < input.options.maxAttempts) {
+        const retryDelayMs = getRetryDelayMs(nextAttempts);
+        retryAt = new Date(Date.now() + retryDelayMs).toISOString();
+        const currentPayload = typeof input.message.payload === 'object' && input.message.payload !== null
+            ? input.message.payload
+            : { payload: input.message.payload };
+        const payloadForRetry = {
+            ...currentPayload,
+            attempts: nextAttempts,
+            timestamp: Date.now() + retryDelayMs,
+        };
+        await Queue.enqueue(input.queueName, payloadForRetry, input.driverName);
+        Logger.info(`${input.options.kindLabel} re-queued for retry`, {
+            ...input.baseLogFields,
+            attempts: nextAttempts,
+            retryDelayMs,
+        });
+    }
+    await Queue.ack(input.queueName, input.message.id, input.driverName);
+    await removeHeartbeatIfSupported(input.queueName, input.message.id);
+    if (typeof input.trackerApi.failed === 'function') {
+        await input.trackerApi.failed({
+            queueName: input.queueName,
+            jobId: input.message.id,
+            attempts: nextAttempts,
+            isFinal,
+            retryAt,
+            error: input.error,
+        });
+    }
+    return true;
+};
+const startTrackingAndHeartbeat = async (input) => {
+    const startedAtMs = Date.now();
+    const timeoutMs = resolveQueueJobTimeoutMs();
+    const heartbeatIntervalMs = Math.max(1000, getEnvInt('JOB_HEARTBEAT_INTERVAL_MS', 10000));
+    const attempts = getAttemptsFromMessage(input.message);
+    const workerInstanceId = getWorkerInstanceId();
+    if (typeof input.trackerApi.started === 'function') {
+        await input.trackerApi.started({
+            queueName: input.queueName,
+            jobId: input.message.id,
+            attempts: attempts + 1,
+            timeoutMs,
+            workerName: input.options.kindLabel,
+            workerInstanceId,
+        });
+    }
+    const heartbeatStore = getHeartbeatStoreApi();
+    if (typeof heartbeatStore.heartbeat === 'function') {
+        await heartbeatStore.heartbeat({
+            queueName: input.queueName,
+            jobId: input.message.id,
+            workerInstanceId,
+            intervalMs: heartbeatIntervalMs,
+        });
+    }
+    const heartbeatTimer = scheduleHeartbeatLoop(input.trackerApi, input.queueName, input.message.id, workerInstanceId, heartbeatIntervalMs);
+    return { startedAtMs, heartbeatTimer };
+};
+const processQueueMessage = async (options, queueName, driverName) => {
+    const message = await Queue.dequeue(queueName, driverName);
+    if (!message)
+        return false;
+    const baseLogFields = buildBaseLogFields(message, options.getLogFields);
+    const isRequeued = await checkAndRequeueIfNotDue(options, queueName, driverName, message, baseLogFields);
+    if (isRequeued)
+        return false;
+    let heartbeatTimer;
+    const trackerApi = getTrackerApi();
+    const timeoutMs = resolveQueueJobTimeoutMs();
+    let startedAtMs;
+    try {
+        const tracking = await startTrackingAndHeartbeat({
+            options,
+            trackerApi,
+            queueName,
+            message,
+        });
+        startedAtMs = tracking.startedAtMs;
+        heartbeatTimer = tracking.heartbeatTimer;
+        Logger.info(`Processing queued ${options.kindLabel}`, baseLogFields);
+        await runWithTimeout(async () => {
+            await options.handle(message.payload);
+        }, timeoutMs, `${options.kindLabel}:${queueName}:${message.id}`);
+        return onProcessSuccess({
+            options,
+            trackerApi,
+            queueName,
+            driverName,
+            message,
+            startedAtMs,
+            baseLogFields,
+        });
+    }
+    catch (error) {
+        return onProcessFailure({
+            options,
+            trackerApi,
+            queueName,
+            driverName,
+            message,
+            baseLogFields,
+            error,
+        });
+    }
+    finally {
+        if (heartbeatTimer !== undefined) {
+            clearInterval(heartbeatTimer);
+        }
+    }
+};
+const createProcessOne = (options) => {
+    return async (queueName = options.defaultQueueName, driverName) => {
+        return processQueueMessage(options, queueName, driverName);
     };
 };
 const createProcessAll = (defaultQueueName, processOne) => {

package/dist/dashboard/workers-api.js

@@ -425,7 +425,14 @@ async function getRedisQueueData() {
         if (redisConfig?.driver !== 'redis') {
             throw ErrorFactory.createConfigError('Redis driver not configured');
         }
-        const monitor = QueueMonitor.create({ redis: redisConfig });
+        const monitor = QueueMonitor.create({
+            redis: {
+                host: redisConfig.host || 'localhost',
+                port: redisConfig.port || 6379,
+                db: redisConfig.database || 1,
+                password: redisConfig.password,
+            },
+        });
         const snapshot = await monitor.getSnapshot();
         let totalJobs = 0;
         let processingJobs = 0;

package/dist/http/WorkerController.js

@@ -3,7 +3,7 @@
  * Worker Controller
  * HTTP handlers for worker management API
  */
-import { Env, Logger, getValidatedBody } from '@zintrust/core';
+import { Cloudflare, Env, Logger, getValidatedBody, } from '@zintrust/core';
 import { CanaryController } from '../CanaryController';
 import { HealthMonitor } from '../HealthMonitor';
 import { getParam } from '../helper';
@@ -24,39 +24,41 @@ const getBody = (req) => {
         {});
 };
 // ==================== Core Worker Operations ====================
-/**
- * Create a new worker instance
- * @param req.body.name - Worker name (required)
- * @param req.body.queueName - Queue name (required)
- * @param req.body.processor - Job processor function (required; internal only)
- * @param req.body.version - Worker version (optional)
- * @param req.body.options - BullMQ worker options (optional)
- * @param req.body.infrastructure - Infrastructure config (optional)
- * @param req.body.features - Feature flags (optional)
- * @param req.body.datacenter - Datacenter placement config (optional)
- * @returns Success response with worker name
- */
-async function create(req, res) {
-    Logger.info('WorkerController.create called');
-    try {
-        const body = req.data();
-        // Validate required fields
-        if (!body.name || !body.queueName || !body.processor || !body.version) {
-            return res.setStatus(400).json({
-                error: 'Missing required fields',
-                message: 'name, queueName, processor, and version are required',
-                code: 'MISSING_REQUIRED_FIELDS',
-            });
-        }
-        const rawProcessor = body.processor;
-        let processor;
-        let processorSpec;
+const isCloudflareEnv = () => Cloudflare.getWorkersEnv() !== null;
+const validateCreatePayload = (body, res) => {
+    if (!body.name || !body.queueName || !body.processor || !body.version) {
+        res.setStatus(400).json({
+            error: 'Missing required fields',
+            message: 'name, queueName, processor, and version are required',
+            code: 'MISSING_REQUIRED_FIELDS',
+        });
+        return false;
+    }
+    return true;
+};
+const respondIfWorkerExists = async (name, persistenceOverride, res) => {
+    const existing = await WorkerFactory.getPersisted(name, persistenceOverride);
+    if (!existing)
+        return false;
+    res.status(409).json({
+        ok: false,
+        error: `Worker ${name} already exists`,
+        code: 'WORKER_EXISTS',
+        worker: existing,
+    });
+    return true;
+};
+const resolveCreateProcessor = async (body, res) => {
+    const rawProcessor = body.processor;
+    let processor = rawProcessor;
+    let processorSpec;
+    if (!isCloudflareEnv()) {
         if (typeof rawProcessor === 'string') {
             processorSpec = rawProcessor;
             const resolved = await WorkerFactory.resolveProcessorSpec(rawProcessor);
             if (!resolved) {
                 res.setStatus(400).json({ error: 'Processor spec could not be resolved' });
-                return;
+                return null;
             }
             processor = resolved;
         }
@@ -65,13 +67,22 @@ async function create(req, res) {
         }
         if (typeof processor !== 'function') {
             res.setStatus(400).json({ error: 'Processor must be a function or resolvable path' });
-            return;
+            return null;
         }
-        const config = {
-            ...body,
-            processor,
-            processorSpec,
-        };
+        return { processor, processorSpec };
+    }
+    // Cloudflare environment: treat string as spec, otherwise accept as-is
+    if (typeof rawProcessor === 'string') {
+        processorSpec = rawProcessor;
+        processor = async () => { };
+    }
+    return { processor, processorSpec };
+};
+const finalizeWorkerCreate = async (config, res) => {
+    const globalAutoStart = Env.getBool('WORKER_AUTO_START', false);
+    const workerAutoStart = config.autoStart ?? globalAutoStart;
+    const isCloudflare = isCloudflareEnv();
+    if (!isCloudflare && globalAutoStart && workerAutoStart) {
         await WorkerFactory.create(config);
         res.json({
             ok: true,
@@ -79,6 +90,50 @@ async function create(req, res) {
             status: 'creating',
             message: 'Worker creation started. Check status endpoint for progress.',
         });
+        return;
+    }
+    await WorkerFactory.register(config);
+    res.json({
+        ok: true,
+        workerName: config.name,
+        status: 'registered',
+        message: isCloudflare
+            ? 'Worker registered. Cloudflare environment detected; worker will be picked up by external processor.'
+            : 'Worker registered successfully.',
+    });
+};
+/**
+ * Create a new worker instance
+ * @param req.body.name - Worker name (required)
+ * @param req.body.queueName - Queue name (required)
+ * @param req.body.processor - Job processor function (required; internal only)
+ * @param req.body.version - Worker version (optional)
+ * @param req.body.options - BullMQ worker options (optional)
+ * @param req.body.infrastructure - Infrastructure config (optional)
+ * @param req.body.features - Feature flags (optional)
+ * @param req.body.datacenter - Datacenter placement config (optional)
+ * @returns Success response with worker name
+ */
+async function create(req, res) {
+    Logger.info('WorkerController.create called');
+    try {
+        const body = req.data();
+        if (!validateCreatePayload(body, res))
+            return;
+        const name = body.name;
+        const persistenceOverride = resolvePersistenceOverride(req);
+        const exists = await respondIfWorkerExists(name, persistenceOverride, res);
+        if (exists)
+            return;
+        const resolvedProcessor = await resolveCreateProcessor(body, res);
+        if (!resolvedProcessor)
+            return;
+        const config = {
+            ...body,
+            processor: resolvedProcessor.processor,
+            processorSpec: resolvedProcessor.processorSpec,
+        };
+        await finalizeWorkerCreate(config, res);
     }
     catch (error) {
         Logger.error('WorkerController.create failed', error);

package/dist/http/WorkerMonitoringService.js

@@ -1,9 +1,36 @@
 import { Logger, NodeSingletons, workersConfig } from '@zintrust/core';
 import { HealthMonitor } from '../HealthMonitor';
 import { getWorkers } from '../dashboard/workers-api';
+const createFallbackEmitter = () => {
+    const listeners = new Map();
+    return {
+        on(event, listener) {
+            const set = listeners.get(event) ?? new Set();
+            set.add(listener);
+            listeners.set(event, set);
+        },
+        off(event, listener) {
+            const set = listeners.get(event);
+            if (!set)
+                return;
+            set.delete(listener);
+            if (set.size === 0)
+                listeners.delete(event);
+        },
+        emit(event, payload) {
+            const set = listeners.get(event);
+            if (!set)
+                return false;
+            for (const listener of set)
+                listener(payload);
+            return true;
+        },
+    };
+};
 // Internal state
-const emitter = new NodeSingletons.EventEmitter();
-emitter.setMaxListeners(Infinity);
+const EventEmitterCtor = NodeSingletons?.EventEmitter;
+const emitter = typeof EventEmitterCtor === 'function' ? new EventEmitterCtor() : createFallbackEmitter();
+emitter.setMaxListeners?.(Infinity);
 let interval = null;
 let subscribers = 0;
 const INTERVAL_MS = workersConfig?.intervalMs || 5000;

package/dist/index.d.ts

@@ -26,14 +26,13 @@ export { WorkerFactory } from './WorkerFactory';
 export type { ProcessorResolver, WorkerFactoryConfig, WorkerPersistenceConfig, } from './WorkerFactory';
 export { WorkerInit } from './WorkerInit';
 export { WorkerShutdown } from './WorkerShutdown';
-export { ZinTrustWorkerShutdownDurableObject } from './WorkerShutdownDurableObject';
 export { WorkerController } from './http/WorkerController';
 export { registerWorkerRoutes } from './routes/workers';
 export { BroadcastWorker } from './BroadcastWorker';
 export { createQueueWorker } from './createQueueWorker';
 export type { CreateQueueWorkerOptions } from './createQueueWorker';
 export { NotificationWorker } from './NotificationWorker';
-export type { RedisConfig, WorkerAutoScalingConfig, WorkerComplianceConfig, WorkerConfig, WorkerCostConfig, WorkerObservabilityConfig, WorkersConfigOverrides, WorkersGlobalConfig, WorkerStatus, WorkerVersioningConfig, } from '@zintrust/core';
+export type { RedisConfig, WorkerAutoScalingConfig, WorkerComplianceConfig, WorkerConfig, WorkerCostConfig, WorkerObservabilityConfig, WorkerStatus, WorkerVersioningConfig, WorkersConfigOverrides, WorkersGlobalConfig, } from '@zintrust/core';
 export type { Job, Worker, WorkerOptions } from 'bullmq';
 export type { IAnomaly, IAnomalyConfig, IForecast, IMetric, IPrediction, IRecommendation, IRootCauseAnalysis, } from './AnomalyDetection';
 export type { IChaosComparison, IChaosExperiment, IChaosReport, IChaosStatus, } from './ChaosEngineering';

package/dist/index.js

@@ -33,7 +33,6 @@ export { WorkerVersioning } from './WorkerVersioning';
 export { WorkerFactory } from './WorkerFactory';
 export { WorkerInit } from './WorkerInit';
 export { WorkerShutdown } from './WorkerShutdown';
-export { ZinTrustWorkerShutdownDurableObject } from './WorkerShutdownDurableObject';
 // HTTP Controllers & Routes
 export { WorkerController } from './http/WorkerController';
 export { registerWorkerRoutes } from './routes/workers';

package/dist/routes/workers.js

@@ -2,7 +2,7 @@
  * Worker Management Routes
  * HTTP API for managing workers with dashboard functionality
  */
-import { Logger, Router } from '@zintrust/core';
+import { Cloudflare, Env, Logger, Router } from '@zintrust/core';
 import { HealthMonitor } from '../HealthMonitor';
 import { ValidationSchemas, withCustomValidation } from '../http/middleware/CustomValidation';
 import { withEditWorkerValidation } from '../http/middleware/EditWorkerValidation';
@@ -70,11 +70,13 @@ function registerUtilityRoutes(r) {
 function registerWorkerLifecycleRoutes(router, middleware) {
     Router.group(router, '/api/workers', (r) => {
         Logger.info('Registering Worker Management Routes');
-        registerMonitoringRoutes(r); // ← Move FIRST - has /events
         registerCoreWorkerRoutes(r);
-        registerWorkerQueryRoutes(r);
-        registerVersioningRoutes(r);
-        registerUtilityRoutes(r);
+        if (Cloudflare.getWorkersEnv() === null) {
+            registerMonitoringRoutes(r); // ← Move FIRST - has /events
+            registerWorkerQueryRoutes(r);
+            registerVersioningRoutes(r);
+            registerUtilityRoutes(r);
+        }
     }, { middleware: middleware });
 }
 function registerWorkerTelemetryRoutes(router, middleware) {
@@ -117,7 +119,8 @@ export function registerWorkerRoutes(router, _options, routeOptions) {
         basePath: '/telemetry',
     });
     dashboard.registerRoutes(router);
-    Logger.info('Worker routes registered at http://127.0.0.1:7777/workers');
-    Logger.info('Telemetry dashboard registered at http://127.0.0.1:7777/telemetry');
+    const port = Env.get('PORT', '7777');
+    Logger.info(`Worker routes registered at http://127.0.0.1:${port}/workers`);
+    Logger.info(`Telemetry dashboard registered at http://127.0.0.1:${port}/telemetry`);
 }
 export default registerWorkerRoutes;

package/dist/storage/WorkerStore.d.ts

@@ -2,8 +2,9 @@
  * Worker Store
  * Persistence layer for workers (memory, redis, db)
  */
-import type { IDatabase } from '@zintrust/core';
-import type { Redis } from 'ioredis';
+import type { createRedisConnection } from '@zintrust/core';
+import { type IDatabase } from '@zintrust/core';
+type RedisConnection = ReturnType<typeof createRedisConnection>;
 export type WorkerRecord = {
     name: string;
     queueName: string;
@@ -36,13 +37,15 @@ export type WorkerStore = {
     update(name: string, patch: Partial<WorkerRecord>): Promise<void>;
     updateMany?: (names: string[], patch: Partial<WorkerRecord>) => Promise<void>;
     remove(name: string): Promise<void>;
+    close?(): Promise<void>;
 };
 export declare const InMemoryWorkerStore: Readonly<{
     create(): WorkerStore;
 }>;
 export declare const RedisWorkerStore: Readonly<{
-    create(client: Redis, keyPrefix?: string): WorkerStore;
+    create(client: RedisConnection, keyPrefix?: string): WorkerStore;
 }>;
 export declare const DbWorkerStore: Readonly<{
     create(db: IDatabase, table?: string): WorkerStore;
 }>;
+export {};