@output.ai/core 0.5.2 → 0.5.4

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

@@ -190,11 +190,14 @@ describe( 'workflow_rewriter tools', () => {
     expect( isWorkflowPath( 'steps.js' ) ).toBe( false );
   } );
 
-  it( 'isEvaluatorsPath: matches evaluators.js at root or subpath', () => {
+  it( 'isEvaluatorsPath: matches local evaluators.js but excludes shared', () => {
     expect( isEvaluatorsPath( 'evaluators.js' ) ).toBe( true );
     expect( isEvaluatorsPath( './evaluators.js' ) ).toBe( true );
     expect( isEvaluatorsPath( '/a/b/evaluators.js' ) ).toBe( true );
     expect( isEvaluatorsPath( './evaluators/quality.js' ) ).toBe( true );
+    // Shared evaluators should NOT match (path traversal or /shared/)
+    expect( isEvaluatorsPath( '../evaluators.js' ) ).toBe( false );
+    expect( isEvaluatorsPath( '../../shared/evaluators/common.js' ) ).toBe( false );
     expect( isEvaluatorsPath( 'evaluators.ts' ) ).toBe( false );
     expect( isEvaluatorsPath( 'steps.js' ) ).toBe( false );
   } );

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

@@ -3,12 +3,14 @@ import {
   buildWorkflowNameMap,
   getLocalNameFromDestructuredProperty,
   isEvaluatorsPath,
+  isSharedEvaluatorsPath,
   isSharedStepsPath,
   isStepsPath,
   isWorkflowPath,
   buildStepsNameMap,
   buildSharedStepsNameMap,
   buildEvaluatorsNameMap,
+  buildSharedEvaluatorsNameMap,
   toAbsolutePath
 } from '../tools.js';
 import {
@@ -25,6 +27,46 @@ import {
 // Handle CJS/ESM interop for Babel packages when executed as a webpack loader
 const traverse = traverseModule.default ?? traverseModule;
 
+const unresolvedImportError = ( name, fileLabel, filePath ) =>
+  new Error(
+    `Unresolved import '${name}' from ${fileLabel} file '${filePath}'. ` +
+    'This export may have been defined with the wrong component type. ' +
+    'Use the matching factory function for the file ' +
+    '(e.g. step() in steps files, evaluator() in evaluators files, workflow() in workflow files).'
+  );
+
+const removeRequireDeclarator = path => {
+  if ( isVariableDeclaration( path.parent ) && path.parent.declarations.length === 1 ) {
+    path.parentPath.remove();
+  } else {
+    path.remove();
+  }
+};
+
+const collectDestructuredRequires = ( path, absolutePath, req, descriptors ) => {
+  const propFilter = p => isObjectProperty( p ) && isIdentifier( p.key );
+  for ( const { match, buildMap, cache, target, valueKey, label } of descriptors ) {
+    if ( !match( req ) ) {
+      continue;
+    }
+    const nameMap = buildMap( absolutePath, cache );
+    for ( const prop of path.node.id.properties.filter( propFilter ) ) {
+      const importedName = prop.key.name;
+      const localName = getLocalNameFromDestructuredProperty( prop );
+      if ( localName ) {
+        const resolved = nameMap.get( importedName );
+        if ( resolved ) {
+          target.push( { localName, [valueKey]: resolved } );
+        } else {
+          throw unresolvedImportError( importedName, label, absolutePath );
+        }
+      }
+    }
+    removeRequireDeclarator( path );
+    return;
+  }
+};
+
 /**
  * Collect and strip target imports and requires from an AST, producing
  * step/workflow import mappings for later rewrites.
@@ -38,22 +80,28 @@ 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, sharedStepsNameCache } ) {
+export default function collectTargetImports(
+  ast, fileDir,
+  { stepsNameCache, workflowNameCache, evaluatorsNameCache, sharedStepsNameCache, sharedEvaluatorsNameCache }
+) {
   const stepImports = [];
   const sharedStepImports = [];
   const flowImports = [];
   const evaluatorImports = [];
+  const sharedEvaluatorImports = [];
 
   traverse( ast, {
     ImportDeclaration: path => {
       const src = path.node.source.value;
       // Ignore other imports
-      if ( !isStepsPath( src ) && !isSharedStepsPath( src ) && !isWorkflowPath( src ) && !isEvaluatorsPath( src ) ) {
+      const isTargetImport = isStepsPath( src ) || isSharedStepsPath( src ) ||
+        isWorkflowPath( src ) || isEvaluatorsPath( src ) || isSharedEvaluatorsPath( src );
+      if ( !isTargetImport ) {
         return;
       }
 
       const absolutePath = toAbsolutePath( fileDir, src );
-      const collectNamedImports = ( match, buildMapFn, cache, targetArr, valueKey ) => {
+      const collectNamedImports = ( match, buildMapFn, cache, targetArr, valueKey, fileLabel ) => {
         if ( !match ) {
           return;
         }
@@ -66,13 +114,19 @@ export default function collectTargetImports( ast, fileDir, { stepsNameCache, wo
             const entry = { localName };
             entry[valueKey] = value;
             targetArr.push( entry );
+          } else {
+            throw unresolvedImportError( importedName, fileLabel, absolutePath );
           }
         }
       };
 
-      collectNamedImports( isStepsPath( src ), buildStepsNameMap, stepsNameCache, stepImports, 'stepName' );
-      collectNamedImports( isSharedStepsPath( src ), buildSharedStepsNameMap, sharedStepsNameCache, sharedStepImports, 'stepName' );
-      collectNamedImports( isEvaluatorsPath( src ), buildEvaluatorsNameMap, evaluatorsNameCache, evaluatorImports, 'evaluatorName' );
+      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'
+      );
       if ( isWorkflowPath( src ) ) {
         const { named, default: defName } = buildWorkflowNameMap( absolutePath, workflowNameCache );
         for ( const s of path.node.specifiers ) {
@@ -85,6 +139,8 @@ export default function collectTargetImports( ast, fileDir, { stepsNameCache, wo
             const workflowName = named.get( importedName );
             if ( workflowName ) {
               flowImports.push( { localName, workflowName } );
+            } else {
+              throw unresolvedImportError( importedName, 'workflow', absolutePath );
             }
           }
         }
@@ -93,90 +149,73 @@ export default function collectTargetImports( ast, fileDir, { stepsNameCache, wo
     },
     VariableDeclarator: path => {
       const init = path.node.init;
-      // Not a require call
       if ( !isCallExpression( init ) ) {
         return;
       }
-      // Different callee
       if ( !isIdentifier( init.callee, { name: 'require' } ) ) {
         return;
       }
       const firstArgument = init.arguments[0];
-      // Dynamic require is not supported
       if ( !isStringLiteral( firstArgument ) ) {
         return;
       }
 
       const req = firstArgument.value;
-      // Must be steps/workflows module
-      if ( !isStepsPath( req ) && !isSharedStepsPath( req ) && !isWorkflowPath( req ) && !isEvaluatorsPath( req ) ) {
+      const isTargetRequire = isStepsPath( req ) || isSharedStepsPath( req ) ||
+        isWorkflowPath( req ) || isEvaluatorsPath( req ) || isSharedEvaluatorsPath( req );
+      if ( !isTargetRequire ) {
         return;
       }
 
       const absolutePath = toAbsolutePath( fileDir, req );
-      if ( isStepsPath( req ) && isObjectPattern( path.node.id ) ) {
-        const nameMap = buildStepsNameMap( absolutePath, 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 ) {
-              stepImports.push( { localName, stepName } );
-            }
-          }
-        }
-        if ( isVariableDeclaration( path.parent ) && path.parent.declarations.length === 1 ) {
-          path.parentPath.remove();
-        } 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 ) ) ) {
-          const importedName = prop.key.name;
-          const localName = getLocalNameFromDestructuredProperty( prop );
-          if ( localName ) {
-            const evaluatorName = nameMap.get( importedName );
-            if ( evaluatorName ) {
-              evaluatorImports.push( { localName, evaluatorName } );
-            }
+
+      // Destructured requires: const { X } = require('./steps.js')
+      if ( isObjectPattern( path.node.id ) ) {
+        const cjsDescriptors = [
+          {
+            match: isStepsPath, buildMap: buildStepsNameMap,
+            cache: stepsNameCache, target: stepImports,
+            valueKey: 'stepName', label: 'steps'
+          },
+          {
+            match: isSharedStepsPath, buildMap: buildSharedStepsNameMap,
+            cache: sharedStepsNameCache ?? stepsNameCache,
+            target: sharedStepImports,
+            valueKey: 'stepName', label: 'shared steps'
+          },
+          {
+            match: isEvaluatorsPath, buildMap: buildEvaluatorsNameMap,
+            cache: evaluatorsNameCache, target: evaluatorImports,
+            valueKey: 'evaluatorName', label: 'evaluators'
+          },
+          {
+            match: isSharedEvaluatorsPath, buildMap: buildSharedEvaluatorsNameMap,
+            cache: sharedEvaluatorsNameCache ?? evaluatorsNameCache,
+            target: sharedEvaluatorImports,
+            valueKey: 'evaluatorName', label: 'shared evaluators'
+          },
+          {
+            match: isWorkflowPath,
+            buildMap: ( p, c ) => buildWorkflowNameMap( p, c ).named,
+            cache: workflowNameCache, target: flowImports,
+            valueKey: 'workflowName', label: 'workflow'
           }
-        }
-        if ( isVariableDeclaration( path.parent ) && path.parent.declarations.length === 1 ) {
-          path.parentPath.remove();
-        } else {
-          path.remove();
-        }
-      } else if ( isWorkflowPath( req ) && isIdentifier( path.node.id ) ) {
+        ];
+        collectDestructuredRequires(
+          path, absolutePath, req, cjsDescriptors
+        );
+        return;
+      }
+
+      // Default workflow require: const WF = require('./workflow.js')
+      if ( isWorkflowPath( req ) && isIdentifier( path.node.id ) ) {
         const { default: defName } = buildWorkflowNameMap( absolutePath, workflowNameCache );
         const localName = path.node.id.name;
         flowImports.push( { localName, workflowName: defName ?? localName } );
-        if ( isVariableDeclaration( path.parent ) && path.parent.declarations.length === 1 ) {
-          path.parentPath.remove();
-        } else {
-          path.remove();
-        }
+        removeRequireDeclarator( path );
       }
     }
   } );
 
-  return { stepImports, sharedStepImports, evaluatorImports, flowImports };
+  return { stepImports, sharedStepImports, evaluatorImports, sharedEvaluatorImports, flowImports };
 };

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

@@ -1,5 +1,5 @@
 import { describe, it, expect } from 'vitest';
-import { mkdtempSync, writeFileSync, rmSync } from 'node:fs';
+import { mkdtempSync, mkdirSync, writeFileSync, rmSync } from 'node:fs';
 import { tmpdir } from 'node:os';
 import { join } from 'node:path';
 import { parse } from '../tools.js';
@@ -75,5 +75,255 @@ const obj = {};`;
 
     rmSync( dir, { recursive: true, force: true } );
   } );
+
+  it( 'throws when ESM import from evaluators.js uses step() instead of evaluator()', () => {
+    const dir = mkdtempSync( join( tmpdir(), 'collect-esm-mismatch-eval-' ) );
+    writeFileSync( join( dir, 'evaluators.js' ), 'export const BadExport = step({ name: \'bad\' });' );
+
+    const source = 'import { BadExport } from \'./evaluators.js\';';
+    const ast = makeAst( source, join( dir, 'file.js' ) );
+
+    expect( () => collectTargetImports(
+      ast,
+      dir,
+      { stepsNameCache: new Map(), evaluatorsNameCache: new Map(), workflowNameCache: new Map() }
+    ) ).toThrow( /Unresolved import 'BadExport' from evaluators file/ );
+
+    rmSync( dir, { recursive: true, force: true } );
+  } );
+
+  it( 'throws when ESM import from steps.js uses evaluator() instead of step()', () => {
+    const dir = mkdtempSync( join( tmpdir(), 'collect-esm-mismatch-step-' ) );
+    writeFileSync( join( dir, 'steps.js' ), 'export const BadExport = evaluator({ name: \'bad\' });' );
+
+    const source = 'import { BadExport } from \'./steps.js\';';
+    const ast = makeAst( source, join( dir, 'file.js' ) );
+
+    expect( () => collectTargetImports(
+      ast,
+      dir,
+      { stepsNameCache: new Map(), evaluatorsNameCache: new Map(), workflowNameCache: new Map() }
+    ) ).toThrow( /Unresolved import 'BadExport' from steps file/ );
+
+    rmSync( dir, { recursive: true, force: true } );
+  } );
+
+  it( 'throws when CJS require from evaluators.js uses step() instead of evaluator()', () => {
+    const dir = mkdtempSync( join( tmpdir(), 'collect-cjs-mismatch-eval-' ) );
+    writeFileSync( join( dir, 'evaluators.js' ), 'export const BadExport = step({ name: \'bad\' });' );
+
+    const source = 'const { BadExport } = require( \'./evaluators.js\' );';
+    const ast = makeAst( source, join( dir, 'file.js' ) );
+
+    expect( () => collectTargetImports(
+      ast,
+      dir,
+      { stepsNameCache: new Map(), evaluatorsNameCache: new Map(), workflowNameCache: new Map() }
+    ) ).toThrow( /Unresolved import 'BadExport' from evaluators file/ );
+
+    rmSync( dir, { recursive: true, force: true } );
+  } );
+
+  it( 'throws when CJS require from steps.js uses evaluator() instead of step()', () => {
+    const dir = mkdtempSync( join( tmpdir(), 'collect-cjs-mismatch-step-' ) );
+    writeFileSync( join( dir, 'steps.js' ), 'export const BadExport = evaluator({ name: \'bad\' });' );
+
+    const source = 'const { BadExport } = require( \'./steps.js\' );';
+    const ast = makeAst( source, join( dir, 'file.js' ) );
+
+    expect( () => collectTargetImports(
+      ast,
+      dir,
+      { stepsNameCache: new Map(), evaluatorsNameCache: new Map(), workflowNameCache: new Map() }
+    ) ).toThrow( /Unresolved import 'BadExport' from steps file/ );
+
+    rmSync( dir, { recursive: true, force: true } );
+  } );
+
+  it( 'throws when ESM import from workflow.js has non-workflow export', () => {
+    const dir = mkdtempSync( join( tmpdir(), 'collect-esm-mismatch-wf-' ) );
+    writeFileSync( join( dir, 'workflow.js' ), 'export const helper = () => 42;' );
+
+    const source = 'import { helper } from \'./workflow.js\';';
+    const ast = makeAst( source, join( dir, 'file.js' ) );
+
+    expect( () => collectTargetImports(
+      ast,
+      dir,
+      { stepsNameCache: new Map(), evaluatorsNameCache: new Map(), workflowNameCache: new Map() }
+    ) ).toThrow( /Unresolved import 'helper' from workflow file/ );
+
+    rmSync( dir, { recursive: true, force: true } );
+  } );
+
+  it( 'throws when CJS destructured require from workflow.js has non-workflow export', () => {
+    const dir = mkdtempSync( join( tmpdir(), 'collect-cjs-mismatch-wf-' ) );
+    writeFileSync( join( dir, 'workflow.js' ), 'export const helper = () => 42;' );
+
+    const source = 'const { helper } = require( \'./workflow.js\' );';
+    const ast = makeAst( source, join( dir, 'file.js' ) );
+
+    expect( () => collectTargetImports(
+      ast,
+      dir,
+      { stepsNameCache: new Map(), evaluatorsNameCache: new Map(), workflowNameCache: new Map() }
+    ) ).toThrow( /Unresolved import 'helper' from workflow file/ );
+
+    rmSync( dir, { recursive: true, force: true } );
+  } );
+
+  it( 'collects CJS destructured require from workflow.js', () => {
+    const dir = mkdtempSync( join( tmpdir(), 'collect-cjs-wf-destruct-' ) );
+    writeFileSync( join( dir, 'workflow.js' ), 'export const FlowX = workflow({ name: \'flow.x\' });' );
+
+    const source = 'const { FlowX } = require( \'./workflow.js\' );\nconst obj = {};';
+    const ast = makeAst( source, join( dir, 'file.js' ) );
+
+    const { flowImports } = collectTargetImports(
+      ast,
+      dir,
+      { stepsNameCache: new Map(), evaluatorsNameCache: new Map(), workflowNameCache: new Map() }
+    );
+    expect( flowImports ).toEqual( [ { localName: 'FlowX', workflowName: 'flow.x' } ] );
+
+    rmSync( dir, { recursive: true, force: true } );
+  } );
+
+  it( 'collects ESM shared evaluator imports', () => {
+    const dir = mkdtempSync( join( tmpdir(), 'collect-esm-shared-eval-' ) );
+    mkdirSync( join( dir, 'shared', 'evaluators' ), { recursive: true } );
+    mkdirSync( join( dir, 'workflows', 'my_workflow' ), { recursive: true } );
+    writeFileSync(
+      join( dir, 'shared', 'evaluators', 'common.js' ),
+      'export const SharedEval = evaluator({ name: \'shared.eval\' });'
+    );
+
+    const source = 'import { SharedEval } from \'../../shared/evaluators/common.js\';';
+    const ast = makeAst( source, join( dir, 'workflows', 'my_workflow', 'workflow.js' ) );
+
+    const { sharedEvaluatorImports } = collectTargetImports(
+      ast,
+      join( dir, 'workflows', 'my_workflow' ),
+      { stepsNameCache: new Map(), evaluatorsNameCache: new Map(), sharedEvaluatorsNameCache: new Map(), workflowNameCache: new Map() }
+    );
+    expect( sharedEvaluatorImports ).toEqual( [ { localName: 'SharedEval', evaluatorName: 'shared.eval' } ] );
+
+    rmSync( dir, { recursive: true, force: true } );
+  } );
+
+  it( 'collects CJS shared evaluator requires', () => {
+    const dir = mkdtempSync( join( tmpdir(), 'collect-cjs-shared-eval-' ) );
+    mkdirSync( join( dir, 'shared', 'evaluators' ), { recursive: true } );
+    mkdirSync( join( dir, 'workflows', 'my_workflow' ), { recursive: true } );
+    writeFileSync(
+      join( dir, 'shared', 'evaluators', 'common.js' ),
+      'export const SharedEval = evaluator({ name: \'shared.eval\' });'
+    );
+
+    const source = 'const { SharedEval } = require( \'../../shared/evaluators/common.js\' );';
+    const ast = makeAst( source, join( dir, 'workflows', 'my_workflow', 'workflow.js' ) );
+
+    const { sharedEvaluatorImports } = collectTargetImports(
+      ast,
+      join( dir, 'workflows', 'my_workflow' ),
+      { stepsNameCache: new Map(), evaluatorsNameCache: new Map(), sharedEvaluatorsNameCache: new Map(), workflowNameCache: new Map() }
+    );
+    expect( sharedEvaluatorImports ).toEqual( [ { localName: 'SharedEval', evaluatorName: 'shared.eval' } ] );
+
+    rmSync( dir, { recursive: true, force: true } );
+  } );
+
+  it( 'collects CJS shared steps requires', () => {
+    const dir = mkdtempSync( join( tmpdir(), 'collect-cjs-shared-step-' ) );
+    mkdirSync( join( dir, 'shared', 'steps' ), { recursive: true } );
+    mkdirSync( join( dir, 'workflows', 'my_workflow' ), { recursive: true } );
+    writeFileSync(
+      join( dir, 'shared', 'steps', 'common.js' ),
+      'export const SharedA = step({ name: \'shared.a\' });'
+    );
+
+    const source = 'const { SharedA } = require( \'../../shared/steps/common.js\' );';
+    const ast = makeAst( source, join( dir, 'workflows', 'my_workflow', 'workflow.js' ) );
+
+    const { sharedStepImports } = collectTargetImports(
+      ast,
+      join( dir, 'workflows', 'my_workflow' ),
+      {
+        stepsNameCache: new Map(), sharedStepsNameCache: new Map(),
+        evaluatorsNameCache: new Map(), sharedEvaluatorsNameCache: new Map(),
+        workflowNameCache: new Map()
+      }
+    );
+    expect( sharedStepImports ).toEqual( [ { localName: 'SharedA', stepName: 'shared.a' } ] );
+
+    rmSync( dir, { recursive: true, force: true } );
+  } );
+
+  it( 'throws when CJS shared steps require uses evaluator() instead of step()', () => {
+    const dir = mkdtempSync( join( tmpdir(), 'collect-cjs-shared-step-mismatch-' ) );
+    mkdirSync( join( dir, 'shared', 'steps' ), { recursive: true } );
+    mkdirSync( join( dir, 'workflows', 'my_workflow' ), { recursive: true } );
+    writeFileSync(
+      join( dir, 'shared', 'steps', 'common.js' ),
+      'export const BadExport = evaluator({ name: \'bad\' });'
+    );
+
+    const source = 'const { BadExport } = require( \'../../shared/steps/common.js\' );';
+    const ast = makeAst( source, join( dir, 'workflows', 'my_workflow', 'workflow.js' ) );
+
+    expect( () => collectTargetImports(
+      ast,
+      join( dir, 'workflows', 'my_workflow' ),
+      {
+        stepsNameCache: new Map(), sharedStepsNameCache: new Map(),
+        evaluatorsNameCache: new Map(), sharedEvaluatorsNameCache: new Map(),
+        workflowNameCache: new Map()
+      }
+    ) ).toThrow( /Unresolved import 'BadExport' from shared steps file/ );
+
+    rmSync( dir, { recursive: true, force: true } );
+  } );
+
+  it( 'throws when CJS shared evaluator require uses step() instead of evaluator()', () => {
+    const dir = mkdtempSync( join( tmpdir(), 'collect-cjs-shared-eval-mismatch-' ) );
+    mkdirSync( join( dir, 'shared', 'evaluators' ), { recursive: true } );
+    mkdirSync( join( dir, 'workflows', 'my_workflow' ), { recursive: true } );
+    writeFileSync(
+      join( dir, 'shared', 'evaluators', 'common.js' ),
+      'export const BadExport = step({ name: \'bad\' });'
+    );
+
+    const source = 'const { BadExport } = require( \'../../shared/evaluators/common.js\' );';
+    const ast = makeAst( source, join( dir, 'workflows', 'my_workflow', 'workflow.js' ) );
+
+    expect( () => collectTargetImports(
+      ast,
+      join( dir, 'workflows', 'my_workflow' ),
+      { stepsNameCache: new Map(), evaluatorsNameCache: new Map(), sharedEvaluatorsNameCache: new Map(), workflowNameCache: new Map() }
+    ) ).toThrow( /Unresolved import 'BadExport' from shared evaluators file/ );
+
+    rmSync( dir, { recursive: true, force: true } );
+  } );
+
+  it( 'throws when ESM shared evaluator import uses step() instead of evaluator()', () => {
+    const dir = mkdtempSync( join( tmpdir(), 'collect-esm-shared-eval-mismatch-' ) );
+    mkdirSync( join( dir, 'shared', 'evaluators' ), { recursive: true } );
+    mkdirSync( join( dir, 'workflows', 'my_workflow' ), { recursive: true } );
+    writeFileSync(
+      join( dir, 'shared', 'evaluators', 'common.js' ),
+      'export const BadExport = step({ name: \'bad\' });'
+    );
+
+    const source = 'import { BadExport } from \'../../shared/evaluators/common.js\';';
+    const ast = makeAst( source, join( dir, 'workflows', 'my_workflow', 'workflow.js' ) );
+
+    expect( () => collectTargetImports(
+      ast,
+      join( dir, 'workflows', 'my_workflow' ),
+      { stepsNameCache: new Map(), evaluatorsNameCache: new Map(), sharedEvaluatorsNameCache: new Map(), workflowNameCache: new Map() }
+    ) ).toThrow( /Unresolved import 'BadExport' from shared evaluators file/ );
+
+    rmSync( dir, { recursive: true, force: true } );
+  } );
 } );
 

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

@@ -12,6 +12,7 @@ const generate = generatorModule.default ?? generatorModule;
 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 sharedEvaluatorsNameCache = new Map(); // path -> Map<exported, evaluatorName> (shared)
 const workflowNameCache = new Map(); // path -> { default?: name, named: Map<exported, flowName> }
 
 /**
@@ -27,20 +28,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, sharedStepsNameCache, evaluatorsNameCache, workflowNameCache };
+  const cache = { stepsNameCache, sharedStepsNameCache, evaluatorsNameCache, sharedEvaluatorsNameCache, workflowNameCache };
 
   try {
     const filename = this.resourcePath;
     const ast = parse( String( source ), filename );
     const fileDir = dirname( filename );
-    const { stepImports, sharedStepImports, evaluatorImports, flowImports } = collectTargetImports( ast, fileDir, cache );
+    const { stepImports, sharedStepImports, evaluatorImports, sharedEvaluatorImports, flowImports } = collectTargetImports( ast, fileDir, cache );
 
     // No imports
-    if ( [].concat( stepImports, sharedStepImports, evaluatorImports, flowImports ).length === 0 ) {
+    if ( [].concat( stepImports, sharedStepImports, evaluatorImports, sharedEvaluatorImports, flowImports ).length === 0 ) {
       return callback( null, source, inputMap );
     }
 
-    const rewrote = rewriteFnBodies( { ast, stepImports, sharedStepImports, evaluatorImports, flowImports } );
+    const rewrote = rewriteFnBodies( { ast, stepImports, sharedStepImports, evaluatorImports, sharedEvaluatorImports, flowImports } );
     // No edits performed
     if ( !rewrote ) {
       return callback( null, source, inputMap );

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

@@ -148,6 +148,54 @@ const obj = { fn: async () => { StepC(); FlowC(); FlowDef(); } }`;
     rmSync( dir, { recursive: true, force: true } );
   } );
 
+  it( 'rewrites ESM shared evaluator imports to invokeSharedEvaluator', async () => {
+    const dir = mkdtempSync( join( tmpdir(), 'ast-loader-esm-shared-eval-' ) );
+    mkdirSync( join( dir, 'shared', 'evaluators' ), { recursive: true } );
+    mkdirSync( join( dir, 'workflows', 'my_workflow' ), { recursive: true } );
+    writeFileSync( join( dir, 'shared', 'evaluators', 'common.js' ), 'export const SharedEval = evaluator({ name: \'shared.eval\' });' );
+
+    const source = `
+import { SharedEval } from '../../shared/evaluators/common.js';
+
+const obj = {
+  fn: async (x) => {
+    SharedEval(1);
+  }
+}`;
+
+    const { code } = await runLoader( source, join( dir, 'workflows', 'my_workflow', 'workflow.js' ) );
+
+    expect( code ).not.toMatch( /from '\.\.\/\.\.\/shared\/evaluators\/common\.js'/ );
+    expect( code ).toMatch( /fn:\s*async function \(x\)/ );
+    expect( code ).toMatch( /this\.invokeSharedEvaluator\('shared\.eval',\s*1\)/ );
+
+    rmSync( dir, { recursive: true, force: true } );
+  } );
+
+  it( 'rewrites CJS shared evaluator requires to invokeSharedEvaluator', async () => {
+    const dir = mkdtempSync( join( tmpdir(), 'ast-loader-cjs-shared-eval-' ) );
+    mkdirSync( join( dir, 'shared', 'evaluators' ), { recursive: true } );
+    mkdirSync( join( dir, 'workflows', 'my_workflow' ), { recursive: true } );
+    writeFileSync( join( dir, 'shared', 'evaluators', 'common.js' ), 'export const SharedEval = evaluator({ name: \'shared.eval\' });' );
+
+    const source = `
+const { SharedEval } = require( '../../shared/evaluators/common.js' );
+
+const obj = {
+  fn: async (y) => {
+    SharedEval();
+  }
+}`;
+
+    const { code } = await runLoader( source, join( dir, 'workflows', 'my_workflow', 'workflow.js' ) );
+
+    expect( code ).not.toMatch( /require\('\.\.\/\.\.\/shared\/evaluators\/common\.js'\)/ );
+    expect( code ).toMatch( /fn:\s*async function \(y\)/ );
+    expect( code ).toMatch( /this\.invokeSharedEvaluator\('shared\.eval'\)/ );
+
+    rmSync( dir, { recursive: true, force: true } );
+  } );
+
   it( 'throws on non-static name', async () => {
     const dir = mkdtempSync( join( tmpdir(), 'ast-loader-error-' ) );
     writeFileSync( join( dir, 'steps.js' ), `

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

@@ -156,13 +156,14 @@ const processFunction = ( { name, bindingPath, state, descriptors, processedFns
  * @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, sharedStepImports = [], evaluatorImports, flowImports } ) {
+export default function rewriteFnBodies( { ast, stepImports, sharedStepImports = [], evaluatorImports, sharedEvaluatorImports = [], flowImports } ) {
   const state = { rewrote: false };
   // Build rewrite descriptors once per traversal
   const descriptors = [
     { list: stepImports, method: 'invokeStep', key: 'stepName' },
     { list: sharedStepImports, method: 'invokeSharedStep', key: 'stepName' },
     { list: evaluatorImports, method: 'invokeEvaluator', key: 'evaluatorName' },
+    { list: sharedEvaluatorImports, method: 'invokeSharedEvaluator', key: 'evaluatorName' },
     { list: flowImports, method: 'startWorkflow', key: 'workflowName' }
   ];
   traverse( ast, {