nestjs-temporal-core 3.2.0 → 3.2.2

package/dist/services/temporal-worker.service.js

@@ -26,7 +26,6 @@ let TemporalWorkerManagerService = TemporalWorkerManagerService_1 = class Tempor
         this.injectedConnection = injectedConnection;
         this.worker = null;
         this.restartCount = 0;
-        this.maxRestarts = 3;
         this.isInitialized = false;
         this.isRunning = false;
         this.lastError = null;
@@ -40,15 +39,25 @@ let TemporalWorkerManagerService = TemporalWorkerManagerService_1 = class Tempor
             logLevel: options.logLevel,
         });
     }
+    get maxRestarts() {
+        return this.options.worker?.maxRestarts ?? this.options.maxRestarts ?? 3;
+    }
+    get autoRestartEnabled() {
+        const workerAutoRestart = this.options.worker?.autoRestart;
+        if (workerAutoRestart !== undefined) {
+            return workerAutoRestart;
+        }
+        return this.options.autoRestart !== false;
+    }
     async onModuleInit() {
         try {
-            this.logger.debug('Initializing Temporal worker manager...');
+            this.logger.verbose('Initializing Temporal worker manager...');
             if (this.options.workers && this.options.workers.length > 0) {
                 await this.initializeMultipleWorkers();
                 return;
             }
             if (!this.shouldInitializeWorker()) {
-                this.logger.info('Worker initialization skipped - no worker configuration provided');
+                this.logger.info('Worker initialization skipped - no configuration provided');
                 return;
             }
             const initResult = await this.initializeWorker();
@@ -60,7 +69,7 @@ let TemporalWorkerManagerService = TemporalWorkerManagerService_1 = class Tempor
                 this.lastError = initResult.error?.message || 'Unknown initialization error';
                 this.logger.error('Failed to initialize worker manager', initResult.error);
                 if (this.options.allowConnectionFailure === true) {
-                    this.logger.warn('Worker initialization failed but connection failures are allowed');
+                    this.logger.warn('Continuing without worker (connection failures allowed)');
                     return;
                 }
                 throw initResult.error || new Error('Worker initialization failed');
@@ -70,7 +79,7 @@ let TemporalWorkerManagerService = TemporalWorkerManagerService_1 = class Tempor
             this.lastError = this.extractErrorMessage(error);
             this.logger.error('Failed to initialize worker manager', error);
             if (this.options.allowConnectionFailure === true) {
-                this.logger.warn('Worker initialization failed but connection failures are allowed');
+                this.logger.warn('Continuing without worker (connection failures allowed)');
                 return;
             }
             throw error;
@@ -153,7 +162,7 @@ let TemporalWorkerManagerService = TemporalWorkerManagerService_1 = class Tempor
         this.logger.info(`Successfully initialized ${this.workers.size} workers`);
     }
     async createWorkerFromDefinition(workerDef) {
-        this.logger.debug(`Creating worker for task queue: ${workerDef.taskQueue}`);
+        this.logger.verbose(`Creating worker for task queue '${workerDef.taskQueue}'`);
         if (this.workers.has(workerDef.taskQueue)) {
             throw new Error(`Worker for task queue '${workerDef.taskQueue}' already exists`);
         }
@@ -194,10 +203,10 @@ let TemporalWorkerManagerService = TemporalWorkerManagerService_1 = class Tempor
             startedAt: null,
             restartCount: 0,
             activities,
-            workflowSource: this.getWorkflowSourceFromDef(workerDef),
+            workflowSource: this.getWorkflowSource(workerDef),
         };
         this.workers.set(workerDef.taskQueue, workerInstance);
-        this.logger.info(`Worker created for task queue '${workerDef.taskQueue}' with ${activities.size} activities`);
+        this.logger.info(`Created worker '${workerDef.taskQueue}' (${activities.size} activities)`);
         return workerInstance;
     }
     async registerWorker(workerDef) {
@@ -219,7 +228,7 @@ let TemporalWorkerManagerService = TemporalWorkerManagerService_1 = class Tempor
             };
         }
         catch (error) {
-            this.logger.error(`Failed to create worker for '${workerDef.taskQueue}'`, error);
+            this.logger.error(`Failed to register worker '${workerDef.taskQueue}'`, error);
             return {
                 success: false,
                 taskQueue: workerDef.taskQueue,
@@ -257,21 +266,18 @@ let TemporalWorkerManagerService = TemporalWorkerManagerService_1 = class Tempor
             return;
         }
         try {
-            this.logger.info(`Starting worker for task queue '${taskQueue}'...`);
+            this.logger.verbose(`Starting worker '${taskQueue}'...`);
             workerInstance.isRunning = true;
             workerInstance.startedAt = new Date();
             workerInstance.lastError = null;
-            workerInstance.worker.run().catch((error) => {
-                workerInstance.lastError = this.extractErrorMessage(error);
-                workerInstance.isRunning = false;
-                this.logger.error(`Worker '${taskQueue}' failed`, error);
-            });
-            this.logger.info(`Worker for '${taskQueue}' started successfully`);
+            workerInstance.restartCount = 0;
+            this.runWorkerWithAutoRestartByTaskQueue(taskQueue);
+            this.logger.info(`Worker '${taskQueue}' started (${workerInstance.activities.size} activities, ${workerInstance.workflowSource})`);
         }
         catch (error) {
             workerInstance.lastError = this.extractErrorMessage(error);
             workerInstance.isRunning = false;
-            this.logger.error(`Failed to start worker for '${taskQueue}'`, error);
+            this.logger.error(`Failed to start worker '${taskQueue}'`, error);
             throw error;
         }
     }
@@ -281,49 +287,91 @@ let TemporalWorkerManagerService = TemporalWorkerManagerService_1 = class Tempor
             throw new Error(`Worker for task queue '${taskQueue}' not found`);
         }
         if (!workerInstance.isRunning) {
-            this.logger.debug(`Worker for '${taskQueue}' is not running`);
+            this.logger.verbose(`Worker '${taskQueue}' is not running`);
             return;
         }
         try {
-            this.logger.info(`Stopping worker for '${taskQueue}'...`);
-            try {
-                const workerState = workerInstance.worker.getState();
-                this.logger.debug(`Worker '${taskQueue}' current state: ${workerState}`);
-                if (workerState === 'INITIALIZED' ||
-                    workerState === 'RUNNING' ||
-                    workerState === 'FAILED') {
-                    await workerInstance.worker.shutdown();
-                    this.logger.info(`Worker for '${taskQueue}' stopped successfully`);
-                }
-                else if (workerState === 'STOPPING' ||
-                    workerState === 'DRAINING' ||
-                    workerState === 'DRAINED') {
-                    this.logger.info(`Worker for '${taskQueue}' is already shutting down (state: ${workerState})`);
-                }
-                else if (workerState === 'STOPPED') {
-                    this.logger.debug(`Worker for '${taskQueue}' is already stopped`);
-                }
-            }
-            catch (shutdownError) {
-                const errorMessage = shutdownError instanceof Error ? shutdownError.message : String(shutdownError);
-                if (errorMessage.includes('Not running') ||
-                    errorMessage.includes('DRAINING') ||
-                    errorMessage.includes('STOPPING')) {
-                    this.logger.debug(`Worker '${taskQueue}' is already shutting down or stopped`);
-                }
-                else {
-                    throw shutdownError;
-                }
-            }
+            this.logger.verbose(`Stopping worker '${taskQueue}'...`);
+            this.safeShutdownWorker(workerInstance.worker, taskQueue, workerInstance.startedAt);
             workerInstance.isRunning = false;
             workerInstance.startedAt = null;
         }
         catch (error) {
             workerInstance.lastError = this.extractErrorMessage(error);
-            this.logger.warn(`Error while stopping worker for '${taskQueue}'`, error);
+            this.logger.warn(`Error stopping worker '${taskQueue}'`, error);
+            workerInstance.isRunning = false;
+        }
+    }
+    runWorkerWithAutoRestartByTaskQueue(taskQueue) {
+        const workerInstance = this.workers.get(taskQueue);
+        if (!workerInstance)
+            return;
+        const workerDef = this.options.workers?.find((w) => w.taskQueue === taskQueue);
+        const maxRestarts = workerDef?.maxRestarts ?? this.options.maxRestarts ?? 3;
+        workerInstance.worker.run().catch((error) => {
+            workerInstance.lastError = this.extractErrorMessage(error);
             workerInstance.isRunning = false;
+            const autoRestartEnabled = workerDef?.autoRestart ?? this.options.autoRestart;
+            if (autoRestartEnabled !== false && workerInstance.restartCount < maxRestarts) {
+                workerInstance.restartCount++;
+                this.logger.warn(`Worker '${taskQueue}' failed, auto-restarting in 1s (attempt ${workerInstance.restartCount}/${maxRestarts})`, error);
+                setTimeout(() => {
+                    this.autoRestartWorkerByTaskQueue(taskQueue).catch((restartError) => {
+                        this.logger.error(`Auto-restart failed for '${taskQueue}'`, restartError);
+                    });
+                }, 1000);
+            }
+            else if (workerInstance.restartCount >= maxRestarts) {
+                this.logger.error(`Worker '${taskQueue}' failed after ${maxRestarts} restart attempts, giving up`, error);
+            }
+            else {
+                this.logger.error(`Worker '${taskQueue}' run failed`, error);
+            }
+        });
+    }
+    async autoRestartWorkerByTaskQueue(taskQueue) {
+        this.logger.info(`Auto-restarting worker '${taskQueue}'...`);
+        try {
+            const workerDef = this.options.workers?.find((w) => w.taskQueue === taskQueue);
+            if (!workerDef) {
+                throw new Error(`Worker definition for '${taskQueue}' not found`);
+            }
+            const oldInstance = this.workers.get(taskQueue);
+            const restartCount = oldInstance?.restartCount ?? 0;
+            await this.cleanupWorkerForRestartByTaskQueue(taskQueue);
+            await new Promise((resolve) => setTimeout(resolve, 500));
+            this.workers.delete(taskQueue);
+            const newInstance = await this.createWorkerFromDefinition(workerDef);
+            newInstance.restartCount = restartCount;
+            newInstance.isRunning = true;
+            newInstance.startedAt = new Date();
+            newInstance.lastError = null;
+            this.runWorkerWithAutoRestartByTaskQueue(taskQueue);
+            this.logger.info(`Worker '${taskQueue}' auto-restarted successfully`);
+        }
+        catch (error) {
+            const workerInstance = this.workers.get(taskQueue);
+            if (workerInstance) {
+                workerInstance.lastError = this.extractErrorMessage(error);
+                workerInstance.isRunning = false;
+            }
+            this.logger.error(`Auto-restart failed for '${taskQueue}'`, error);
+            throw error;
         }
     }
+    async cleanupWorkerForRestartByTaskQueue(taskQueue) {
+        const workerInstance = this.workers.get(taskQueue);
+        if (!workerInstance?.worker)
+            return;
+        try {
+            this.safeShutdownWorker(workerInstance.worker, taskQueue);
+        }
+        catch (error) {
+            this.logger.warn(`Error during worker '${taskQueue}' cleanup (continuing with restart)`, error);
+        }
+        workerInstance.isRunning = false;
+        workerInstance.startedAt = null;
+    }
     getConnection() {
         return this.connection;
     }
@@ -331,12 +379,11 @@ let TemporalWorkerManagerService = TemporalWorkerManagerService_1 = class Tempor
         const uptime = workerInstance.startedAt
             ? Date.now() - workerInstance.startedAt.getTime()
             : undefined;
+        const isHealthy = this.calculateWorkerHealth(workerInstance);
         return {
             isInitialized: workerInstance.isInitialized,
             isRunning: workerInstance.isRunning,
-            isHealthy: workerInstance.isInitialized &&
-                !workerInstance.lastError &&
-                workerInstance.isRunning,
+            isHealthy,
             taskQueue: workerInstance.taskQueue,
             namespace: workerInstance.namespace,
             workflowSource: workerInstance.workflowSource,
@@ -347,16 +394,7 @@ let TemporalWorkerManagerService = TemporalWorkerManagerService_1 = class Tempor
         };
     }
     async loadActivitiesForWorker(activities, activityClasses) {
-        let attempts = 0;
-        const maxAttempts = 30;
-        while (attempts < maxAttempts) {
-            const healthStatus = this.discoveryService.getHealthStatus();
-            if (healthStatus.isComplete) {
-                break;
-            }
-            await new Promise((resolve) => setTimeout(resolve, 100));
-            attempts++;
-        }
+        await this.waitForDiscoveryCompletion();
         if (!activityClasses || activityClasses.length === 0) {
             const allActivities = this.discoveryService.getAllActivities();
             for (const [activityName, handler] of Object.entries(allActivities)) {
@@ -381,13 +419,6 @@ let TemporalWorkerManagerService = TemporalWorkerManagerService_1 = class Tempor
             }
         }
     }
-    getWorkflowSourceFromDef(workerDef) {
-        if (workerDef.workflowBundle)
-            return 'bundle';
-        if (workerDef.workflowsPath)
-            return 'filesystem';
-        return 'none';
-    }
     async startWorker() {
         if (!this.worker) {
             throw new Error('Worker not initialized. Cannot start worker.');
@@ -421,12 +452,10 @@ let TemporalWorkerManagerService = TemporalWorkerManagerService_1 = class Tempor
                     try {
                         this.worker.run().catch((error) => {
                             this.lastError = this.extractErrorMessage(error);
-                            this.logger.error('Worker run failed', error);
                             this.isRunning = false;
-                            if (this.options.autoRestart !== false &&
-                                this.restartCount < this.maxRestarts) {
+                            if (this.autoRestartEnabled && this.restartCount < this.maxRestarts) {
                                 this.restartCount++;
-                                this.logger.info(`Auto-restart enabled, attempting to restart worker (attempt ${this.restartCount}/${this.maxRestarts}) in 1 second...`);
+                                this.logger.warn(`Worker failed, auto-restarting in 1s (attempt ${this.restartCount}/${this.maxRestarts})`, error);
                                 setTimeout(async () => {
                                     try {
                                         await this.autoRestartWorker();
@@ -437,7 +466,10 @@ let TemporalWorkerManagerService = TemporalWorkerManagerService_1 = class Tempor
                                 }, 1000);
                             }
                             else if (this.restartCount >= this.maxRestarts) {
-                                this.logger.error(`Max restart attempts (${this.maxRestarts}) exceeded. Stopping auto-restart.`);
+                                this.logger.error(`Worker failed after ${this.maxRestarts} restart attempts, giving up`, error);
+                            }
+                            else {
+                                this.logger.error('Worker run failed', error);
                             }
                         });
                         setTimeout(() => resolve(), 500);
@@ -455,14 +487,17 @@ let TemporalWorkerManagerService = TemporalWorkerManagerService_1 = class Tempor
     async autoRestartWorker() {
         this.logger.info('Auto-restarting Temporal worker...');
         try {
-            if (this.worker) {
-                await this.worker.shutdown();
-            }
+            await this.cleanupWorkerForRestart();
             await new Promise((resolve) => setTimeout(resolve, 500));
+            const initResult = await this.initializeWorker();
+            if (!initResult.success) {
+                throw initResult.error || new Error('Failed to reinitialize worker');
+            }
+            this.isInitialized = true;
             this.isRunning = true;
             this.startedAt = new Date();
             this.lastError = null;
-            this.runWorkerWithAutoRestart();
+            await this.runWorkerWithAutoRestart();
             this.logger.info('Temporal worker auto-restarted successfully');
         }
         catch (error) {
@@ -472,29 +507,29 @@ let TemporalWorkerManagerService = TemporalWorkerManagerService_1 = class Tempor
             throw error;
         }
     }
+    async cleanupWorkerForRestart() {
+        if (!this.worker) {
+            return;
+        }
+        try {
+            this.safeShutdownWorker(this.worker, 'legacy');
+        }
+        catch (error) {
+            this.logger.warn('Error during worker cleanup (continuing with restart)', error);
+        }
+        this.worker = null;
+        this.isRunning = false;
+        this.startedAt = null;
+    }
     async stopWorker() {
         if (!this.worker || !this.isRunning) {
             this.logger.debug('Worker is not running or not initialized');
             return;
         }
         try {
-            this.logger.info('Stopping Temporal worker...');
-            const workerState = this.worker.getState();
-            this.logger.debug(`Worker current state: ${workerState}`);
-            if (workerState === 'INITIALIZED' ||
-                workerState === 'RUNNING' ||
-                workerState === 'FAILED') {
-                await this.worker.shutdown();
-                this.logger.info('Temporal worker stopped successfully');
-            }
-            else if (workerState === 'STOPPING' ||
-                workerState === 'DRAINING' ||
-                workerState === 'DRAINED') {
-                this.logger.info(`Worker is already shutting down (state: ${workerState})`);
-            }
-            else if (workerState === 'STOPPED') {
-                this.logger.debug('Worker is already stopped');
-            }
+            this.logger.verbose('Stopping Temporal worker...');
+            const taskQueue = this.options.taskQueue || 'default';
+            this.safeShutdownWorker(this.worker, taskQueue, this.startedAt);
             this.isRunning = false;
             this.startedAt = null;
         }
@@ -532,10 +567,11 @@ let TemporalWorkerManagerService = TemporalWorkerManagerService_1 = class Tempor
     }
     getWorkerStatus() {
         const uptime = this.startedAt ? Date.now() - this.startedAt.getTime() : undefined;
+        const isHealthy = this.calculateWorkerHealth();
         return {
             isInitialized: this.isInitialized,
             isRunning: this.isRunning,
-            isHealthy: this.isInitialized && !this.lastError && this.isRunning,
+            isHealthy,
             taskQueue: this.options.taskQueue || 'default',
             namespace: this.options.connection?.namespace || 'default',
             workflowSource: this.getWorkflowSource(),
@@ -556,27 +592,18 @@ let TemporalWorkerManagerService = TemporalWorkerManagerService_1 = class Tempor
         const errors = [];
         let registeredCount = 0;
         try {
-            let attempts = 0;
-            const maxAttempts = 30;
-            while (attempts < maxAttempts) {
-                const healthStatus = this.discoveryService.getHealthStatus();
-                if (healthStatus.isComplete) {
-                    break;
-                }
-                await new Promise((resolve) => setTimeout(resolve, 100));
-                attempts++;
-            }
+            await this.waitForDiscoveryCompletion();
             const allActivities = this.discoveryService.getAllActivities();
             for (const [activityName, handler] of Object.entries(allActivities)) {
                 try {
                     this.activities.set(activityName, handler);
                     registeredCount++;
-                    this.logger.debug(`Registered activity: ${activityName}`);
+                    this.logger.verbose(`Registered activity: ${activityName}`);
                 }
                 catch (error) {
                     const errorMessage = error instanceof Error ? error.message : 'Unknown error';
                     errors.push({ activityName, error: errorMessage });
-                    this.logger.warn(`Failed to register activity ${activityName}: ${errorMessage}`);
+                    this.logger.warn(`Failed to register activity '${activityName}': ${errorMessage}`);
                 }
             }
             this.logger.info(`Registered ${registeredCount} activities from discovery service`);
@@ -602,13 +629,11 @@ let TemporalWorkerManagerService = TemporalWorkerManagerService_1 = class Tempor
     isWorkerRunning() {
         return this.isRunning;
     }
-    getStatus() {
-        return this.getWorkerStatus();
-    }
     getHealthStatus() {
         const uptime = this.startedAt ? Date.now() - this.startedAt.getTime() : undefined;
+        const isHealthy = this.calculateWorkerHealth();
         return {
-            isHealthy: this.isInitialized && !this.lastError && this.isRunning,
+            isHealthy,
             isRunning: this.isRunning,
             isInitialized: this.isInitialized,
             lastError: this.lastError || undefined,
@@ -645,30 +670,6 @@ let TemporalWorkerManagerService = TemporalWorkerManagerService_1 = class Tempor
             throw new Error('Cannot specify both workflowsPath and workflowBundle');
         }
     }
-    getEnvironmentDefaults() {
-        return {
-            taskQueue: this.options.taskQueue || 'default',
-            namespace: this.options.connection?.namespace || 'default',
-        };
-    }
-    buildWorkerOptions() {
-        const baseOptions = this.getEnvironmentDefaults();
-        if (this.options.worker?.workflowsPath) {
-            Object.assign(baseOptions, { workflowsPath: this.options.worker.workflowsPath });
-        }
-        else if (this.options.worker?.workflowBundle) {
-            Object.assign(baseOptions, { workflowBundle: this.options.worker.workflowBundle });
-        }
-        const activitiesObj = {};
-        for (const [name, func] of this.activities.entries()) {
-            activitiesObj[name] = func;
-        }
-        Object.assign(baseOptions, { activities: activitiesObj });
-        if (this.options.worker?.workerOptions) {
-            Object.assign(baseOptions, this.options.worker.workerOptions);
-        }
-        return baseOptions;
-    }
     async createConnection() {
         if (this.injectedConnection) {
             this.connection = this.injectedConnection;
@@ -690,51 +691,21 @@ let TemporalWorkerManagerService = TemporalWorkerManagerService_1 = class Tempor
                     authorization: `Bearer ${this.options.connection.apiKey}`,
                 };
             }
-            this.logger.debug(`Creating NativeConnection to ${address}`);
+            this.logger.verbose(`Connecting to Temporal server at ${address}...`);
             this.connection = await worker_1.NativeConnection.connect(connectOptions);
-            this.logger.info(`Connection established to ${address}`);
+            const ns = this.options.connection?.namespace || 'default';
+            this.logger.info(`Connected to ${address} (namespace: ${ns})`);
         }
         catch (error) {
             this.logger.error('Failed to create connection', error);
             if (this.options.allowConnectionFailure !== false) {
-                this.logger.warn('Worker connection failed - continuing without worker functionality');
+                this.logger.warn('Connection failed, continuing without worker');
                 this.connection = null;
                 return;
             }
             throw error;
         }
     }
-    async createWorker() {
-        await this.createConnection();
-        if (!this.connection) {
-            throw new Error('Connection not established');
-        }
-        const workerConfig = await this.createWorkerConfig();
-        const { Worker } = await Promise.resolve().then(() => require('@temporalio/worker'));
-        this.worker = await Worker.create(workerConfig);
-    }
-    logWorkerConfiguration() {
-        this.logger.debug(`Worker configuration: ${JSON.stringify(this.options.worker)}`);
-    }
-    async runWorkerLoop() {
-        if (!this.worker) {
-            throw new Error('Temporal worker not initialized');
-        }
-        try {
-            await this.worker.run();
-        }
-        catch (error) {
-            this.logger.error('Worker execution failed', error);
-            throw new Error('Execution error');
-        }
-    }
-    startWorkerInBackground() {
-        if (this.worker && !this.isRunning) {
-            this.startWorker().catch((error) => {
-                this.logger.error('Background worker start failed', error);
-            });
-        }
-    }
     shouldInitializeWorker() {
         return Boolean(this.options.worker &&
             (this.options.worker.workflowsPath ||
@@ -768,7 +739,7 @@ let TemporalWorkerManagerService = TemporalWorkerManagerService_1 = class Tempor
             const workerConfig = await this.createWorkerConfig();
             const { Worker } = await Promise.resolve().then(() => require('@temporalio/worker'));
             this.worker = await Worker.create(workerConfig);
-            this.logger.debug(`Worker created - TaskQueue: ${workerConfig.taskQueue}, Activities: ${this.activities.size}, Source: ${this.getWorkflowSource()}`);
+            this.logger.verbose(`Worker created: queue='${workerConfig.taskQueue}', activities=${this.activities.size}, workflows=${this.getWorkflowSource()}`);
             return {
                 success: true,
                 worker: this.worker,
@@ -795,31 +766,23 @@ let TemporalWorkerManagerService = TemporalWorkerManagerService_1 = class Tempor
         let discoveredActivities = 0;
         let loadedActivities = 0;
         try {
-            let attempts = 0;
-            const maxAttempts = 30;
-            while (attempts < maxAttempts) {
-                const healthStatus = this.discoveryService.getHealthStatus();
-                if (healthStatus.isComplete) {
-                    break;
-                }
-                await new Promise((resolve) => setTimeout(resolve, 100));
-                attempts++;
-            }
+            await this.waitForDiscoveryCompletion();
             const allActivities = this.discoveryService.getAllActivities();
             discoveredActivities = Object.keys(allActivities).length;
             for (const [activityName, handler] of Object.entries(allActivities)) {
                 try {
                     this.activities.set(activityName, handler);
                     loadedActivities++;
-                    this.logger.debug(`Loaded activity: ${activityName}`);
+                    this.logger.verbose(`Loaded activity: ${activityName}`);
                 }
                 catch (error) {
                     const errorMessage = error instanceof Error ? error.message : 'Unknown error';
-                    errors.push({ component: activityName, error: errorMessage });
-                    this.logger.warn(`Failed to load activity ${activityName}: ${errorMessage}`);
+                    errors.push({ name: activityName, error: errorMessage });
+                    this.logger.warn(`Failed to load activity '${activityName}': ${errorMessage}`);
                 }
             }
-            this.logger.info(`Loaded ${loadedActivities} activities from discovery service`);
+            const duration = Date.now() - startTime;
+            this.logger.info(`Loaded ${loadedActivities} ${loadedActivities === 1 ? 'activity' : 'activities'} from discovery in ${duration}ms`);
             return {
                 success: errors.length === 0,
                 discoveredActivities,
@@ -835,7 +798,7 @@ let TemporalWorkerManagerService = TemporalWorkerManagerService_1 = class Tempor
                 success: false,
                 discoveredActivities,
                 loadedActivities,
-                errors: [{ component: 'discovery', error: errorMessage }],
+                errors: [{ name: 'discovery', error: errorMessage }],
                 duration: Date.now() - startTime,
             };
         }
@@ -854,14 +817,14 @@ let TemporalWorkerManagerService = TemporalWorkerManagerService_1 = class Tempor
         };
         if (this.options.worker?.workflowsPath) {
             config.workflowsPath = this.options.worker.workflowsPath;
-            this.logger.debug(`Using workflows from path: ${this.options.worker.workflowsPath}`);
+            this.logger.verbose(`Using workflows from: ${this.options.worker.workflowsPath}`);
         }
         else if (this.options.worker?.workflowBundle) {
             config.workflowBundle = this.options.worker.workflowBundle;
-            this.logger.debug('Using workflow bundle');
+            this.logger.verbose('Using workflow bundle');
         }
         else {
-            this.logger.warn('No workflow configuration provided - worker will only handle activities');
+            this.logger.warn('No workflow configuration - worker will only handle activities');
         }
         if (this.options.worker?.workerOptions) {
             Object.assign(config, this.options.worker.workerOptions);
@@ -886,38 +849,7 @@ let TemporalWorkerManagerService = TemporalWorkerManagerService_1 = class Tempor
                         try {
                             if (workerInstance.isRunning && workerInstance.worker) {
                                 this.logger.debug(`Stopping worker for '${taskQueue}'...`);
-                                try {
-                                    const workerState = workerInstance.worker.getState();
-                                    if (workerState === 'INITIALIZED' ||
-                                        workerState === 'RUNNING' ||
-                                        workerState === 'FAILED') {
-                                        await workerInstance.worker.shutdown();
-                                        this.logger.debug(`Worker '${taskQueue}' shut down successfully`);
-                                    }
-                                    else if (workerState === 'STOPPING' ||
-                                        workerState === 'DRAINING' ||
-                                        workerState === 'DRAINED') {
-                                        this.logger.debug(`Worker '${taskQueue}' is already shutting down (state: ${workerState})`);
-                                    }
-                                    else if (workerState === 'STOPPED') {
-                                        this.logger.debug(`Worker '${taskQueue}' is already stopped`);
-                                    }
-                                }
-                                catch (shutdownError) {
-                                    const errorMessage = shutdownError instanceof Error
-                                        ? shutdownError.message
-                                        : String(shutdownError);
-                                    if (errorMessage.includes('Not running') ||
-                                        errorMessage.includes('DRAINING') ||
-                                        errorMessage.includes('STOPPING')) {
-                                        this.logger.debug(`Worker '${taskQueue}' is already shutting down or stopped`);
-                                    }
-                                    else {
-                                        this.logger.warn(`Unexpected error shutting down worker '${taskQueue}': ${errorMessage}`, shutdownError instanceof Error
-                                            ? shutdownError.stack
-                                            : undefined);
-                                    }
-                                }
+                                this.safeShutdownWorker(workerInstance.worker, taskQueue);
                                 workerInstance.isRunning = false;
                             }
                         }
@@ -955,13 +887,95 @@ let TemporalWorkerManagerService = TemporalWorkerManagerService_1 = class Tempor
             this.shutdownPromise = null;
         }
     }
-    getWorkflowSource() {
-        if (this.options.worker?.workflowBundle)
+    getWorkflowSource(config) {
+        const source = config ?? this.options.worker;
+        if (source?.workflowBundle)
             return 'bundle';
-        if (this.options.worker?.workflowsPath)
+        if (source?.workflowsPath)
             return 'filesystem';
         return 'none';
     }
+    getNativeState() {
+        if (!this.worker) {
+            return null;
+        }
+        try {
+            return this.worker.getState();
+        }
+        catch {
+            return null;
+        }
+    }
+    calculateWorkerHealth(workerInstance = null) {
+        if (workerInstance) {
+            let nativeState = null;
+            try {
+                nativeState = workerInstance.worker?.getState() ?? null;
+            }
+            catch {
+                nativeState = null;
+            }
+            return (workerInstance.isInitialized &&
+                !workerInstance.lastError &&
+                workerInstance.isRunning &&
+                nativeState === 'RUNNING');
+        }
+        const nativeState = this.getNativeState();
+        return this.isInitialized && !this.lastError && this.isRunning && nativeState === 'RUNNING';
+    }
+    async waitForDiscoveryCompletion(maxWaitMs = 3000) {
+        const pollInterval = 100;
+        const maxAttempts = Math.ceil(maxWaitMs / pollInterval);
+        let attempts = 0;
+        while (attempts < maxAttempts) {
+            const healthStatus = this.discoveryService.getHealthStatus();
+            if (healthStatus.isComplete) {
+                return true;
+            }
+            await new Promise((resolve) => setTimeout(resolve, pollInterval));
+            attempts++;
+        }
+        return false;
+    }
+    safeShutdownWorker(worker, identifier, startedAt) {
+        try {
+            const workerState = worker.getState();
+            if (workerState === 'INITIALIZED' ||
+                workerState === 'RUNNING' ||
+                workerState === 'FAILED') {
+                worker.shutdown();
+                if (startedAt) {
+                    const uptime = Math.round((Date.now() - startedAt.getTime()) / 1000);
+                    this.logger.info(`Worker '${identifier}' stopped (uptime: ${uptime}s)`);
+                }
+                else {
+                    this.logger.verbose(`Worker '${identifier}' shut down`);
+                }
+                return true;
+            }
+            if (workerState === 'STOPPING' ||
+                workerState === 'DRAINING' ||
+                workerState === 'DRAINED') {
+                this.logger.verbose(`Worker '${identifier}' already shutting down (${workerState})`);
+                return false;
+            }
+            if (workerState === 'STOPPED') {
+                this.logger.verbose(`Worker '${identifier}' already stopped`);
+                return false;
+            }
+            return false;
+        }
+        catch (error) {
+            const msg = error instanceof Error ? error.message : String(error);
+            if (msg.includes('Not running') ||
+                msg.includes('DRAINING') ||
+                msg.includes('STOPPING')) {
+                this.logger.verbose(`Worker '${identifier}' already shutting down`);
+                return false;
+            }
+            throw error;
+        }
+    }
     extractErrorMessage(error) {
         if (error instanceof Error) {
             return error.message;