@zintrust/core 0.1.42 → 0.1.44

package/packages/workers/src/http/middleware/QueueNameSanitizer.js

@@ -0,0 +1,45 @@
+import { Logger } from '../../../../../src/index.js';
+const QUEUE_NAME_PATTERN = /^[a-zA-Z0-9_-]{3,50}$/;
+export const withQueueNameValidation = (handler) => {
+    return async (req, res) => {
+        try {
+            const data = req.data();
+            const queueName = data['queueName'];
+            if (!queueName) {
+                return res.setStatus(400).json({
+                    error: 'Queue name is required',
+                    code: 'MISSING_QUEUE_NAME',
+                });
+            }
+            if (!QUEUE_NAME_PATTERN.test(queueName)) {
+                return res.setStatus(400).json({
+                    error: 'Invalid queue name',
+                    message: 'Queue name must be 3-50 characters long and contain only letters, numbers, hyphens, and underscores',
+                    code: 'INVALID_QUEUE_NAME',
+                });
+            }
+            // Sanitize the queue name
+            const sanitizedQueueName = queueName
+                .trim()
+                .replaceAll(/[^a-zA-Z0-9_-]/g, '')
+                .substring(0, 50);
+            if (sanitizedQueueName.length < 3) {
+                return res.setStatus(400).json({
+                    error: 'Queue name too short after sanitization',
+                    message: 'Queue name must be at least 3 characters long',
+                    code: 'QUEUE_NAME_TOO_SHORT',
+                });
+            }
+            const currentBody = req.getBody();
+            req.setBody({ ...currentBody, queueName: sanitizedQueueName });
+            return handler(req, res);
+        }
+        catch (error) {
+            Logger.error('Queue name validation failed', error);
+            return res.setStatus(500).json({
+                error: 'Internal validation error',
+                code: 'VALIDATION_ERROR',
+            });
+        }
+    };
+};

package/packages/workers/src/http/middleware/ValidateDriver.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Validate Driver Middleware
+ * Ensures the 'driver' query parameter is valid if present.
+ */
+import type { IRequest, IResponse } from '../../../../../src/index.js';
+export type RouteHandler = (req: IRequest, res: IResponse) => Promise<void> | void;
+export declare const withDriverValidation: (handler: RouteHandler) => RouteHandler;
+//# sourceMappingURL=ValidateDriver.d.ts.map

package/packages/workers/src/http/middleware/ValidateDriver.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ValidateDriver.d.ts","sourceRoot":"","sources":["../../../../../../packages/workers/src/http/middleware/ValidateDriver.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,KAAK,EAAE,QAAQ,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAC;AAE1D,MAAM,MAAM,YAAY,GAAG,CAAC,GAAG,EAAE,QAAQ,EAAE,GAAG,EAAE,SAAS,KAAK,OAAO,CAAC,IAAI,CAAC,GAAG,IAAI,CAAC;AAInF,eAAO,MAAM,oBAAoB,GAAI,SAAS,YAAY,KAAG,YAiB5D,CAAC"}

package/packages/workers/src/http/middleware/ValidateDriver.js

@@ -0,0 +1,20 @@
+/**
+ * Validate Driver Middleware
+ * Ensures the 'driver' query parameter is valid if present.
+ */
+const VALID_DRIVERS = new Set(['database', 'redis', 'memory']);
+export const withDriverValidation = (handler) => {
+    return async (req, res) => {
+        const driver = req.getQueryParam('driver');
+        // Normalize to string if it's an array (take first)
+        const driverValue = Array.isArray(driver) ? driver[0] : driver;
+        if (driverValue && !VALID_DRIVERS.has(driverValue)) {
+            res.setStatus(400).json({
+                error: 'Invalid driver parameter',
+                message: 'Driver must be one of: database, redis, memory',
+            });
+            return;
+        }
+        return handler(req, res);
+    };
+};

package/packages/workers/src/http/middleware/VersionSanitizer.d.ts

@@ -0,0 +1,4 @@
+import { type IRequest, type IResponse } from '../../../../../src/index.js';
+export type RouteHandler = (req: IRequest, res: IResponse) => Promise<void> | void;
+export declare const withVersionValidation: (handler: RouteHandler) => RouteHandler;
+//# sourceMappingURL=VersionSanitizer.d.ts.map

package/packages/workers/src/http/middleware/VersionSanitizer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"VersionSanitizer.d.ts","sourceRoot":"","sources":["../../../../../../packages/workers/src/http/middleware/VersionSanitizer.ts"],"names":[],"mappings":"AAAA,OAAO,EAAU,KAAK,QAAQ,EAAE,KAAK,SAAS,EAAE,MAAM,gBAAgB,CAAC;AAEvE,MAAM,MAAM,YAAY,GAAG,CAAC,GAAG,EAAE,QAAQ,EAAE,GAAG,EAAE,SAAS,KAAK,OAAO,CAAC,IAAI,CAAC,GAAG,IAAI,CAAC;AAInF,eAAO,MAAM,qBAAqB,GAAI,SAAS,YAAY,KAAG,YAuB7D,CAAC"}

package/packages/workers/src/http/middleware/VersionSanitizer.js

@@ -0,0 +1,25 @@
+import { Logger } from '../../../../../src/index.js';
+const VERSION_PATTERN = /^\d+\.\d+\.\d+$/;
+export const withVersionValidation = (handler) => {
+    return async (req, res) => {
+        try {
+            const data = req.data();
+            const version = data['version'];
+            if (version && !VERSION_PATTERN.test(version)) {
+                return res.setStatus(400).json({
+                    error: 'Invalid version format',
+                    message: 'Version must follow semantic versioning (e.g., 1.0.0)',
+                    code: 'INVALID_VERSION_FORMAT',
+                });
+            }
+            return handler(req, res);
+        }
+        catch (error) {
+            Logger.error('Version validation failed', error);
+            return res.setStatus(500).json({
+                error: 'Internal validation error',
+                code: 'VALIDATION_ERROR',
+            });
+        }
+    };
+};

package/packages/workers/src/http/middleware/WorkerNameSanitizer.d.ts

@@ -0,0 +1,4 @@
+import { type IRequest, type IResponse } from '../../../../../src/index.js';
+export type RouteHandler = (req: IRequest, res: IResponse) => Promise<void> | void;
+export declare const withWorkerNameValidation: (handler: RouteHandler) => RouteHandler;
+//# sourceMappingURL=WorkerNameSanitizer.d.ts.map

package/packages/workers/src/http/middleware/WorkerNameSanitizer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"WorkerNameSanitizer.d.ts","sourceRoot":"","sources":["../../../../../../packages/workers/src/http/middleware/WorkerNameSanitizer.ts"],"names":[],"mappings":"AAAA,OAAO,EAAU,KAAK,QAAQ,EAAE,KAAK,SAAS,EAAE,MAAM,gBAAgB,CAAC;AAEvE,MAAM,MAAM,YAAY,GAAG,CAAC,GAAG,EAAE,QAAQ,EAAE,GAAG,EAAE,SAAS,KAAK,OAAO,CAAC,IAAI,CAAC,GAAG,IAAI,CAAC;AAInF,eAAO,MAAM,wBAAwB,GAAI,SAAS,YAAY,KAAG,YAiDhE,CAAC"}

package/packages/workers/src/http/middleware/WorkerNameSanitizer.js

@@ -0,0 +1,46 @@
+import { Logger } from '../../../../../src/index.js';
+const WORKER_NAME_PATTERN = /^[a-zA-Z0-9_-]{3,50}$/;
+export const withWorkerNameValidation = (handler) => {
+    return async (req, res) => {
+        try {
+            const data = req.data();
+            const workerName = data['name'];
+            if (!workerName) {
+                return res.setStatus(400).json({
+                    error: 'Worker name is required',
+                    code: 'MISSING_WORKER_NAME',
+                });
+            }
+            if (!WORKER_NAME_PATTERN.test(workerName)) {
+                return res.setStatus(400).json({
+                    error: 'Invalid worker name',
+                    message: 'Worker name must be 3-50 characters long and contain only letters, numbers, hyphens, and underscores',
+                    code: 'INVALID_WORKER_NAME',
+                });
+            }
+            // Sanitize the name
+            const sanitizedName = workerName
+                .trim()
+                .replaceAll(/[^a-zA-Z0-9_-]/g, '')
+                .substring(0, 50);
+            if (sanitizedName.length < 3) {
+                return res.setStatus(400).json({
+                    error: 'Worker name too short after sanitization',
+                    message: 'Worker name must be at least 3 characters long',
+                    code: 'WORKER_NAME_TOO_SHORT',
+                });
+            }
+            // Update the request data with sanitized value
+            const currentBody = req.getBody();
+            req.setBody({ ...currentBody, name: sanitizedName });
+            return handler(req, res);
+        }
+        catch (error) {
+            Logger.error('Worker name validation failed', error);
+            return res.setStatus(500).json({
+                error: 'Internal validation error',
+                code: 'VALIDATION_ERROR',
+            });
+        }
+    };
+};

package/packages/workers/src/http/middleware/WorkerValidationChain.d.ts

@@ -0,0 +1,28 @@
+import { type IRequest, type IResponse } from '../../../../../src/index.js';
+export type RouteHandler = (req: IRequest, res: IResponse) => Promise<void> | void;
+/**
+ * Composite middleware for worker creation validation
+ * Validates all required fields for creating a new worker
+ */
+export declare const withCreateWorkerValidation: (handler: RouteHandler) => RouteHandler;
+/**
+ * Composite middleware for worker update validation
+ * Validates optional fields for updating an existing worker
+ */
+export declare const withUpdateWorkerValidation: (handler: RouteHandler) => RouteHandler;
+/**
+ * Composite middleware for worker operation validation
+ * Validates worker name for operations like start, stop, restart, etc.
+ */
+export declare const withWorkerOperationValidation: (handler: RouteHandler) => RouteHandler;
+/**
+ * Composite middleware for bulk operations validation
+ * Validates arrays of worker names and operation parameters
+ */
+export declare const withBulkOperationValidation: (handler: RouteHandler) => RouteHandler;
+/**
+ * Composite middleware for canary deployment validation
+ * Validates canary-specific parameters
+ */
+export declare const withCanaryDeploymentValidation: (handler: RouteHandler) => RouteHandler;
+//# sourceMappingURL=WorkerValidationChain.d.ts.map

package/packages/workers/src/http/middleware/WorkerValidationChain.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"WorkerValidationChain.d.ts","sourceRoot":"","sources":["../../../../../../packages/workers/src/http/middleware/WorkerValidationChain.ts"],"names":[],"mappings":"AAAA,OAAO,EAAU,KAAK,QAAQ,EAAE,KAAK,SAAS,EAAE,MAAM,gBAAgB,CAAC;AAEvE,MAAM,MAAM,YAAY,GAAG,CAAC,GAAG,EAAE,QAAQ,EAAE,GAAG,EAAE,SAAS,KAAK,OAAO,CAAC,IAAI,CAAC,GAAG,IAAI,CAAC;AAanF;;;GAGG;AACH,eAAO,MAAM,0BAA0B,GAAI,SAAS,YAAY,KAAG,YA2BlE,CAAC;AAEF;;;GAGG;AACH,eAAO,MAAM,0BAA0B,GAAI,SAAS,YAAY,KAAG,YAIlE,CAAC;AAEF;;;GAGG;AACH,eAAO,MAAM,6BAA6B,GAAI,SAAS,YAAY,KAAG,YAErE,CAAC;AAEF;;;GAGG;AACH,eAAO,MAAM,2BAA2B,GAAI,SAAS,YAAY,KAAG,YA8EnE,CAAC;AAEF;;;GAGG;AACH,eAAO,MAAM,8BAA8B,GAAI,SAAS,YAAY,KAAG,YA4EtE,CAAC"}

package/packages/workers/src/http/middleware/WorkerValidationChain.js

@@ -0,0 +1,186 @@
+import { Logger } from '../../../../../src/index.js';
+// Import individual validators
+import { withDatacenterValidation } from './DatacenterValidator.js';
+import { withFeaturesValidation } from './FeaturesValidator.js';
+import { withInfrastructureValidation } from './InfrastructureValidator.js';
+import { withOptionsValidation } from './OptionsValidator.js';
+import { withStrictPayloadKeys } from './PayloadSanitizer.js';
+import { withProcessorPathValidation } from './ProcessorPathSanitizer.js';
+import { withQueueNameValidation } from './QueueNameSanitizer.js';
+import { withVersionValidation } from './VersionSanitizer.js';
+import { withWorkerNameValidation } from './WorkerNameSanitizer.js';
+/**
+ * Composite middleware for worker creation validation
+ * Validates all required fields for creating a new worker
+ */
+export const withCreateWorkerValidation = (handler) => {
+    return withStrictPayloadKeys([
+        'name',
+        'queueName',
+        'processor',
+        'version',
+        'options',
+        'infrastructure',
+        'features',
+        'datacenter',
+        'activeStatus',
+    ], withProcessorPathValidation(withWorkerNameValidation(withQueueNameValidation(withVersionValidation(withOptionsValidation(withInfrastructureValidation(withFeaturesValidation(withDatacenterValidation(handler)))))))));
+};
+/**
+ * Composite middleware for worker update validation
+ * Validates optional fields for updating an existing worker
+ */
+export const withUpdateWorkerValidation = (handler) => {
+    return withVersionValidation(withInfrastructureValidation(withFeaturesValidation(withDatacenterValidation(handler))));
+};
+/**
+ * Composite middleware for worker operation validation
+ * Validates worker name for operations like start, stop, restart, etc.
+ */
+export const withWorkerOperationValidation = (handler) => {
+    return withWorkerNameValidation(handler);
+};
+/**
+ * Composite middleware for bulk operations validation
+ * Validates arrays of worker names and operation parameters
+ */
+export const withBulkOperationValidation = (handler) => {
+    return async (req, res) => {
+        try {
+            const data = req.data();
+            const workerNames = data['workerNames'];
+            // Handle single worker name or array of names
+            const names = Array.isArray(workerNames) ? workerNames : [workerNames];
+            // Prevent enormous bulk operations
+            const MAX_BULK_NAMES = 1000;
+            if (names.length > MAX_BULK_NAMES) {
+                return res.setStatus(413).json({
+                    error: 'Too many worker names',
+                    message: `Bulk operation exceeds maximum allowed names (${MAX_BULK_NAMES})`,
+                    code: 'BULK_OPERATION_TOO_LARGE',
+                });
+            }
+            if (!names || names.length === 0) {
+                return res.setStatus(400).json({
+                    error: 'Worker names are required',
+                    message: 'At least one worker name must be provided',
+                    code: 'MISSING_WORKER_NAMES',
+                });
+            }
+            // Validate each worker name
+            const WORKER_NAME_PATTERN = /^[a-zA-Z0-9_-]{3,50}$/;
+            for (const name of names) {
+                if (!name || typeof name !== 'string') {
+                    return res.setStatus(400).json({
+                        error: 'Invalid worker name',
+                        message: 'Worker name must be a string',
+                        code: 'INVALID_WORKER_NAME_TYPE',
+                    });
+                }
+                if (!WORKER_NAME_PATTERN.test(name)) {
+                    return res.setStatus(400).json({
+                        error: 'Invalid worker name',
+                        message: `Worker name "${name}" must be 3-50 characters long and contain only letters, numbers, hyphens, and underscores`,
+                        code: 'INVALID_WORKER_NAME',
+                    });
+                }
+            }
+            // Sanitize worker names
+            const sanitizedNames = names
+                .map((name) => name
+                .trim()
+                .replaceAll(/[^a-zA-Z0-9_-]/g, '')
+                .substring(0, 50))
+                .filter((name) => name.length >= 3);
+            if (sanitizedNames.length === 0) {
+                return res.setStatus(400).json({
+                    error: 'No valid worker names after sanitization',
+                    message: 'All worker names were invalid after sanitization',
+                    code: 'NO_VALID_WORKER_NAMES',
+                });
+            }
+            // Update request data with sanitized names
+            const currentBody = req.getBody();
+            req.setBody({ ...currentBody, workerNames: sanitizedNames });
+            return handler(req, res);
+        }
+        catch (error) {
+            Logger.error('Bulk operation validation failed', error);
+            return res.setStatus(500).json({
+                error: 'Internal validation error',
+                code: 'VALIDATION_ERROR',
+            });
+        }
+    };
+};
+/**
+ * Composite middleware for canary deployment validation
+ * Validates canary-specific parameters
+ */
+export const withCanaryDeploymentValidation = (handler) => {
+    return async (req, res) => {
+        try {
+            const data = req.data();
+            const newVersion = data['newVersion'];
+            const initialTrafficPercent = data['initialTrafficPercent'];
+            const targetTrafficPercent = data['targetTrafficPercent'];
+            // Validate new version
+            if (!newVersion) {
+                return res.setStatus(400).json({
+                    error: 'New version is required',
+                    code: 'MISSING_NEW_VERSION',
+                });
+            }
+            const VERSION_PATTERN = /^\d+\.\d+\.\d+$/;
+            if (!VERSION_PATTERN.test(newVersion)) {
+                return res.setStatus(400).json({
+                    error: 'Invalid version format',
+                    message: 'Version must follow semantic versioning (e.g., 1.0.0)',
+                    code: 'INVALID_VERSION_FORMAT',
+                });
+            }
+            // Validate initial traffic percent
+            if (initialTrafficPercent !== undefined) {
+                if (typeof initialTrafficPercent !== 'number' ||
+                    initialTrafficPercent < 0 ||
+                    initialTrafficPercent > 100) {
+                    return res.setStatus(400).json({
+                        error: 'Invalid initial traffic percent',
+                        message: 'Initial traffic percent must be a number between 0 and 100',
+                        code: 'INVALID_INITIAL_TRAFFIC_PERCENT',
+                    });
+                }
+            }
+            // Validate target traffic percent
+            if (targetTrafficPercent !== undefined) {
+                if (typeof targetTrafficPercent !== 'number' ||
+                    targetTrafficPercent < 0 ||
+                    targetTrafficPercent > 100) {
+                    return res.setStatus(400).json({
+                        error: 'Invalid target traffic percent',
+                        message: 'Target traffic percent must be a number between 0 and 100',
+                        code: 'INVALID_TARGET_TRAFFIC_PERCENT',
+                    });
+                }
+            }
+            // Validate traffic progression
+            if (initialTrafficPercent !== undefined && targetTrafficPercent !== undefined) {
+                if (targetTrafficPercent < initialTrafficPercent) {
+                    return res.setStatus(400).json({
+                        error: 'Invalid traffic progression',
+                        message: 'Target traffic percent must be greater than or equal to initial traffic percent',
+                        code: 'INVALID_TRAFFIC_PROGRESSION',
+                    });
+                }
+            }
+            return handler(req, res);
+        }
+        catch (error) {
+            Logger.error('Canary deployment validation failed', error);
+            return res.setStatus(500).json({
+                error: 'Internal validation error',
+                code: 'VALIDATION_ERROR',
+            });
+        }
+    };
+};

package/packages/workers/src/index.d.ts

@@ -0,0 +1,47 @@
+/**
+ * Worker Management System - Public API
+ *
+ * Central export file for all worker management modules.
+ */
+export { ClusterLock } from './ClusterLock';
+export { PriorityQueue } from './PriorityQueue';
+export { WorkerMetrics } from './WorkerMetrics';
+export { WorkerRegistry } from './WorkerRegistry';
+export { AutoScaler } from './AutoScaler';
+export { CircuitBreaker } from './CircuitBreaker';
+export { DeadLetterQueue } from './DeadLetterQueue';
+export { HealthMonitor } from './HealthMonitor';
+export { ResourceMonitor } from './ResourceMonitor';
+export { SLAMonitor } from './SLAMonitor';
+export { ComplianceManager } from './ComplianceManager';
+export { Observability } from './Observability';
+export { PluginManager } from './PluginManager';
+export { AnomalyDetection } from './AnomalyDetection';
+export { CanaryController } from './CanaryController';
+export { ChaosEngineering } from './ChaosEngineering';
+export { DatacenterOrchestrator } from './DatacenterOrchestrator';
+export { MultiQueueWorker } from './MultiQueueWorker';
+export { WorkerVersioning } from './WorkerVersioning';
+export { WorkerFactory } from './WorkerFactory';
+export type { ProcessorResolver, WorkerFactoryConfig, WorkerPersistenceConfig, } from './WorkerFactory';
+export { WorkerInit } from './WorkerInit';
+export { WorkerShutdown } from './WorkerShutdown';
+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, WorkerStatus, WorkerVersioningConfig, WorkersConfigOverrides, WorkersGlobalConfig, } from '../../../src/index.js';
+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';
+export type { ISLAConfig, ISLAReport, ISLAStatus, ISLAViolation, ITimeRange } from './SLAMonitor';
+export type * from './type';
+/**
+ * Package version and build metadata
+ * Available at runtime for debugging and health checks
+ */
+export declare const _ZINTRUST_WORKERS_VERSION = "0.1.0";
+export declare const _ZINTRUST_WORKERS_BUILD_DATE = "__BUILD_DATE__";
+//# sourceMappingURL=index.d.ts.map

package/packages/workers/src/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../packages/workers/src/index.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAGH,OAAO,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAC5C,OAAO,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAChD,OAAO,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAChD,OAAO,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAC;AAGlD,OAAO,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAC1C,OAAO,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAC;AAClD,OAAO,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAC;AAGpD,OAAO,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAChD,OAAO,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAC;AACpD,OAAO,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAG1C,OAAO,EAAE,iBAAiB,EAAE,MAAM,qBAAqB,CAAC;AAGxD,OAAO,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAGhD,OAAO,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAGhD,OAAO,EAAE,gBAAgB,EAAE,MAAM,oBAAoB,CAAC;AACtD,OAAO,EAAE,gBAAgB,EAAE,MAAM,oBAAoB,CAAC;AACtD,OAAO,EAAE,gBAAgB,EAAE,MAAM,oBAAoB,CAAC;AACtD,OAAO,EAAE,sBAAsB,EAAE,MAAM,0BAA0B,CAAC;AAClE,OAAO,EAAE,gBAAgB,EAAE,MAAM,oBAAoB,CAAC;AACtD,OAAO,EAAE,gBAAgB,EAAE,MAAM,oBAAoB,CAAC;AAGtD,OAAO,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAChD,YAAY,EACV,iBAAiB,EACjB,mBAAmB,EACnB,uBAAuB,GACxB,MAAM,iBAAiB,CAAC;AACzB,OAAO,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAC1C,OAAO,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAC;AAGlD,OAAO,EAAE,gBAAgB,EAAE,MAAM,yBAAyB,CAAC;AAC3D,OAAO,EAAE,oBAAoB,EAAE,MAAM,kBAAkB,CAAC;AAGxD,OAAO,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAC;AACpD,OAAO,EAAE,iBAAiB,EAAE,MAAM,qBAAqB,CAAC;AACxD,YAAY,EAAE,wBAAwB,EAAE,MAAM,qBAAqB,CAAC;AAEpE,OAAO,EAAE,kBAAkB,EAAE,MAAM,sBAAsB,CAAC;AAG1D,YAAY,EACV,WAAW,EACX,uBAAuB,EACvB,sBAAsB,EACtB,YAAY,EACZ,gBAAgB,EAChB,yBAAyB,EACzB,YAAY,EACZ,sBAAsB,EACtB,sBAAsB,EACtB,mBAAmB,GACpB,MAAM,gBAAgB,CAAC;AAGxB,YAAY,EAAE,GAAG,EAAE,MAAM,EAAE,aAAa,EAAE,MAAM,QAAQ,CAAC;AAEzD,YAAY,EACV,QAAQ,EACR,cAAc,EACd,SAAS,EACT,OAAO,EACP,WAAW,EACX,eAAe,EACf,kBAAkB,GACnB,MAAM,oBAAoB,CAAC;AAC5B,YAAY,EACV,gBAAgB,EAChB,gBAAgB,EAChB,YAAY,EACZ,YAAY,GACb,MAAM,oBAAoB,CAAC;AAC5B,YAAY,EAAE,UAAU,EAAE,UAAU,EAAE,UAAU,EAAE,aAAa,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAElG,mBAAmB,QAAQ,CAAC;AAE5B;;;GAGG;AACH,eAAO,MAAM,yBAAyB,UAAU,CAAC;AACjD,eAAO,MAAM,4BAA4B,mBAAmB,CAAC"}

package/packages/workers/src/index.js

@@ -0,0 +1,48 @@
+/**
+ * Worker Management System - Public API
+ *
+ * Central export file for all worker management modules.
+ */
+// Core Infrastructure
+export { ClusterLock } from './ClusterLock.js';
+export { PriorityQueue } from './PriorityQueue.js';
+export { WorkerMetrics } from './WorkerMetrics.js';
+export { WorkerRegistry } from './WorkerRegistry.js';
+// Resilience & Recovery
+export { AutoScaler } from './AutoScaler.js';
+export { CircuitBreaker } from './CircuitBreaker.js';
+export { DeadLetterQueue } from './DeadLetterQueue.js';
+// Monitoring & Resources
+export { HealthMonitor } from './HealthMonitor.js';
+export { ResourceMonitor } from './ResourceMonitor.js';
+export { SLAMonitor } from './SLAMonitor.js';
+// Compliance & Security
+export { ComplianceManager } from './ComplianceManager.js';
+// Observability
+export { Observability } from './Observability.js';
+// Plugin System
+export { PluginManager } from './PluginManager.js';
+// Advanced Features
+export { AnomalyDetection } from './AnomalyDetection.js';
+export { CanaryController } from './CanaryController.js';
+export { ChaosEngineering } from './ChaosEngineering.js';
+export { DatacenterOrchestrator } from './DatacenterOrchestrator.js';
+export { MultiQueueWorker } from './MultiQueueWorker.js';
+export { WorkerVersioning } from './WorkerVersioning.js';
+// Factory & Lifecycle
+export { WorkerFactory } from './WorkerFactory.js';
+export { WorkerInit } from './WorkerInit.js';
+export { WorkerShutdown } from './WorkerShutdown.js';
+// HTTP Controllers & Routes
+export { WorkerController } from './http/WorkerController.js';
+export { registerWorkerRoutes } from './routes/workers.js';
+// Queue Workers
+export { BroadcastWorker } from './BroadcastWorker.js';
+export { createQueueWorker } from './createQueueWorker.js';
+export { NotificationWorker } from './NotificationWorker.js';
+/**
+ * Package version and build metadata
+ * Available at runtime for debugging and health checks
+ */
+export const _ZINTRUST_WORKERS_VERSION = '0.1.0';
+export const _ZINTRUST_WORKERS_BUILD_DATE = '__BUILD_DATE__';

package/packages/workers/src/routes/workers.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Worker Management Routes
+ * HTTP API for managing workers with dashboard functionality
+ */
+import type { IRouter } from '../../../../src/index.js';
+import { type WorkersDashboardUiOptions } from '../dashboard';
+type WorkerUiOptions = WorkersDashboardUiOptions;
+type RouteOptions = {
+    middleware?: ReadonlyArray<string>;
+} | undefined;
+export declare function registerWorkerRoutes(router: IRouter, _options?: WorkerUiOptions, routeOptions?: RouteOptions): void;
+export default registerWorkerRoutes;
+//# sourceMappingURL=workers.d.ts.map

package/packages/workers/src/routes/workers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"workers.d.ts","sourceRoot":"","sources":["../../../../../packages/workers/src/routes/workers.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,KAAK,EAAuB,OAAO,EAAE,MAAM,gBAAgB,CAAC;AAEnE,OAAO,EAAE,KAAK,yBAAyB,EAAE,MAAM,cAAc,CAAC;AAe9D,KAAK,eAAe,GAAG,yBAAyB,CAAC;AACjD,KAAK,YAAY,GAAG;IAAE,UAAU,CAAC,EAAE,aAAa,CAAC,MAAM,CAAC,CAAA;CAAE,GAAG,SAAS,CAAC;AA0KvE,wBAAgB,oBAAoB,CAClC,MAAM,EAAE,OAAO,EACf,QAAQ,CAAC,EAAE,eAAe,EAC1B,YAAY,CAAC,EAAE,YAAY,GAC1B,IAAI,CAaN;AAED,eAAe,oBAAoB,CAAC"}

package/packages/workers/src/routes/workers.js

@@ -0,0 +1,126 @@
+/**
+ * Worker Management Routes
+ * HTTP API for managing workers with dashboard functionality
+ */
+import { Cloudflare, Env, Logger, Router } from '../../../../src/index.js';
+import { HealthMonitor } from '../HealthMonitor.js';
+import { ValidationSchemas, withCustomValidation } from '../http/middleware/CustomValidation.js';
+import { withEditWorkerValidation } from '../http/middleware/EditWorkerValidation.js';
+import { withDriverValidation } from '../http/middleware/ValidateDriver.js';
+import { withCreateWorkerValidation, withWorkerOperationValidation, } from '../http/middleware/WorkerValidationChain.js';
+import { WorkerApiController } from '../http/WorkerApiController.js';
+import { WorkerController } from '../http/WorkerController.js';
+import { ResourceMonitor } from '../ResourceMonitor.js';
+import { TelemetryDashboard } from '../telemetry/index.js';
+import { registerStaticAssets } from '../ui/router/ui.js';
+import { WorkerFactory } from '../WorkerFactory.js';
+const controller = WorkerController.create();
+const apiController = WorkerApiController.create();
+function registerCoreWorkerRoutes(r) {
+    // Core worker operations
+    Router.post(r, '/create', withCreateWorkerValidation(controller.create));
+    Router.put(r, '/:name', withCreateWorkerValidation(controller.update));
+    // Worker editing with custom validation that handles mapping
+    Router.put(r, '/:name/edit', withEditWorkerValidation(controller.update));
+    Router.post(r, '/:name/start', withDriverValidation(withWorkerOperationValidation(controller.start)));
+    Router.post(r, '/:name/auto-start', withDriverValidation(withWorkerOperationValidation(controller.setAutoStart)));
+    Router.post(r, '/:name/stop', withDriverValidation(withWorkerOperationValidation(controller.stop)));
+    Router.post(r, '/:name/restart', withDriverValidation(withWorkerOperationValidation(controller.restart)));
+    Router.post(r, '/:name/pause', withDriverValidation(withWorkerOperationValidation(controller.pause)));
+    Router.post(r, '/:name/resume', withDriverValidation(withWorkerOperationValidation(controller.resume)));
+    Router.del(r, '/:name', withDriverValidation(withWorkerOperationValidation(controller.remove)));
+}
+function registerWorkerQueryRoutes(r) {
+    // Worker listing and filtering
+    Router.get(r, '/', withDriverValidation(withCustomValidation(ValidationSchemas.workerFilter, apiController.listWorkers)));
+    Router.get(r, '/:name', withDriverValidation(withWorkerOperationValidation(controller.get)));
+    Router.get(r, '/:name/status', withWorkerOperationValidation(controller.status));
+    Router.get(r, '/:name/creation-status', withWorkerOperationValidation(controller.getCreationStatus));
+    Router.get(r, '/:name/metrics', withWorkerOperationValidation(controller.metrics));
+    Router.get(r, '/:name/health', withWorkerOperationValidation(controller.health));
+    // Worker details
+    Router.get(r, '/:name/details', withDriverValidation(apiController.getWorkerDetailsHandler));
+    // Worker driver data for editing
+    Router.get(r, '/:name/driver-data', withDriverValidation(apiController.getWorkerDriverDataHandler));
+}
+function registerMonitoringRoutes(r) {
+    // SSE events stream for monitoring + workers snapshot
+    Router.get(r, '/events', controller.eventsStream);
+    // Health monitoring
+    Router.post(r, '/:name/monitoring/start', controller.startMonitoring);
+    Router.post(r, '/:name/monitoring/stop', controller.stopMonitoring);
+    Router.get(r, '/:name/monitoring/history', controller.healthHistory);
+    Router.get(r, '/:name/monitoring/trend', controller.healthTrend);
+    Router.put(r, '/:name/monitoring/config', controller.updateMonitoringConfig);
+    // SLA monitoring
+    Router.get(r, '/:name/sla/status', controller.getSlaStatus);
+}
+function registerVersioningRoutes(r) {
+    // Versioning
+    Router.post(r, '/:name/versions', controller.registerVersion);
+    Router.get(r, '/:name/versions', controller.listVersions);
+    Router.get(r, '/:name/versions/:version', controller.getVersion);
+}
+function registerUtilityRoutes(r) {
+    // Utility endpoints
+    Router.get(r, '/drivers', apiController.getDriversHandler);
+    Router.get(r, '/queue-data', apiController.getQueueDataHandler);
+    Router.get(r, '/health', apiController.getHealthSummaryHandler);
+}
+function registerWorkerLifecycleRoutes(router, middleware) {
+    Router.group(router, '/api/workers', (r) => {
+        Logger.info('Registering Worker Management Routes');
+        registerCoreWorkerRoutes(r);
+        if (Cloudflare.getWorkersEnv() === null) {
+            registerMonitoringRoutes(r); // ← Move FIRST - has /events
+            registerWorkerQueryRoutes(r);
+            registerVersioningRoutes(r);
+            registerUtilityRoutes(r);
+        }
+    }, { middleware: middleware });
+}
+function registerWorkerTelemetryRoutes(router, middleware) {
+    const options = middleware ? { middleware } : undefined;
+    Router.group(router, '/api', (r) => {
+        Router.get(r, '/workers/system/summary', async (_req, res) => {
+            const workers = WorkerFactory.list();
+            const monitoringSummary = await HealthMonitor.getSummary();
+            const resourceUsage = ResourceMonitor.getCurrentUsage('system');
+            res.json({
+                ok: true,
+                summary: {
+                    workers: workers.length,
+                    monitoring: monitoringSummary,
+                    resources: resourceUsage,
+                },
+            });
+        });
+        Router.get(r, '/workers/system/monitoring/summary', async (_req, res) => {
+            const summary = await HealthMonitor.getSummary();
+            res.json({ ok: true, summary });
+        });
+        Router.get(r, '/resources/current', async (_req, res) => {
+            const usage = ResourceMonitor.getCurrentUsage('system');
+            res.json({ ok: true, usage });
+        });
+        Router.get(r, '/resources/trends', async (req, res) => {
+            const period = (req.getParam('period') ?? 'day');
+            const trends = ResourceMonitor.getAllTrends('system', period);
+            res.json({ ok: true, trends });
+        });
+    }, options);
+}
+export function registerWorkerRoutes(router, _options, routeOptions) {
+    registerStaticAssets(router, routeOptions?.middleware ?? []);
+    registerWorkerLifecycleRoutes(router, routeOptions?.middleware);
+    registerWorkerTelemetryRoutes(router, routeOptions?.middleware);
+    // Register Telemetry Dashboard
+    const dashboard = TelemetryDashboard.create({
+        basePath: '/telemetry',
+    });
+    dashboard.registerRoutes(router);
+    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;