@outputai/core 0.10.0 → 0.10.1-next.09ed166.0

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

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

@@ -5,327 +5,130 @@ import { join } from 'node:path';
 import { parse } from '../tools.js';
 import collectTargetImports from './collect_target_imports.js';
 
-function makeAst( source, filename ) {
-  return parse( source, filename );
-}
+const caches = () => ( {
+  stepsNameCache: new Map(),
+  evaluatorsNameCache: new Map(),
+  sharedStepsNameCache: new Map(),
+  sharedEvaluatorsNameCache: new Map()
+} );
+
+const makeAst = ( source, filename ) => parse( source, filename );
 
 describe( 'collect_target_imports', () => {
-  it( 'collects ESM imports for steps and evaluators and leaves workflow imports intact', () => {
+  it( 'collects ESM activity imports and leaves workflow imports intact', () => {
     const dir = mkdtempSync( join( tmpdir(), 'collect-esm-' ) );
-    writeFileSync( join( dir, 'steps.js' ), `
-export const StepA = step({ name: 'step.a' });
-export const StepB = step({ name: 'step.b' });` );
+    writeFileSync( join( dir, 'steps.js' ), 'export const StepA = step({ name: \'step.a\' });' );
     writeFileSync( join( dir, 'evaluators.js' ), 'export const EvalA = evaluator({ name: \'eval.a\' });' );
-    writeFileSync( join( dir, 'workflow.js' ), `
-export const FlowA = workflow({ name: 'flow.a' });
-export default workflow({ name: 'flow.def' });` );
+    writeFileSync( join( dir, 'workflow.js' ), 'export const FlowA = workflow({ name: \'flow.a\' });' );
 
-    const source = `
+    const ast = makeAst( `
 import { StepA } from './steps.js';
 import { EvalA } from './evaluators.js';
-import WF, { FlowA } from './workflow.js';
-const x = 1;`;
+import { FlowA } from './workflow.js';`, join( dir, 'file.js' ) );
 
-    const ast = makeAst( source, join( dir, 'file.js' ) );
-    const { stepImports, evaluatorImports } = collectTargetImports(
-      ast,
-      dir,
-      { stepsNameCache: new Map(), evaluatorsNameCache: new Map() }
-    );
-    expect( evaluatorImports ).toEqual( [ { localName: 'EvalA', evaluatorName: 'eval.a' } ] );
+    const { activityImports } = collectTargetImports( ast, dir, caches() );
 
-    expect( stepImports ).toEqual( [ { localName: 'StepA', stepName: 'step.a' } ] );
+    expect( activityImports ).toEqual( [
+      { localName: 'StepA', activityName: 'step.a' },
+      { localName: 'EvalA', activityName: 'eval.a' }
+    ] );
     expect( ast.program.body.find( n => n.type === 'ImportDeclaration' )?.source.value ).toBe( './workflow.js' );
-
     rmSync( dir, { recursive: true, force: true } );
   } );
 
-  it( 'collects CJS requires for steps and evaluators and leaves workflow requires intact', () => {
+  it( 'collects CJS activity requires and leaves workflow requires intact', () => {
     const dir = mkdtempSync( join( tmpdir(), 'collect-cjs-' ) );
-    writeFileSync( join( dir, 'steps.js' ), 'export const StepB = step({ name: \'step.b\' })' );
-    writeFileSync( join( dir, 'evaluators.js' ), 'export const EvalB = evaluator({ name: \'eval.b\' })' );
-    writeFileSync( join( dir, 'workflow.js' ), 'export default workflow({ name: \'flow.c\' })' );
-
-    const source = `
-const { StepB } = require( './steps.js' );
-const { EvalB } = require( './evaluators.js' );
-const WF = require( './workflow.js' );
-const obj = {};`;
-
-    const ast = makeAst( source, join( dir, 'file.js' ) );
-    const { stepImports, evaluatorImports } = collectTargetImports(
-      ast,
-      dir,
-      { stepsNameCache: new Map(), evaluatorsNameCache: new Map() }
-    );
-    expect( evaluatorImports ).toEqual( [ { localName: 'EvalB', evaluatorName: 'eval.b' } ] );
-
-    expect( stepImports ).toEqual( [ { localName: 'StepB', stepName: 'step.b' } ] );
-    // Only non-target require declarators should remain.
-    const hasRequireDecl = ast.program.body.some( n =>
-      n.type === 'VariableDeclaration' && n.declarations.some( d => d.init && d.init.type === 'CallExpression' )
-    );
-    expect( hasRequireDecl ).toBe( true );
-
-    rmSync( dir, { recursive: true, force: true } );
-  } );
-
-  it( 'resolves ESM import from evaluators.js regardless of callee name', () => {
-    const dir = mkdtempSync( join( tmpdir(), 'collect-esm-mismatch-eval-' ) );
-    writeFileSync( join( dir, 'evaluators.js' ), 'export const MyExport = step({ name: \'bad\' });' );
-
-    const source = 'import { MyExport } from \'./evaluators.js\';';
-    const ast = makeAst( source, join( dir, 'file.js' ) );
-
-    const { evaluatorImports } = collectTargetImports(
-      ast,
-      dir,
-      { stepsNameCache: new Map(), evaluatorsNameCache: new Map() }
-    );
-    expect( evaluatorImports ).toEqual( [ { localName: 'MyExport', evaluatorName: 'bad' } ] );
-
-    rmSync( dir, { recursive: true, force: true } );
-  } );
-
-  it( 'resolves ESM import from steps.js regardless of callee name', () => {
-    const dir = mkdtempSync( join( tmpdir(), 'collect-esm-mismatch-step-' ) );
-    writeFileSync( join( dir, 'steps.js' ), 'export const MyExport = evaluator({ name: \'bad\' });' );
-
-    const source = 'import { MyExport } from \'./steps.js\';';
-    const ast = makeAst( source, join( dir, 'file.js' ) );
-
-    const { stepImports } = collectTargetImports(
-      ast,
-      dir,
-      { stepsNameCache: new Map(), evaluatorsNameCache: new Map() }
-    );
-    expect( stepImports ).toEqual( [ { localName: 'MyExport', stepName: 'bad' } ] );
-
-    rmSync( dir, { recursive: true, force: true } );
-  } );
-
-  it( 'resolves CJS require from evaluators.js regardless of callee name', () => {
-    const dir = mkdtempSync( join( tmpdir(), 'collect-cjs-mismatch-eval-' ) );
-    writeFileSync( join( dir, 'evaluators.js' ), 'export const MyExport = step({ name: \'bad\' });' );
-
-    const source = 'const { MyExport } = require( \'./evaluators.js\' );';
-    const ast = makeAst( source, join( dir, 'file.js' ) );
-
-    const { evaluatorImports } = collectTargetImports(
-      ast,
-      dir,
-      { stepsNameCache: new Map(), evaluatorsNameCache: new Map() }
-    );
-    expect( evaluatorImports ).toEqual( [ { localName: 'MyExport', evaluatorName: 'bad' } ] );
-
-    rmSync( dir, { recursive: true, force: true } );
-  } );
-
-  it( 'resolves CJS require from steps.js regardless of callee name', () => {
-    const dir = mkdtempSync( join( tmpdir(), 'collect-cjs-mismatch-step-' ) );
-    writeFileSync( join( dir, 'steps.js' ), 'export const MyExport = evaluator({ name: \'bad\' });' );
-
-    const source = 'const { MyExport } = require( \'./steps.js\' );';
-    const ast = makeAst( source, join( dir, 'file.js' ) );
-
-    const { stepImports } = collectTargetImports(
-      ast,
-      dir,
-      { stepsNameCache: new Map(), evaluatorsNameCache: new Map() }
-    );
-    expect( stepImports ).toEqual( [ { localName: 'MyExport', stepName: 'bad' } ] );
-
-    rmSync( dir, { recursive: true, force: true } );
-  } );
-
-  it( 'leaves ESM imports from workflow.js alone', () => {
-    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() }
-    ) ).not.toThrow();
-    expect( ast.program.body.find( n => n.type === 'ImportDeclaration' )?.source.value ).toBe( './workflow.js' );
-
-    rmSync( dir, { recursive: true, force: true } );
-  } );
-
-  it( 'leaves CJS requires from workflow.js alone', () => {
-    const dir = mkdtempSync( join( tmpdir(), 'collect-cjs-mismatch-wf-' ) );
+    writeFileSync( join( dir, 'steps.js' ), 'export const StepB = step({ name: \'step.b\' });' );
+    writeFileSync( join( dir, 'evaluators.js' ), 'export const EvalB = evaluator({ name: \'eval.b\' });' );
     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() }
-    ) ).not.toThrow();
-    expect( ast.program.body.some( n => n.type === 'VariableDeclaration' ) ).toBe( true );
-
-    rmSync( dir, { recursive: true, force: true } );
-  } );
-
-  it( 'does not collect 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 ast = makeAst( `
+const { StepB } = require('./steps.js');
+const { EvalB } = require('./evaluators.js');
+const { helper } = require('./workflow.js');`, join( dir, 'file.js' ) );
 
-    const source = 'const { FlowX } = require( \'./workflow.js\' );\nconst obj = {};';
-    const ast = makeAst( source, join( dir, 'file.js' ) );
+    const { activityImports } = collectTargetImports( ast, dir, caches() );
 
-    collectTargetImports(
-      ast,
-      dir,
-      { stepsNameCache: new Map(), evaluatorsNameCache: new Map() }
-    );
+    expect( activityImports ).toEqual( [
+      { localName: 'StepB', activityName: 'step.b' },
+      { localName: 'EvalB', activityName: 'eval.b' }
+    ] );
     expect( ast.program.body.some( n => n.type === 'VariableDeclaration' ) ).toBe( true );
-
     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() }
-    );
-    expect( sharedEvaluatorImports ).toEqual( [ { localName: 'SharedEval', evaluatorName: 'shared.eval' } ] );
-
+  it( 'uses file path to choose component type instead of factory callee name', () => {
+    const dir = mkdtempSync( join( tmpdir(), 'collect-path-scoped-' ) );
+    writeFileSync( join( dir, 'steps.js' ), 'export const StepExport = evaluator({ name: \'from.steps\' });' );
+    writeFileSync( join( dir, 'evaluators.js' ), 'export const EvalExport = step({ name: \'from.evaluators\' });' );
+
+    const esmAst = makeAst( `
+import { StepExport } from './steps.js';
+import { EvalExport } from './evaluators.js';`, join( dir, 'esm.js' ) );
+    const cjsAst = makeAst( `
+const { StepExport } = require('./steps.js');
+const { EvalExport } = require('./evaluators.js');`, join( dir, 'cjs.js' ) );
+
+    expect( collectTargetImports( esmAst, dir, caches() ).activityImports ).toEqual( [
+      { localName: 'StepExport', activityName: 'from.steps' },
+      { localName: 'EvalExport', activityName: 'from.evaluators' }
+    ] );
+    expect( collectTargetImports( cjsAst, dir, caches() ).activityImports ).toEqual( [
+      { localName: 'StepExport', activityName: 'from.steps' },
+      { localName: 'EvalExport', activityName: 'from.evaluators' }
+    ] );
     rmSync( dir, { recursive: true, force: true } );
   } );
 
-  it( 'collects CJS shared evaluator requires', () => {
-    const dir = mkdtempSync( join( tmpdir(), 'collect-cjs-shared-eval-' ) );
+  it( 'collects shared steps and evaluators from ESM and CJS imports', () => {
+    const dir = mkdtempSync( join( tmpdir(), 'collect-shared-' ) );
+    mkdirSync( join( dir, 'shared', 'steps' ), { recursive: true } );
     mkdirSync( join( dir, 'shared', 'evaluators' ), { recursive: true } );
     mkdirSync( join( dir, 'workflows', 'my_workflow' ), { recursive: true } );
+    writeFileSync( join( dir, 'shared', 'steps', 'common.js' ), 'export const SharedStep = step({ name: \'shared.step\' });' );
     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() }
-    );
-    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()
-      }
-    );
-    expect( sharedStepImports ).toEqual( [ { localName: 'SharedA', stepName: 'shared.a' } ] );
-
-    rmSync( dir, { recursive: true, force: true } );
-  } );
-
-  it( 'resolves CJS shared steps require regardless of callee name', () => {
-    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 MyExport = evaluator({ name: \'bad\' });'
-    );
-
-    const source = 'const { MyExport } = 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()
-      }
-    );
-    expect( sharedStepImports ).toEqual( [ { localName: 'MyExport', stepName: 'bad' } ] );
-
+    const fileDir = join( dir, 'workflows', 'my_workflow' );
+    const esmAst = makeAst( `
+import { SharedStep } from '../../shared/steps/common.js';
+import { SharedEval } from '../../shared/evaluators/common.js';`, join( fileDir, 'workflow.js' ) );
+    const cjsAst = makeAst( `
+const { SharedStep } = require('../../shared/steps/common.js');
+const { SharedEval } = require('../../shared/evaluators/common.js');`, join( fileDir, 'helper.js' ) );
+
+    expect( collectTargetImports( esmAst, fileDir, caches() ).activityImports ).toEqual( [
+      { localName: 'SharedStep', activityName: 'shared.step' },
+      { localName: 'SharedEval', activityName: 'shared.eval' }
+    ] );
+    expect( collectTargetImports( cjsAst, fileDir, caches() ).activityImports ).toEqual( [
+      { localName: 'SharedStep', activityName: 'shared.step' },
+      { localName: 'SharedEval', activityName: 'shared.eval' }
+    ] );
     rmSync( dir, { recursive: true, force: true } );
   } );
 
-  it( 'resolves CJS shared evaluator require regardless of callee name', () => {
-    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 MyExport = step({ name: \'bad\' });'
-    );
-
-    const source = 'const { MyExport } = require( \'../../shared/evaluators/common.js\' );';
-    const ast = makeAst( source, join( dir, 'workflows', 'my_workflow', 'workflow.js' ) );
+  it( 'leaves destructured workflow requires untouched', () => {
+    const dir = mkdtempSync( join( tmpdir(), 'collect-workflow-require-' ) );
+    writeFileSync( join( dir, 'workflow.js' ), 'export const FlowX = workflow({ name: \'flow.x\' });' );
 
-    const { sharedEvaluatorImports } = collectTargetImports(
-      ast,
-      join( dir, 'workflows', 'my_workflow' ),
-      { stepsNameCache: new Map(), evaluatorsNameCache: new Map(), sharedEvaluatorsNameCache: new Map() }
-    );
-    expect( sharedEvaluatorImports ).toEqual( [ { localName: 'MyExport', evaluatorName: 'bad' } ] );
+    const ast = makeAst( 'const { FlowX } = require(\'./workflow.js\');', join( dir, 'file.js' ) );
+    const { activityImports } = collectTargetImports( ast, dir, caches() );
 
+    expect( activityImports ).toEqual( [] );
+    expect( ast.program.body.some( n => n.type === 'VariableDeclaration' ) ).toBe( true );
     rmSync( dir, { recursive: true, force: true } );
   } );
 
-  it( 'resolves ESM shared evaluator import regardless of callee name', () => {
-    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 MyExport = step({ name: \'bad\' });'
-    );
-
-    const source = 'import { MyExport } from \'../../shared/evaluators/common.js\';';
-    const ast = makeAst( source, join( dir, 'workflows', 'my_workflow', 'workflow.js' ) );
+  it( 'throws when a named activity import cannot be resolved from the target file', () => {
+    const dir = mkdtempSync( join( tmpdir(), 'collect-unresolved-' ) );
+    writeFileSync( join( dir, 'steps.js' ), 'export const StepA = step({ name: \'step.a\' });' );
 
-    const { sharedEvaluatorImports } = collectTargetImports(
-      ast,
-      join( dir, 'workflows', 'my_workflow' ),
-      { stepsNameCache: new Map(), evaluatorsNameCache: new Map(), sharedEvaluatorsNameCache: new Map() }
-    );
-    expect( sharedEvaluatorImports ).toEqual( [ { localName: 'MyExport', evaluatorName: 'bad' } ] );
+    const ast = makeAst( 'import { MissingStep } from \'./steps.js\';', join( dir, 'file.js' ) );
 
+    expect( () => collectTargetImports( ast, dir, caches() ) ).toThrow( /Unresolved import 'MissingStep'/ );
     rmSync( dir, { recursive: true, force: true } );
   } );
-
 } );
-

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

@@ -2,7 +2,7 @@ import { dirname } from 'node:path';
 import generatorModule from '@babel/generator';
 import { parse } from '../tools.js';
 
-import rewriteFnBodies from './rewrite_fn_bodies.js';
+import rewriteActivityCalls from './rewrite_activity_calls.js';
 import collectTargetImports from './collect_target_imports.js';
 
 // Handle CJS/ESM interop for Babel packages when executed as a webpack loader
@@ -15,8 +15,8 @@ const evaluatorsNameCache = new Map(); // path -> Map<exported, evaluatorName>
 const sharedEvaluatorsNameCache = new Map(); // path -> Map<exported, evaluatorName> (shared)
 
 /**
- * Webpack loader that rewrites step/evaluator calls by reading names from
- * the respective modules and transforming `fn` bodies accordingly.
+ * Webpack loader that rewrites imported step/evaluator calls by reading
+ * declared activity names and transforming function-body activity calls accordingly.
  * Preserves sourcemaps.
  *
  * @param {string|Buffer} source - Module source code.
@@ -33,15 +33,14 @@ export default function stepImportRewriterAstLoader( source, inputMap ) {
     const filename = this.resourcePath;
     const ast = parse( String( source ), filename );
     const fileDir = dirname( filename );
-    const { stepImports, sharedStepImports, evaluatorImports, sharedEvaluatorImports } =
-      collectTargetImports( ast, fileDir, cache, filename );
+    const { activityImports } = collectTargetImports( ast, fileDir, cache );
 
     // No imports
-    if ( [].concat( stepImports, sharedStepImports, evaluatorImports, sharedEvaluatorImports ).length === 0 ) {
+    if ( activityImports.length === 0 ) {
       return callback( null, source, inputMap );
     }
 
-    const rewrote = rewriteFnBodies( { ast, stepImports, sharedStepImports, evaluatorImports, sharedEvaluatorImports } );
+    const rewrote = rewriteActivityCalls( { ast, activityImports } );
     // No edits performed
     if ( !rewrote ) {
       return callback( null, source, inputMap );