@outputai/core 0.1.0

package/src/worker/catalog_workflow/index.spec.js

@@ -0,0 +1,196 @@
+import { describe, it, expect, vi } from 'vitest';
+import { z } from 'zod';
+
+// Provide the same symbol to the module under test and to the test
+const METADATA_ACCESS_SYMBOL = Symbol( '__metadata' );
+vi.mock( '#consts', () => ( {
+  METADATA_ACCESS_SYMBOL
+} ) );
+
+const setMetadata = ( target, values ) =>
+  Object.defineProperty( target, METADATA_ACCESS_SYMBOL, { value: values, writable: false, enumerable: false, configurable: false } );
+
+describe( 'createCatalog', () => {
+  it( 'builds catalog with activities grouped by workflow path and returns Catalog with CatalogWorkflow entries', async () => {
+    const { createCatalog } = await import( './index.js' );
+
+    const workflows = [
+      {
+        name: 'flow1',
+        path: '/flows/flow1/workflow.js',
+        description: 'desc-flow1',
+        inputSchema: z.object( { in: z.literal( 'f1' ) } ),
+        outputSchema: z.object( { out: z.literal( 'f1' ) } )
+      },
+      {
+        name: 'flow2',
+        path: '/flows/flow2/workflow.js',
+        description: 'desc-flow2',
+        inputSchema: z.object( { in: z.literal( 'f2' ) } ),
+        outputSchema: z.object( { out: z.literal( 'f2' ) } )
+      }
+    ];
+
+    const activity1 = () => {};
+    setMetadata( activity1, {
+      name: 'A1',
+      path: '/flows/flow1#A1',
+      description: 'desc-a1',
+      inputSchema: z.object( { in: z.literal( 'a1' ) } ),
+      outputSchema: z.object( { out: z.literal( 'a1' ) } )
+    } );
+
+    const activity2 = () => {};
+    setMetadata( activity2, {
+      name: 'A2',
+      path: '/flows/flow1#A2',
+      description: 'desc-a2',
+      inputSchema: z.object( { in: z.literal( 'a2' ) } ),
+      outputSchema: z.object( { out: z.literal( 'a2' ) } )
+    } );
+
+    const activity3 = () => {};
+    setMetadata( activity3, {
+      name: 'B1',
+      path: '/flows/flow2#B1',
+      description: 'desc-b1',
+      inputSchema: z.object( { in: z.literal( 'b1' ) } ),
+      outputSchema: z.object( { out: z.literal( 'b1' ) } )
+    } );
+
+    const activity4 = () => {};
+    setMetadata( activity4, {
+      name: 'X',
+      path: '/other#X',
+      description: 'desc-x',
+      inputSchema: z.object( { in: z.literal( 'x' ) } ),
+      outputSchema: z.object( { out: z.literal( 'x' ) } )
+    } );
+
+    const activities = {
+      '/flows/flow1#A1': activity1,
+      '/flows/flow1#A2': activity2,
+      '/flows/flow2#B1': activity3,
+      '/other#X': activity4
+    };
+
+    const catalog = createCatalog( { workflows, activities } );
+
+    const mapped = catalog.workflows.map( w => ( {
+      name: w.name,
+      path: w.path,
+      description: w.description,
+      inputSchema: w.inputSchema,
+      outputSchema: w.outputSchema,
+      activities: w.activities.map( a => ( {
+        name: a.name,
+        description: a.description,
+        inputSchema: a.inputSchema,
+        outputSchema: a.outputSchema
+      } ) )
+    } ) );
+
+    expect( mapped ).toEqual( [
+      {
+        name: 'flow1',
+        path: '/flows/flow1/workflow.js',
+        description: 'desc-flow1',
+        inputSchema: {
+          $schema: 'https://json-schema.org/draft/2020-12/schema',
+          type: 'object',
+          properties: { in: { type: 'string', const: 'f1' } },
+          required: [ 'in' ],
+          additionalProperties: false
+        },
+        outputSchema: {
+          $schema: 'https://json-schema.org/draft/2020-12/schema',
+          type: 'object',
+          properties: { out: { type: 'string', const: 'f1' } },
+          required: [ 'out' ],
+          additionalProperties: false
+        },
+        activities: [
+          {
+            name: 'A1',
+            description: 'desc-a1',
+            inputSchema: {
+              $schema: 'https://json-schema.org/draft/2020-12/schema',
+              type: 'object',
+              properties: { in: { type: 'string', const: 'a1' } },
+              required: [ 'in' ],
+              additionalProperties: false
+            },
+            outputSchema: {
+              $schema: 'https://json-schema.org/draft/2020-12/schema',
+              type: 'object',
+              properties: { out: { type: 'string', const: 'a1' } },
+              required: [ 'out' ],
+              additionalProperties: false
+            }
+          },
+          {
+            name: 'A2',
+            description: 'desc-a2',
+            inputSchema: {
+              $schema: 'https://json-schema.org/draft/2020-12/schema',
+              type: 'object',
+              properties: { in: { type: 'string', const: 'a2' } },
+              required: [ 'in' ],
+              additionalProperties: false
+            },
+            outputSchema: {
+              $schema: 'https://json-schema.org/draft/2020-12/schema',
+              type: 'object',
+              properties: { out: { type: 'string', const: 'a2' } },
+              required: [ 'out' ],
+              additionalProperties: false
+            }
+          }
+        ]
+      },
+      {
+        name: 'flow2',
+        path: '/flows/flow2/workflow.js',
+        description: 'desc-flow2',
+        inputSchema: {
+          $schema: 'https://json-schema.org/draft/2020-12/schema',
+          type: 'object',
+          properties: { in: { type: 'string', const: 'f2' } },
+          required: [ 'in' ],
+          additionalProperties: false
+        },
+        outputSchema: {
+          $schema: 'https://json-schema.org/draft/2020-12/schema',
+          type: 'object',
+          properties: { out: { type: 'string', const: 'f2' } },
+          required: [ 'out' ],
+          additionalProperties: false
+        },
+        activities: [
+          {
+            name: 'B1',
+            description: 'desc-b1',
+            inputSchema: {
+              $schema: 'https://json-schema.org/draft/2020-12/schema',
+              type: 'object',
+              properties: { in: { type: 'string', const: 'b1' } },
+              required: [ 'in' ],
+              additionalProperties: false
+            },
+            outputSchema: {
+              $schema: 'https://json-schema.org/draft/2020-12/schema',
+              type: 'object',
+              properties: { out: { type: 'string', const: 'b1' } },
+              required: [ 'out' ],
+              additionalProperties: false
+            }
+          }
+        ]
+      }
+    ] );
+
+    // Original inputs are not mutated
+    expect( workflows[0].path ).toBe( '/flows/flow1/workflow.js' );
+    expect( workflows[1].path ).toBe( '/flows/flow2/workflow.js' );
+  } );
+} );

package/src/worker/catalog_workflow/workflow.js

@@ -0,0 +1,24 @@
+import { defineQuery, setHandler, condition, defineUpdate } from '@temporalio/workflow';
+
+/**
+ * This is a special workflow, unique to each worker, which holds the meta information of all other workflows in that worker.
+ *
+ * The information is set in the startup and is accessible via a query called 'get'.
+ *
+ * @param {object} catalog - The catalog information
+ */
+export default async function catalogWorkflow( catalog ) {
+  const state = { canEnd: false };
+
+  // Returns the catalog
+  setHandler( defineQuery( 'get' ), () => catalog );
+
+  // Politely respond to a ping
+  setHandler( defineQuery( 'ping' ), () => 'pong' );
+
+  // Listen to this update to complete the workflow
+  setHandler( defineUpdate( 'complete' ), () => state.canEnd = true );
+
+  // Wait indefinitely, until the state changes
+  await condition( () => state.canEnd );
+};

package/src/worker/configs.js

@@ -0,0 +1,49 @@
+import * as z from 'zod';
+import { isStringboolTrue } from '#utils';
+
+class InvalidEnvVarsErrors extends Error { }
+
+const coalesceEmptyString = v => v === '' ? undefined : v;
+
+const envVarSchema = z.object( {
+  OUTPUT_CATALOG_ID: z.string().regex( /^[a-z0-9_.@-]+$/i ),
+  TEMPORAL_ADDRESS: z.string().default( 'localhost:7233' ),
+  TEMPORAL_API_KEY: z.string().optional(),
+  TEMPORAL_NAMESPACE: z.string().optional().default( 'default' ),
+  // Worker concurrency — tune these via env vars to adjust for your workload.
+  // Each step (API, LLM, etc.) call is one activity. Lower this to reduce memory pressure.
+  TEMPORAL_MAX_CONCURRENT_ACTIVITY_TASK_EXECUTIONS: z.preprocess( coalesceEmptyString, z.coerce.number().int().positive().default( 40 ) ),
+  // Workflows are lightweight state machines — this can be high.
+  TEMPORAL_MAX_CONCURRENT_WORKFLOW_TASK_EXECUTIONS: z.preprocess( coalesceEmptyString, z.coerce.number().int().positive().default( 200 ) ),
+  // LRU cache for sticky workflow execution. Lower values free memory faster after surges.
+  TEMPORAL_MAX_CACHED_WORKFLOWS: z.preprocess( coalesceEmptyString, z.coerce.number().int().positive().default( 1000 ) ),
+  // How aggressively the worker pulls tasks from Temporal.
+  TEMPORAL_MAX_CONCURRENT_ACTIVITY_TASK_POLLS: z.preprocess( coalesceEmptyString, z.coerce.number().int().positive().default( 5 ) ),
+  TEMPORAL_MAX_CONCURRENT_WORKFLOW_TASK_POLLS: z.preprocess( coalesceEmptyString, z.coerce.number().int().positive().default( 5 ) ),
+  // Activity configs
+  // How often the worker sends a heartbeat to the Temporal Service during activity execution
+  OUTPUT_ACTIVITY_HEARTBEAT_INTERVAL_MS: z.preprocess( coalesceEmptyString, z.coerce.number().int().positive().default( 2 * 60 * 1000 ) ), // 2min
+  // Whether to send activity heartbeats (enabled by default)
+  OUTPUT_ACTIVITY_HEARTBEAT_ENABLED: z.transform( v => v === undefined ? true : isStringboolTrue( v ) ),
+  // Time to allow for hooks to flush before shutdown
+  OUTPUT_PROCESS_FAILURE_SHUTDOWN_DELAY: z.preprocess( coalesceEmptyString, z.coerce.number().int().positive().default( 3000 ) )
+} );
+
+const { data: envVars, error } = envVarSchema.safeParse( process.env );
+if ( error ) {
+  throw new InvalidEnvVarsErrors( z.prettifyError( error ) );
+}
+
+export const address = envVars.TEMPORAL_ADDRESS;
+export const apiKey = envVars.TEMPORAL_API_KEY;
+export const maxConcurrentActivityTaskExecutions = envVars.TEMPORAL_MAX_CONCURRENT_ACTIVITY_TASK_EXECUTIONS;
+export const maxConcurrentWorkflowTaskExecutions = envVars.TEMPORAL_MAX_CONCURRENT_WORKFLOW_TASK_EXECUTIONS;
+export const maxCachedWorkflows = envVars.TEMPORAL_MAX_CACHED_WORKFLOWS;
+export const maxConcurrentActivityTaskPolls = envVars.TEMPORAL_MAX_CONCURRENT_ACTIVITY_TASK_POLLS;
+export const maxConcurrentWorkflowTaskPolls = envVars.TEMPORAL_MAX_CONCURRENT_WORKFLOW_TASK_POLLS;
+export const namespace = envVars.TEMPORAL_NAMESPACE;
+export const taskQueue = envVars.OUTPUT_CATALOG_ID;
+export const catalogId = envVars.OUTPUT_CATALOG_ID;
+export const activityHeartbeatIntervalMs = envVars.OUTPUT_ACTIVITY_HEARTBEAT_INTERVAL_MS;
+export const activityHeartbeatEnabled = envVars.OUTPUT_ACTIVITY_HEARTBEAT_ENABLED;
+export const processFailureShutdownDelay = envVars.OUTPUT_PROCESS_FAILURE_SHUTDOWN_DELAY;

package/src/worker/configs.spec.js

@@ -0,0 +1,130 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+
+const CONFIG_KEYS = [
+  'OUTPUT_CATALOG_ID',
+  'TEMPORAL_ADDRESS',
+  'TEMPORAL_API_KEY',
+  'TEMPORAL_NAMESPACE',
+  'TEMPORAL_MAX_CONCURRENT_ACTIVITY_TASK_EXECUTIONS',
+  'TEMPORAL_MAX_CONCURRENT_WORKFLOW_TASK_EXECUTIONS',
+  'TEMPORAL_MAX_CACHED_WORKFLOWS',
+  'TEMPORAL_MAX_CONCURRENT_ACTIVITY_TASK_POLLS',
+  'TEMPORAL_MAX_CONCURRENT_WORKFLOW_TASK_POLLS',
+  'OUTPUT_ACTIVITY_HEARTBEAT_INTERVAL_MS',
+  'OUTPUT_ACTIVITY_HEARTBEAT_ENABLED'
+];
+
+const setEnv = ( overrides = {} ) => {
+  process.env.OUTPUT_CATALOG_ID = overrides.OUTPUT_CATALOG_ID ?? 'test-catalog';
+  CONFIG_KEYS.forEach( key => {
+    if ( overrides[key] !== undefined ) {
+      process.env[key] = String( overrides[key] );
+    }
+  } );
+};
+
+const clearEnv = () => {
+  CONFIG_KEYS.forEach( key => delete process.env[key] );
+};
+
+async function loadConfigs() {
+  vi.resetModules();
+  return import( './configs.js' );
+}
+
+describe( 'worker/configs', () => {
+  beforeEach( () => clearEnv() );
+  afterEach( () => clearEnv() );
+
+  it( 'throws when OUTPUT_CATALOG_ID is missing', async () => {
+    clearEnv();
+    vi.resetModules();
+
+    await expect( import( './configs.js' ) ).rejects.toThrow();
+  } );
+
+  it( 'throws when OUTPUT_CATALOG_ID does not match regex', async () => {
+    setEnv( { OUTPUT_CATALOG_ID: 'invalid space' } );
+    vi.resetModules();
+
+    await expect( import( './configs.js' ) ).rejects.toThrow();
+  } );
+
+  it( 'uses defaults when only OUTPUT_CATALOG_ID is set', async () => {
+    setEnv();
+    const configs = await loadConfigs();
+
+    expect( configs.address ).toBe( 'localhost:7233' );
+    expect( configs.namespace ).toBe( 'default' );
+    expect( configs.maxConcurrentActivityTaskExecutions ).toBe( 40 );
+    expect( configs.maxConcurrentWorkflowTaskExecutions ).toBe( 200 );
+    expect( configs.maxCachedWorkflows ).toBe( 1000 );
+    expect( configs.maxConcurrentActivityTaskPolls ).toBe( 5 );
+    expect( configs.maxConcurrentWorkflowTaskPolls ).toBe( 5 );
+    expect( configs.activityHeartbeatIntervalMs ).toBe( 2 * 60 * 1000 );
+    expect( configs.activityHeartbeatEnabled ).toBe( true );
+    expect( configs.taskQueue ).toBe( 'test-catalog' );
+    expect( configs.catalogId ).toBe( 'test-catalog' );
+  } );
+
+  it( 'treats empty string for optional number as default (preprocess)', async () => {
+    setEnv( { TEMPORAL_MAX_CONCURRENT_ACTIVITY_TASK_EXECUTIONS: '' } );
+    const configs = await loadConfigs();
+
+    expect( configs.maxConcurrentActivityTaskExecutions ).toBe( 40 );
+  } );
+
+  it( 'parses custom numeric env vars', async () => {
+    setEnv( {
+      TEMPORAL_MAX_CONCURRENT_ACTIVITY_TASK_EXECUTIONS: '10',
+      TEMPORAL_MAX_CONCURRENT_WORKFLOW_TASK_EXECUTIONS: '50',
+      TEMPORAL_MAX_CACHED_WORKFLOWS: '500',
+      OUTPUT_ACTIVITY_HEARTBEAT_INTERVAL_MS: '60000'
+    } );
+    const configs = await loadConfigs();
+
+    expect( configs.maxConcurrentActivityTaskExecutions ).toBe( 10 );
+    expect( configs.maxConcurrentWorkflowTaskExecutions ).toBe( 50 );
+    expect( configs.maxCachedWorkflows ).toBe( 500 );
+    expect( configs.activityHeartbeatIntervalMs ).toBe( 60000 );
+  } );
+
+  it( 'throws when optional number is zero or negative', async () => {
+    setEnv( { TEMPORAL_MAX_CONCURRENT_ACTIVITY_TASK_EXECUTIONS: '0' } );
+    vi.resetModules();
+
+    await expect( import( './configs.js' ) ).rejects.toThrow();
+  } );
+
+  it( 'OUTPUT_ACTIVITY_HEARTBEAT_ENABLED: "true"|"1"|"on" → true', async () => {
+    for ( const val of [ 'true', '1', 'on' ] ) {
+      setEnv( { OUTPUT_ACTIVITY_HEARTBEAT_ENABLED: val } );
+      const configs = await loadConfigs();
+      expect( configs.activityHeartbeatEnabled ).toBe( true );
+      clearEnv();
+    }
+  } );
+
+  it( 'OUTPUT_ACTIVITY_HEARTBEAT_ENABLED: "false"|other → false, undefined → true', async () => {
+    setEnv( { OUTPUT_ACTIVITY_HEARTBEAT_ENABLED: 'false' } );
+    const configsFalse = await loadConfigs();
+    expect( configsFalse.activityHeartbeatEnabled ).toBe( false );
+
+    setEnv( { OUTPUT_ACTIVITY_HEARTBEAT_ENABLED: '0' } );
+    const configsZero = await loadConfigs();
+    expect( configsZero.activityHeartbeatEnabled ).toBe( false );
+
+    clearEnv();
+    setEnv(); // only OUTPUT_CATALOG_ID; OUTPUT_ACTIVITY_HEARTBEAT_ENABLED absent → default true
+    const configsDefault = await loadConfigs();
+    expect( configsDefault.activityHeartbeatEnabled ).toBe( true );
+  } );
+
+  it( 'parses TEMPORAL_ADDRESS and TEMPORAL_NAMESPACE', async () => {
+    setEnv( { TEMPORAL_ADDRESS: 'temporal:7233', TEMPORAL_NAMESPACE: 'my-ns' } );
+    const configs = await loadConfigs();
+
+    expect( configs.address ).toBe( 'temporal:7233' );
+    expect( configs.namespace ).toBe( 'my-ns' );
+  } );
+} );

package/src/worker/index.js

@@ -0,0 +1,89 @@
+import { Worker, NativeConnection } from '@temporalio/worker';
+import * as configs from './configs.js';
+import { loadActivities, loadHooks, loadWorkflows, createWorkflowsEntryPoint } from './loader.js';
+import { sinks } from './sinks.js';
+import { createCatalog } from './catalog_workflow/index.js';
+import { init as initTracing } from '#tracing';
+import { webpackConfigHook } from './bundler_options.js';
+import { initInterceptors } from './interceptors.js';
+import { createChildLogger } from '#logger';
+import { registerShutdown } from './shutdown.js';
+import { startCatalog } from './start_catalog.js';
+import { messageBus } from '#bus';
+import './log_hooks.js';
+import { BusEventType } from '#consts';
+
+const log = createChildLogger( 'Worker' );
+
+// Get caller directory from command line arguments
+const callerDir = process.argv[2];
+
+( async () => {
+  const {
+    address,
+    apiKey,
+    namespace,
+    taskQueue,
+    maxConcurrentWorkflowTaskExecutions,
+    maxConcurrentActivityTaskExecutions,
+    maxCachedWorkflows,
+    maxConcurrentActivityTaskPolls,
+    maxConcurrentWorkflowTaskPolls
+  } = configs;
+
+  log.info( 'Loading config...', { callerDir } );
+  await loadHooks( callerDir );
+
+  log.info( 'Loading workflows...', { callerDir } );
+  const workflows = await loadWorkflows( callerDir );
+
+  log.info( 'Loading activities...', { callerDir } );
+  const activities = await loadActivities( callerDir, workflows );
+
+  log.info( 'Creating worker entry point...' );
+  const workflowsPath = createWorkflowsEntryPoint( workflows );
+
+  log.info( 'Initializing tracing...' );
+  await initTracing();
+
+  log.info( 'Creating workflows catalog...' );
+  const catalog = createCatalog( { workflows, activities } );
+
+  log.info( 'Connecting Temporal...' );
+  // Enable TLS when connecting to remote Temporal (API key present)
+  const connection = await NativeConnection.connect( { address, tls: Boolean( apiKey ), apiKey } );
+
+  log.info( 'Creating worker...' );
+  const worker = await Worker.create( {
+    connection,
+    namespace,
+    taskQueue,
+    workflowsPath,
+    activities,
+    sinks,
+    interceptors: initInterceptors( { activities, workflows } ),
+    maxConcurrentWorkflowTaskExecutions,
+    maxConcurrentActivityTaskExecutions,
+    maxCachedWorkflows,
+    maxConcurrentActivityTaskPolls,
+    maxConcurrentWorkflowTaskPolls,
+    bundlerOptions: { webpackConfigHook }
+  } );
+
+  registerShutdown( { worker, log } );
+
+  log.info( 'Running worker...' );
+  await Promise.all( [ worker.run(), startCatalog( { connection, namespace, catalog } ) ] );
+
+  log.info( 'Closing connection...' );
+  await connection.close();
+
+  log.info( 'Bye' );
+
+  process.exit( 0 );
+} )().catch( error => {
+  log.error( 'Fatal error', { message: error.message, stack: error.stack } );
+  messageBus.emit( BusEventType.RUNTIME_ERROR, { error } );
+  log.info( `Exiting in ${configs.processFailureShutdownDelay}ms` );
+  setTimeout( () => process.exit( 1 ), configs.processFailureShutdownDelay );
+} );

package/src/worker/index.spec.js

@@ -0,0 +1,177 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+
+const mockLog = { info: vi.fn(), warn: vi.fn(), error: vi.fn() };
+vi.mock( '#logger', () => ( { createChildLogger: () => mockLog } ) );
+
+vi.mock( '#consts', async importOriginal => {
+  const actual = await importOriginal();
+  return { ...actual };
+} );
+
+vi.mock( '#tracing', () => ( { init: vi.fn().mockResolvedValue( undefined ) } ) );
+
+const configValues = {
+  address: 'localhost:7233',
+  apiKey: undefined,
+  namespace: 'default',
+  taskQueue: 'test-queue',
+  catalogId: 'test-catalog',
+  maxConcurrentWorkflowTaskExecutions: 200,
+  maxConcurrentActivityTaskExecutions: 40,
+  maxCachedWorkflows: 1000,
+  maxConcurrentActivityTaskPolls: 5,
+  maxConcurrentWorkflowTaskPolls: 5,
+  processFailureShutdownDelay: 0
+};
+vi.mock( './configs.js', () => configValues );
+
+const messageBusMock = { on: vi.fn(), emit: vi.fn() };
+vi.mock( '#bus', () => ( { messageBus: messageBusMock } ) );
+
+const loadWorkflowsMock = vi.fn().mockResolvedValue( [] );
+const loadActivitiesMock = vi.fn().mockResolvedValue( {} );
+const loadHooksMock = vi.fn().mockResolvedValue( undefined );
+const createWorkflowsEntryPointMock = vi.fn().mockReturnValue( '/fake/workflows/path.js' );
+vi.mock( './loader.js', () => ( {
+  loadWorkflows: loadWorkflowsMock,
+  loadActivities: loadActivitiesMock,
+  loadHooks: loadHooksMock,
+  createWorkflowsEntryPoint: createWorkflowsEntryPointMock
+} ) );
+
+vi.mock( './sinks.js', () => ( { sinks: {} } ) );
+
+const createCatalogMock = vi.fn().mockReturnValue( { workflows: [], activities: {} } );
+vi.mock( './catalog_workflow/index.js', () => ( { createCatalog: createCatalogMock } ) );
+
+vi.mock( './bundler_options.js', () => ( { webpackConfigHook: vi.fn() } ) );
+
+const initInterceptorsMock = vi.fn().mockReturnValue( [] );
+vi.mock( './interceptors.js', () => ( { initInterceptors: initInterceptorsMock } ) );
+
+const startCatalogMock = vi.fn().mockResolvedValue( undefined );
+vi.mock( './start_catalog.js', () => ( { startCatalog: startCatalogMock } ) );
+
+const registerShutdownMock = vi.fn();
+vi.mock( './shutdown.js', () => ( { registerShutdown: registerShutdownMock } ) );
+
+vi.mock( './log_hooks.js', () => ( {} ) );
+
+const runState = { resolve: null };
+const runPromise = new Promise( r => {
+  runState.resolve = r;
+} );
+const shutdownMock = vi.fn();
+const mockConnection = { close: vi.fn().mockResolvedValue( undefined ) };
+const mockWorker = { run: () => runPromise, shutdown: shutdownMock };
+
+vi.mock( '@temporalio/worker', () => ( {
+  Worker: { create: vi.fn().mockResolvedValue( mockWorker ) },
+  NativeConnection: { connect: vi.fn().mockResolvedValue( mockConnection ) }
+} ) );
+
+describe( 'worker/index', () => {
+  const exitMock = vi.fn();
+  const originalArgv = process.argv;
+  const originalExit = process.exit;
+
+  beforeEach( () => {
+    vi.clearAllMocks();
+    process.argv = [ ...originalArgv.slice( 0, 2 ), '/test/caller/dir' ];
+    process.exit = exitMock;
+  } );
+
+  afterEach( () => {
+    process.argv = originalArgv;
+    process.exit = originalExit;
+    configValues.apiKey = undefined;
+  } );
+
+  it( 'loads configs, workflows, activities and creates worker with correct options', async () => {
+    const { Worker, NativeConnection } = await import( '@temporalio/worker' );
+    const { init: initTracing } = await import( '#tracing' );
+
+    import( './index.js' );
+
+    await vi.waitFor( () => {
+      expect( loadHooksMock ).toHaveBeenCalledWith( '/test/caller/dir' );
+    } );
+    expect( loadWorkflowsMock ).toHaveBeenCalledWith( '/test/caller/dir' );
+    expect( loadActivitiesMock ).toHaveBeenCalledWith( '/test/caller/dir', [] );
+    expect( createWorkflowsEntryPointMock ).toHaveBeenCalledWith( [] );
+    expect( initTracing ).toHaveBeenCalled();
+    expect( createCatalogMock ).toHaveBeenCalledWith( { workflows: [], activities: {} } );
+    expect( NativeConnection.connect ).toHaveBeenCalledWith( {
+      address: configValues.address,
+      tls: false,
+      apiKey: undefined
+    } );
+    expect( Worker.create ).toHaveBeenCalledWith( expect.objectContaining( {
+      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( initInterceptorsMock ).toHaveBeenCalledWith( { activities: {}, workflows: [] } );
+    expect( registerShutdownMock ).toHaveBeenCalledWith( { worker: mockWorker, log: mockLog } );
+    expect( startCatalogMock ).toHaveBeenCalledWith( {
+      connection: mockConnection,
+      namespace: configValues.namespace,
+      catalog: { workflows: [], activities: {} }
+    } );
+
+    runState.resolve();
+    await vi.waitFor( () => {
+      expect( mockConnection.close ).toHaveBeenCalled();
+    } );
+    expect( exitMock ).toHaveBeenCalledWith( 0 );
+  } );
+
+  it( 'enables TLS when apiKey is set', async () => {
+    configValues.apiKey = 'secret';
+    vi.resetModules();
+
+    const { NativeConnection } = await import( '@temporalio/worker' );
+    import( './index.js' );
+
+    await vi.waitFor( () => {
+      expect( NativeConnection.connect ).toHaveBeenCalledWith( expect.objectContaining( {
+        tls: true,
+        apiKey: 'secret'
+      } ) );
+    } );
+    runState.resolve();
+    await vi.waitFor( () => expect( exitMock ).toHaveBeenCalled() );
+  } );
+
+  it( 'calls registerShutdown with worker and log', async () => {
+    vi.resetModules();
+
+    import( './index.js' );
+
+    await vi.waitFor( () => {
+      expect( registerShutdownMock ).toHaveBeenCalledWith( { worker: mockWorker, log: mockLog } );
+    } );
+    runState.resolve();
+    await vi.waitFor( () => expect( exitMock ).toHaveBeenCalled() );
+  } );
+
+  it( 'calls process.exit(1) on fatal error', async () => {
+    loadWorkflowsMock.mockRejectedValueOnce( new Error( 'load failed' ) );
+    vi.resetModules();
+
+    import( './index.js' );
+
+    await vi.waitFor( () => {
+      expect( mockLog.error ).toHaveBeenCalledWith( 'Fatal error', expect.any( Object ) );
+    } );
+    await vi.waitFor( () => {
+      expect( exitMock ).toHaveBeenCalledWith( 1 );
+    } );
+  } );
+} );