@zintrust/workers 0.1.30 → 0.1.43

package/dist/ui/workers/zintrust.svg

@@ -0,0 +1,30 @@
+<svg width="120" height="120" viewBox="0 0 100 100" fill="none" xmlns="http://www.w3.org/2000/svg">
+  <defs>
+    <linearGradient id="zt-g2d" x1="10" y1="50" x2="90" y2="50" gradientUnits="userSpaceOnUse">
+      <stop stop-color="#22c55e" />
+      <stop offset="1" stop-color="#38bdf8" />
+    </linearGradient>
+  </defs>
+  <circle cx="50" cy="50" r="34" stroke="rgba(255,255,255,0.16)" stroke-width="4" />
+  <ellipse cx="50" cy="50" rx="40" ry="18" stroke="url(#zt-g2d)" stroke-width="4" />
+  <ellipse cx="50" cy="50" rx="18" ry="40" stroke="url(#zt-g2d)" stroke-width="4" opacity="0.75" />
+  <circle cx="50" cy="50" r="6" fill="url(#zt-g2d)" />
+  <path
+    d="M40 52C35 52 32 49 32 44C32 39 35 36 40 36H48"
+    stroke="white"
+    stroke-width="6"
+    stroke-linecap="round"
+  />
+  <path
+    d="M60 48C65 48 68 51 68 56C68 61 65 64 60 64H52"
+    stroke="white"
+    stroke-width="6"
+    stroke-linecap="round"
+  />
+  <path
+    d="M44 50H56"
+    stroke="rgba(255,255,255,0.22)"
+    stroke-width="6"
+    stroke-linecap="round"
+  />
+</svg>

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zintrust/workers",
-  "version": "0.1.30",
+  "version": "0.1.43",
   "private": false,
   "type": "module",
   "main": "./dist/index.js",
@@ -35,13 +35,13 @@
     "node": ">=20.0.0"
   },
   "peerDependencies": {
-    "@zintrust/core": "file:../../dist"
+    "@zintrust/core": "^0.1.43"
   },
   "publishConfig": {
     "access": "public"
   },
   "scripts": {
-    "build": "tsc -p tsconfig.json",
+    "build": "node scripts/generate-embedded-assets.mjs && tsc -p tsconfig.json",
     "prepublishOnly": "npm run build"
   },
   "dependencies": {
@@ -53,7 +53,7 @@
     "simple-statistics": "^7.8.8"
   },
   "optionalDependencies": {
-    "@zintrust/queue-redis": "^0.1.27",
-    "@zintrust/queue-monitor": "^0.1.27"
+    "@zintrust/queue-monitor": "^0.1.27",
+    "@zintrust/queue-redis": "^0.1.27"
   }
 }

package/src/ClusterLock.ts

@@ -12,7 +12,8 @@ import {
   generateUuid,
   type RedisConfig,
 } from '@zintrust/core';
-import type IORedis from 'ioredis';
+
+type RedisConnection = ReturnType<typeof createRedisConnection>;
 
 export type LockAcquisitionOptions = {
   lockKey: string;
@@ -60,7 +61,7 @@ const LOCK_PREFIX = 'worker:lock:';
 const AUDIT_PREFIX = 'worker:audit:lock:';
 
 // Internal state
-let redisClient: IORedis | null = null;
+let redisClient: RedisConnection | null = null;
 let heartbeatInterval: NodeJS.Timeout | null = null;
 const activeLocks = new Map<string, LockInfo>();
 
@@ -81,7 +82,7 @@ const getAuditKey = (lockKey: string): string => {
 /**
  * Helper: Store audit log entry in Redis
  */
-const auditLockOperation = async (client: IORedis, entry: AuditLogEntry): Promise<void> => {
+const auditLockOperation = async (client: RedisConnection, entry: AuditLogEntry): Promise<void> => {
   try {
     const auditKey = getAuditKey(entry.lockKey);
     const auditData = JSON.stringify(entry);
@@ -103,7 +104,11 @@ const auditLockOperation = async (client: IORedis, entry: AuditLogEntry): Promis
 /**
  * Helper: Extend lock TTL
  */
-const extendLockTTL = async (client: IORedis, lockKey: string, ttl: number): Promise<boolean> => {
+const extendLockTTL = async (
+  client: RedisConnection,
+  lockKey: string,
+  ttl: number
+): Promise<boolean> => {
   const redisKey = getLockKey(lockKey);
   const value = await client.get(redisKey);
 
@@ -118,7 +123,7 @@ const extendLockTTL = async (client: IORedis, lockKey: string, ttl: number): Pro
 /**
  * Helper: Start heartbeat for lock extension
  */
-const startHeartbeat = (client: IORedis): void => {
+const startHeartbeat = (client: RedisConnection): void => {
   if (heartbeatInterval) {
     return; // Already running
   }
@@ -188,8 +193,9 @@ export const ClusterLock = Object.freeze({
       return;
     }
 
-    redisClient = createRedisConnection(config);
-    startHeartbeat(redisClient);
+    const client = createRedisConnection(config);
+    redisClient = client;
+    startHeartbeat(client);
 
     Logger.info('ClusterLock initialized', { instanceId: getInstanceId() });
   },

package/src/ComplianceManager.ts

@@ -11,7 +11,8 @@ import {
   createRedisConnection,
   type RedisConfig,
 } from '@zintrust/core';
-import type IORedis from 'ioredis';
+
+type RedisConnection = ReturnType<typeof createRedisConnection>;
 
 type CryptoAdapter = {
   createCipheriv: typeof NodeSingletons.createCipheriv;
@@ -134,7 +135,7 @@ const VIOLATION_PREFIX = 'compliance:violation:';
 const CONSENT_PREFIX = 'compliance:consent:';
 
 // Internal state
-let redisClient: IORedis | null = null;
+let redisClient: RedisConnection | null = null;
 let complianceConfig: ComplianceConfig | null = null;
 
 // Default configuration

package/src/DeadLetterQueue.ts

@@ -5,7 +5,9 @@
  */
 
 import { ErrorFactory, Logger, createRedisConnection, type RedisConfig } from '@zintrust/core';
-import type IORedis from 'ioredis';
+import { keyPrefix } from './config/workerConfig';
+
+type RedisConnection = ReturnType<typeof createRedisConnection>;
 
 export type FailedJobEntry = {
   id: string;
@@ -72,15 +74,15 @@ export type DLQStats = {
 
 // Redis key prefixes - using workers package prefix system
 const getDLQPrefix = (): string => {
-  return 'worker:dlq:';
+  return keyPrefix() + ':dlq:';
 };
 
 const getAuditPrefix = (): string => {
-  return 'worker:dlq:audit:';
+  return keyPrefix() + ':dlq:audit:';
 };
 
 // Internal state
-let redisClient: IORedis | null = null;
+let redisClient: RedisConnection | null = null;
 let retentionPolicy: RetentionPolicy | null = null;
 let cleanupInterval: NodeJS.Timeout | null = null;
 

package/src/HealthMonitor.ts

@@ -70,11 +70,7 @@ const persistStatusChange = async (
   }
 };
 
-const verifyWorkerHealth = async (
-  worker: Worker,
-  _name: string,
-  _queueName: string
-): Promise<boolean> => {
+const verifyWorkerHealth = async (worker: Worker): Promise<boolean> => {
   // Check if isClosing exists (isClosing check safe for mocks)
   const workerAny = worker as unknown as Record<string, unknown>;
   const isClosingFn = workerAny['isClosing'];
@@ -94,10 +90,38 @@ const verifyWorkerHealth = async (
   if (pingResult !== 'PONG') {
     throw ErrorFactory.createWorkerError(`Redis ping failed: ${pingResult}`);
   }
-  Logger.debug(`Worker health verification passed for ${_name} ${_queueName}`);
   return true;
 };
 
+const withTimeout = async <T>(
+  promise: Promise<T>,
+  timeoutMs: number,
+  onTimeout: () => Error
+): Promise<T> => {
+  let timeoutId: NodeJS.Timeout | null = null;
+
+  return await new Promise<T>((resolve, reject) => {
+    timeoutId = globalThis.setTimeout(() => {
+      if (timeoutId) {
+        clearTimeout(timeoutId);
+        timeoutId = null;
+      }
+      reject(onTimeout());
+    }, timeoutMs);
+    timeoutId.unref();
+
+    promise
+      .then(resolve)
+      .catch(reject)
+      .finally(() => {
+        if (timeoutId) {
+          clearTimeout(timeoutId);
+          timeoutId = null;
+        }
+      });
+  });
+};
+
 const updateState = (
   state: WorkerHealthState,
   isHealthy: boolean,
@@ -177,17 +201,9 @@ const performCheck = async (state: WorkerHealthState): Promise<void> => {
       throw ErrorFactory.createWorkerError('Worker instance not available');
     }
 
-    isHealthy = await Promise.race([
-      verifyWorkerHealth(state.worker, state.name, state.queueName || 'unknown'),
-      new Promise<boolean>((_, reject) => {
-        // eslint-disable-next-line
-        const id = setTimeout(() => {
-          reject(ErrorFactory.createWorkerError('Health check timeout'));
-        }, config.checkTimeoutMs);
-        // Unref to prevent holding event loop if everything else finishes
-        id.unref();
-      }),
-    ]);
+    isHealthy = await withTimeout(verifyWorkerHealth(state.worker), config.checkTimeoutMs, () =>
+      ErrorFactory.createWorkerError('Health check timeout')
+    );
   } catch (err) {
     isHealthy = false;
     errorMsg = (err as Error).message;

package/src/Observability.ts

@@ -64,6 +64,13 @@ let spanSweepInterval: NodeJS.Timeout | null = null;
 const MAX_ACTIVE_SPANS = 1000;
 const SPAN_TTL_MS = 5 * 60 * 1000;
 
+type UnrefableTimer = { unref: () => void };
+
+const isUnrefableTimer = (value: unknown): value is UnrefableTimer => {
+  if (typeof value !== 'object' || value === null) return false;
+  return 'unref' in value && typeof (value as UnrefableTimer).unref === 'function';
+};
+
 const cleanupStaleSpans = (): void => {
   const now = Date.now();
   for (const [spanId, entry] of activeSpans.entries()) {
@@ -237,6 +244,10 @@ export const Observability = Object.freeze({
       spanSweepInterval = setInterval(() => {
         cleanupStaleSpans();
       }, SPAN_TTL_MS);
+
+      if (isUnrefableTimer(spanSweepInterval)) {
+        spanSweepInterval.unref();
+      }
     }
 
     Logger.info('Observability initialized', {