@output.ai/core 0.5.1 → 0.5.3

package/src/worker/catalog_workflow/workflow.js

@@ -1,4 +1,4 @@
-import { defineQuery, setHandler, condition } from '@temporalio/workflow';
+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.
@@ -8,7 +8,13 @@ import { defineQuery, setHandler, condition } from '@temporalio/workflow';
  * @param {object} catalog - The catalog information
  */
 export default async function catalogWorkflow( catalog ) {
+  const state = { canEnd: false };
+
   setHandler( defineQuery( 'get' ), () => catalog );
-  // Wait indefinitely but remain responsive to workflow cancellation
-  await condition( () => false );
+
+  // 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/index.js

@@ -1,15 +1,14 @@
 import { Worker, NativeConnection } from '@temporalio/worker';
-import { Client } from '@temporalio/client';
-import { WorkflowIdConflictPolicy } from '@temporalio/common';
 import * as configs from './configs.js';
 import { loadActivities, loadWorkflows, createWorkflowsEntryPoint } from './loader.js';
 import { sinks } from './sinks.js';
 import { createCatalog } from './catalog_workflow/index.js';
 import { init as initTracing } from '#tracing';
-import { WORKFLOW_CATALOG } from '#consts';
 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';
 
 const log = createChildLogger( 'Worker' );
 
@@ -22,7 +21,6 @@ const callerDir = process.argv[2];
     apiKey,
     namespace,
     taskQueue,
-    catalogId,
     maxConcurrentWorkflowTaskExecutions,
     maxConcurrentActivityTaskExecutions,
     maxCachedWorkflows,
@@ -66,45 +64,15 @@ const callerDir = process.argv[2];
     bundlerOptions: { webpackConfigHook }
   } );
 
-  log.info( 'Starting catalog workflow...' );
-  await new Client( { connection, namespace } ).workflow.start( WORKFLOW_CATALOG, {
-    taskQueue,
-    workflowId: catalogId, // use the name of the task queue as the catalog name, ensuring uniqueness
-    workflowIdConflictPolicy: WorkflowIdConflictPolicy.TERMINATE_EXISTING,
-    args: [ catalog ]
-  } );
+  registerShutdown( { worker, log } );
 
   log.info( 'Running worker...' );
+  await Promise.all( [ worker.run(), startCatalog( { connection, namespace, catalog } ) ] );
 
-  // FORCE_QUIT_GRACE_MS delays the second instance of a shutdown command.
-  // If running output-worker directly with npx, 2 signals are recieved in
-  // rapid succession, and users see the force quit message.
-  const FORCE_QUIT_GRACE_MS = 1000;
-  const state = { isShuttingDown: false, shutdownStartedAt: null };
-
-  const shutdown = signal => {
-    if ( state.isShuttingDown ) {
-      const elapsed = Date.now() - state.shutdownStartedAt;
-      if ( elapsed < FORCE_QUIT_GRACE_MS ) {
-        return; // ignore rapid duplicate signals
-      }
-      log.warn( 'Force quitting...' );
-      process.exit( 1 );
-    }
-    state.isShuttingDown = true;
-    state.shutdownStartedAt = Date.now();
-    log.info( 'Shutting down...', { signal } );
-    worker.shutdown();
-  };
-
-  process.on( 'SIGTERM', () => shutdown( 'SIGTERM' ) );
-  process.on( 'SIGINT', () => shutdown( 'SIGINT' ) );
-
-  await worker.run();
-  log.info( 'Worker stopped.' );
-
+  log.info( 'Closing connection...' );
   await connection.close();
-  log.info( 'Connection closed.' );
+
+  log.info( 'Bye' );
 
   process.exit( 0 );
 } )().catch( error => {

package/src/worker/index.spec.js

@@ -0,0 +1,162 @@
+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', () => ( { WORKFLOW_CATALOG: 'catalog' } ) );
+
+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
+};
+vi.mock( './configs.js', () => configValues );
+
+const loadWorkflowsMock = vi.fn().mockResolvedValue( [] );
+const loadActivitiesMock = vi.fn().mockResolvedValue( {} );
+const createWorkflowsEntryPointMock = vi.fn().mockReturnValue( '/fake/workflows/path.js' );
+vi.mock( './loader.js', () => ( {
+  loadWorkflows: loadWorkflowsMock,
+  loadActivities: loadActivitiesMock,
+  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 } ) );
+
+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( 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: {} } );
+    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'
+      } ) );
+    } );
+    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 ) );
+    } );
+    expect( exitMock ).toHaveBeenCalledWith( 1 );
+  } );
+} );

package/src/worker/interceptors/workflow.js

@@ -49,7 +49,7 @@ class WorkflowExecutionInterceptor {
       }
 
       sinks.trace.addWorkflowEventError( error );
-      const failure = new ApplicationFailure( error.message, error.constructor.name );
+      const failure = new ApplicationFailure( error.message, error.constructor.name, undefined, undefined, error );
 
       /*
        * If intercepted error has metadata, set it to .details property of Temporal's ApplicationFailure instance.

package/src/worker/shutdown.js

@@ -0,0 +1,26 @@
+const FORCE_QUIT_GRACE_MS = 1000;
+
+export const registerShutdown = ( { worker, log } ) => {
+  const state = { isShuttingDown: false, shutdownStartedAt: null };
+
+  const shutdown = signal => {
+    if ( state.isShuttingDown ) {
+      const elapsed = Date.now() - state.shutdownStartedAt;
+
+      // If running with npx, 2 kill signals are received in rapid succession,
+      // this ignores the second interruption when it is right after the first.
+      if ( elapsed < FORCE_QUIT_GRACE_MS ) {
+        return;
+      }
+      log.warn( 'Force quitting...' );
+      process.exit( 1 );
+    }
+    state.isShuttingDown = true;
+    state.shutdownStartedAt = Date.now();
+    log.info( 'Shutting down...', { signal } );
+    worker.shutdown();
+  };
+
+  process.on( 'SIGTERM', () => shutdown( 'SIGTERM' ) );
+  process.on( 'SIGINT', () => shutdown( 'SIGINT' ) );
+};

package/src/worker/shutdown.spec.js

@@ -0,0 +1,82 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import { registerShutdown } from './shutdown.js';
+
+describe( 'worker/shutdown', () => {
+  const mockLog = { info: vi.fn(), warn: vi.fn() };
+  const shutdownMock = vi.fn();
+  const mockWorker = { shutdown: shutdownMock };
+  const onHandlers = {};
+  const exitMock = vi.fn();
+  const originalOn = process.on;
+  const originalExit = process.exit;
+
+  beforeEach( () => {
+    vi.clearAllMocks();
+    Object.keys( onHandlers ).forEach( k => delete onHandlers[k] );
+    process.on = vi.fn( ( event, handler ) => {
+      onHandlers[event] = handler;
+    } );
+    process.exit = exitMock;
+  } );
+
+  afterEach( () => {
+    process.on = originalOn;
+    process.exit = originalExit;
+  } );
+
+  it( 'registers SIGTERM and SIGINT handlers', () => {
+    registerShutdown( { worker: mockWorker, log: mockLog } );
+
+    expect( process.on ).toHaveBeenCalledWith( 'SIGTERM', expect.any( Function ) );
+    expect( process.on ).toHaveBeenCalledWith( 'SIGINT', expect.any( Function ) );
+  } );
+
+  it( 'on first signal: logs, calls worker.shutdown(), does not exit', () => {
+    registerShutdown( { worker: mockWorker, log: mockLog } );
+
+    onHandlers.SIGTERM();
+
+    expect( mockLog.info ).toHaveBeenCalledWith( 'Shutting down...', { signal: 'SIGTERM' } );
+    expect( shutdownMock ).toHaveBeenCalledTimes( 1 );
+    expect( mockLog.warn ).not.toHaveBeenCalled();
+    expect( exitMock ).not.toHaveBeenCalled();
+  } );
+
+  it( 'on first SIGINT: logs with SIGINT', () => {
+    registerShutdown( { worker: mockWorker, log: mockLog } );
+
+    onHandlers.SIGINT();
+
+    expect( mockLog.info ).toHaveBeenCalledWith( 'Shutting down...', { signal: 'SIGINT' } );
+    expect( shutdownMock ).toHaveBeenCalledTimes( 1 );
+  } );
+
+  it( 'on second signal within grace period: ignores (no force quit)', () => {
+    vi.useFakeTimers();
+    registerShutdown( { worker: mockWorker, log: mockLog } );
+
+    onHandlers.SIGTERM();
+    onHandlers.SIGINT();
+
+    expect( mockLog.info ).toHaveBeenCalledTimes( 1 );
+    expect( shutdownMock ).toHaveBeenCalledTimes( 1 );
+    expect( mockLog.warn ).not.toHaveBeenCalled();
+    expect( exitMock ).not.toHaveBeenCalled();
+
+    vi.useRealTimers();
+  } );
+
+  it( 'on second signal after grace period: logs force quit and exits with 1', () => {
+    vi.useFakeTimers();
+    registerShutdown( { worker: mockWorker, log: mockLog } );
+
+    onHandlers.SIGTERM();
+    vi.advanceTimersByTime( 1001 );
+    onHandlers.SIGINT();
+
+    expect( mockLog.warn ).toHaveBeenCalledWith( 'Force quitting...' );
+    expect( exitMock ).toHaveBeenCalledWith( 1 );
+
+    vi.useRealTimers();
+  } );
+} );

package/src/worker/start_catalog.js

@@ -0,0 +1,36 @@
+import { Client, WorkflowNotFoundError } from '@temporalio/client';
+import { WorkflowIdConflictPolicy } from '@temporalio/common';
+import { WORKFLOW_CATALOG } from '#consts';
+import { catalogId, taskQueue } from './configs.js';
+import { createChildLogger } from '#logger';
+
+const log = createChildLogger( 'Catalog' );
+
+export const startCatalog = async ( { connection, namespace, catalog } ) => {
+  const client = new Client( { connection, namespace } );
+  const catalogWorkflowHandle = client.workflow.getHandle( catalogId );
+
+  try {
+    const catalogWorkflowDescription = await catalogWorkflowHandle.describe();
+    if ( !catalogWorkflowDescription.closeTime ) {
+      log.info( 'Completing previous catalog workflow...' );
+      await catalogWorkflowHandle.executeUpdate( 'complete', { args: [] } );
+    }
+  } catch ( error ) {
+    // When "not found", it's either a cold start or the catalog was already stopped/terminated, ignore it.
+    // Otherwise, create a log and try the next operation:
+    // A. If the workflow is still running, the start() will fail and throw;
+    // B. If the workflow is no running, the start() will succeed, and the error was transient;
+    if ( !( error instanceof WorkflowNotFoundError ) ) {
+      log.warn( 'Error interacting with previous catalog workflow', { error } );
+    }
+  }
+
+  log.info( 'Starting catalog workflow...' );
+  await client.workflow.start( WORKFLOW_CATALOG, {
+    taskQueue,
+    workflowId: catalogId, // use the name of the task queue as the catalog name, ensuring uniqueness
+    workflowIdConflictPolicy: WorkflowIdConflictPolicy.FAIL,
+    args: [ catalog ]
+  } );
+};

package/src/worker/start_catalog.spec.js

@@ -0,0 +1,116 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { WorkflowNotFoundError } from '@temporalio/client';
+
+const mockLog = { info: vi.fn(), warn: vi.fn(), error: vi.fn() };
+vi.mock( '#logger', () => ( { createChildLogger: () => mockLog } ) );
+
+vi.mock( '#consts', () => ( { WORKFLOW_CATALOG: 'catalog' } ) );
+
+const catalogId = 'test-catalog';
+const taskQueue = 'test-queue';
+vi.mock( './configs.js', () => ( { catalogId, taskQueue } ) );
+
+const describeMock = vi.fn();
+const executeUpdateMock = vi.fn();
+const workflowStartMock = vi.fn().mockResolvedValue( undefined );
+vi.mock( '@temporalio/client', async importOriginal => {
+  const actual = await importOriginal();
+  return {
+    ...actual,
+    Client: vi.fn().mockImplementation( () => ( {
+      workflow: {
+        start: workflowStartMock,
+        getHandle: () => ( { describe: describeMock, executeUpdate: executeUpdateMock } )
+      }
+    } ) )
+  };
+} );
+
+vi.mock( '@temporalio/common', () => ( { WorkflowIdConflictPolicy: { FAIL: 'FAIL' } } ) );
+
+describe( 'worker/start_catalog', () => {
+  const mockConnection = {};
+  const namespace = 'default';
+  const catalog = { workflows: [], activities: {} };
+
+  beforeEach( () => {
+    vi.clearAllMocks();
+    workflowStartMock.mockResolvedValue( undefined );
+  } );
+
+  it( 'when previous catalog still running: completes it then starts catalog workflow', async () => {
+    describeMock.mockResolvedValue( { closeTime: undefined } );
+    executeUpdateMock.mockResolvedValue( undefined );
+
+    const { startCatalog } = await import( './start_catalog.js' );
+    await startCatalog( { connection: mockConnection, namespace, catalog } );
+
+    expect( describeMock ).toHaveBeenCalled();
+    expect( mockLog.info ).toHaveBeenCalledWith( 'Completing previous catalog workflow...' );
+    expect( executeUpdateMock ).toHaveBeenCalledWith( 'complete', { args: [] } );
+    expect( mockLog.info ).toHaveBeenCalledWith( 'Starting catalog workflow...' );
+    expect( workflowStartMock ).toHaveBeenCalledWith( 'catalog', {
+      taskQueue,
+      workflowId: catalogId,
+      workflowIdConflictPolicy: 'FAIL',
+      args: [ catalog ]
+    } );
+  } );
+
+  it( 'when no previous catalog: ignores and starts catalog workflow', async () => {
+    describeMock.mockRejectedValue( new WorkflowNotFoundError( 'not found' ) );
+
+    const { startCatalog } = await import( './start_catalog.js' );
+    await startCatalog( { connection: mockConnection, namespace, catalog } );
+
+    expect( describeMock ).toHaveBeenCalled();
+    expect( mockLog.warn ).not.toHaveBeenCalled();
+    expect( mockLog.info ).toHaveBeenCalledWith( 'Starting catalog workflow...' );
+    expect( executeUpdateMock ).not.toHaveBeenCalled();
+    expect( workflowStartMock ).toHaveBeenCalledWith( 'catalog', {
+      taskQueue,
+      workflowId: catalogId,
+      workflowIdConflictPolicy: 'FAIL',
+      args: [ catalog ]
+    } );
+  } );
+
+  it( 'when previous catalog already closed: skips complete and starts catalog workflow', async () => {
+    describeMock.mockResolvedValue( { closeTime: '2024-01-01T00:00:00Z' } );
+
+    const { startCatalog } = await import( './start_catalog.js' );
+    await startCatalog( { connection: mockConnection, namespace, catalog } );
+
+    expect( describeMock ).toHaveBeenCalled();
+    expect( mockLog.info ).not.toHaveBeenCalledWith( 'Completing previous catalog workflow...' );
+    expect( executeUpdateMock ).not.toHaveBeenCalled();
+    expect( mockLog.info ).toHaveBeenCalledWith( 'Starting catalog workflow...' );
+    expect( workflowStartMock ).toHaveBeenCalledWith( 'catalog', {
+      taskQueue,
+      workflowId: catalogId,
+      workflowIdConflictPolicy: 'FAIL',
+      args: [ catalog ]
+    } );
+  } );
+
+  it( 'when describe or complete fails with other error: logs warn and still starts catalog workflow', async () => {
+    describeMock.mockResolvedValue( { closeTime: undefined } );
+    executeUpdateMock.mockRejectedValue( new Error( 'Connection refused' ) );
+
+    const { startCatalog } = await import( './start_catalog.js' );
+    await startCatalog( { connection: mockConnection, namespace, catalog } );
+
+    expect( describeMock ).toHaveBeenCalled();
+    expect( executeUpdateMock ).toHaveBeenCalledWith( 'complete', { args: [] } );
+    expect( mockLog.warn ).toHaveBeenCalledWith( 'Error interacting with previous catalog workflow', {
+      error: expect.any( Error )
+    } );
+    expect( mockLog.info ).toHaveBeenCalledWith( 'Starting catalog workflow...' );
+    expect( workflowStartMock ).toHaveBeenCalledWith( 'catalog', {
+      taskQueue,
+      workflowId: catalogId,
+      workflowIdConflictPolicy: 'FAIL',
+      args: [ catalog ]
+    } );
+  } );
+} );

package/src/worker/webpack_loaders/tools.js

@@ -156,8 +156,13 @@ export const isAnyStepsPath = value =>
  * @param {string} value - Module path or request string.
  * @returns {boolean} True if it matches an evaluators path.
  */
-export const isEvaluatorsPath = value =>
-  EVALUATORS_FILE_REGEX.test( value ) || EVALUATORS_FOLDER_REGEX.test( value );
+export const isEvaluatorsPath = value => {
+  // Exclude shared evaluators (paths with ../ or containing /shared/)
+  if ( PATH_TRAVERSAL_REGEX.test( value ) || SHARED_PATH_REGEX.test( value ) ) {
+    return false;
+  }
+  return EVALUATORS_FILE_REGEX.test( value ) || EVALUATORS_FOLDER_REGEX.test( value );
+};
 
 /**
  * Check if a module specifier or request string points to shared evaluators.
@@ -174,6 +179,15 @@ export const isSharedEvaluatorsPath = value => {
   return PATH_TRAVERSAL_REGEX.test( value ) || SHARED_PATH_REGEX.test( value );
 };
 
+/**
+ * Check if a path matches any evaluators pattern (local or shared).
+ * Used for validation purposes.
+ * @param {string} value - Module path or request string.
+ * @returns {boolean} True if it matches any evaluators path pattern.
+ */
+export const isAnyEvaluatorsPath = value =>
+  EVALUATORS_FILE_REGEX.test( value ) || EVALUATORS_FOLDER_REGEX.test( value );
+
 /**
  * Check if a module specifier or request string points to workflow.js.
  * @param {string} value - Module path or request string.
@@ -187,7 +201,7 @@ export const isWorkflowPath = value => /(^|\/)workflow\.js$/.test( value );
  * @returns {boolean} True if it matches any component file path.
  */
 export const isComponentFile = value =>
-  isAnyStepsPath( value ) || isEvaluatorsPath( value ) || isWorkflowPath( value );
+  isAnyStepsPath( value ) || isAnyEvaluatorsPath( value ) || isWorkflowPath( value );
 
 /**
  * Determine file kind based on its path.
@@ -199,7 +213,7 @@ export const getFileKind = path => {
   if ( isAnyStepsPath( path ) ) {
     return ComponentFile.STEPS;
   }
-  if ( isEvaluatorsPath( path ) ) {
+  if ( isAnyEvaluatorsPath( path ) ) {
     return ComponentFile.EVALUATORS;
   }
   if ( isWorkflowPath( path ) ) {
@@ -357,6 +371,22 @@ export const buildEvaluatorsNameMap = ( path, cache ) => buildComponentNameMap(
   invalidMessagePrefix: 'Invalid evaluator name in'
 } );
 
+/**
+ * Build a map from exported shared evaluator identifier to declared evaluator name.
+ * Same as buildEvaluatorsNameMap but for shared evaluators.
+ *
+ * @param {string} path - Absolute path to the shared evaluators module file.
+ * @param {Map<string, Map<string,string>>} cache - Cache of computed evaluator name maps.
+ * @returns {Map<string,string>} Exported identifier -> evaluator name.
+ * @throws {Error} When an evaluator name is invalid (non-static or missing).
+ */
+export const buildSharedEvaluatorsNameMap = ( path, cache ) => buildComponentNameMap( {
+  path,
+  cache,
+  calleeName: 'evaluator',
+  invalidMessagePrefix: 'Invalid shared evaluator name in'
+} );
+
 /**
  * Build a structure with default and named workflow names from a workflow module.
  * Extracts names from `workflow({ name: '...' })` calls.

package/src/worker/webpack_loaders/tools.spec.js

@@ -190,11 +190,14 @@ describe( 'workflow_rewriter tools', () => {
     expect( isWorkflowPath( 'steps.js' ) ).toBe( false );
   } );
 
-  it( 'isEvaluatorsPath: matches evaluators.js at root or subpath', () => {
+  it( 'isEvaluatorsPath: matches local evaluators.js but excludes shared', () => {
     expect( isEvaluatorsPath( 'evaluators.js' ) ).toBe( true );
     expect( isEvaluatorsPath( './evaluators.js' ) ).toBe( true );
     expect( isEvaluatorsPath( '/a/b/evaluators.js' ) ).toBe( true );
     expect( isEvaluatorsPath( './evaluators/quality.js' ) ).toBe( true );
+    // Shared evaluators should NOT match (path traversal or /shared/)
+    expect( isEvaluatorsPath( '../evaluators.js' ) ).toBe( false );
+    expect( isEvaluatorsPath( '../../shared/evaluators/common.js' ) ).toBe( false );
     expect( isEvaluatorsPath( 'evaluators.ts' ) ).toBe( false );
     expect( isEvaluatorsPath( 'steps.js' ) ).toBe( false );
   } );