@output.ai/core 0.1.0 → 0.1.2

package/src/worker/loader.js

@@ -1,51 +1,87 @@
-import { dirname, join } from 'path';
+import { basename, dirname, join } from 'node:path';
+import { mkdirSync, writeFileSync } from 'node:fs';
+import { EOL } from 'node:os';
 import { fileURLToPath } from 'url';
-import { sendWebhook, readTraceFile } from '#internal_activities';
-import { ACTIVITY_SEND_WEBHOOK, ACTIVITY_READ_TRACE_FILE, WORKFLOWS_INDEX_FILENAME } from '#consts';
+import { sendWebhook } from '#internal_activities';
+import { importComponents } from './loader_tools.js';
 import {
-  iteratorOverImportedComponents,
-  recursiveNavigateWhileCollecting,
-  writeFileOnLocationSync
-} from './internal_utils.js';
+  ACTIVITY_SEND_WEBHOOK,
+  ACTIVITY_OPTIONS_FILENAME,
+  SHARED_STEP_PREFIX,
+  WORKFLOWS_INDEX_FILENAME,
+  WORKFLOW_CATALOG
+} from '#consts';
 
 const __dirname = dirname( fileURLToPath( import.meta.url ) );
 
-// returns a map of activities, where the key is they path + name and the value is the function with metadata
-export async function loadActivities( path ) {
-  const activityPaths = recursiveNavigateWhileCollecting( path, [ 'steps.js', 'evaluators.js' ] );
-  const activities = [];
-  for await ( const { component, metadata, pathname, path } of iteratorOverImportedComponents( activityPaths ) ) {
-    console.log( '[Core.Scanner]', 'Component loaded:', metadata.type, metadata.name, 'at', pathname );
-    activities[`${path}#${metadata.name}`] = component;
+/**
+ * Writes to file the activity options
+ *
+ * @param {object} optionsMap
+ */
+const writeActivityOptionsFile = map => {
+  const path = join( __dirname, 'temp', ACTIVITY_OPTIONS_FILENAME );
+  mkdirSync( dirname( path ), { recursive: true } );
+  writeFileSync( path, `export default ${JSON.stringify( map, undefined, 2 )};`, 'utf-8' );
+};
+
+/**
+ * Builds a map of activities, where the key is their path and name and the value is the function
+ *
+ * @param {string} target
+ * @returns {object}
+ */
+export async function loadActivities( target ) {
+  const activities = {};
+  const activityOptionsMap = {};
+  for await ( const { fn, metadata, path } of importComponents( target, [ 'steps.js', 'evaluators.js', 'shared_steps.js' ] ) ) {
+    const isShared = basename( path ) === 'shared_steps.js';
+    const prefix = isShared ? SHARED_STEP_PREFIX : dirname( path );
+
+    console.log( '[Core.Scanner]', 'Component loaded:', metadata.type, metadata.name, 'at', path );
+    activities[`${prefix}#${metadata.name}`] = fn;
+    if ( metadata.options ) {
+      activityOptionsMap[`${prefix}#${metadata.name}`] = metadata.options;
+    }
   }
 
+  // writes down the activity option overrides
+  writeActivityOptionsFile( activityOptionsMap );
+
   // system activities
   activities[ACTIVITY_SEND_WEBHOOK] = sendWebhook;
-  activities[ACTIVITY_READ_TRACE_FILE] = readTraceFile;
   return activities;
 };
 
-// Returns array of workflow object, which are function with metadata attached
-export async function loadWorkflows( path ) {
-  const workflowPaths = recursiveNavigateWhileCollecting( path, [ 'workflow.js' ] );
+/**
+ * Builds an array of workflow objects
+ *
+ * @param {string} target
+ * @returns {object[]}
+ */
+export async function loadWorkflows( target ) {
   const workflows = [];
-  for await ( const { metadata, pathname, path } of iteratorOverImportedComponents( workflowPaths ) ) {
-    workflows.push( { ...metadata, pathname, path } );
-    console.log( '[Core.Scanner]', 'Workflow loaded:', metadata.name, 'at', pathname );
+  for await ( const { metadata, path } of importComponents( target, [ 'workflow.js' ] ) ) {
+    console.log( '[Core.Scanner]', 'Workflow loaded:', metadata.name, 'at', path );
+    workflows.push( { ...metadata, path } );
   }
   return workflows;
 };
 
-// Creates a temporary index file importing all workflows
+/**
+ * Creates a temporary index file importing all workflows
+ *
+ * @param {object[]} workflows
+ * @returns
+ */
 export function createWorkflowsEntryPoint( workflows ) {
-  const entryPoint = join( __dirname, 'temp', WORKFLOWS_INDEX_FILENAME );
+  const path = join( __dirname, 'temp', WORKFLOWS_INDEX_FILENAME );
 
   // default system catalog workflow
-  const catalogWorkflow = { name: 'catalog', pathname: join( __dirname, './catalog_workflow/workflow.js' ) };
-  const workflowsIndex = [ ... workflows, catalogWorkflow ]
-    .map( ( { name, pathname } ) => `export { default as ${name} } from '${pathname}';` )
-    .join( '\n' );
+  const catalog = { name: WORKFLOW_CATALOG, path: join( __dirname, './catalog_workflow/workflow.js' ) };
+  const content = [ ... workflows, catalog ].map( ( { name, path } ) => `export { default as ${name} } from '${path}';` ).join( EOL );
 
-  writeFileOnLocationSync( entryPoint, workflowsIndex );
-  return entryPoint;
+  mkdirSync( dirname( path ), { recursive: true } );
+  writeFileSync( path, content, 'utf-8' );
+  return path;
 };

package/src/worker/loader.spec.js

@@ -2,25 +2,24 @@ import { describe, it, expect, vi, beforeEach } from 'vitest';
 
 vi.mock( '#consts', () => ( {
   ACTIVITY_SEND_WEBHOOK: '__internal#sendWebhook',
-  ACTIVITY_READ_TRACE_FILE: '__internal#readTraceFile',
-  WORKFLOWS_INDEX_FILENAME: '__workflows_entrypoint.js'
+  WORKFLOWS_INDEX_FILENAME: '__workflows_entrypoint.js',
+  WORKFLOW_CATALOG: 'catalog',
+  ACTIVITY_OPTIONS_FILENAME: '__activity_options.js'
 } ) );
 
 const sendWebhookMock = vi.fn();
-const readTraceFileMock = vi.fn();
 vi.mock( '#internal_activities', () => ( {
-  sendWebhook: sendWebhookMock,
-  readTraceFile: readTraceFileMock
+  sendWebhook: sendWebhookMock
 } ) );
 
-// Mock internal_utils to control filesystem-independent behavior
-const iteratorMock = vi.fn();
-const recursiveMock = vi.fn();
-const writeFileMock = vi.fn();
-vi.mock( './internal_utils.js', () => ( {
-  iteratorOverImportedComponents: iteratorMock,
-  recursiveNavigateWhileCollecting: recursiveMock,
-  writeFileOnLocationSync: writeFileMock
+const importComponentsMock = vi.fn();
+vi.mock( './loader_tools.js', () => ( { importComponents: importComponentsMock } ) );
+
+const mkdirSyncMock = vi.fn();
+const writeFileSyncMock = vi.fn();
+vi.mock( 'node:fs', () => ( {
+  mkdirSync: mkdirSyncMock,
+  writeFileSync: writeFileSyncMock
 } ) );
 
 describe( 'worker/loader', () => {
@@ -28,42 +27,50 @@ describe( 'worker/loader', () => {
     vi.clearAllMocks();
   } );
 
-  it( 'loadActivities returns map including system activity', async () => {
+  it( 'loadActivities returns map including system activity and writes options file', async () => {
     const { loadActivities } = await import( './loader.js' );
 
-    recursiveMock.mockReturnValue( [ { pathname: '/a/steps.js', path: '/a', url: 'file:///a/steps.js' } ] );
-    iteratorMock.mockImplementation( async function *() {
-      yield { component: () => {}, metadata: { name: 'Act1' }, pathname: '/a/steps.js', path: '/a' };
+    importComponentsMock.mockImplementationOnce( async function *() {
+      yield { fn: () => {}, metadata: { name: 'Act1', options: { retry: { maximumAttempts: 3 } } }, path: '/a/steps.js' };
     } );
 
     const activities = await loadActivities( '/root' );
     expect( activities['/a#Act1'] ).toBeTypeOf( 'function' );
     expect( activities['__internal#sendWebhook'] ).toBe( sendWebhookMock );
-    expect( activities['__internal#readTraceFile'] ).toBe( readTraceFileMock );
+
+    // options file written with the collected map
+    expect( writeFileSyncMock ).toHaveBeenCalledTimes( 1 );
+    const [ writtenPath, contents ] = writeFileSyncMock.mock.calls[0];
+    expect( writtenPath ).toMatch( /temp\/__activity_options\.js$/ );
+    expect( contents ).toContain( 'export default' );
+    expect( JSON.parse( contents.replace( /^export default\s*/, '' ).replace( /;\s*$/, '' ) ) ).toEqual( {
+      '/a#Act1': { retry: { maximumAttempts: 3 } }
+    } );
+    expect( mkdirSyncMock ).toHaveBeenCalled();
   } );
 
   it( 'loadWorkflows returns array of workflows with metadata', async () => {
     const { loadWorkflows } = await import( './loader.js' );
 
-    recursiveMock.mockReturnValue( [ { pathname: '/b/workflow.js', path: '/b', url: 'file:///b/workflow.js' } ] );
-    iteratorMock.mockImplementation( async function *() {
-      yield { metadata: { name: 'Flow1', description: 'd' }, pathname: '/b/workflow.js', path: '/b' };
+    importComponentsMock.mockImplementationOnce( async function *() {
+      yield { metadata: { name: 'Flow1', description: 'd' }, path: '/b/workflow.js' };
     } );
 
     const workflows = await loadWorkflows( '/root' );
-    expect( workflows ).toEqual( [ { name: 'Flow1', description: 'd', pathname: '/b/workflow.js', path: '/b' } ] );
+    expect( workflows ).toEqual( [ { name: 'Flow1', description: 'd', path: '/b/workflow.js' } ] );
   } );
 
   it( 'createWorkflowsEntryPoint writes index and returns its path', async () => {
     const { createWorkflowsEntryPoint } = await import( './loader.js' );
 
-    const workflows = [ { name: 'W', pathname: '/abs/wf.js' } ];
+    const workflows = [ { name: 'W', path: '/abs/wf.js' } ];
     const entry = createWorkflowsEntryPoint( workflows );
 
-    expect( writeFileMock ).toHaveBeenCalledTimes( 1 );
-    const [ writtenPath, contents ] = writeFileMock.mock.calls[0];
+    expect( writeFileSyncMock ).toHaveBeenCalledTimes( 1 );
+    const [ writtenPath, contents ] = writeFileSyncMock.mock.calls[0];
     expect( entry ).toBe( writtenPath );
     expect( contents ).toContain( 'export { default as W } from \'/abs/wf.js\';' );
     expect( contents ).toContain( 'export { default as catalog }' );
+    expect( mkdirSyncMock ).toHaveBeenCalledTimes( 1 );
   } );
 } );

package/src/worker/loader_tools.js

@@ -0,0 +1,63 @@
+import { resolve } from 'path';
+import { pathToFileURL } from 'url';
+import { METADATA_ACCESS_SYMBOL } from '#consts';
+import { readdirSync } from 'fs';
+
+/**
+ * @typedef {object} CollectedFile
+ * @property {string} path - The file path
+ * @property {string} url - The resolved url of the file, ready to be imported
+ */
+/**
+ * @typedef {object} Component
+ * @property {Function} fn - The loaded component function
+ * @property {object} metadata - Associated metadata with the component
+ * @property {string} path - Associated metadata with the component
+ */
+
+/**
+ * Recursive traverse directories looking for files with given name.
+ *
+ * @param {string} path - The path to scan
+ * @param {string[]} filenames  - The filenames to look for
+ * @returns {CollectedFile[]} An array containing the collected files
+ * */
+const findByNameRecursively = ( parentPath, filenames, collection = [], ignoreDirNames = [ 'vendor', 'node_modules' ] ) => {
+  for ( const entry of readdirSync( parentPath, { withFileTypes: true } ) ) {
+    if ( ignoreDirNames.includes( entry.name ) ) {
+      continue;
+    }
+
+    const path = resolve( parentPath, entry.name );
+    if ( entry.isDirectory() ) {
+      findByNameRecursively( path, filenames, collection );
+    } else if ( filenames.includes( entry.name ) ) {
+      collection.push( { path, url: pathToFileURL( path ).href } );
+    }
+  }
+
+  return collection;
+};
+
+/**
+ * For each path, dynamic import it, and for each exported component with metadata (step, workflow), yields it.
+ *
+ * @generator
+ * @async
+ * @function importComponents
+ * @param {string} target - Place to look for files
+ * @param {string[]} filenames - File names to load recursively from target
+ * @yields {Component}
+ */
+export async function *importComponents( target, filenames ) {
+  for ( const { url, path } of findByNameRecursively( target, filenames ) ) {
+    const imported = await import( url );
+    for ( const fn of Object.values( imported ) ) {
+      const metadata = fn[METADATA_ACCESS_SYMBOL];
+      if ( !metadata ) {
+        continue;
+      }
+      yield { fn, metadata, path };
+    }
+  }
+};

package/src/worker/loader_tools.spec.js

@@ -0,0 +1,85 @@
+import { describe, it, expect } from 'vitest';
+import { mkdirSync, writeFileSync, rmSync } from 'node:fs';
+import { join } from 'node:path';
+import { importComponents } from './loader_tools.js';
+
+describe( '.importComponents', () => {
+  it( 'imports modules and yields metadata from exports tagged with METADATA_ACCESS_SYMBOL', async () => {
+    const root = join( process.cwd(), 'sdk/core/temp_test_modules', `meta-${Date.now()}` );
+    mkdirSync( root, { recursive: true } );
+    const file = join( root, 'meta.module.js' );
+    writeFileSync( file, [
+      'import { METADATA_ACCESS_SYMBOL } from "#consts";',
+      'export const StepA = () => {};',
+      'StepA[METADATA_ACCESS_SYMBOL] = { kind: "step", name: "a" };',
+      'export const FlowB = () => {};',
+      'FlowB[METADATA_ACCESS_SYMBOL] = { kind: "workflow", name: "b" };'
+    ].join( '\n' ) );
+
+    const collected = [];
+    for await ( const m of importComponents( root, [ 'meta.module.js' ] ) ) {
+      collected.push( m );
+    }
+
+    expect( collected.length ).toBe( 2 );
+    expect( collected.map( m => m.metadata.name ).sort() ).toEqual( [ 'a', 'b' ] );
+    expect( collected.map( m => m.metadata.kind ).sort() ).toEqual( [ 'step', 'workflow' ] );
+    for ( const m of collected ) {
+      expect( m.path ).toBe( file );
+      expect( typeof m.fn ).toBe( 'function' );
+    }
+
+    rmSync( root, { recursive: true, force: true } );
+  } );
+
+  it( 'ignores exports without metadata symbol', async () => {
+    const root = join( process.cwd(), 'sdk/core/temp_test_modules', `meta-${Date.now()}-nometa` );
+    mkdirSync( root, { recursive: true } );
+    const file = join( root, 'meta.module.js' );
+    writeFileSync( file, [
+      'export const Plain = () => {};',
+      'export const AlsoPlain = {}'
+    ].join( '\n' ) );
+
+    const collected = [];
+    for await ( const m of importComponents( root, [ 'meta.module.js' ] ) ) {
+      collected.push( m );
+    }
+
+    expect( collected.length ).toBe( 0 );
+    rmSync( root, { recursive: true, force: true } );
+  } );
+
+  it( 'skips files inside ignored directories (node_modules, vendor)', async () => {
+    const root = join( process.cwd(), 'sdk/core/temp_test_modules', `meta-${Date.now()}-ignoredirs` );
+    const okDir = join( root, 'ok' );
+    const nmDir = join( root, 'node_modules' );
+    const vendorDir = join( root, 'vendor' );
+    mkdirSync( okDir, { recursive: true } );
+    mkdirSync( nmDir, { recursive: true } );
+    mkdirSync( vendorDir, { recursive: true } );
+
+    const okFile = join( okDir, 'meta.module.js' );
+    const nmFile = join( nmDir, 'meta.module.js' );
+    const vendorFile = join( vendorDir, 'meta.module.js' );
+
+    const fileContents = [
+      'import { METADATA_ACCESS_SYMBOL } from "#consts";',
+      'export const C = () => {};',
+      'C[METADATA_ACCESS_SYMBOL] = { kind: "step", name: "c" };'
+    ].join( '\n' );
+    writeFileSync( okFile, fileContents );
+    writeFileSync( nmFile, fileContents );
+    writeFileSync( vendorFile, fileContents );
+
+    const collected = [];
+    for await ( const m of importComponents( root, [ 'meta.module.js' ] ) ) {
+      collected.push( m );
+    }
+
+    expect( collected.length ).toBe( 1 );
+    expect( collected[0].path ).toBe( okFile );
+
+    rmSync( root, { recursive: true, force: true } );
+  } );
+} );

package/src/worker/sinks.js

@@ -1,3 +1,4 @@
+import { WORKFLOW_CATALOG } from '#consts';
 import { addEventStart, addEventEnd, addEventError } from '#tracing';
 
 /**
@@ -8,8 +9,11 @@ import { addEventStart, addEventEnd, addEventError } from '#tracing';
  * @param {object} details - Teh details to attach to the event
  */
 const addWorkflowEvent = ( method, workflowInfo, details ) => {
-  const { workflowId: id, workflowType: name, memo: { parentId, traceId, traceHelm } } = workflowInfo;
-  method( { id, kind: 'workflow', name, details, parentId, traceId, traceHelm } );
+  const { workflowId: id, workflowType: name, memo: { parentId, executionContext } } = workflowInfo;
+  if ( name === WORKFLOW_CATALOG ) {
+    return;
+  } // ignore internal catalog events
+  method( { id, kind: 'workflow', name, details, parentId, executionContext } );
 };
 
 /**
@@ -21,8 +25,8 @@ const addWorkflowEvent = ( method, workflowInfo, details ) => {
  */
 const addEvent = ( method, workflowInfo, options ) => {
   const { id, name, kind, details } = options;
-  const { workflowId, memo: { traceId, traceHelm } } = workflowInfo;
-  method( { id, kind, name, details, parentId: workflowId, traceId, traceHelm } );
+  const { workflowId, memo: { executionContext } } = workflowInfo;
+  method( { id, kind, name, details, parentId: workflowId, executionContext } );
 };
 
 // This sink allow for sandbox Temporal environment to send trace logs back to the main thread.

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

@@ -3,9 +3,11 @@ import {
   buildWorkflowNameMap,
   getLocalNameFromDestructuredProperty,
   isEvaluatorsPath,
+  isSharedStepsPath,
   isStepsPath,
   isWorkflowPath,
   buildStepsNameMap,
+  buildSharedStepsNameMap,
   buildEvaluatorsNameMap,
   toAbsolutePath
 } from './tools.js';
@@ -36,8 +38,9 @@ const traverse = traverseModule.default ?? traverseModule;
  * @returns {{ stepImports: Array<{localName:string,stepName:string}>,
  *  flowImports: Array<{localName:string,workflowName:string}> }} Collected info mappings.
  */
-export default function collectTargetImports( ast, fileDir, { stepsNameCache, workflowNameCache, evaluatorsNameCache } ) {
+export default function collectTargetImports( ast, fileDir, { stepsNameCache, workflowNameCache, evaluatorsNameCache, sharedStepsNameCache } ) {
   const stepImports = [];
+  const sharedStepImports = [];
   const flowImports = [];
   const evaluatorImports = [];
 
@@ -45,33 +48,31 @@ export default function collectTargetImports( ast, fileDir, { stepsNameCache, wo
     ImportDeclaration: path => {
       const src = path.node.source.value;
       // Ignore other imports
-      if ( !isStepsPath( src ) && !isWorkflowPath( src ) && !isEvaluatorsPath( src ) ) {
+      if ( !isStepsPath( src ) && !isSharedStepsPath( src ) && !isWorkflowPath( src ) && !isEvaluatorsPath( src ) ) {
         return;
       }
 
       const absolutePath = toAbsolutePath( fileDir, src );
-      if ( isStepsPath( src ) ) {
-        const nameMap = buildStepsNameMap( absolutePath, stepsNameCache );
-        for ( const s of path.node.specifiers.filter( s => isImportSpecifier( s ) ) ) {
-          const importedName = s.imported.name;
-          const localName = s.local.name;
-          const stepName = nameMap.get( importedName );
-          if ( stepName ) {
-            stepImports.push( { localName, stepName } );
-          }
+      const collectNamedImports = ( match, buildMapFn, cache, targetArr, valueKey ) => {
+        if ( !match ) {
+          return;
         }
-      }
-      if ( isEvaluatorsPath( src ) ) {
-        const nameMap = buildEvaluatorsNameMap( absolutePath, evaluatorsNameCache );
+        const nameMap = buildMapFn( absolutePath, cache );
         for ( const s of path.node.specifiers.filter( s => isImportSpecifier( s ) ) ) {
           const importedName = s.imported.name;
           const localName = s.local.name;
-          const evaluatorName = nameMap.get( importedName );
-          if ( evaluatorName ) {
-            evaluatorImports.push( { localName, evaluatorName } );
+          const value = nameMap.get( importedName );
+          if ( value ) {
+            const entry = { localName };
+            entry[valueKey] = value;
+            targetArr.push( entry );
           }
         }
-      }
+      };
+
+      collectNamedImports( isStepsPath( src ), buildStepsNameMap, stepsNameCache, stepImports, 'stepName' );
+      collectNamedImports( isSharedStepsPath( src ), buildSharedStepsNameMap, sharedStepsNameCache, sharedStepImports, 'stepName' );
+      collectNamedImports( isEvaluatorsPath( src ), buildEvaluatorsNameMap, evaluatorsNameCache, evaluatorImports, 'evaluatorName' );
       if ( isWorkflowPath( src ) ) {
         const { named, default: defName } = buildWorkflowNameMap( absolutePath, workflowNameCache );
         for ( const s of path.node.specifiers ) {
@@ -108,7 +109,7 @@ export default function collectTargetImports( ast, fileDir, { stepsNameCache, wo
 
       const req = firstArgument.value;
       // Must be steps/workflows module
-      if ( !isStepsPath( req ) && !isWorkflowPath( req ) && !isEvaluatorsPath( req ) ) {
+      if ( !isStepsPath( req ) && !isSharedStepsPath( req ) && !isWorkflowPath( req ) && !isEvaluatorsPath( req ) ) {
         return;
       }
 
@@ -130,6 +131,23 @@ export default function collectTargetImports( ast, fileDir, { stepsNameCache, wo
         } else {
           path.remove();
         }
+      } else if ( isSharedStepsPath( req ) && isObjectPattern( path.node.id ) ) {
+        const nameMap = buildSharedStepsNameMap( absolutePath, sharedStepsNameCache ?? stepsNameCache );
+        for ( const prop of path.node.id.properties.filter( prop => isObjectProperty( prop ) && isIdentifier( prop.key ) ) ) {
+          const importedName = prop.key.name;
+          const localName = getLocalNameFromDestructuredProperty( prop );
+          if ( localName ) {
+            const stepName = nameMap.get( importedName );
+            if ( stepName ) {
+              sharedStepImports.push( { localName, stepName } );
+            }
+          }
+        }
+        if ( isVariableDeclaration( path.parent ) && path.parent.declarations.length === 1 ) {
+          path.parentPath.remove();
+        } else {
+          path.remove();
+        }
       } else if ( isEvaluatorsPath( req ) && isObjectPattern( path.node.id ) ) {
         const nameMap = buildEvaluatorsNameMap( absolutePath, evaluatorsNameCache );
         for ( const prop of path.node.id.properties.filter( prop => isObjectProperty( prop ) && isIdentifier( prop.key ) ) ) {
@@ -160,5 +178,5 @@ export default function collectTargetImports( ast, fileDir, { stepsNameCache, wo
     }
   } );
 
-  return { stepImports, evaluatorImports, flowImports };
+  return { stepImports, sharedStepImports, evaluatorImports, flowImports };
 };

package/src/worker/webpack_loaders/workflow_rewriter/index.mjs

@@ -10,6 +10,7 @@ const generate = generatorModule.default ?? generatorModule;
 
 // Caches to avoid re-reading files during a build
 const stepsNameCache = new Map(); // path -> Map<exported, stepName>
+const sharedStepsNameCache = new Map(); // path -> Map<exported, stepName> (shared)
 const evaluatorsNameCache = new Map(); // path -> Map<exported, evaluatorName>
 const workflowNameCache = new Map(); // path -> { default?: name, named: Map<exported, flowName> }
 
@@ -26,20 +27,20 @@ const workflowNameCache = new Map(); // path -> { default?: name, named: Map<exp
 export default function stepImportRewriterAstLoader( source, inputMap ) {
   this.cacheable?.( true );
   const callback = this.async?.() ?? this.callback;
-  const cache = { stepsNameCache, evaluatorsNameCache, workflowNameCache };
+  const cache = { stepsNameCache, sharedStepsNameCache, evaluatorsNameCache, workflowNameCache };
 
   try {
     const filename = this.resourcePath;
     const ast = parse( String( source ), filename );
     const fileDir = dirname( filename );
-    const { stepImports, evaluatorImports, flowImports } = collectTargetImports( ast, fileDir, cache );
+    const { stepImports, sharedStepImports, evaluatorImports, flowImports } = collectTargetImports( ast, fileDir, cache );
 
     // No imports
-    if ( [].concat( stepImports, evaluatorImports, flowImports ).length === 0 ) {
+    if ( [].concat( stepImports, sharedStepImports, evaluatorImports, flowImports ).length === 0 ) {
       return callback( null, source, inputMap );
     }
 
-    const rewrote = rewriteFnBodies( { ast, stepImports, evaluatorImports, flowImports } );
+    const rewrote = rewriteFnBodies( { ast, stepImports, sharedStepImports, evaluatorImports, flowImports } );
     // No edits performed
     if ( !rewrote ) {
       return callback( null, source, inputMap );

package/src/worker/webpack_loaders/workflow_rewriter/index.spec.js

@@ -51,6 +51,54 @@ describe( 'workflows_rewriter Webpack loader spec', () => {
     rmSync( dir, { recursive: true, force: true } );
   } );
 
+  it( 'rewrites ESM shared_steps imports to invokeSharedStep', async () => {
+    const dir = mkdtempSync( join( tmpdir(), 'ast-loader-esm-shared-' ) );
+    writeFileSync( join( dir, 'shared_steps.js' ), 'export const SharedA = step({ name: \'shared.a\' })\n' );
+
+    const source = [
+      'import { SharedA } from \'./shared_steps.js\';',
+      '',
+      'const obj = {',
+      '  fn: async (x) => {',
+      '    SharedA(1);',
+      '  }',
+      '}',
+      ''
+    ].join( '\n' );
+
+    const { code } = await runLoader( source, join( dir, 'file.js' ) );
+
+    expect( code ).not.toMatch( /from '\.\/shared_steps\.js'/ );
+    expect( code ).toMatch( /fn:\s*async function \(x\)/ );
+    expect( code ).toMatch( /this\.invokeSharedStep\('shared\.a',\s*1\)/ );
+
+    rmSync( dir, { recursive: true, force: true } );
+  } );
+
+  it( 'rewrites CJS shared_steps requires to invokeSharedStep', async () => {
+    const dir = mkdtempSync( join( tmpdir(), 'ast-loader-cjs-shared-' ) );
+    writeFileSync( join( dir, 'shared_steps.js' ), 'export const SharedB = step({ name: \'shared.b\' })\n' );
+
+    const source = [
+      'const { SharedB } = require(\'./shared_steps.js\');',
+      '',
+      'const obj = {',
+      '  fn: async (y) => {',
+      '    SharedB();',
+      '  }',
+      '}',
+      ''
+    ].join( '\n' );
+
+    const { code } = await runLoader( source, join( dir, 'file.js' ) );
+
+    expect( code ).not.toMatch( /require\('\.\/shared_steps\.js'\)/ );
+    expect( code ).toMatch( /fn:\s*async function \(y\)/ );
+    expect( code ).toMatch( /this\.invokeSharedStep\('shared\.b'\)/ );
+
+    rmSync( dir, { recursive: true, force: true } );
+  } );
+
   it( 'rewrites CJS requires and converts fn arrow to function', async () => {
     const dir = mkdtempSync( join( tmpdir(), 'ast-loader-cjs-' ) );
     writeFileSync( join( dir, 'steps.js' ), 'export const StepB = step({ name: \'step.b\' })\n' );

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

@@ -18,11 +18,12 @@ const traverse = traverseModule.default ?? traverseModule;
  * @param {object} params
  * @param {import('@babel/types').File} params.ast - Parsed file AST.
  * @param {Array<{localName:string,stepName:string}>} params.stepImports - Step imports.
+ * @param {Array<{localName:string,stepName:string}>} params.sharedStepImports - Shared step imports.
  * @param {Array<{localName:string,evaluatorName:string}>} params.evaluatorImports - Evaluator imports.
  * @param {Array<{localName:string,workflowName:string}>} params.flowImports - Workflow imports.
  * @returns {boolean} True if the AST was modified; false otherwise.
  */
-export default function rewriteFnBodies( { ast, stepImports, evaluatorImports, flowImports } ) {
+export default function rewriteFnBodies( { ast, stepImports, sharedStepImports = [], evaluatorImports, flowImports } ) {
   const state = { rewrote: false };
   traverse( ast, {
     ObjectProperty: path => {
@@ -51,25 +52,20 @@ export default function rewriteFnBodies( { ast, stepImports, evaluatorImports, f
           if ( !isIdentifier( callee ) ) {
             return;
           } // Skip: complex callee not supported
-          const step = stepImports.find( x => x.localName === callee.name );
-          if ( step ) {
-            const args = cPath.node.arguments;
-            cPath.replaceWith( createThisMethodCall( 'invokeStep', step.stepName, args ) );
-            state.rewrote = true;
-            return; // Stop after rewriting as step call
-          }
-          const evaluator = evaluatorImports.find( x => x.localName === callee.name );
-          if ( evaluator ) {
-            const args = cPath.node.arguments;
-            cPath.replaceWith( createThisMethodCall( 'invokeEvaluator', evaluator.evaluatorName, args ) );
-            state.rewrote = true;
-            return; // Stop after rewriting as evaluator call
-          }
-          const flow = flowImports.find( x => x.localName === callee.name );
-          if ( flow ) {
-            const args = cPath.node.arguments;
-            cPath.replaceWith( createThisMethodCall( 'startWorkflow', flow.workflowName, args ) );
-            state.rewrote = true;
+          const descriptors = [
+            { list: stepImports, method: 'invokeStep', key: 'stepName' },
+            { list: sharedStepImports, method: 'invokeSharedStep', key: 'stepName' },
+            { list: evaluatorImports, method: 'invokeEvaluator', key: 'evaluatorName' },
+            { list: flowImports, method: 'startWorkflow', key: 'workflowName' }
+          ];
+          for ( const { list, method, key } of descriptors ) {
+            const found = list.find( x => x.localName === callee.name );
+            if ( found ) {
+              const args = cPath.node.arguments;
+              cPath.replaceWith( createThisMethodCall( method, found[key], args ) );
+              state.rewrote = true;
+              return;
+            }
           }
         }
       } );