@outputai/core 0.9.3-next.c318502.0 → 0.10.1-dev.b7b2fbe.0

package/src/worker/configs_tuner_schema.spec.js

@@ -0,0 +1,127 @@
+import { describe, expect, it } from 'vitest';
+import { workerTunerEnvSchema } from './configs_tuner_schema.js';
+
+const parseWorkerTuner = value => workerTunerEnvSchema.parse( value );
+
+describe( 'worker/configs_tuner_schema', () => {
+  it( 'treats empty string as unset', () => {
+    expect( parseWorkerTuner( '' ) ).toBeUndefined();
+  } );
+
+  it( 'parses resource-based Temporal worker tuner JSON', () => {
+    const workerTuner = {
+      tunerOptions: {
+        targetMemoryUsage: 0.8,
+        targetCpuUsage: 0.9
+      },
+      activityTaskSlotOptions: {
+        minimumSlots: 1,
+        maximumSlots: 100,
+        rampThrottle: '50ms'
+      }
+    };
+
+    expect( parseWorkerTuner( JSON.stringify( workerTuner ) ) ).toEqual( workerTuner );
+  } );
+
+  it( 'parses per-task Temporal worker tuner JSON', () => {
+    const resourceBasedSupplier = {
+      type: 'resource-based',
+      tunerOptions: {
+        targetMemoryUsage: 0.8,
+        targetCpuUsage: 0.9
+      },
+      minimumSlots: 1,
+      maximumSlots: 100,
+      rampThrottle: '50ms'
+    };
+    const workerTuner = {
+      workflowTaskSlotSupplier: {
+        type: 'fixed-size',
+        numSlots: 10
+      },
+      activityTaskSlotSupplier: resourceBasedSupplier,
+      localActivityTaskSlotSupplier: {
+        type: 'fixed-size',
+        numSlots: 10
+      },
+      nexusTaskSlotSupplier: {
+        type: 'fixed-size',
+        numSlots: 10
+      }
+    };
+
+    expect( parseWorkerTuner( JSON.stringify( workerTuner ) ) ).toEqual( workerTuner );
+  } );
+
+  it( 'throws when tuner is not valid JSON', () => {
+    expect( () => parseWorkerTuner( '{invalid' ) ).toThrow();
+  } );
+
+  it( 'throws when tuner is not a JSON object', () => {
+    expect( () => parseWorkerTuner( '[]' ) ).toThrow();
+  } );
+
+  it( 'throws when tuner is missing required per-task suppliers', () => {
+    const workerTuner = {
+      workflowTaskSlotSupplier: {
+        type: 'fixed-size',
+        numSlots: 10
+      },
+      activityTaskSlotSupplier: {
+        type: 'fixed-size',
+        numSlots: 10
+      }
+    };
+
+    expect( () => parseWorkerTuner( JSON.stringify( workerTuner ) ) ).toThrow();
+  } );
+
+  it( 'throws when tuner uses custom suppliers', () => {
+    const workerTuner = {
+      workflowTaskSlotSupplier: {
+        type: 'custom'
+      },
+      activityTaskSlotSupplier: {
+        type: 'fixed-size',
+        numSlots: 10
+      },
+      localActivityTaskSlotSupplier: {
+        type: 'fixed-size',
+        numSlots: 10
+      },
+      nexusTaskSlotSupplier: {
+        type: 'fixed-size',
+        numSlots: 10
+      }
+    };
+
+    expect( () => parseWorkerTuner( JSON.stringify( workerTuner ) ) ).toThrow();
+  } );
+
+  it( 'throws when target usage is outside range', () => {
+    const workerTuner = {
+      tunerOptions: {
+        targetMemoryUsage: 1.5,
+        targetCpuUsage: 0.9
+      }
+    };
+
+    expect( () => parseWorkerTuner( JSON.stringify( workerTuner ) ) ).toThrow();
+  } );
+
+  it( 'throws when minimum slots exceeds maximum slots', () => {
+    const workerTuner = {
+      tunerOptions: {
+        targetMemoryUsage: 0.8,
+        targetCpuUsage: 0.9
+      },
+      activityTaskSlotOptions: {
+        minimumSlots: 10,
+        maximumSlots: 5
+      }
+    };
+
+    expect( () => parseWorkerTuner( JSON.stringify( workerTuner ) ) ).toThrow();
+  } );
+} );

package/src/worker/index.js

@@ -36,7 +36,8 @@ const {
   maxConcurrentActivityTaskPolls,
   maxConcurrentWorkflowTaskPolls,
   shutdownForceTime,
-  shutdownGraceTime
+  shutdownGraceTime,
+  workerTuner
 } = configs;
 
 const state = {
@@ -88,6 +89,9 @@ const execute = async () => {
   state.catalogJob = new CatalogJob( { connection: state.connection, namespace, catalog, catalogHash } );
 
   log.info( 'Creating worker...' );
+  if ( workerTuner ) {
+    log.info( 'Using worker tuner options', { ...workerTuner } );
+  }
   const worker = await Worker.create( {
     connection: state.connection,
     namespace,
@@ -96,8 +100,13 @@ const execute = async () => {
     activities,
     sinks,
     interceptors: initInterceptors( { activities, workflows } ),
-    maxConcurrentWorkflowTaskExecutions,
-    maxConcurrentActivityTaskExecutions,
+    // tuner isn't compatible with concurrent task executions configs
+    ...( workerTuner ? {
+      tuner: workerTuner
+    } : {
+      maxConcurrentWorkflowTaskExecutions,
+      maxConcurrentActivityTaskExecutions
+    } ),
     maxCachedWorkflows,
     maxConcurrentActivityTaskPolls,
     maxConcurrentWorkflowTaskPolls,

package/src/worker/index.spec.js

@@ -45,6 +45,7 @@ const {
     maxCachedWorkflows: 1000,
     maxConcurrentActivityTaskPolls: 5,
     maxConcurrentWorkflowTaskPolls: 5,
+    workerTuner: undefined,
     processFailureShutdownDelay: 0,
     shutdownForceTime: undefined,
     shutdownGraceTime: undefined
@@ -185,6 +186,7 @@ describe( 'worker/index', () => {
     resetPromises();
     configValues.apiKey = undefined;
     configValues.grpcProxy = undefined;
+    configValues.workerTuner = undefined;
     configValues.shutdownForceTime = undefined;
     configValues.shutdownGraceTime = undefined;
     catalogJobInstance.error = null;
@@ -263,6 +265,32 @@ describe( 'worker/index', () => {
     expect( mockLog.info ).toHaveBeenCalledWith( 'Bye' );
   } );
 
+  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();
+  } );
+
   it( 'enables TLS when apiKey is set', async () => {
     configValues.apiKey = 'secret';
     const { NativeConnection } = await import( '@temporalio/worker' );

package/src/worker/interceptors/workflow.js

@@ -7,7 +7,7 @@ import { METADATA_ACCESS_SYMBOL, WorkflowSpecialOutput } from '#consts';
 import { createWorkflowDetails } from '#helpers/temporal_context';
 
 // this is a dynamic generated file with activity configs overwrites
-import stepOptions from '../temp/__activity_options.js';
+import activityOptionsMap from '../temp/__activity_options.js';
 
 /*
   This interceptor adds Memo and serialized workflowInfo() to the Activity invocation headers.
@@ -22,10 +22,10 @@ class HeadersInjectionInterceptor {
       ...memo,
       workflowDetails: createWorkflowDetails( info )
     } ) );
-    // apply per-invocation options passed as second argument by rewritten calls
-    const options = stepOptions[input.activityType];
-    if ( options ) {
-      input.options = deepMerge( memo.activityOptions, options );
+    // Apply component-level activity options on top of workflow options.
+    const activityOptionsOverrides = activityOptionsMap[input.activityType];
+    if ( activityOptionsOverrides ) {
+      input.options = deepMerge( input.options ?? {}, activityOptionsOverrides );
     }
     return next( input );
   }

package/src/worker/interceptors/workflow.spec.js

@@ -56,12 +56,13 @@ vi.mock( './headers.js', () => ( { memoToHeaders: ( ...args ) => memoToHeadersMo
 const deepMergeMock = vi.fn( ( a, b ) => ( { ...( a || {} ), ...( b || {} ) } ) );
 vi.mock( '#helpers/object', () => ( { deepMerge: ( ...args ) => deepMergeMock( ...args ) } ) );
 
-const stepOptionsDefault = {};
-vi.mock( '../temp/__activity_options.js', () => ( { default: stepOptionsDefault } ) );
+const activityOptionsDefault = {};
+vi.mock( '../temp/__activity_options.js', () => ( { default: activityOptionsDefault } ) );
 
 describe( 'workflow interceptors', () => {
   beforeEach( () => {
     vi.clearAllMocks();
+    Object.keys( activityOptionsDefault ).forEach( key => delete activityOptionsDefault[key] );
     isCancellationMock.mockReturnValue( false );
     workflowInfoMock.mockReturnValue( workflowInfo );
   } );
@@ -91,11 +92,11 @@ describe( 'workflow interceptors', () => {
       expect( out ).toBe( 'result' );
     } );
 
-    it( 'merges stepOptions with memo.activityOptions when stepOptions exist for activityType', async () => {
-      stepOptionsDefault['MyWorkflow#step1'] = { scheduleToCloseTimeout: 60 };
+    it( 'merges component activity options over the scheduled activity input options', async () => {
+      activityOptionsDefault['MyWorkflow#step1'] = { scheduleToCloseTimeout: 60 };
       workflowInfoMock.mockReturnValue( {
         ...workflowInfo,
-        memo: { traceInfo: workflowInfo.memo.traceInfo, activityOptions: { heartbeatTimeout: 10 } }
+        memo: { traceInfo: workflowInfo.memo.traceInfo }
       } );
       memoToHeadersMock.mockReturnValue( {} );
       deepMergeMock.mockReturnValue( { heartbeatTimeout: 10, scheduleToCloseTimeout: 60 } );
@@ -103,14 +104,13 @@ describe( 'workflow interceptors', () => {
       const { interceptors } = await import( './workflow.js' );
       const { outbound } = interceptors();
       const interceptor = outbound[0];
-      const input = { headers: {}, activityType: 'MyWorkflow#step1' };
+      const input = { headers: {}, activityType: 'MyWorkflow#step1', options: { heartbeatTimeout: 10 } };
       const next = vi.fn().mockResolvedValue( undefined );
 
       await interceptor.scheduleActivity( input, next );
 
       expect( deepMergeMock ).toHaveBeenCalledWith( { heartbeatTimeout: 10 }, { scheduleToCloseTimeout: 60 } );
       expect( input.options ).toEqual( { heartbeatTimeout: 10, scheduleToCloseTimeout: 60 } );
-      delete stepOptionsDefault['MyWorkflow#step1'];
     } );
   } );
 

package/src/worker/loader/activities.js

@@ -2,74 +2,90 @@ import { dirname } from 'node:path';
 import { getTraceDestinations, sendHttpRequest } from '#internal_activities';
 import { findSharedActivitiesFromWorkflows, importComponents, matchFiles, writeFileInTempDir } from './tools.js';
 import { buildActivityMatcher, staticMatchers } from './matchers.js';
-import { ACTIVITY_SEND_HTTP_REQUEST, ACTIVITY_OPTIONS_FILENAME, SHARED_STEP_PREFIX, ACTIVITY_GET_TRACE_DESTINATIONS } from '#consts';
+import { ACTIVITY_SEND_HTTP_REQUEST, ACTIVITY_OPTIONS_FILENAME, ACTIVITY_GET_TRACE_DESTINATIONS } from '#consts';
 import { createChildLogger } from '#logger';
 import { ValidationError } from '#errors';
 
 const log = createChildLogger( 'Activities Loader' );
 
 /**
- * Load activities:
- * - Scans activities based on workflows, using each workflow folder as a point to lookup for steps, evaluators files;
- * - Scans shared activities in the rootDir;
- * - Loads internal activities as well;
+ * Load activities
+ * - Scan local project and external workflow npm packages and look for shared activities.
+ * - For each workflow, register shared activities under the workflow namespace.
+ * - For each workflow, load activities declared relative to that workflow directory.
  *
- * Builds a map of activities, where they is generated according to the type of activity and the value is the function itself and return it.
- * - Shared activity keys have a common prefix followed by the activity name;
- * - Internal activities are registered with a fixed key;
- * - Workflow activities keys are composed using the workflow name and the activity name;
+ * Builds a map of activities, key is workflowType#activityType, value is the component wrapper function.
  *
  * @param {string} rootDir
  * @param {import('./workflows.js').Workflow[]} workflows
  * @returns {object}
  */
 export async function loadActivities( rootDir, workflows ) {
-  const activities = {};
-  const activityOptionsMap = {};
+  const activities = new Map();
+  const activityOptions = new Map();
 
-  // Load workflow-based activities
-  for ( const { path: workflowPath, name: workflowName, external } of workflows ) {
-    const dir = dirname( workflowPath );
-    for await ( const { fn, metadata, path } of importComponents( matchFiles( dir, [ buildActivityMatcher( dir ) ] ) ) ) {
-      // Activities loaded from a workflow path will use the workflow name as a namespace, which is unique across the platform, avoiding collision
-      const activityKey = `${workflowName}#${metadata.name}`;
-
-      log.info( metadata.name, { workflow: workflowName, type: metadata.type, ...( external && { external } ), path } );
-
-      if ( activities[activityKey] ) {
-        throw new ValidationError( `Activity "${metadata.name}" in workflow "${workflowName}" conflicts with another \
-activity in the same workflow. Activity names must be unique within a workflow.` );
-      }
-      activities[activityKey] = fn;
-      // propagate the custom options set on the step()/evaluator() constructor
-      activityOptionsMap[activityKey] = metadata.options?.activityOptions ?? undefined;
-    }
-  }
+  const sharedActivities = new Map();
+  const sharedActivitiesOptions = new Map();
 
   // Load shared activities/evaluators from local and external npm modules
   const localSharedActivities = matchFiles( rootDir, [ staticMatchers.sharedStepsDir, staticMatchers.sharedEvaluatorsDir ] );
   const externalSharedActivities = findSharedActivitiesFromWorkflows( workflows.filter( w => w.external ) );
   for await ( const { fn, metadata, path } of importComponents( [ ...localSharedActivities, ...externalSharedActivities ] ) ) {
     const external = externalSharedActivities.some( a => a.path === path );
-    // Uses a global namespace for shared activities
-    const activityKey = `${SHARED_STEP_PREFIX}#${metadata.name}`;
 
+    if ( sharedActivities.has( metadata.name ) ) {
+      throw new ValidationError( `Shared activity "${metadata.name}" conflicts with another shared activity.` +
+        ' Shared activity names must be unique.' );
+    }
     log.info( metadata.name, { shared: true, type: metadata.type, ...( external && { external } ), path } );
 
-    if ( activities[activityKey] ) {
-      throw new ValidationError( `Shared activity "${metadata.name}" conflicts with another shared activity. \
-Shared activity names must be unique.` );
+    sharedActivities.set( metadata.name, fn );
+    if ( metadata.options?.activityOptions ) {
+      sharedActivitiesOptions.set( metadata.name, metadata.options.activityOptions );
+    }
+  }
+
+  // Discover and load workflow activities
+  for ( const { path: workflowPath, name: workflowName, external } of workflows ) {
+    const dir = dirname( workflowPath );
+
+    // Add shared activities to this workflow namespace
+    for ( const [ name, fn ] of sharedActivities ) {
+      const id = `${workflowName}#${name}`;
+      activities.set( id, fn );
+      if ( sharedActivitiesOptions.has( name ) ) {
+        activityOptions.set( id, sharedActivitiesOptions.get( name ) );
+      }
+    }
+
+    for await ( const { fn, metadata, path } of importComponents( matchFiles( dir, [ buildActivityMatcher( dir ) ] ) ) ) {
+      // Activities loaded from a workflow path will use the workflow name as a namespace, which is unique across the platform, avoiding collision
+      const id = `${workflowName}#${metadata.name}`;
+
+      if ( sharedActivities.has( metadata.name ) ) {
+        throw new ValidationError( `Activity "${metadata.name}" in workflow "${workflowName}" conflicts with a shared activity.` +
+          ' Workflow activity names must not overlap with shared activity names.' );
+      }
+
+      if ( activities.has( id ) ) {
+        throw new ValidationError( `Activity "${metadata.name}" in workflow "${workflowName}" conflicts with another activity in the same workflow.` +
+          ' Activity names must be unique within a workflow.' );
+      }
+
+      log.info( metadata.name, { workflow: workflowName, type: metadata.type, ...( external && { external } ), path } );
+      activities.set( id, fn );
+      if ( metadata.options?.activityOptions ) {
+        activityOptions.set( id, metadata.options.activityOptions );
+      }
     }
-    activities[activityKey] = fn;
-    activityOptionsMap[activityKey] = metadata.options?.activityOptions ?? undefined;
   }
 
   // writes down the activity option overrides
-  const optionsContent = `export default ${JSON.stringify( activityOptionsMap, undefined, 2 )};`;
+  const optionsContent = `export default ${JSON.stringify( Object.fromEntries( activityOptions ), undefined, 2 )};`;
   const optionsFile = writeFileInTempDir( optionsContent, ACTIVITY_OPTIONS_FILENAME );
 
   // system activities
-  activities[ACTIVITY_SEND_HTTP_REQUEST] = sendHttpRequest;
-  activities[ACTIVITY_GET_TRACE_DESTINATIONS] = getTraceDestinations;
-  return { activities, optionsFile };
+  activities.set( ACTIVITY_SEND_HTTP_REQUEST, sendHttpRequest );
+  activities.set( ACTIVITY_GET_TRACE_DESTINATIONS, getTraceDestinations );
+  return { activities: Object.fromEntries( activities ), optionsFile };
 };

package/src/worker/loader/activities.spec.js

@@ -5,8 +5,7 @@ vi.mock( '#consts', () => ( {
   ACTIVITY_GET_TRACE_DESTINATIONS: '__internal#getTraceDestinations',
   WORKFLOWS_INDEX_FILENAME: '__workflows_entrypoint.js',
   WORKFLOW_CATALOG: 'catalog',
-  ACTIVITY_OPTIONS_FILENAME: '__activity_options.js',
-  SHARED_STEP_PREFIX: '$shared'
+  ACTIVITY_OPTIONS_FILENAME: '__activity_options.js'
 } ) );
 
 const sendHttpRequestMock = vi.fn();
@@ -63,6 +62,7 @@ describe( 'loadActivities', () => {
   it( 'loadActivities returns map including system activity and writes options file', async () => {
     const { loadActivities } = await import( './activities.js' );
 
+    importComponentsMock.mockImplementationOnce( async function *() {} );
     importComponentsMock.mockImplementationOnce( async function *() {
       yield {
         fn: () => {},
@@ -70,7 +70,6 @@ describe( 'loadActivities', () => {
         path: '/a/steps.js'
       };
     } );
-    importComponentsMock.mockImplementationOnce( async function *() {} );
 
     const workflows = [ { name: 'A', path: '/a/workflow.js' } ];
     const { activities, optionsFile } = await loadActivities( '/root', workflows );
@@ -89,11 +88,11 @@ describe( 'loadActivities', () => {
 
   it( 'loadActivities omits activity options when component has no options or no activityOptions', async () => {
     const { loadActivities } = await import( './activities.js' );
+    importComponentsMock.mockImplementationOnce( async function *() {} );
     importComponentsMock.mockImplementationOnce( async function *() {
       yield { fn: () => {}, metadata: { name: 'NoOptions' }, path: '/a/steps.js' };
       yield { fn: () => {}, metadata: { name: 'EmptyOptions', options: {} }, path: '/a/steps2.js' };
     } );
-    importComponentsMock.mockImplementationOnce( async function *() {} );
 
     await loadActivities( '/root', [ { name: 'A', path: '/a/workflow.js' } ] );
     const written = JSON.parse(
@@ -105,6 +104,7 @@ describe( 'loadActivities', () => {
 
   it( 'loadActivities throws when two activities in the same workflow share a name', async () => {
     const { loadActivities } = await import( './activities.js' );
+    importComponentsMock.mockImplementationOnce( async function *() {} );
     importComponentsMock.mockImplementationOnce( async function *() {
       yield { fn: () => {}, metadata: { name: 'DuplicateActivity' }, path: '/a/steps.js' };
       yield { fn: () => {}, metadata: { name: 'DuplicateActivity' }, path: '/a/evaluators.js' };
@@ -118,7 +118,6 @@ Activity names must be unique within a workflow.'
 
   it( 'loadActivities throws when two shared activities share a name', async () => {
     const { loadActivities } = await import( './activities.js' );
-    importComponentsMock.mockImplementationOnce( async function *() {} );
     importComponentsMock.mockImplementationOnce( async function *() {
       yield { fn: () => {}, metadata: { name: 'DuplicateShared' }, path: '/root/shared/steps/a.js' };
       yield { fn: () => {}, metadata: { name: 'DuplicateShared' }, path: '/root/shared/evaluators/a.js' };
@@ -133,8 +132,8 @@ Activity names must be unique within a workflow.'
     const { loadActivities } = await import( './activities.js' );
     const workflowFiles = [ { path: '/a/steps/foo.js' } ];
     const sharedFiles = [ { path: '/root/shared/steps/baz.js' } ];
-    matchFilesMock.mockReturnValueOnce( workflowFiles );
     matchFilesMock.mockReturnValueOnce( sharedFiles );
+    matchFilesMock.mockReturnValueOnce( workflowFiles );
     importComponentsMock.mockImplementationOnce( async function *() {} );
     importComponentsMock.mockImplementationOnce( async function *() {} );
 
@@ -143,12 +142,12 @@ Activity names must be unique within a workflow.'
 
     expect( matchFilesMock ).toHaveBeenCalledTimes( 2 );
     expect( buildActivityMatcherMock ).toHaveBeenCalledWith( '/a' );
-    expect( matchFilesMock ).toHaveBeenNthCalledWith( 1, '/a', [ activityMatcherMock ] );
-    expect( matchFilesMock ).toHaveBeenNthCalledWith( 2, '/root', [ sharedStepsDirMock, sharedEvaluatorsDirMock ] );
+    expect( matchFilesMock ).toHaveBeenNthCalledWith( 1, '/root', [ sharedStepsDirMock, sharedEvaluatorsDirMock ] );
+    expect( matchFilesMock ).toHaveBeenNthCalledWith( 2, '/a', [ activityMatcherMock ] );
 
     expect( importComponentsMock ).toHaveBeenCalledTimes( 2 );
-    expect( importComponentsMock ).toHaveBeenNthCalledWith( 1, workflowFiles );
-    expect( importComponentsMock ).toHaveBeenNthCalledWith( 2, sharedFiles );
+    expect( importComponentsMock ).toHaveBeenNthCalledWith( 1, sharedFiles );
+    expect( importComponentsMock ).toHaveBeenNthCalledWith( 2, workflowFiles );
   } );
 
   it( 'loads shared activities from external workflow packages', async () => {
@@ -157,8 +156,6 @@ Activity names must be unique within a workflow.'
     const localWorkflow = { name: 'Local', path: '/root/workflows/local/workflow.js' };
     const externalWorkflow = { name: 'External', path: '/root/node_modules/pkg/workflows/a/workflow.js', external: true };
     findSharedActivitiesFromWorkflowsMock.mockReturnValue( externalSharedFiles );
-    importComponentsMock.mockImplementationOnce( async function *() {} );
-    importComponentsMock.mockImplementationOnce( async function *() {} );
     importComponentsMock.mockImplementationOnce( async function *() {
       yield {
         fn: () => {},
@@ -170,27 +167,29 @@ Activity names must be unique within a workflow.'
     const { activities } = await loadActivities( '/root', [ localWorkflow, externalWorkflow ] );
 
     expect( findSharedActivitiesFromWorkflowsMock ).toHaveBeenCalledWith( [ externalWorkflow ] );
-    expect( importComponentsMock ).toHaveBeenNthCalledWith( 3, externalSharedFiles );
-    expect( activities['$shared#ExternalShared'] ).toBeTypeOf( 'function' );
+    expect( importComponentsMock ).toHaveBeenNthCalledWith( 1, externalSharedFiles );
+    expect( activities['Local#ExternalShared'] ).toBeTypeOf( 'function' );
+    expect( activities['External#ExternalShared'] ).toBeTypeOf( 'function' );
     const written = JSON.parse(
       writeFileInTempDirMock.mock.calls[0][0].replace( /^export default\s*/, '' ).replace( /;\s*$/, '' )
     );
-    expect( written['$shared#ExternalShared'] ).toEqual( { retry: { maximumAttempts: 2 } } );
+    expect( written['Local#ExternalShared'] ).toEqual( { retry: { maximumAttempts: 2 } } );
+    expect( written['External#ExternalShared'] ).toEqual( { retry: { maximumAttempts: 2 } } );
   } );
 
   it( 'loadActivities includes nested workflow steps and shared evaluators', async () => {
     const { loadActivities } = await import( './activities.js' );
     importComponentsMock.mockImplementationOnce( async function *() {
-      yield { fn: () => {}, metadata: { name: 'ActNested' }, path: '/a/steps/foo.js' };
+      yield { fn: () => {}, metadata: { name: 'SharedEval' }, path: '/root/shared/evaluators/bar.js' };
     } );
     importComponentsMock.mockImplementationOnce( async function *() {
-      yield { fn: () => {}, metadata: { name: 'SharedEval' }, path: '/root/shared/evaluators/bar.js' };
+      yield { fn: () => {}, metadata: { name: 'ActNested' }, path: '/a/steps/foo.js' };
     } );
 
     const workflows = [ { name: 'A', path: '/a/workflow.js' } ];
     const { activities } = await loadActivities( '/root', workflows );
     expect( activities['A#ActNested'] ).toBeTypeOf( 'function' );
-    expect( activities['$shared#SharedEval'] ).toBeTypeOf( 'function' );
+    expect( activities['A#SharedEval'] ).toBeTypeOf( 'function' );
   } );
 
   it( 'collects shared nested steps and evaluators across multiple subfolders', async () => {
@@ -205,9 +204,9 @@ Activity names must be unique within a workflow.'
 
     const workflows = [ { name: 'A', path: '/a/workflow.js' } ];
     const { activities } = await loadActivities( '/root', workflows );
-    expect( activities['$shared#SharedStepPrimary'] ).toBeTypeOf( 'function' );
-    expect( activities['$shared#SharedStepSecondary'] ).toBeTypeOf( 'function' );
-    expect( activities['$shared#SharedEvalPrimary'] ).toBeTypeOf( 'function' );
-    expect( activities['$shared#SharedEvalSecondary'] ).toBeTypeOf( 'function' );
+    expect( activities['A#SharedStepPrimary'] ).toBeTypeOf( 'function' );
+    expect( activities['A#SharedStepSecondary'] ).toBeTypeOf( 'function' );
+    expect( activities['A#SharedEvalPrimary'] ).toBeTypeOf( 'function' );
+    expect( activities['A#SharedEvalSecondary'] ).toBeTypeOf( 'function' );
   } );
 } );

package/src/worker/loader/workflows.spec.js

@@ -5,8 +5,7 @@ vi.mock( '#consts', () => ( {
   ACTIVITY_GET_TRACE_DESTINATIONS: '__internal#getTraceDestinations',
   WORKFLOWS_INDEX_FILENAME: '__workflows_entrypoint.js',
   WORKFLOW_CATALOG: 'catalog',
-  ACTIVITY_OPTIONS_FILENAME: '__activity_options.js',
-  SHARED_STEP_PREFIX: '$shared'
+  ACTIVITY_OPTIONS_FILENAME: '__activity_options.js'
 } ) );
 
 const { importComponentsMock, findWorkflowsInNodeModulesMock, matchFilesMock, writeFileInTempDirMock } = vi.hoisted( () => ( {

package/src/worker/webpack_loaders/consts.js

@@ -7,3 +7,9 @@ export const ComponentFile = {
   STEPS: 'steps',
   WORKFLOW: 'workflow'
 };
+
+export const ComponentFactory = {
+  EVALUATOR: 'evaluator',
+  STEP: 'step',
+  WORKFLOW: 'workflow'
+};