@outputai/core 0.10.1-next.b7b2fbe.0 → 0.10.1-next.bf95a6f.0

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

@@ -1,12 +1,14 @@
 import { describe, it, expect, vi, beforeEach } from 'vitest';
 import { ApplicationFailure } from '@temporalio/common';
-import { METADATA_ACCESS_SYMBOL } from '#consts';
+import { FatalError, TransparentFatalError, ValidationError } from '#errors';
 
 const workflowInfoMock = vi.fn();
 const workflowStartMock = vi.fn();
 const workflowEndMock = vi.fn();
 const workflowErrorMock = vi.fn();
 const isCancellationMock = vi.fn();
+const upsertMemoMock = vi.fn();
+const traceInfoBuildMock = vi.fn();
 const startTime = new Date( '2026-06-02T09:00:00.000Z' );
 const runStartTime = new Date( '2026-06-02T09:05:00.000Z' );
 const workflowDetails = {
@@ -36,19 +38,26 @@ const workflowInfo = {
   memo: { traceInfo: { runId: 'root-run' } }
 };
 
-vi.mock( '@temporalio/workflow', () => ( {
-  workflowInfo: ( ...args ) => workflowInfoMock( ...args ),
-  proxySinks: () => ( {
-    workflow: { start: workflowStartMock, end: workflowEndMock, error: workflowErrorMock }
-  } ),
-  ContinueAsNew: class ContinueAsNew extends Error {
-    constructor() {
-      super( 'ContinueAsNew' );
-      this.name = 'ContinueAsNew';
-    }
-  },
-  isCancellation: ( ...args ) => isCancellationMock( ...args )
-} ) );
+vi.mock( '@temporalio/workflow', async importOriginal => {
+  const actual = await importOriginal();
+  return {
+    ...actual,
+    workflowInfo: ( ...args ) => workflowInfoMock( ...args ),
+    proxySinks: () => ( {
+      workflow: { start: workflowStartMock, end: workflowEndMock, error: workflowErrorMock }
+    } ),
+    ContinueAsNew: class ContinueAsNew extends Error {
+      constructor() {
+        super( 'ContinueAsNew' );
+        this.name = 'ContinueAsNew';
+      }
+    },
+    isCancellation: ( ...args ) => isCancellationMock( ...args ),
+    upsertMemo: ( ...args ) => upsertMemoMock( ...args )
+  };
+} );
+
+vi.mock( '#helpers/trace_info', () => ( { TraceInfo: { build: ( ...args ) => traceInfoBuildMock( ...args ) } } ) );
 
 const memoToHeadersMock = vi.fn( memo => ( memo ? { ...memo, __asHeaders: true } : {} ) );
 vi.mock( './headers.js', () => ( { memoToHeaders: ( ...args ) => memoToHeadersMock( ...args ) } ) );
@@ -56,13 +65,20 @@ 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 } ) );
+
+const workflowOptionsDefault = {};
+vi.mock( '../temp/__workflow_options.js', () => ( { default: workflowOptionsDefault } ) );
 
 describe( 'workflow interceptors', () => {
   beforeEach( () => {
     vi.clearAllMocks();
+    Object.keys( activityOptionsDefault ).forEach( key => delete activityOptionsDefault[key] );
+    Object.keys( workflowOptionsDefault ).forEach( key => delete workflowOptionsDefault[key] );
+    workflowOptionsDefault.MyWorkflow = { disableTrace: false };
     isCancellationMock.mockReturnValue( false );
+    traceInfoBuildMock.mockReturnValue( { workflowId: 'workflow-1', runId: 'run-1' } );
     workflowInfoMock.mockReturnValue( workflowInfo );
   } );
 
@@ -71,7 +87,7 @@ describe( 'workflow interceptors', () => {
       const { interceptors } = await import( './workflow.js' );
       const { outbound } = interceptors();
       const interceptor = outbound[0];
-      const input = { headers: { existing: 'header' }, activityType: 'MyWorkflow#step1' };
+      const input = { headers: { existing: 'header' }, activityType: 'MyWorkflow#step1', options: {} };
       const next = vi.fn().mockResolvedValue( 'result' );
 
       memoToHeadersMock.mockReturnValue( { traceInfo: workflowInfo.memo.traceInfo, workflowDetails } );
@@ -91,30 +107,101 @@ 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 } );
+      deepMergeMock.mockReturnValue( {
+        heartbeatTimeout: 10,
+        scheduleToCloseTimeout: 60,
+        retry: { maximumAttempts: 2, nonRetryableErrorTypes: [ 'StepError' ] }
+      } );
 
       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'];
+      expect( input.options ).toEqual( {
+        heartbeatTimeout: 10,
+        scheduleToCloseTimeout: 60,
+        retry: {
+          maximumAttempts: 2,
+          nonRetryableErrorTypes: [ 'StepError', 'FatalError' ]
+        }
+      } );
+    } );
+
+    it( 'adds FatalError to activity retry options without duplicates', async () => {
+      const { interceptors } = await import( './workflow.js' );
+      const { outbound } = interceptors();
+      const interceptor = outbound[0];
+      const input = {
+        headers: {},
+        activityType: 'MyWorkflow#step1',
+        options: {
+          retry: {
+            maximumAttempts: 4,
+            nonRetryableErrorTypes: [ 'DomainError', 'FatalError' ]
+          }
+        }
+      };
+      const next = vi.fn().mockResolvedValue( undefined );
+
+      await interceptor.scheduleActivity( input, next );
+
+      expect( input.options.retry ).toEqual( {
+        maximumAttempts: 4,
+        nonRetryableErrorTypes: [ 'DomainError', 'FatalError' ]
+      } );
     } );
   } );
 
   describe( 'WorkflowExecutionInterceptor', () => {
+    it( 'upserts root trace info before starting the workflow trace', async () => {
+      const { interceptors } = await import( './workflow.js' );
+      const { inbound } = interceptors();
+      const traceInfo = { workflowId: 'workflow-1', runId: 'run-1' };
+      traceInfoBuildMock.mockReturnValue( traceInfo );
+
+      await inbound[0].execute( { args: [ {} ] }, vi.fn().mockResolvedValue( undefined ) );
+
+      expect( traceInfoBuildMock ).toHaveBeenCalledOnce();
+      expect( upsertMemoMock ).toHaveBeenCalledWith( { payloadVersion: '2', traceInfo } );
+      expect( upsertMemoMock.mock.invocationCallOrder[0] ).toBeLessThan( workflowStartMock.mock.invocationCallOrder[0] );
+    } );
+
+    it.each( [
+      {
+        name: 'tracing is disabled',
+        info: workflowInfo,
+        options: { disableTrace: true }
+      },
+      {
+        name: 'the workflow has a root',
+        info: { ...workflowInfo, root: { workflowId: 'root-workflow', runId: 'root-run' } },
+        options: { disableTrace: false }
+      }
+    ] )( 'does not build trace info when $name', async ( { info, options } ) => {
+      workflowInfoMock.mockReturnValue( info );
+      workflowOptionsDefault.MyWorkflow = options;
+      const { interceptors } = await import( './workflow.js' );
+      const { inbound } = interceptors();
+
+      await inbound[0].execute( { args: [ {} ] }, vi.fn().mockResolvedValue( undefined ) );
+
+      expect( traceInfoBuildMock ).not.toHaveBeenCalled();
+      expect( upsertMemoMock ).toHaveBeenCalledOnce();
+      expect( upsertMemoMock ).toHaveBeenCalledWith( { payloadVersion: '2' } );
+    } );
+
     it( 'calls sinks.workflow.start, next, then sinks.workflow.end on success', async () => {
       const { interceptors } = await import( './workflow.js' );
       const { inbound } = interceptors();
@@ -131,7 +218,7 @@ describe( 'workflow interceptors', () => {
       expect( workflowErrorMock ).not.toHaveBeenCalled();
     } );
 
-    it( 'calls sinks.workflow.error and rethrows workflow errors', async () => {
+    it( 'rethrows native errors as Workflow Task failures without a terminal sink event', async () => {
       const { interceptors } = await import( './workflow.js' );
       const { inbound } = interceptors();
       const interceptor = inbound[0];
@@ -141,17 +228,19 @@ describe( 'workflow interceptors', () => {
 
       await expect( interceptor.execute( input, next ) ).rejects.toBe( err );
       expect( workflowStartMock ).toHaveBeenCalled();
-      expect( workflowErrorMock ).toHaveBeenCalledWith( err );
+      expect( workflowErrorMock ).not.toHaveBeenCalled();
       expect( workflowEndMock ).not.toHaveBeenCalled();
     } );
 
-    it( 'wraps workflow errors with metadata in ApplicationFailure details', async () => {
+    it.each( [
+      { ErrorType: FatalError, type: 'FatalError' },
+      { ErrorType: ValidationError, type: 'ValidationError' }
+    ] )( 'converts $type into a non-retryable ApplicationFailure with serialized details', async ( { ErrorType, type } ) => {
       const { interceptors } = await import( './workflow.js' );
       const { inbound } = interceptors();
       const interceptor = inbound[0];
-      const trace = { trace: { destinations: { local: '/tmp/trace' } } };
-      const err = new Error( 'workflow failed' );
-      err[METADATA_ACCESS_SYMBOL] = trace;
+      const err = new ErrorType( 'workflow failed' );
+      err.code = 'EWORKFLOW';
       const next = vi.fn().mockRejectedValue( err );
 
       const thrown = await interceptor.execute( { args: [ {} ] }, next ).catch( e => e );
@@ -159,44 +248,78 @@ describe( 'workflow interceptors', () => {
       expect( thrown ).toBeInstanceOf( ApplicationFailure );
       expect( thrown ).toMatchObject( {
         message: 'workflow failed',
-        type: 'Error',
-        details: [ trace ],
+        type,
+        nonRetryable: true,
+        details: [ {
+          error: {
+            name: type,
+            message: 'workflow failed',
+            code: 'EWORKFLOW'
+          }
+        } ],
         cause: err
       } );
-      expect( workflowErrorMock ).toHaveBeenCalledWith( err );
+      expect( workflowErrorMock ).toHaveBeenCalledWith( expect.objectContaining( {
+        name: type,
+        message: 'workflow failed',
+        code: 'EWORKFLOW',
+        stack: expect.any( String )
+      } ) );
+      expect( workflowErrorMock.mock.calls[0][0] ).not.toBeInstanceOf( Error );
       expect( workflowEndMock ).not.toHaveBeenCalled();
     } );
 
-    it( 'preserves ApplicationFailure metadata when wrapping workflow errors with details', async () => {
+    it( 'uses a transparent error cause for the sink and ApplicationFailure', async () => {
       const { interceptors } = await import( './workflow.js' );
       const { inbound } = interceptors();
       const interceptor = inbound[0];
-      const trace = { trace: { destinations: { local: '/tmp/trace' } } };
-      const err = ApplicationFailure.create( {
-        message: 'domain failed',
-        type: 'DomainFailure',
-        nonRetryable: true,
-        details: [ { domain: { reason: 'bad-input' } } ]
-      } );
-      err[METADATA_ACCESS_SYMBOL] = trace;
-      const next = vi.fn().mockRejectedValue( err );
+      const cause = new TypeError( 'provider rejected request' );
+      cause.code = 'EAUTH';
+      const error = new TransparentFatalError( cause );
+      const next = vi.fn().mockRejectedValue( error );
 
       const thrown = await interceptor.execute( { args: [ {} ] }, next ).catch( e => e );
 
-      expect( thrown ).toBeInstanceOf( ApplicationFailure );
-      expect( thrown ).not.toBe( err );
-      expect( thrown.cause ).toBe( err );
-      expect( thrown.cause ).not.toBe( thrown );
       expect( thrown ).toMatchObject( {
-        message: 'domain failed',
-        type: 'DomainFailure',
+        message: 'provider rejected request',
+        type: 'TypeError',
         nonRetryable: true,
-        details: [
-          { domain: { reason: 'bad-input' } },
-          trace
-        ]
+        cause,
+        details: [ {
+          error: {
+            name: 'TypeError',
+            message: 'provider rejected request',
+            code: 'EAUTH'
+          }
+        } ]
       } );
-      expect( workflowErrorMock ).toHaveBeenCalledWith( err );
+      expect( workflowErrorMock ).toHaveBeenCalledWith( expect.objectContaining( {
+        name: 'TypeError',
+        message: 'provider rejected request',
+        code: 'EAUTH',
+        stack: expect.any( String )
+      } ) );
+      expect( workflowErrorMock.mock.calls[0][0] ).not.toHaveProperty( 'cause' );
+      expect( workflowEndMock ).not.toHaveBeenCalled();
+    } );
+
+    it( 'sinks and rethrows existing Temporal failures unchanged', async () => {
+      const { interceptors } = await import( './workflow.js' );
+      const { inbound } = interceptors();
+      const interceptor = inbound[0];
+      const err = ApplicationFailure.retryable( 'domain failed', 'DomainFailure', { reason: 'invalid' } );
+      const next = vi.fn().mockRejectedValue( err );
+
+      await expect( interceptor.execute( { args: [ {} ] }, next ) ).rejects.toBe( err );
+      expect( workflowErrorMock ).toHaveBeenCalledWith( expect.objectContaining( {
+        name: 'ApplicationFailure',
+        message: 'domain failed',
+        type: 'DomainFailure',
+        details: [ { reason: 'invalid' } ],
+        stack: expect.any( String )
+      } ) );
+      expect( workflowErrorMock.mock.calls[0][0] ).not.toBeInstanceOf( Error );
+      expect( workflowEndMock ).not.toHaveBeenCalled();
     } );
 
     it( 'calls sinks.workflow.error and rethrows cancellation errors without wrapping', async () => {
@@ -209,11 +332,15 @@ describe( 'workflow interceptors', () => {
 
       await expect( interceptor.execute( { args: [ {} ] }, next ) ).rejects.toBe( cancellation );
       expect( isCancellationMock ).toHaveBeenCalledWith( cancellation );
-      expect( workflowErrorMock ).toHaveBeenCalledWith( cancellation );
+      expect( workflowErrorMock ).toHaveBeenCalledWith( {
+        name: 'Error',
+        message: 'Workflow cancelled'
+      } );
+      expect( workflowErrorMock.mock.calls[0][0] ).not.toBeInstanceOf( Error );
       expect( workflowEndMock ).not.toHaveBeenCalled();
     } );
 
-    it( 'on ContinueAsNew calls sinks.trace.addWorkflowEventEnd and rethrows', async () => {
+    it( 'ends the workflow trace and rethrows ContinueAsNew', async () => {
       const { ContinueAsNew } = await import( '@temporalio/workflow' );
       const { WorkflowSpecialOutput } = await import( '#consts' );
       const { interceptors } = await import( './workflow.js' );

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' );
   } );
 } );