@output.ai/core 0.1.1 → 0.1.3

package/src/utils/resolve_invocation_dir.spec.js

@@ -0,0 +1,102 @@
+import { afterEach, describe, expect, it } from 'vitest';
+import resolveInvocationDir from './resolve_invocation_dir';
+
+const OriginalError = Error;
+
+describe( 'Resolve Invocation Dir', () => {
+  afterEach( () => {
+    Error = OriginalError;
+  } );
+
+  it( 'Should detect the invocation dir from the tests workflow', () => {
+    const stack = `Error
+    at resolveInvocationDir (file:///app/sdk/core/src/utils/resolve_invocation_dir.js)
+    at fn (file:///app/test_workflows/dist/simple/steps.js:8:21)
+    at wrapper (file:///app/sdk/core/src/interface/step.js:12:26)
+    at executeNextHandler (/app/node_modules/@temporalio/worker/lib/activity.js:99:54)
+    at Storage.runWithContext.parentId (file:///app/sdk/core/src/worker/interceptors/activity.js:31:63)
+    at AsyncLocalStorage.run (node:internal/async_local_storage/async_context_frame:63:14)
+    at Object.runWithContext (file:///app/sdk/core/src/async_storage.js:12:44)
+    at ActivityExecutionInterceptor.execute (file:///app/sdk/core/src/worker/interceptors/activity.js:31:36)
+    at next (/app/node_modules/@temporalio/common/lib/interceptors.js:22:51)
+    at Activity.execute (/app/node_modules/@temporalio/worker/lib/activity.js:101:26)
+    at /app/node_modules/@temporalio/worker/lib/activity.js:149:29`;
+
+    Error = class extends OriginalError {
+      constructor( ...args ) {
+        super( ...args );
+        this.stack = stack;
+      }
+    };
+
+    expect( resolveInvocationDir() ).toBe( '/app/test_workflows/dist/simple' );
+  } );
+
+  it( 'Should detect the invocation dir from the sandbox environment at sdk/core', () => {
+    const stack = `Error
+    at resolveInvocationDir (file:///app/sdk/core/src/utils/resolve_invocation_dir.js)
+    at workflow (file:///app/sdk/core/src/interface/workflow.js:25:16)
+    at file:///app/test_workflows/dist/nested/workflow.js:4:16
+    at ModuleJob.run (node:internal/modules/esm/module_job:365:25)
+    at async onImport.tracePromise.__proto__ (node:internal/modules/esm/loader:665:26)
+    at async importComponents (file:///app/sdk/core/src/worker/loader_tools.js:54:22)
+    at async loadWorkflows (file:///app/sdk/core/src/worker/loader.js:64:38)
+    at async file:///app/sdk/core/src/worker/index.js:21:21`;
+
+    Error = class extends OriginalError {
+      constructor( ...args ) {
+        super( ...args );
+        this.stack = stack;
+      }
+    };
+
+    expect( resolveInvocationDir() ).toBe( '/app/test_workflows/dist/nested' );
+  } );
+
+  it( 'Should detect the invocation dir from workflow loading at core', () => {
+    const stack = `Error
+    at __WEBPACK_DEFAULT_EXPORT__ (/app/sdk/core/src/utils/resolve_invocation_dir.js:13:0)
+    at workflow (/app/sdk/core/src/interface/workflow.js:22:43)
+    at ../../test_workflows/dist/nested/workflow.js (/app/test_workflows/dist/nested/workflow.js:4:24)
+    at __webpack_require__ (webpack/bootstrap:19:0)
+    at ./src/worker/temp/__workflows_entrypoint.js (null:null:null)
+    at __webpack_require__ (webpack/bootstrap:19:0)
+    at importWorkflows (/app/sdk/core/src/worker/temp/__workflows_entrypoint-autogenerated-entrypoint.cjs:9:9)
+    at Object.initRuntime (/app/node_modules/@temporalio/workflow/src/worker-interface.ts:78:16)
+    at __TEMPORAL_CALL_INTO_SCOPE (evalmachine.<anonymous>:30:40)
+    at evalmachine.<anonymous>:1:1`;
+
+    Error = class extends OriginalError {
+      constructor( ...args ) {
+        super( ...args );
+        this.stack = stack;
+      }
+    };
+
+    expect( resolveInvocationDir() ).toBe( '/app/test_workflows/dist/nested' );
+  } );
+
+  it( 'Should detect the invocation dir from a workflow using core installed via NPM', () => {
+    const stack = `Error
+    at resolveInvocationDir (file:///app/node_modules/@output.ai/core/src/utils/resolve_invocation_dir.js)
+    at fn (file:///app/dist/simple/steps.js:8:21)
+    at wrapper (file:///app/node_modules/@output.ai/core/src/interface/step.js:12:26)
+    at executeNextHandler (/app/node_modules/@temporalio/worker/lib/activity.js:99:54)
+    at Storage.runWithContext.parentId (file:///app/node_modules/@output.ai/core/src/worker/interceptors/activity.js:31:63)
+    at AsyncLocalStorage.run (node:internal/async_local_storage/async_context_frame:63:14)
+    at Object.runWithContext (file:///app/node_modules/@output.ai/core/src/async_storage.js:12:44)
+    at ActivityExecutionInterceptor.execute (file:///app/node_modules/@output.ai/core/src/worker/interceptors/activity.js:31:36)
+    at next (/app/node_modules/@temporalio/common/lib/interceptors.js:22:51)
+    at Activity.execute (/app/node_modules/@temporalio/worker/lib/activity.js:101:26)
+    at /app/node_modules/@temporalio/worker/lib/activity.js:149:29`;
+
+    Error = class extends OriginalError {
+      constructor( ...args ) {
+        super( ...args );
+        this.stack = stack;
+      }
+    };
+
+    expect( resolveInvocationDir() ).toBe( '/app/dist/simple' );
+  } );
+} );

package/src/utils/utils.js

@@ -0,0 +1,37 @@
+import { METADATA_ACCESS_SYMBOL } from '#consts';
+
+/**
+ * Node safe clone implementation that doesn't use global structuredClone()
+ * @param {object} v
+ * @returns {object}
+ */
+export const clone = v => JSON.parse( JSON.stringify( v ) );
+
+/**
+ * Throw given error
+ * @param {Error} e
+ * @throws {e}
+ */
+export const throws = e => {
+  throw e;
+};
+
+/**
+ * Add metadata "values" property to a given object
+ * @param {object} target
+ * @param {object} values
+ * @returns
+ */
+export const setMetadata = ( target, values ) =>
+  Object.defineProperty( target, METADATA_ACCESS_SYMBOL, { value: values, writable: false, enumerable: false, configurable: false } );
+
+/**
+ * Merge two temporal activity options
+ * @param {import('@temporalio/workflow').ActivityOptions} base
+ * @param {import('@temporalio/workflow').ActivityOptions} ext
+ * @returns {import('@temporalio/workflow').ActivityOptions}
+ */
+export const mergeActivityOptions = ( base = {}, ext = {} ) =>
+  Object.entries( ext ).reduce( ( options, [ k, v ] ) =>
+    Object.assign( options, { [k]: typeof v === 'object' ? mergeActivityOptions( options[k], v ) : v } )
+  , clone( base ) );

package/src/utils/utils.spec.js

@@ -0,0 +1,60 @@
+import { describe, it, expect } from 'vitest';
+import { clone, mergeActivityOptions } from './utils.js';
+
+describe( 'clone', () => {
+  it( 'produces a deep copy without shared references', () => {
+    const original = { a: 1, nested: { b: 2 } };
+    const copied = clone( original );
+
+    copied.nested.b = 3;
+
+    expect( original.nested.b ).toBe( 2 );
+    expect( copied.nested.b ).toBe( 3 );
+    expect( copied ).not.toBe( original );
+  } );
+} );
+
+describe( 'mergeActivityOptions', () => {
+  it( 'recursively merges nested objects', () => {
+    const base = {
+      taskQueue: 'q1',
+      retry: { maximumAttempts: 3, backoffCoefficient: 2 }
+    };
+    const ext = {
+      retry: { maximumAttempts: 5, initialInterval: '1s' }
+    };
+
+    const result = mergeActivityOptions( base, ext );
+
+    expect( result ).toEqual( {
+      taskQueue: 'q1',
+      retry: { maximumAttempts: 5, backoffCoefficient: 2, initialInterval: '1s' }
+    } );
+  } );
+
+  it( 'omitted properties in second do not overwrite first', () => {
+    const base = {
+      taskQueue: 'q2',
+      retry: { initialInterval: '2s', backoffCoefficient: 2 }
+    };
+    const ext = {
+      retry: { backoffCoefficient: 3 }
+    };
+
+    const result = mergeActivityOptions( base, ext );
+
+    expect( result.retry.initialInterval ).toBe( '2s' );
+    expect( result.retry.backoffCoefficient ).toBe( 3 );
+    expect( result.taskQueue ).toBe( 'q2' );
+  } );
+
+  it( 'handles omitted second argument by returning a clone', () => {
+    const base = { taskQueue: 'q3', retry: { maximumAttempts: 2 } };
+
+    const result = mergeActivityOptions( base );
+
+    expect( result ).toEqual( base );
+    expect( result ).not.toBe( base );
+  } );
+} );
+

package/src/worker/interceptors/workflow.js

@@ -1,6 +1,9 @@
 // THIS RUNS IN THE TEMPORAL'S SANDBOX ENVIRONMENT
 import { workflowInfo, proxySinks, ApplicationFailure } from '@temporalio/workflow';
 import { memoToHeaders } from '../sandboxed_utils.js';
+import { mergeActivityOptions } from '#utils';
+// this is a dynamic generated file with activity configs overwrites
+import stepOptions from '../temp/__activity_options.js';
 
 /*
   This is not an AI comment!
@@ -13,7 +16,13 @@ import { memoToHeaders } from '../sandboxed_utils.js';
 */
 class HeadersInjectionInterceptor {
   async scheduleActivity( input, next ) {
-    Object.assign( input.headers, memoToHeaders( workflowInfo().memo ) );
+    const memo = workflowInfo().memo ?? {};
+    Object.assign( input.headers, memoToHeaders( memo ) );
+    // apply per-invocation options passed as second argument by rewritten calls
+    const options = stepOptions[input.activityType];
+    if ( options ) {
+      input.options = mergeActivityOptions( memo.activityOptions, options );
+    }
     return next( input );
   }
 };

package/src/worker/loader.js

@@ -1,13 +1,30 @@
-import { dirname, join } from 'node: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 } from '#internal_activities';
-import { ACTIVITY_SEND_WEBHOOK, WORKFLOWS_INDEX_FILENAME, WORKFLOW_CATALOG } from '#consts';
 import { importComponents } from './loader_tools.js';
+import {
+  ACTIVITY_SEND_WEBHOOK,
+  ACTIVITY_OPTIONS_FILENAME,
+  SHARED_STEP_PREFIX,
+  WORKFLOWS_INDEX_FILENAME,
+  WORKFLOW_CATALOG
+} from '#consts';
 
 const __dirname = dirname( fileURLToPath( import.meta.url ) );
 
+/**
+ * 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
  *
@@ -16,11 +33,21 @@ const __dirname = dirname( fileURLToPath( import.meta.url ) );
  */
 export async function loadActivities( target ) {
   const activities = {};
-  for await ( const { fn, metadata, path } of importComponents( target, [ 'steps.js', 'evaluators.js' ] ) ) {
+  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[`${dirname( path )}#${metadata.name}`] = fn;
+    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;
   return activities;

package/src/worker/loader.spec.js

@@ -3,7 +3,8 @@ import { describe, it, expect, vi, beforeEach } from 'vitest';
 vi.mock( '#consts', () => ( {
   ACTIVITY_SEND_WEBHOOK: '__internal#sendWebhook',
   WORKFLOWS_INDEX_FILENAME: '__workflows_entrypoint.js',
-  WORKFLOW_CATALOG: 'catalog'
+  WORKFLOW_CATALOG: 'catalog',
+  ACTIVITY_OPTIONS_FILENAME: '__activity_options.js'
 } ) );
 
 const sendWebhookMock = vi.fn();
@@ -26,16 +27,26 @@ 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' );
 
     importComponentsMock.mockImplementationOnce( async function *() {
-      yield { fn: () => {}, metadata: { name: 'Act1' }, path: '/a/steps.js' };
+      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 );
+
+    // 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 () => {

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

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

@@ -106,6 +106,13 @@ export const toFunctionExpression = arrow => {
  */
 export const isStepsPath = value => /(^|\/)steps\.js$/.test( value );
 
+/**
+ * Check if a module specifier or request string points to shared_steps.js.
+ * @param {string} value - Module path or request string.
+ * @returns {boolean} True if it matches shared_steps.js.
+ */
+export const isSharedStepsPath = value => /(^|\/)shared_steps\.js$/.test( value );
+
 /**
  * Check if a module specifier or request string points to evaluators.js.
  * @param {string} value - Module path or request string.
@@ -215,6 +222,22 @@ export const buildStepsNameMap = ( path, cache ) => buildComponentNameMap( {
   invalidMessagePrefix: 'Invalid step name in'
 } );
 
+/**
+ * Build a map from exported shared step identifier to declared step name.
+ * Parses `shared_steps.js` for `export const X = step({ name: '...' })`.
+ * Uses the same factory as regular steps.
+ *
+ * @param {string} path - Absolute path to the shared steps module file.
+ * @param {Map<string, Map<string,string>>} cache - Cache of computed name maps.
+ * @returns {Map<string,string>} Exported identifier -> step name.
+ */
+export const buildSharedStepsNameMap = ( path, cache ) => buildComponentNameMap( {
+  path,
+  cache,
+  calleeName: 'step',
+  invalidMessagePrefix: 'Invalid shared step name in'
+} );
+
 /**
  * Build a map from exported evaluator identifier to declared evaluator name.
  * Parses `evaluators.js` for `export const X = evaluator({ name: '...' })`.

package/src/interface/metadata.js

@@ -1,4 +0,0 @@
-import { METADATA_ACCESS_SYMBOL } from '#consts';
-
-export const setMetadata = ( target, values ) =>
-  Object.defineProperty( target, METADATA_ACCESS_SYMBOL, { value: values, writable: false, enumerable: false, configurable: false } );

package/src/interface/utils.js

@@ -1,19 +0,0 @@
-/**
- * Function rigged to return the folder path of the source of calls for the interface methods (step/workflow)
- *
- * IMPORTANT!!!
- * If to refactor this, pay attention to the depth in the stack trace to extract the info.
- * Currently it is 3:
- * - 1st line is the name of the function;
- * - 2nd line is this function;
- * - 3rd line is step/workflow;
- * - 4th line is caller;
- *
- * @returns {string} The folder path of the caller
- */
-export const getInvocationDir = () => new Error()
-  .stack.split( '\n' )[3]
-  .split( ' ' )
-  .at( -1 )
-  .replace( /\((.+):\d+:\d+\)/, '$1' )
-  .split( '/' ).slice( 0, -1 ).join( '/' );