@outputai/core 0.10.0 → 0.10.1-dev.b7b2fbe.0

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

package/src/worker/webpack_loaders/tools.js

@@ -2,27 +2,14 @@ import parser from '@babel/parser';
 import { resolve as resolvePath } from 'node:path';
 import { readFileSync } from 'node:fs';
 import {
-  blockStatement,
-  callExpression,
-  functionExpression,
-  identifier,
-  isArrowFunctionExpression,
   isAssignmentPattern,
-  isBlockStatement,
   isCallExpression,
   isExportNamedDeclaration,
-  isFunctionExpression,
   isIdentifier,
-  isVariableDeclarator,
   isStringLiteral,
   isVariableDeclaration,
   isObjectExpression,
-  memberExpression,
-  returnStatement,
-  stringLiteral,
-  thisExpression,
-  isExportDefaultDeclaration,
-  isFunctionDeclaration
+  isExportDefaultDeclaration
 } from '@babel/types';
 import { ComponentFile, NodeType } from './consts.js';
 
@@ -100,17 +87,6 @@ export const getLocalNameFromDestructuredProperty = prop => {
   return null;
 };
 
-/**
- * Convert an ArrowFunctionExpression to a FunctionExpression.
- * Wraps expression bodies in a block with a return statement.
- * @param {import('@babel/types').ArrowFunctionExpression} arrow - Arrow function.
- * @returns {import('@babel/types').FunctionExpression} Function expression.
- */
-export const toFunctionExpression = arrow => {
-  const body = isBlockStatement( arrow.body ) ? arrow.body : blockStatement( [ returnStatement( arrow.body ) ] );
-  return functionExpression( null, arrow.params, body, arrow.generator ?? false, arrow.async ?? false );
-};
-
 /**
  * Check if a module specifier or request string points to steps.js or is in a steps folder.
  * Matches: steps.js, /steps.js, /steps/*.js
@@ -231,38 +207,6 @@ export const getFileKind = path => {
   return null;
 };
 
-/**
- * Create a `this.method(literalName, ...args)` CallExpression.
- * @param {string} method - Method name on `this`.
- * @param {string} literalName - First string literal argument.
- * @param {import('@babel/types').Expression[]} args - Remaining call arguments.
- * @returns {import('@babel/types').CallExpression} Call expression node.
- */
-export const createThisMethodCall = ( method, literalName, args ) =>
-  callExpression( memberExpression( thisExpression(), identifier( method ) ), [ stringLiteral( literalName ), ...args ] );
-
-/**
- * Build a CallExpression that binds `this` at the call site:
- *   fn(arg1, arg2) -> fn.call(this, arg1, arg2)
- *
- * When to use:
- * - Inside workflow `fn` rewriting, local call-chain functions must receive the dynamic `this`
- *   so that emitted `this.invokeStep(...)` and similar calls inside them operate correctly.
- *
- * Example:
- *   // Input AST intent:
- *   foo(a, b);
- *
- *   // Rewritten AST:
- *   foo.call(this, a, b);
- *
- * @param {string} calleeName - Identifier name of the function being called (e.g., 'foo').
- * @param {import('@babel/types').Expression[]} args - Original call arguments.
- * @returns {import('@babel/types').CallExpression} CallExpression node representing `callee.call(this, ...args)`.
- */
-export const bindThisAtCallSite = ( calleeName, args ) =>
-  callExpression( memberExpression( identifier( calleeName ), identifier( 'call' ) ), [ thisExpression(), ...args ] );
-
 /**
  * Resolve an options object's name property to a string.
  * Accepts literal strings or top-level const string identifiers.
@@ -466,92 +410,3 @@ export const buildWorkflowNameMap = ( path, cache ) => {
   return result;
 };
 
-/**
- * Determine whether a node represents a function body usable as a workflow `fn`.
- *
- * Why this matters:
- * - Workflow `fn` needs a dynamic `this` so the rewriter can emit calls like `this.invokeStep(...)`.
- * - Arrow functions do not have their own `this`; they capture `this` lexically, which breaks the runtime contract.
- *
- * Accepts:
- * - FunctionExpression (possibly async/generator), e.g.:
- *   const obj = {
- *     fn: async function (input) {
- *       return input;
- *     }
- *   };
- *
- * Rejects:
- * - ArrowFunctionExpression, e.g.:
- *   const obj = {
- *     fn: async (input) => input
- *   };
- *
- * - Any other non-function expression.
- *
- * Notes:
- * - The rewriter will proactively convert arrow `fn` to a FunctionExpression before further processing.
- *
- * @param {import('@babel/types').Expression} v - Candidate node for `fn` value.
- * @returns {boolean} True if `v` is a FunctionExpression and not an arrow function.
- */
-export const isFunction = v => isFunctionExpression( v ) && !isArrowFunctionExpression( v );
-
-/**
- * Determine whether a variable declarator represents a function-like value.
- *
- * Use case:
- * - When `fn` calls a locally-declared function (directly or transitively), we need to:
- *   - propagate `this` to that function call (`callee.call(this, ...)`)
- *   - traverse into that function's body to rewrite imported step/workflow/evaluator calls.
- *
- * Matches patterns like:
- * - Function expression:
- *   const foo = function (x) { return x + 1; };
- *
- * - Async/generator function expression:
- *   const foo = async function (x) { return await work(x); };
- *
- * - Arrow function (will be normalized to FunctionExpression by the rewriter):
- *   const foo = (x) => x + 1;
- *   const foo = async (x) => await work(x);
- *
- * Does not match:
- * - Non-function initializers:
- *   const foo = 42;
- *   const foo = someIdentifier;
- *
- * @param {import('@babel/types').Node} v - AST node (typically a VariableDeclarator).
- * @returns {boolean} True if the declarator's initializer is a function (arrow or function expression).
- */
-export const isVarFunction = v =>
-  isVariableDeclarator( v ) && ( isFunctionExpression( v.init ) || isArrowFunctionExpression( v.init ) );
-
-/**
- * Determine whether a binding node corresponds to a function-like declaration usable
- * as a call-chain function target during workflow rewriting.
- *
- * Matches:
- * - FunctionDeclaration:
- *     function foo(x) { return x + 1; }
- *
- * - VariableDeclarator initialized with a function or arrow (normalized later):
- *     const foo = function (x) { return x + 1; };
- *     const foo = (x) => x + 1;
- *
- * Non-matches:
- * - Any binding that is not a function declaration nor a variable declarator with a function initializer.
- *
- * Why this matters:
- * - The rewriter traverses call chains from the workflow `fn`. It must recognize which local
- *   callees are valid function bodies to rewrite and into which it can propagate `this`.
- *
- * @param {import('@babel/types').Node} node - Binding path node (FunctionDeclaration or VariableDeclarator).
- * @returns {boolean} True if the node represents a function-like binding.
- */
-export const isFunctionLikeBinding = node =>
-  isFunctionDeclaration( node ) ||
-  (
-    isVariableDeclarator( node ) &&
-    ( isFunctionExpression( node.init ) || isArrowFunctionExpression( node.init ) )
-  );

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

@@ -9,7 +9,6 @@ import {
   extractTopLevelStringConsts,
   getObjectKeyName,
   getLocalNameFromDestructuredProperty,
-  toFunctionExpression,
   isStepsPath,
   isSharedStepsPath,
   isAnyStepsPath,
@@ -17,7 +16,6 @@ import {
   isSharedEvaluatorsPath,
   isWorkflowPath,
   isAbsoluteWorkflowJsResource,
-  createThisMethodCall,
   resolveNameFromArg,
   resolveNameFromOptions,
   buildStepsNameMap,
@@ -130,17 +128,6 @@ describe( 'workflow_rewriter tools', () => {
     rmSync( dir, { recursive: true, force: true } );
   } );
 
-  it( 'toFunctionExpression: converts arrow, wraps expression bodies', () => {
-    const arrowExprBody = t.arrowFunctionExpression( [ t.identifier( 'x' ) ], t.identifier( 'x' ) );
-    const arrowBlockBody = t.arrowFunctionExpression( [], t.blockStatement( [ t.returnStatement( t.numericLiteral( 1 ) ) ] ) );
-    const fn1 = toFunctionExpression( arrowExprBody );
-    const fn2 = toFunctionExpression( arrowBlockBody );
-    expect( t.isFunctionExpression( fn1 ) ).toBe( true );
-    expect( t.isBlockStatement( fn1.body ) ).toBe( true );
-    expect( t.isReturnStatement( fn1.body.body[0] ) ).toBe( true );
-    expect( t.isFunctionExpression( fn2 ) ).toBe( true );
-  } );
-
   it( 'isStepsPath: matches LOCAL steps.js (no path traversal)', () => {
     // Local steps (without ../ or /shared/)
     expect( isStepsPath( 'steps.js' ) ).toBe( true );
@@ -226,16 +213,6 @@ describe( 'workflow_rewriter tools', () => {
     expect( isSharedEvaluatorsPath( 'steps.js' ) ).toBe( false );
   } );
 
-  it( 'createThisMethodCall: builds this.method(\'name\', ...args) call', () => {
-    const call = createThisMethodCall( 'invoke', 'n', [ t.numericLiteral( 1 ), t.identifier( 'x' ) ] );
-    expect( t.isCallExpression( call ) ).toBe( true );
-    expect( t.isMemberExpression( call.callee ) ).toBe( true );
-    expect( t.isThisExpression( call.callee.object ) ).toBe( true );
-    expect( t.isIdentifier( call.callee.property, { name: 'invoke' } ) ).toBe( true );
-    expect( t.isStringLiteral( call.arguments[0], { value: 'n' } ) ).toBe( true );
-    expect( call.arguments.length ).toBe( 3 );
-  } );
-
   it( 'buildSharedStepsNameMap: reads names from shared steps module and caches result', () => {
     const dir = mkdtempSync( join( tmpdir(), 'tools-shared-steps-' ) );
     mkdirSync( join( dir, 'shared', 'steps' ), { recursive: true } );

package/src/worker/webpack_loaders/workflow_rewriter/collect_target_imports.js

@@ -43,7 +43,7 @@ const removeRequireDeclarator = path => {
 
 const collectDestructuredRequires = ( path, absolutePath, req, descriptors ) => {
   const propFilter = p => isObjectProperty( p ) && isIdentifier( p.key );
-  for ( const { match, buildMap, cache, target, valueKey, label } of descriptors ) {
+  for ( const { match, buildMap, cache, label, target } of descriptors ) {
     if ( !match( req ) ) {
       continue;
     }
@@ -54,7 +54,7 @@ const collectDestructuredRequires = ( path, absolutePath, req, descriptors ) =>
       if ( localName ) {
         const resolved = nameMap.get( importedName );
         if ( resolved ) {
-          target.push( { localName, [valueKey]: resolved } );
+          target.push( { localName, activityName: resolved } );
         } else {
           throw unresolvedImportError( importedName, label, absolutePath );
         }
@@ -67,25 +67,26 @@ const collectDestructuredRequires = ( path, absolutePath, req, descriptors ) =>
 
 /**
  * Collect and strip target imports and requires from an AST, producing
- * step/evaluator import mappings for later rewrites.
+ * activity import mappings for later rewrites.
  *
  * Mutates the AST by removing matching import declarations and require declarators.
  *
  * @param {import('@babel/types').File} ast - Parsed file AST.
  * @param {string} fileDir - Absolute directory of the file represented by `ast`.
- * @param {{ stepsNameCache: Map<string,Map<string,string>> }} caches
+ * @param {{
+ *  stepsNameCache: Map<string,Map<string,string>>,
+ *  evaluatorsNameCache: Map<string,Map<string,string>>,
+ *  sharedStepsNameCache: Map<string,Map<string,string>>,
+ *  sharedEvaluatorsNameCache: Map<string,Map<string,string>>
+ * }} caches
  *  Resolved-name caches to avoid re-reading same modules.
- * @returns {{ stepImports: Array<{localName:string,stepName:string}>,
- *  evaluatorImports: Array<{localName:string,evaluatorName:string}> }} Collected info mappings.
+ * @returns {{ activityImports: Array<{localName:string,activityName:string}> }} Collected import mappings.
  */
 export default function collectTargetImports(
   ast, fileDir,
   { stepsNameCache, evaluatorsNameCache, sharedStepsNameCache, sharedEvaluatorsNameCache }
 ) {
-  const stepImports = [];
-  const sharedStepImports = [];
-  const evaluatorImports = [];
-  const sharedEvaluatorImports = [];
+  const activityImports = [];
 
   traverse( ast, {
     ImportDeclaration: path => {
@@ -98,7 +99,7 @@ export default function collectTargetImports(
       }
 
       const absolutePath = toAbsolutePath( fileDir, src );
-      const collectNamedImports = ( match, buildMapFn, cache, targetArr, valueKey, fileLabel ) => {
+      const collectNamedImports = ( match, buildMapFn, cache, fileLabel ) => {
         if ( !match ) {
           return;
         }
@@ -108,22 +109,17 @@ export default function collectTargetImports(
           const localName = s.local.name;
           const value = nameMap.get( importedName );
           if ( value ) {
-            const entry = { localName };
-            entry[valueKey] = value;
-            targetArr.push( entry );
+            activityImports.push( { localName, activityName: value } );
           } else {
             throw unresolvedImportError( importedName, fileLabel, absolutePath );
           }
         }
       };
 
-      collectNamedImports( isStepsPath( src ), buildStepsNameMap, stepsNameCache, stepImports, 'stepName', 'steps' );
-      collectNamedImports( isSharedStepsPath( src ), buildSharedStepsNameMap, sharedStepsNameCache, sharedStepImports, 'stepName', 'shared steps' );
-      collectNamedImports( isEvaluatorsPath( src ), buildEvaluatorsNameMap, evaluatorsNameCache, evaluatorImports, 'evaluatorName', 'evaluators' );
-      collectNamedImports(
-        isSharedEvaluatorsPath( src ), buildSharedEvaluatorsNameMap,
-        sharedEvaluatorsNameCache, sharedEvaluatorImports, 'evaluatorName', 'shared evaluators'
-      );
+      collectNamedImports( isStepsPath( src ), buildStepsNameMap, stepsNameCache, 'steps' );
+      collectNamedImports( isSharedStepsPath( src ), buildSharedStepsNameMap, sharedStepsNameCache, 'shared steps' );
+      collectNamedImports( isEvaluatorsPath( src ), buildEvaluatorsNameMap, evaluatorsNameCache, 'evaluators' );
+      collectNamedImports( isSharedEvaluatorsPath( src ), buildSharedEvaluatorsNameMap, sharedEvaluatorsNameCache, 'shared evaluators' );
       path.remove();
     },
     VariableDeclarator: path => {
@@ -153,25 +149,21 @@ export default function collectTargetImports(
         const cjsDescriptors = [
           {
             match: isStepsPath, buildMap: buildStepsNameMap,
-            cache: stepsNameCache, target: stepImports,
-            valueKey: 'stepName', label: 'steps'
+            cache: stepsNameCache, target: activityImports, label: 'steps'
           },
           {
             match: isSharedStepsPath, buildMap: buildSharedStepsNameMap,
-            cache: sharedStepsNameCache ?? stepsNameCache,
-            target: sharedStepImports,
-            valueKey: 'stepName', label: 'shared steps'
+            cache: sharedStepsNameCache,
+            target: activityImports, label: 'shared steps'
           },
           {
             match: isEvaluatorsPath, buildMap: buildEvaluatorsNameMap,
-            cache: evaluatorsNameCache, target: evaluatorImports,
-            valueKey: 'evaluatorName', label: 'evaluators'
+            cache: evaluatorsNameCache, target: activityImports, label: 'evaluators'
           },
           {
             match: isSharedEvaluatorsPath, buildMap: buildSharedEvaluatorsNameMap,
-            cache: sharedEvaluatorsNameCache ?? evaluatorsNameCache,
-            target: sharedEvaluatorImports,
-            valueKey: 'evaluatorName', label: 'shared evaluators'
+            cache: sharedEvaluatorsNameCache,
+            target: activityImports, label: 'shared evaluators'
           }
         ];
         collectDestructuredRequires(
@@ -182,5 +174,5 @@ export default function collectTargetImports(
     }
   } );
 
-  return { stepImports, sharedStepImports, evaluatorImports, sharedEvaluatorImports };
+  return { activityImports };
 }