@outputai/core 0.12.0 → 0.12.1-next.1243f78.0

package/src/worker/index.spec.js

@@ -1,13 +1,19 @@
 import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import { BusEventType } from '#consts';
 
 const {
-  catalogJobInstance,
   bindGlobalFunctionsMock,
+  catalogPublisherInstance,
   configValues,
   connectionMonitorInstance,
   createCatalogMock,
   flushPendingHooksMock,
+  hashSourceCodeMock,
   initInterceptorsMock,
+  interruption,
+  loadActivitiesMock,
+  loadHooksMock,
+  loadWorkflowsMock,
   mainEventBusMock,
   mockConnection,
   mockLog,
@@ -17,8 +23,10 @@ const {
   serializeErrorMock,
   setupClientConfigMock,
   setupInterruptionHandlerMock,
+  setupTelemetryMock,
   setupTemporalLoggerMock,
-  setupTelemetryMock
+  shutdownServicesMock,
+  workerRunnerInstance
 } = vi.hoisted( () => {
   const createDeferred = () => {
     const state = {};
@@ -31,9 +39,8 @@ const {
 
   const promises = {};
   const resetPromises = () => {
-    promises.workerRun = createDeferred();
+    promises.workerRunner = createDeferred();
     promises.connectionMonitor = createDeferred();
-    promises.catalogJob = createDeferred();
   };
   resetPromises();
 
@@ -54,122 +61,139 @@ const {
     shutdownGraceTime: undefined
   };
 
-  const connectionMonitorInstance = {
+  /**
+   * The real runner only settles once the worker finished draining, which is triggered by stop().
+   * Aborting alone leaves it running, so the shutdown sequence is the one awaiting the drain.
+   */
+  const workerRunnerInstance = {
     running: false,
-    connectionLossError: null,
-    onConnectionLost: vi.fn( cb => {
-      connectionMonitorInstance.connectionLostCb = cb;
+    options: null,
+    start: vi.fn( () => {
+      workerRunnerInstance.running = true;
+      return promises.workerRunner.promise.finally( () => {
+        workerRunnerInstance.running = false;
+      } );
     } ),
+    stop: vi.fn( () => {
+      promises.workerRunner.resolve();
+      return promises.workerRunner.promise.catch( () => {} );
+    } )
+  };
+
+  /** The real monitor exits its loop as soon as the signal aborts, so it settles on its own. */
+  const connectionMonitorInstance = {
+    running: false,
+    options: null,
     start: vi.fn( () => {
       connectionMonitorInstance.running = true;
+      connectionMonitorInstance.options?.signal.addEventListener(
+        'abort',
+        () => promises.connectionMonitor.resolve(),
+        { once: true }
+      );
       return promises.connectionMonitor.promise.finally( () => {
         connectionMonitorInstance.running = false;
       } );
     } ),
     stop: vi.fn( () => {
-      connectionMonitorInstance.running = false;
       promises.connectionMonitor.resolve();
-      return promises.connectionMonitor.promise;
-    } ),
-    connectionLostCb: null
+      return promises.connectionMonitor.promise.catch( () => {} );
+    } )
   };
 
-  const catalogJobInstance = {
+  const catalogPublisherInstance = {
     running: false,
-    error: null,
-    onError: vi.fn( cb => {
-      catalogJobInstance.errorCb = cb;
-    } ),
-    run: vi.fn( () => {
-      catalogJobInstance.running = true;
-      return promises.catalogJob.promise.finally( () => {
-        catalogJobInstance.running = false;
-      } );
-    } ),
-    interrupt: vi.fn( () => {
-      catalogJobInstance.running = false;
-      promises.catalogJob.resolve();
-      return promises.catalogJob.promise;
-    } ),
-    errorCb: null
+    options: null,
+    run: vi.fn().mockResolvedValue( undefined ),
+    interrupt: vi.fn().mockResolvedValue( undefined )
+  };
+
+  class KillSignError extends Error {
+    name = 'KillSignError';
   };
 
-  const mockWorker = {
-    getStatus: vi.fn( () => ( { runState: mockWorker.runState } ) ),
-    run: vi.fn( () => promises.workerRun.promise ),
-    runState: 'RUNNING',
-    shutdown: vi.fn()
+  class UncaughtError extends Error {
+    name = 'UncaughtError';
   };
 
+  const interruption = { controller: null, KillSignError, UncaughtError };
+
   return {
-    catalogJobInstance,
     bindGlobalFunctionsMock: vi.fn(),
+    catalogPublisherInstance,
     configValues,
     connectionMonitorInstance,
-    createCatalogMock: vi.fn().mockReturnValue( { workflows: [], activities: {} } ),
-    createWorkflowsEntryPointMock: vi.fn().mockReturnValue( '/fake/workflows/path.js' ),
+    createCatalogMock: vi.fn().mockReturnValue( { workflowNames: [ 'demo' ] } ),
     flushPendingHooksMock: vi.fn().mockResolvedValue( undefined ),
     hashSourceCodeMock: vi.fn().mockResolvedValue( 'catalog-hash' ),
     initInterceptorsMock: vi.fn().mockReturnValue( [] ),
-    loadActivitiesMock: vi.fn().mockResolvedValue( {} ),
+    interruption,
+    loadActivitiesMock: vi.fn().mockResolvedValue( { activities: {} } ),
     loadHooksMock: vi.fn().mockResolvedValue( undefined ),
-    loadWorkflowsMock: vi.fn().mockResolvedValue( [] ),
+    loadWorkflowsMock: vi.fn().mockResolvedValue( { workflows: [], entrypoint: '/fake/workflows/path.js' } ),
     mainEventBusMock: { emit: vi.fn(), on: vi.fn() },
     mockConnection: { close: vi.fn().mockResolvedValue( undefined ) },
     mockLog: { error: vi.fn(), info: vi.fn(), warn: vi.fn() },
-    mockWorker,
+    mockWorker: { name: 'temporal-worker' },
     promises,
     resetPromises,
-    serializeErrorMock: vi.fn( error => ( {
-      name: error.name,
-      message: error.message,
-      stack: error.stack
-    } ) ),
+    serializeErrorMock: vi.fn( error => ( { name: error.name, message: error.message } ) ),
     setupClientConfigMock: vi.fn(),
-    setupInterruptionHandlerMock: vi.fn(),
+    setupInterruptionHandlerMock: vi.fn( controller => {
+      interruption.controller = controller;
+    } ),
+    setupTelemetryMock: vi.fn(),
     setupTemporalLoggerMock: vi.fn(),
-    setupTelemetryMock: vi.fn()
+    shutdownServicesMock: vi.fn().mockResolvedValue( [] ),
+    workerRunnerInstance
   };
 } );
 
+const initTracing = vi.fn().mockResolvedValue( undefined );
+
 vi.mock( '#logger', () => ( { createChildLogger: () => mockLog } ) );
 vi.mock( '#helpers/error_serializer', () => ( { serializeError: serializeErrorMock } ) );
-const initTracing = vi.fn().mockResolvedValue( undefined );
 vi.mock( '#tracing', () => ( { init: initTracing } ) );
 vi.mock( '#bus', () => ( { mainEventBus: mainEventBusMock } ) );
 vi.mock( '#hooks/pending_hooks', () => ( { flushPendingHooks: flushPendingHooksMock } ) );
-
-const loadWorkflowsMock = vi.fn().mockResolvedValue( { workflows: [], entrypoint: '/fake/workflows/path.js' } );
-const loadActivitiesMock = vi.fn().mockResolvedValue( { activities: {} } );
-const loadHooksMock = vi.fn().mockResolvedValue( undefined );
+vi.mock( '#temporal/client', () => ( { setupClientConfig: setupClientConfigMock } ) );
+vi.mock( './configs.js', () => configValues );
 vi.mock( './loader/workflows.js', () => ( { loadWorkflows: loadWorkflowsMock } ) );
 vi.mock( './loader/activities.js', () => ( { loadActivities: loadActivitiesMock } ) );
 vi.mock( './loader/hooks.js', () => ( { loadHooks: loadHooksMock } ) );
-vi.mock( './configs.js', () => configValues );
-
-const hashSourceCodeMock = vi.fn().mockResolvedValue( 'catalog-hash' );
 vi.mock( './loader/tools.js', () => ( { hashSourceCode: hashSourceCodeMock } ) );
-
 vi.mock( './sinks.js', () => ( { sinks: {} } ) );
 vi.mock( './catalog_workflow/index.js', () => ( { createCatalog: createCatalogMock } ) );
 vi.mock( './bundler_options.js', () => ( { webpackConfigHook: vi.fn() } ) );
 vi.mock( './interceptors/index.js', () => ( { initInterceptors: initInterceptorsMock } ) );
 vi.mock( './telemetry.js', () => ( { setupTelemetry: setupTelemetryMock } ) );
-vi.mock( './interruption.js', () => ( { setupInterruptionHandler: setupInterruptionHandlerMock } ) );
 vi.mock( './global_functions.js', () => ( { bindGlobalFunctions: bindGlobalFunctionsMock } ) );
+vi.mock( './temporal_logger.js', () => ( { setupTemporalLogger: setupTemporalLoggerMock } ) );
+vi.mock( './log_hooks.js', () => ( {} ) );
+vi.mock( './interruption.js', () => ( {
+  setupInterruptionHandler: setupInterruptionHandlerMock,
+  KillSignError: interruption.KillSignError,
+  UncaughtError: interruption.UncaughtError
+} ) );
+vi.mock( './worker_runner.js', () => ( {
+  WorkerRunner: vi.fn( function ( options ) {
+    workerRunnerInstance.options = options;
+    return workerRunnerInstance;
+  } )
+} ) );
 vi.mock( './connection_monitor.js', () => ( {
-  TemporalConnectionMonitor: vi.fn( function () {
+  TemporalConnectionMonitor: vi.fn( function ( options ) {
+    connectionMonitorInstance.options = options;
     return connectionMonitorInstance;
   } )
 } ) );
-vi.mock( './catalog_workflow/catalog_job.js', () => ( {
-  CatalogJob: vi.fn( function () {
-    return catalogJobInstance;
+vi.mock( './catalog_workflow/catalog_publisher.js', () => ( {
+  CatalogPublisher: vi.fn( function ( options ) {
+    catalogPublisherInstance.options = options;
+    return catalogPublisherInstance;
   } )
 } ) );
-vi.mock( './log_hooks.js', () => ( {} ) );
-vi.mock( './temporal_logger.js', () => ( { setupTemporalLogger: setupTemporalLoggerMock } ) );
-vi.mock( '#temporal/client', () => ( { setupClientConfig: setupClientConfigMock } ) );
+vi.mock( './shutdown.js', () => ( { shutdownServices: shutdownServicesMock } ) );
 vi.mock( '@temporalio/worker', () => ( {
   NativeConnection: { connect: vi.fn().mockResolvedValue( mockConnection ) },
   Worker: { create: vi.fn().mockResolvedValue( mockWorker ) }
@@ -180,15 +204,18 @@ const importWorker = async () => {
   await import( './index.js' );
 };
 
-const settleWorker = async () => {
-  promises.catalogJob.resolve();
-  promises.connectionMonitor.resolve();
-  promises.workerRun.resolve();
-  await vi.waitFor( () => expect( mockConnection.close ).toHaveBeenCalled() );
+/** Imports the worker and waits until it is polling, which is where a healthy boot settles. */
+const bootWorker = async () => {
+  await importWorker();
+  await vi.waitFor( () => {
+    expect( workerRunnerInstance.start ).toHaveBeenCalled();
+    expect( connectionMonitorInstance.start ).toHaveBeenCalled();
+  } );
 };
 
+const waitForExit = () => vi.waitFor( () => expect( process.exit ).toHaveBeenCalled() );
+
 describe( 'worker/index', () => {
-  const exitMock = vi.fn();
   const originalArgv = process.argv;
 
   beforeEach( () => {
@@ -199,16 +226,16 @@ describe( 'worker/index', () => {
     configValues.workerTuner = undefined;
     configValues.shutdownForceTime = undefined;
     configValues.shutdownGraceTime = undefined;
-    catalogJobInstance.error = null;
-    catalogJobInstance.errorCb = null;
-    catalogJobInstance.running = false;
-    connectionMonitorInstance.connectionLossError = null;
-    connectionMonitorInstance.connectionLostCb = null;
+    workerRunnerInstance.running = false;
+    workerRunnerInstance.options = null;
     connectionMonitorInstance.running = false;
+    connectionMonitorInstance.options = null;
+    catalogPublisherInstance.running = false;
+    catalogPublisherInstance.options = null;
+    interruption.controller = null;
     mockConnection.close.mockResolvedValue( undefined );
-    mockWorker.runState = 'RUNNING';
     process.argv = [ ...originalArgv.slice( 0, 2 ), '/test/caller/dir' ];
-    vi.spyOn( process, 'exit' ).mockImplementation( exitMock );
+    vi.spyOn( process, 'exit' ).mockImplementation( () => undefined );
   } );
 
   afterEach( () => {
@@ -216,225 +243,284 @@ describe( 'worker/index', () => {
     vi.restoreAllMocks();
   } );
 
-  it( 'creates the worker lifecycle jobs with expected dependencies', async () => {
-    const { NativeConnection, Worker } = await import( '@temporalio/worker' );
-    const { TemporalConnectionMonitor } = await import( './connection_monitor.js' );
-    const { CatalogJob } = await import( './catalog_workflow/catalog_job.js' );
-
-    await importWorker();
-
-    await vi.waitFor( () => expect( Worker.create ).toHaveBeenCalled() );
-
-    expect( loadHooksMock ).toHaveBeenCalledWith( '/test/caller/dir' );
-    expect( setupTemporalLoggerMock ).toHaveBeenCalledOnce();
-    expect( loadWorkflowsMock ).toHaveBeenCalledWith( '/test/caller/dir' );
-    expect( loadActivitiesMock ).toHaveBeenCalledWith( '/test/caller/dir', [] );
-    expect( initTracing ).toHaveBeenCalled();
-    expect( createCatalogMock ).toHaveBeenCalledWith( { workflows: [], activities: {} } );
-    expect( hashSourceCodeMock ).toHaveBeenCalledWith( '/test/caller/dir' );
-    expect( NativeConnection.connect ).toHaveBeenCalledWith( {
-      address: configValues.address,
-      tls: false,
-      apiKey: undefined,
-      proxy: undefined
+  describe( 'startup', () => {
+    it( 'wires every lifecycle component with the shared abort signal', async () => {
+      const { NativeConnection, Worker } = await import( '@temporalio/worker' );
+      const { TemporalConnectionMonitor } = await import( './connection_monitor.js' );
+      const { CatalogPublisher } = await import( './catalog_workflow/catalog_publisher.js' );
+      const { WorkerRunner } = await import( './worker_runner.js' );
+
+      await bootWorker();
+
+      const { signal } = interruption.controller;
+
+      expect( setupInterruptionHandlerMock ).toHaveBeenCalledWith( expect.any( AbortController ) );
+      expect( setupTemporalLoggerMock ).toHaveBeenCalledOnce();
+      expect( loadHooksMock ).toHaveBeenCalledWith( '/test/caller/dir' );
+      expect( loadWorkflowsMock ).toHaveBeenCalledWith( '/test/caller/dir' );
+      expect( loadActivitiesMock ).toHaveBeenCalledWith( '/test/caller/dir', [] );
+      expect( mainEventBusMock.emit ).toHaveBeenCalledWith( BusEventType.WORKER_BEFORE_START );
+      expect( initTracing ).toHaveBeenCalledOnce();
+      expect( createCatalogMock ).toHaveBeenCalledWith( { workflows: [], activities: {} } );
+      expect( hashSourceCodeMock ).toHaveBeenCalledWith( '/test/caller/dir' );
+      expect( NativeConnection.connect ).toHaveBeenCalledWith( {
+        address: configValues.address,
+        tls: false,
+        apiKey: undefined,
+        proxy: undefined
+      } );
+      expect( setupClientConfigMock ).toHaveBeenCalledWith( {
+        connection: mockConnection,
+        namespace: configValues.namespace
+      } );
+      expect( CatalogPublisher ).toHaveBeenCalledWith( {
+        connection: mockConnection,
+        namespace: configValues.namespace,
+        catalog: { workflowNames: [ 'demo' ] },
+        catalogHash: 'catalog-hash',
+        signal
+      } );
+      expect( catalogPublisherInstance.run ).toHaveBeenCalledOnce();
+      expect( TemporalConnectionMonitor ).toHaveBeenCalledWith( { connection: mockConnection, signal } );
+      expect( Worker.create ).toHaveBeenCalledWith( expect.objectContaining( {
+        connection: mockConnection,
+        namespace: configValues.namespace,
+        taskQueue: configValues.taskQueue,
+        workflowsPath: '/fake/workflows/path.js',
+        activities: {},
+        maxConcurrentWorkflowTaskExecutions: configValues.maxConcurrentWorkflowTaskExecutions,
+        maxConcurrentActivityTaskExecutions: configValues.maxConcurrentActivityTaskExecutions,
+        maxCachedWorkflows: configValues.maxCachedWorkflows,
+        maxConcurrentActivityTaskPolls: configValues.maxConcurrentActivityTaskPolls,
+        maxConcurrentWorkflowTaskPolls: configValues.maxConcurrentWorkflowTaskPolls
+      } ) );
+      expect( Worker.create.mock.calls[0][0] ).not.toHaveProperty( 'shutdownForceTime' );
+      expect( Worker.create.mock.calls[0][0] ).not.toHaveProperty( 'shutdownGraceTime' );
+      expect( initInterceptorsMock ).toHaveBeenCalledWith( { activities: {}, workflows: [] } );
+      expect( setupTelemetryMock ).toHaveBeenCalledWith( { worker: mockWorker } );
+      expect( WorkerRunner ).toHaveBeenCalledWith( { worker: mockWorker, signal } );
+    } );
+
+    it( 'publishes the catalog before creating the worker', async () => {
+      const { Worker } = await import( '@temporalio/worker' );
+
+      await bootWorker();
+
+      // The worker never exists unless its catalog matches its own source code.
+      expect( catalogPublisherInstance.run.mock.invocationCallOrder[0] )
+        .toBeLessThan( Worker.create.mock.invocationCallOrder[0] );
     } );
-    expect( setupClientConfigMock ).toHaveBeenCalledWith( {
-      connection: mockConnection,
-      namespace: configValues.namespace
+
+    it( 'passes worker tuner instead of incompatible execution concurrency options', async () => {
+      configValues.workerTuner = { tunerOptions: { targetMemoryUsage: 0.8, targetCpuUsage: 0.9 } };
+      const { Worker } = await import( '@temporalio/worker' );
+
+      await bootWorker();
+
+      const workerOptions = Worker.create.mock.calls[0][0];
+      expect( workerOptions ).toEqual( expect.objectContaining( { tuner: configValues.workerTuner } ) );
+      expect( workerOptions ).not.toHaveProperty( 'maxConcurrentWorkflowTaskExecutions' );
+      expect( workerOptions ).not.toHaveProperty( 'maxConcurrentActivityTaskExecutions' );
     } );
-    expect( bindGlobalFunctionsMock ).toHaveBeenCalledTimes( 1 );
-    expect( bindGlobalFunctionsMock.mock.invocationCallOrder[0] ).toBeLessThan(
-      NativeConnection.connect.mock.invocationCallOrder[0]
-    );
-    expect( TemporalConnectionMonitor ).toHaveBeenCalledWith( mockConnection );
-    expect( CatalogJob ).toHaveBeenCalledWith( {
-      connection: mockConnection,
-      namespace: configValues.namespace,
-      catalog: { workflows: [], activities: {} },
-      catalogHash: 'catalog-hash'
+
+    it( 'enables TLS when an apiKey is set', async () => {
+      configValues.apiKey = 'secret';
+      const { NativeConnection } = await import( '@temporalio/worker' );
+
+      await bootWorker();
+
+      expect( NativeConnection.connect ).toHaveBeenCalledWith( expect.objectContaining( { apiKey: 'secret', tls: true } ) );
     } );
-    expect( Worker.create ).toHaveBeenCalledWith( expect.objectContaining( {
-      connection: mockConnection,
-      namespace: configValues.namespace,
-      taskQueue: configValues.taskQueue,
-      workflowsPath: '/fake/workflows/path.js',
-      activities: {},
-      maxConcurrentWorkflowTaskExecutions: configValues.maxConcurrentWorkflowTaskExecutions,
-      maxConcurrentActivityTaskExecutions: configValues.maxConcurrentActivityTaskExecutions,
-      maxCachedWorkflows: configValues.maxCachedWorkflows,
-      maxConcurrentActivityTaskPolls: configValues.maxConcurrentActivityTaskPolls,
-      maxConcurrentWorkflowTaskPolls: configValues.maxConcurrentWorkflowTaskPolls
-    } ) );
-    expect( Worker.create.mock.calls[0][0] ).not.toHaveProperty( 'shutdownForceTime' );
-    expect( Worker.create.mock.calls[0][0] ).not.toHaveProperty( 'shutdownGraceTime' );
-    expect( initInterceptorsMock ).toHaveBeenCalledWith( { activities: {}, workflows: [] } );
-    expect( setupTelemetryMock ).toHaveBeenCalledWith( { worker: mockWorker } );
-    expect( setupInterruptionHandlerMock ).toHaveBeenCalledWith( expect.any( Function ) );
-    expect( connectionMonitorInstance.onConnectionLost ).toHaveBeenCalledWith( expect.any( Function ) );
-    expect( catalogJobInstance.onError ).toHaveBeenCalledWith( expect.any( Function ) );
-    expect( mockWorker.run ).toHaveBeenCalled();
-    expect( connectionMonitorInstance.start ).toHaveBeenCalled();
-    expect( catalogJobInstance.run ).toHaveBeenCalled();
 
-    await settleWorker();
-    await vi.waitFor( () => expect( flushPendingHooksMock ).toHaveBeenCalledOnce() );
-    expect( mockLog.info ).toHaveBeenCalledWith( 'Bye' );
-  } );
+    it( 'routes the connection through the configured gRPC proxy', async () => {
+      configValues.grpcProxy = 'proxy:1234';
+      const { NativeConnection } = await import( '@temporalio/worker' );
 
-  it( 'passes worker tuner instead of incompatible execution concurrency options', async () => {
-    configValues.workerTuner = {
-      tunerOptions: {
-        targetMemoryUsage: 0.8,
-        targetCpuUsage: 0.9
-      }
-    };
-    const { Worker } = await import( '@temporalio/worker' );
-
-    await importWorker();
-
-    await vi.waitFor( () => expect( Worker.create ).toHaveBeenCalled() );
-
-    const workerOptions = Worker.create.mock.calls[0][0];
-    expect( workerOptions ).toEqual( expect.objectContaining( {
-      tuner: configValues.workerTuner,
-      maxCachedWorkflows: configValues.maxCachedWorkflows,
-      maxConcurrentActivityTaskPolls: configValues.maxConcurrentActivityTaskPolls,
-      maxConcurrentWorkflowTaskPolls: configValues.maxConcurrentWorkflowTaskPolls
-    } ) );
-    expect( workerOptions ).not.toHaveProperty( 'maxConcurrentWorkflowTaskExecutions' );
-    expect( workerOptions ).not.toHaveProperty( 'maxConcurrentActivityTaskExecutions' );
-
-    await settleWorker();
-  } );
+      await bootWorker();
 
-  it( 'enables TLS when apiKey is set', async () => {
-    configValues.apiKey = 'secret';
-    const { NativeConnection } = await import( '@temporalio/worker' );
+      expect( NativeConnection.connect ).toHaveBeenCalledWith( expect.objectContaining( {
+        proxy: { type: 'http-connect', targetHost: 'proxy:1234' }
+      } ) );
+    } );
 
-    await importWorker();
+    it( 'passes configured shutdown durations to the worker', async () => {
+      configValues.shutdownForceTime = '30s';
+      configValues.shutdownGraceTime = '10s';
+      const { Worker } = await import( '@temporalio/worker' );
 
-    await vi.waitFor( () => expect( NativeConnection.connect ).toHaveBeenCalledWith( expect.objectContaining( {
-      apiKey: 'secret',
-      tls: true
-    } ) ) );
+      await bootWorker();
 
-    await settleWorker();
+      expect( Worker.create ).toHaveBeenCalledWith( expect.objectContaining( {
+        shutdownForceTime: '30s',
+        shutdownGraceTime: '10s'
+      } ) );
+    } );
+
+    it( 'stops advancing through startup once the signal aborts', async () => {
+      const { NativeConnection } = await import( '@temporalio/worker' );
+      loadHooksMock.mockImplementationOnce( async () => {
+        interruption.controller.abort( new interruption.KillSignError( 'SIGTERM' ) );
+      } );
+
+      await importWorker();
+      await waitForExit();
+
+      expect( loadWorkflowsMock ).not.toHaveBeenCalled();
+      expect( NativeConnection.connect ).not.toHaveBeenCalled();
+      expect( mockLog.error ).not.toHaveBeenCalled();
+      expect( process.exit ).toHaveBeenCalledWith( 0 );
+    } );
   } );
 
-  it( 'passes configured shutdown durations to the worker', async () => {
-    configValues.shutdownForceTime = '30s';
-    configValues.shutdownGraceTime = '10s';
-    const { Worker } = await import( '@temporalio/worker' );
+  describe( 'clean termination', () => {
+    it( 'shuts every service down and exits successfully on a kill signal', async () => {
+      await bootWorker();
 
-    await importWorker();
+      interruption.controller.abort( new interruption.KillSignError( 'SIGTERM' ) );
+      await waitForExit();
 
-    await vi.waitFor( () => expect( Worker.create ).toHaveBeenCalledWith( expect.objectContaining( {
-      shutdownForceTime: '30s',
-      shutdownGraceTime: '10s'
-    } ) ) );
+      expect( shutdownServicesMock ).toHaveBeenCalledOnce();
+      expect( shutdownServicesMock ).toHaveBeenCalledWith( {
+        workerRunner: workerRunnerInstance,
+        connectionMonitor: connectionMonitorInstance,
+        catalogPublisher: catalogPublisherInstance,
+        connection: mockConnection
+      } );
+      expect( mockLog.error ).not.toHaveBeenCalled();
+      expect( mainEventBusMock.emit ).not.toHaveBeenCalledWith( BusEventType.RUNTIME_ERROR, expect.anything() );
+      expect( mockLog.info ).toHaveBeenCalledWith( 'Bye' );
+      expect( process.exit ).toHaveBeenCalledWith( 0 );
+    } );
 
-    await settleWorker();
-  } );
+    it( 'still exits cleanly when a service other than the worker failed to stop', async () => {
+      await bootWorker();
+      shutdownServicesMock.mockResolvedValueOnce( [ { service: 'connection', error: new Error( 'close failed' ) } ] );
 
-  it( 'runs graceful shutdown when interrupted', async () => {
-    await importWorker();
+      interruption.controller.abort( new interruption.KillSignError( 'SIGTERM' ) );
+      await waitForExit();
 
-    await vi.waitFor( () => expect( setupInterruptionHandlerMock ).toHaveBeenCalled() );
-    const [ shutdown ] = setupInterruptionHandlerMock.mock.calls[0];
+      expect( mockLog.error ).not.toHaveBeenCalled();
+      expect( process.exit ).toHaveBeenCalledWith( 0 );
+    } );
 
-    shutdown();
+    it( 'does not report the worker as terminated when a signal ended the run', async () => {
+      await bootWorker();
 
-    expect( mockWorker.shutdown ).toHaveBeenCalledOnce();
-    expect( connectionMonitorInstance.stop ).toHaveBeenCalledOnce();
-    expect( catalogJobInstance.interrupt ).toHaveBeenCalledOnce();
+      interruption.controller.abort( new interruption.KillSignError( 'SIGTERM' ) );
+      await waitForExit();
 
-    promises.workerRun.resolve();
-    await vi.waitFor( () => expect( mockConnection.close ).toHaveBeenCalled() );
-    expect( mockLog.info ).toHaveBeenCalledWith( 'Bye' );
-  } );
+      expect( mockLog.info ).not.toHaveBeenCalledWith( 'Worker terminated' );
+    } );
 
-  it( 'does not call worker.shutdown when worker has already failed', async () => {
-    const error = new Error( 'Big Failure' );
+    it( 'reports a terminated worker when the run ends without an abort', async () => {
+      await bootWorker();
 
-    await importWorker();
-    await vi.waitFor( () => expect( mockWorker.run ).toHaveBeenCalled() );
+      promises.connectionMonitor.resolve();
+      await waitForExit();
 
-    mockWorker.runState = 'FAILED';
-    promises.workerRun.reject( error );
+      expect( mockLog.info ).toHaveBeenCalledWith( 'Worker terminated' );
+      expect( process.exit ).toHaveBeenCalledWith( 0 );
+    } );
 
-    await vi.waitFor( () => expect( connectionMonitorInstance.stop ).toHaveBeenCalled() );
-    expect( mockWorker.shutdown ).not.toHaveBeenCalled();
+    it( 'flushes pending hooks before exiting', async () => {
+      await bootWorker();
 
-    promises.connectionMonitor.resolve();
-    promises.catalogJob.resolve();
+      interruption.controller.abort( new interruption.KillSignError( 'SIGTERM' ) );
+      await waitForExit();
 
-    await vi.waitFor( () => {
-      expect( mockLog.error ).toHaveBeenCalledWith( 'Fatal error', expect.objectContaining( {
-        error: expect.objectContaining( { message: 'Big Failure' } )
-      } ) );
+      expect( flushPendingHooksMock ).toHaveBeenCalledOnce();
+      expect( shutdownServicesMock.mock.invocationCallOrder[0] )
+        .toBeLessThan( flushPendingHooksMock.mock.invocationCallOrder[0] );
+      expect( flushPendingHooksMock.mock.invocationCallOrder[0] )
+        .toBeLessThan( process.exit.mock.invocationCallOrder[0] );
     } );
-    expect( serializeErrorMock ).toHaveBeenCalledWith( error );
-    expect( mainEventBusMock.emit ).toHaveBeenCalledWith( expect.any( String ), { error } );
-    await vi.waitFor( () => expect( exitMock ).toHaveBeenCalledWith( 1 ) );
-    expect( flushPendingHooksMock ).toHaveBeenCalledOnce();
-    expect( mainEventBusMock.emit.mock.invocationCallOrder[0] ).toBeLessThan( flushPendingHooksMock.mock.invocationCallOrder[0] );
-    expect( flushPendingHooksMock.mock.invocationCallOrder[0] ).toBeLessThan( exitMock.mock.invocationCallOrder[0] );
   } );
 
-  it( 'throws connection monitor errors after graceful shutdown', async () => {
-    const error = new Error( 'connection lost' );
+  describe( 'failures', () => {
+    it( 'reports an uncaught error captured by the interruption handler', async () => {
+      const cause = new Error( 'boom' );
+      await bootWorker();
+
+      const fault = new interruption.UncaughtError( 'uncaughtException', { cause } );
+      interruption.controller.abort( fault );
+      await waitForExit();
+
+      expect( mockLog.error ).toHaveBeenCalledWith( 'Worker error', {
+        error: expect.objectContaining( { name: 'UncaughtError', message: 'uncaughtException' } )
+      } );
+      expect( mainEventBusMock.emit ).toHaveBeenCalledWith( BusEventType.RUNTIME_ERROR, { error: fault } );
+      expect( process.exit ).toHaveBeenCalledWith( 1 );
+    } );
+
+    it( 'exits with a failure when the worker never finished draining', async () => {
+      await bootWorker();
+      shutdownServicesMock.mockResolvedValueOnce( [ { service: 'worker', error: new Error( 'drain failed' ) } ] );
+
+      interruption.controller.abort( new interruption.KillSignError( 'SIGTERM' ) );
+      await waitForExit();
+
+      expect( process.exit ).toHaveBeenCalledWith( 1 );
+    } );
 
-    await importWorker();
-    await vi.waitFor( () => expect( connectionMonitorInstance.onConnectionLost ).toHaveBeenCalled() );
+    it( 'reports a lost connection and shuts down', async () => {
+      const error = new Error( 'connection lost' );
+      await bootWorker();
 
-    connectionMonitorInstance.connectionLossError = error;
-    connectionMonitorInstance.connectionLostCb( error );
-    promises.workerRun.resolve();
+      promises.connectionMonitor.reject( error );
+      await waitForExit();
 
-    await vi.waitFor( () => {
-      expect( mockLog.error ).toHaveBeenCalledWith( 'Fatal error', expect.objectContaining( {
+      expect( shutdownServicesMock ).toHaveBeenCalledOnce();
+      expect( serializeErrorMock ).toHaveBeenCalledWith( error );
+      expect( mockLog.error ).toHaveBeenCalledWith( 'Worker error', {
         error: expect.objectContaining( { message: 'connection lost' } )
-      } ) );
+      } );
+      expect( mainEventBusMock.emit ).toHaveBeenCalledWith( BusEventType.RUNTIME_ERROR, { error } );
+      expect( process.exit ).toHaveBeenCalledWith( 1 );
     } );
-    expect( mockWorker.shutdown ).toHaveBeenCalledOnce();
-    expect( catalogJobInstance.interrupt ).toHaveBeenCalledOnce();
-    expect( mainEventBusMock.emit ).toHaveBeenCalledWith( expect.any( String ), { error } );
-  } );
 
-  it( 'throws catalog job errors after graceful shutdown', async () => {
-    const error = new Error( 'catalog failed' );
+    it( 'reports a failed worker run', async () => {
+      const error = new Error( 'worker crashed' );
+      await bootWorker();
 
-    await importWorker();
-    await vi.waitFor( () => expect( catalogJobInstance.onError ).toHaveBeenCalled() );
+      promises.workerRunner.reject( error );
+      await waitForExit();
 
-    catalogJobInstance.error = error;
-    catalogJobInstance.errorCb( error );
-    promises.workerRun.resolve();
+      expect( shutdownServicesMock ).toHaveBeenCalledOnce();
+      expect( mockLog.error ).toHaveBeenCalledWith( 'Worker error', {
+        error: expect.objectContaining( { message: 'worker crashed' } )
+      } );
+      expect( process.exit ).toHaveBeenCalledWith( 1 );
+    } );
 
-    await vi.waitFor( () => {
-      expect( mockLog.error ).toHaveBeenCalledWith( 'Fatal error', expect.objectContaining( {
+    it( 'never creates the worker when publishing the catalog fails', async () => {
+      const { Worker } = await import( '@temporalio/worker' );
+      catalogPublisherInstance.run.mockRejectedValueOnce( new Error( 'catalog failed' ) );
+
+      await importWorker();
+      await waitForExit();
+
+      expect( Worker.create ).not.toHaveBeenCalled();
+      expect( workerRunnerInstance.start ).not.toHaveBeenCalled();
+      expect( shutdownServicesMock ).toHaveBeenCalledOnce();
+      expect( mockLog.error ).toHaveBeenCalledWith( 'Worker error', {
         error: expect.objectContaining( { message: 'catalog failed' } )
-      } ) );
+      } );
+      expect( process.exit ).toHaveBeenCalledWith( 1 );
     } );
-    expect( mockWorker.shutdown ).toHaveBeenCalledOnce();
-    expect( connectionMonitorInstance.stop ).toHaveBeenCalledOnce();
-    expect( mainEventBusMock.emit ).toHaveBeenCalledWith( expect.any( String ), { error } );
-  } );
 
-  it( 'cleans up partial startup failures after connecting', async () => {
-    const { Worker } = await import( '@temporalio/worker' );
-    const error = new Error( 'worker create failed' );
-    Worker.create.mockRejectedValueOnce( error );
+    it( 'hands the partially built services to shutdown when startup fails', async () => {
+      const { Worker } = await import( '@temporalio/worker' );
+      Worker.create.mockRejectedValueOnce( new Error( 'worker create failed' ) );
 
-    await importWorker();
+      await importWorker();
+      await waitForExit();
 
-    await vi.waitFor( () => expect( mockConnection.close ).toHaveBeenCalled() );
-    expect( connectionMonitorInstance.stop ).not.toHaveBeenCalled();
-    expect( catalogJobInstance.interrupt ).not.toHaveBeenCalled();
-    await vi.waitFor( () => {
-      expect( mockLog.error ).toHaveBeenCalledWith( 'Fatal error', expect.objectContaining( {
-        error: expect.objectContaining( { message: 'worker create failed' } )
+      expect( workerRunnerInstance.start ).not.toHaveBeenCalled();
+      expect( shutdownServicesMock ).toHaveBeenCalledWith( expect.objectContaining( {
+        workerRunner: null,
+        connection: mockConnection
       } ) );
+      expect( process.exit ).toHaveBeenCalledWith( 1 );
     } );
   } );
 } );