@outputai/core 0.7.1-next.bd6bd49.0 → 0.7.1-next.c005dac.0

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

@@ -1,31 +1,20 @@
-import { join } from 'node:path';
 import traverseModule from '@babel/traverse';
 import {
-  buildWorkflowNameMap,
   buildEvaluatorsNameMap,
   buildSharedEvaluatorsNameMap,
   buildSharedStepsNameMap,
   buildStepsNameMap,
   getLocalNameFromDestructuredProperty,
-  isAbsoluteWorkflowJsResource,
   isEvaluatorsPath,
   isSharedEvaluatorsPath,
   isSharedStepsPath,
   isStepsPath,
-  isWorkflowPath,
   toAbsolutePath
 } from '../tools.js';
-import {
-  isBareNpmSpecifier,
-  resolveBareImportSpecifiersAsWorkflows,
-  resolveBareDestructuredRequireAsWorkflows,
-  resolveBareDefaultRequireAsWorkflow
-} from '../npm_workflow_export_resolve.js';
 
 import {
   isCallExpression,
   isIdentifier,
-  isImportDefaultSpecifier,
   isImportSpecifier,
   isObjectPattern,
   isObjectProperty,
@@ -44,12 +33,6 @@ const unresolvedImportError = ( name, fileLabel, filePath ) =>
     '(e.g. step() in steps files, evaluator() in evaluators files, workflow() in workflow files).'
   );
 
-const mixedBareWorkflowImportError = ( specifier, resourcePath ) => new Error(
-  `Workflow file '${resourcePath}': import from '${specifier}' mixes workflow exports with ` +
-  'non-workflow exports, or could not resolve every binding to a workflow.js module. ' +
-  'Split npm imports so each declaration only imports workflows, or only non-workflows.'
-);
-
 const removeRequireDeclarator = path => {
   if ( isVariableDeclaration( path.parent ) && path.parent.declarations.length === 1 ) {
     path.parentPath.remove();
@@ -84,28 +67,23 @@ const collectDestructuredRequires = ( path, absolutePath, req, descriptors ) =>
 
 /**
  * Collect and strip target imports and requires from an AST, producing
- * step/workflow import mappings for later rewrites.
+ * step/evaluator 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>>, workflowNameCache: Map<string,{default:(string|null),named:Map<string,string>}> }} caches
+ * @param {{ stepsNameCache: Map<string,Map<string,string>> }} caches
  *  Resolved-name caches to avoid re-reading same modules.
- * @param {string} [resourcePath] - Absolute path of the file being transformed; used to resolve
- *  npm package imports from `workflow.js` via Node resolution and export following.
  * @returns {{ stepImports: Array<{localName:string,stepName:string}>,
- *  flowImports: Array<{localName:string,workflowName:string}> }} Collected info mappings.
+ *  evaluatorImports: Array<{localName:string,evaluatorName:string}> }} Collected info mappings.
  */
 export default function collectTargetImports(
   ast, fileDir,
-  { stepsNameCache, workflowNameCache, evaluatorsNameCache, sharedStepsNameCache, sharedEvaluatorsNameCache },
-  resourcePath
+  { stepsNameCache, evaluatorsNameCache, sharedStepsNameCache, sharedEvaluatorsNameCache }
 ) {
-  const resolutionPath = resourcePath ?? join( fileDir, 'file.js' );
   const stepImports = [];
   const sharedStepImports = [];
-  const flowImports = [];
   const evaluatorImports = [];
   const sharedEvaluatorImports = [];
 
@@ -113,27 +91,7 @@ export default function collectTargetImports(
     ImportDeclaration: path => {
       const src = path.node.source.value;
 
-      if ( isBareNpmSpecifier( src ) && isAbsoluteWorkflowJsResource( resolutionPath ) ) {
-        const outcome = resolveBareImportSpecifiersAsWorkflows( {
-          fromAbsoluteFile: resolutionPath,
-          specifier: src,
-          specifiers: path.node.specifiers,
-          workflowNameCache
-        } );
-        if ( outcome.type === 'partial' ) {
-          throw mixedBareWorkflowImportError( src, resolutionPath );
-        }
-        if ( outcome.type === 'all' ) {
-          for ( const { localName, workflowName } of outcome.bindings ) {
-            flowImports.push( { localName, workflowName } );
-          }
-          path.remove();
-          return;
-        }
-      }
-
       const isTargetImport = isStepsPath( src ) || isSharedStepsPath( src ) ||
-        isWorkflowPath( src ) ||
         isEvaluatorsPath( src ) || isSharedEvaluatorsPath( src );
       if ( !isTargetImport ) {
         return;
@@ -166,24 +124,6 @@ export default function collectTargetImports(
         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 ) {
-          if ( isImportDefaultSpecifier( s ) ) {
-            const localName = s.local.name;
-            flowImports.push( { localName, workflowName: defName ?? localName } );
-          } else if ( isImportSpecifier( s ) ) {
-            const importedName = s.imported.name;
-            const localName = s.local.name;
-            const workflowName = named.get( importedName );
-            if ( workflowName ) {
-              flowImports.push( { localName, workflowName } );
-            } else {
-              throw unresolvedImportError( importedName, 'workflow', absolutePath );
-            }
-          }
-        }
-      }
       path.remove();
     },
     VariableDeclarator: path => {
@@ -201,38 +141,7 @@ export default function collectTargetImports(
 
       const req = firstArgument.value;
 
-      if ( isBareNpmSpecifier( req ) && isAbsoluteWorkflowJsResource( resolutionPath ) ) {
-        if ( isObjectPattern( path.node.id ) ) {
-          const outcome = resolveBareDestructuredRequireAsWorkflows( {
-            fromAbsoluteFile: resolutionPath,
-            specifier: req,
-            properties: path.node.id.properties,
-            workflowNameCache
-          } );
-          if ( outcome.type === 'partial' ) {
-            throw mixedBareWorkflowImportError( req, resolutionPath );
-          }
-          if ( outcome.type === 'all' ) {
-            for ( const { localName, workflowName } of outcome.bindings ) {
-              flowImports.push( { localName, workflowName } );
-            }
-            removeRequireDeclarator( path );
-            return;
-          }
-        } else if ( isIdentifier( path.node.id ) ) {
-          const outcome = resolveBareDefaultRequireAsWorkflow(
-            resolutionPath, req, path.node.id.name, workflowNameCache
-          );
-          if ( outcome.type === 'binding' ) {
-            flowImports.push( { localName: outcome.localName, workflowName: outcome.workflowName } );
-            removeRequireDeclarator( path );
-            return;
-          }
-        }
-      }
-
       const isTargetRequire = isStepsPath( req ) || isSharedStepsPath( req ) ||
-        isWorkflowPath( req ) ||
         isEvaluatorsPath( req ) || isSharedEvaluatorsPath( req );
       if ( !isTargetRequire ) {
         return;
@@ -263,12 +172,6 @@ export default function collectTargetImports(
             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'
           }
         ];
         collectDestructuredRequires(
@@ -276,15 +179,8 @@ export default function collectTargetImports(
         );
         return;
       }
-
-      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 } );
-        removeRequireDeclarator( path );
-      }
     }
   } );
 
-  return { stepImports, sharedStepImports, evaluatorImports, sharedEvaluatorImports, flowImports };
+  return { stepImports, sharedStepImports, evaluatorImports, sharedEvaluatorImports };
 }

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

@@ -10,7 +10,7 @@ function makeAst( source, filename ) {
 }
 
 describe( 'collect_target_imports', () => {
-  it( 'collects ESM imports for steps and workflows and flags changes', () => {
+  it( 'collects ESM imports for steps and evaluators and leaves workflow imports intact', () => {
     const dir = mkdtempSync( join( tmpdir(), 'collect-esm-' ) );
     writeFileSync( join( dir, 'steps.js' ), `
 export const StepA = step({ name: 'step.a' });
@@ -27,25 +27,20 @@ import WF, { FlowA } from './workflow.js';
 const x = 1;`;
 
     const ast = makeAst( source, join( dir, 'file.js' ) );
-    const { stepImports, evaluatorImports, flowImports } = collectTargetImports(
+    const { stepImports, evaluatorImports } = collectTargetImports(
       ast,
       dir,
-      { stepsNameCache: new Map(), evaluatorsNameCache: new Map(), workflowNameCache: new Map() }
+      { stepsNameCache: new Map(), evaluatorsNameCache: new Map() }
     );
     expect( evaluatorImports ).toEqual( [ { localName: 'EvalA', evaluatorName: 'eval.a' } ] );
 
     expect( stepImports ).toEqual( [ { localName: 'StepA', stepName: 'step.a' } ] );
-    expect( flowImports ).toEqual( [
-      { localName: 'WF', workflowName: 'flow.def' },
-      { localName: 'FlowA', workflowName: 'flow.a' }
-    ] );
-    // Import declarations should have been removed
-    expect( ast.program.body.find( n => n.type === 'ImportDeclaration' ) ).toBeUndefined();
+    expect( ast.program.body.find( n => n.type === 'ImportDeclaration' )?.source.value ).toBe( './workflow.js' );
 
     rmSync( dir, { recursive: true, force: true } );
   } );
 
-  it( 'collects CJS requires and removes declarators (steps + default workflow)', () => {
+  it( 'collects CJS requires for steps and evaluators 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\' })' );
@@ -58,20 +53,19 @@ const WF = require( './workflow.js' );
 const obj = {};`;
 
     const ast = makeAst( source, join( dir, 'file.js' ) );
-    const { stepImports, evaluatorImports, flowImports } = collectTargetImports(
+    const { stepImports, evaluatorImports } = collectTargetImports(
       ast,
       dir,
-      { stepsNameCache: new Map(), evaluatorsNameCache: new Map(), workflowNameCache: new Map() }
+      { stepsNameCache: new Map(), evaluatorsNameCache: new Map() }
     );
     expect( evaluatorImports ).toEqual( [ { localName: 'EvalB', evaluatorName: 'eval.b' } ] );
 
     expect( stepImports ).toEqual( [ { localName: 'StepB', stepName: 'step.b' } ] );
-    expect( flowImports ).toEqual( [ { localName: 'WF', workflowName: 'flow.c' } ] );
-    // All require-based declarators should have been removed (only non-require decls may remain)
+    // 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( false );
+    expect( hasRequireDecl ).toBe( true );
 
     rmSync( dir, { recursive: true, force: true } );
   } );
@@ -86,7 +80,7 @@ const obj = {};`;
     const { evaluatorImports } = collectTargetImports(
       ast,
       dir,
-      { stepsNameCache: new Map(), evaluatorsNameCache: new Map(), workflowNameCache: new Map() }
+      { stepsNameCache: new Map(), evaluatorsNameCache: new Map() }
     );
     expect( evaluatorImports ).toEqual( [ { localName: 'MyExport', evaluatorName: 'bad' } ] );
 
@@ -103,7 +97,7 @@ const obj = {};`;
     const { stepImports } = collectTargetImports(
       ast,
       dir,
-      { stepsNameCache: new Map(), evaluatorsNameCache: new Map(), workflowNameCache: new Map() }
+      { stepsNameCache: new Map(), evaluatorsNameCache: new Map() }
     );
     expect( stepImports ).toEqual( [ { localName: 'MyExport', stepName: 'bad' } ] );
 
@@ -120,7 +114,7 @@ const obj = {};`;
     const { evaluatorImports } = collectTargetImports(
       ast,
       dir,
-      { stepsNameCache: new Map(), evaluatorsNameCache: new Map(), workflowNameCache: new Map() }
+      { stepsNameCache: new Map(), evaluatorsNameCache: new Map() }
     );
     expect( evaluatorImports ).toEqual( [ { localName: 'MyExport', evaluatorName: 'bad' } ] );
 
@@ -137,14 +131,14 @@ const obj = {};`;
     const { stepImports } = collectTargetImports(
       ast,
       dir,
-      { stepsNameCache: new Map(), evaluatorsNameCache: new Map(), workflowNameCache: new Map() }
+      { stepsNameCache: new Map(), evaluatorsNameCache: new Map() }
     );
     expect( stepImports ).toEqual( [ { localName: 'MyExport', stepName: 'bad' } ] );
 
     rmSync( dir, { recursive: true, force: true } );
   } );
 
-  it( 'throws when ESM import from workflow.js has non-workflow export', () => {
+  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;' );
 
@@ -154,13 +148,14 @@ const obj = {};`;
     expect( () => collectTargetImports(
       ast,
       dir,
-      { stepsNameCache: new Map(), evaluatorsNameCache: new Map(), workflowNameCache: new Map() }
-    ) ).toThrow( /Unresolved import 'helper' from workflow file/ );
+      { 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( 'throws when CJS destructured require from workflow.js has non-workflow export', () => {
+  it( 'leaves CJS requires from workflow.js alone', () => {
     const dir = mkdtempSync( join( tmpdir(), 'collect-cjs-mismatch-wf-' ) );
     writeFileSync( join( dir, 'workflow.js' ), 'export const helper = () => 42;' );
 
@@ -170,25 +165,26 @@ const obj = {};`;
     expect( () => collectTargetImports(
       ast,
       dir,
-      { stepsNameCache: new Map(), evaluatorsNameCache: new Map(), workflowNameCache: new Map() }
-    ) ).toThrow( /Unresolved import 'helper' from workflow file/ );
+      { 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( 'collects CJS destructured require from workflow.js', () => {
+  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 source = 'const { FlowX } = require( \'./workflow.js\' );\nconst obj = {};';
     const ast = makeAst( source, join( dir, 'file.js' ) );
 
-    const { flowImports } = collectTargetImports(
+    collectTargetImports(
       ast,
       dir,
-      { stepsNameCache: new Map(), evaluatorsNameCache: new Map(), workflowNameCache: new Map() }
+      { stepsNameCache: new Map(), evaluatorsNameCache: new Map() }
     );
-    expect( flowImports ).toEqual( [ { localName: 'FlowX', workflowName: 'flow.x' } ] );
+    expect( ast.program.body.some( n => n.type === 'VariableDeclaration' ) ).toBe( true );
 
     rmSync( dir, { recursive: true, force: true } );
   } );
@@ -208,7 +204,7 @@ const obj = {};`;
     const { sharedEvaluatorImports } = collectTargetImports(
       ast,
       join( dir, 'workflows', 'my_workflow' ),
-      { stepsNameCache: new Map(), evaluatorsNameCache: new Map(), sharedEvaluatorsNameCache: new Map(), workflowNameCache: new Map() }
+      { stepsNameCache: new Map(), evaluatorsNameCache: new Map(), sharedEvaluatorsNameCache: new Map() }
     );
     expect( sharedEvaluatorImports ).toEqual( [ { localName: 'SharedEval', evaluatorName: 'shared.eval' } ] );
 
@@ -230,7 +226,7 @@ const obj = {};`;
     const { sharedEvaluatorImports } = collectTargetImports(
       ast,
       join( dir, 'workflows', 'my_workflow' ),
-      { stepsNameCache: new Map(), evaluatorsNameCache: new Map(), sharedEvaluatorsNameCache: new Map(), workflowNameCache: new Map() }
+      { stepsNameCache: new Map(), evaluatorsNameCache: new Map(), sharedEvaluatorsNameCache: new Map() }
     );
     expect( sharedEvaluatorImports ).toEqual( [ { localName: 'SharedEval', evaluatorName: 'shared.eval' } ] );
 
@@ -254,8 +250,7 @@ const obj = {};`;
       join( dir, 'workflows', 'my_workflow' ),
       {
         stepsNameCache: new Map(), sharedStepsNameCache: new Map(),
-        evaluatorsNameCache: new Map(), sharedEvaluatorsNameCache: new Map(),
-        workflowNameCache: new Map()
+        evaluatorsNameCache: new Map(), sharedEvaluatorsNameCache: new Map()
       }
     );
     expect( sharedStepImports ).toEqual( [ { localName: 'SharedA', stepName: 'shared.a' } ] );
@@ -280,8 +275,7 @@ const obj = {};`;
       join( dir, 'workflows', 'my_workflow' ),
       {
         stepsNameCache: new Map(), sharedStepsNameCache: new Map(),
-        evaluatorsNameCache: new Map(), sharedEvaluatorsNameCache: new Map(),
-        workflowNameCache: new Map()
+        evaluatorsNameCache: new Map(), sharedEvaluatorsNameCache: new Map()
       }
     );
     expect( sharedStepImports ).toEqual( [ { localName: 'MyExport', stepName: 'bad' } ] );
@@ -304,7 +298,7 @@ const obj = {};`;
     const { sharedEvaluatorImports } = collectTargetImports(
       ast,
       join( dir, 'workflows', 'my_workflow' ),
-      { stepsNameCache: new Map(), evaluatorsNameCache: new Map(), sharedEvaluatorsNameCache: new Map(), workflowNameCache: new Map() }
+      { stepsNameCache: new Map(), evaluatorsNameCache: new Map(), sharedEvaluatorsNameCache: new Map() }
     );
     expect( sharedEvaluatorImports ).toEqual( [ { localName: 'MyExport', evaluatorName: 'bad' } ] );
 
@@ -326,78 +320,12 @@ const obj = {};`;
     const { sharedEvaluatorImports } = collectTargetImports(
       ast,
       join( dir, 'workflows', 'my_workflow' ),
-      { stepsNameCache: new Map(), evaluatorsNameCache: new Map(), sharedEvaluatorsNameCache: new Map(), workflowNameCache: new Map() }
+      { stepsNameCache: new Map(), evaluatorsNameCache: new Map(), sharedEvaluatorsNameCache: new Map() }
     );
     expect( sharedEvaluatorImports ).toEqual( [ { localName: 'MyExport', evaluatorName: 'bad' } ] );
 
     rmSync( dir, { recursive: true, force: true } );
   } );
 
-  it( 'collects ESM imports from @growthxlabs/workflows_catalog', () => {
-    const dir = mkdtempSync( join( tmpdir(), 'collect-cat-esm-' ) );
-    const pkgRoot = join( dir, 'node_modules', '@growthxlabs', 'workflows_catalog' );
-    const srcDir = join( pkgRoot, 'src' );
-    mkdirSync( join( srcDir, 'workflows', 'wf' ), { recursive: true } );
-    writeFileSync( join( pkgRoot, 'package.json' ), JSON.stringify( {
-      name: '@growthxlabs/workflows_catalog',
-      type: 'module',
-      main: './src/index.js',
-      dependencies: { '@outputai/core': '1.0.0' }
-    } ) );
-    writeFileSync( join( srcDir, 'index.js' ), 'export { default as sumNumbers } from \'./workflows/wf/workflow.js\';\n' );
-    writeFileSync( join( srcDir, 'workflows', 'wf', 'workflow.js' ), 'export default workflow({ name: \'cat.flow\' });\n' );
-
-    const fileDir = join( dir, 'consumer' );
-    mkdirSync( fileDir, { recursive: true } );
-    const resourcePath = join( fileDir, 'workflow.js' );
-
-    const source = `
-import { sumNumbers as SN } from '@growthxlabs/workflows_catalog';
-const x = 1;`;
-    const ast = makeAst( source, resourcePath );
-
-    const { flowImports } = collectTargetImports(
-      ast,
-      fileDir,
-      { stepsNameCache: new Map(), evaluatorsNameCache: new Map(), workflowNameCache: new Map() },
-      resourcePath
-    );
-    expect( flowImports ).toEqual( [ { localName: 'SN', workflowName: 'cat.flow' } ] );
-    expect( ast.program.body.find( n => n.type === 'ImportDeclaration' ) ).toBeUndefined();
-
-    rmSync( dir, { recursive: true, force: true } );
-  } );
-
-  it( 'collects CJS destructured require from @growthxlabs/workflows_catalog', () => {
-    const dir = mkdtempSync( join( tmpdir(), 'collect-cat-cjs-' ) );
-    const pkgRoot = join( dir, 'node_modules', '@growthxlabs', 'workflows_catalog' );
-    const srcDir = join( pkgRoot, 'src' );
-    mkdirSync( join( srcDir, 'workflows', 'wf' ), { recursive: true } );
-    writeFileSync( join( pkgRoot, 'package.json' ), JSON.stringify( {
-      name: '@growthxlabs/workflows_catalog',
-      type: 'module',
-      main: './src/index.js',
-      dependencies: { '@outputai/core': '1.0.0' }
-    } ) );
-    writeFileSync( join( srcDir, 'index.js' ), 'export { default as sumNumbers } from \'./workflows/wf/workflow.js\';\n' );
-    writeFileSync( join( srcDir, 'workflows', 'wf', 'workflow.js' ), 'export default workflow({ name: \'cat.flow2\' });\n' );
-
-    const fileDir = join( dir, 'consumer' );
-    mkdirSync( fileDir, { recursive: true } );
-    const resourcePath = join( fileDir, 'workflow.js' );
-
-    const source = 'const { sumNumbers } = require( \'@growthxlabs/workflows_catalog\' );\nconst x = 1;';
-    const ast = makeAst( source, resourcePath );
-
-    const { flowImports } = collectTargetImports(
-      ast,
-      fileDir,
-      { stepsNameCache: new Map(), evaluatorsNameCache: new Map(), workflowNameCache: new Map() },
-      resourcePath
-    );
-    expect( flowImports ).toEqual( [ { localName: 'sumNumbers', workflowName: 'cat.flow2' } ] );
-
-    rmSync( dir, { recursive: true, force: true } );
-  } );
 } );
 

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

@@ -13,10 +13,9 @@ 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> }
 
 /**
- * Webpack loader that rewrites step/workflow calls by reading names from
+ * Webpack loader that rewrites step/evaluator calls by reading names from
  * the respective modules and transforming `fn` bodies accordingly.
  * Preserves sourcemaps.
  *
@@ -28,21 +27,21 @@ 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, sharedEvaluatorsNameCache, workflowNameCache };
+  const cache = { stepsNameCache, sharedStepsNameCache, evaluatorsNameCache, sharedEvaluatorsNameCache };
 
   try {
     const filename = this.resourcePath;
     const ast = parse( String( source ), filename );
     const fileDir = dirname( filename );
-    const { stepImports, sharedStepImports, evaluatorImports, sharedEvaluatorImports, flowImports } =
+    const { stepImports, sharedStepImports, evaluatorImports, sharedEvaluatorImports } =
       collectTargetImports( ast, fileDir, cache, filename );
 
     // No imports
-    if ( [].concat( stepImports, sharedStepImports, evaluatorImports, sharedEvaluatorImports, flowImports ).length === 0 ) {
+    if ( [].concat( stepImports, sharedStepImports, evaluatorImports, sharedEvaluatorImports ).length === 0 ) {
       return callback( null, source, inputMap );
     }
 
-    const rewrote = rewriteFnBodies( { ast, stepImports, sharedStepImports, evaluatorImports, sharedEvaluatorImports, flowImports } );
+    const rewrote = rewriteFnBodies( { ast, stepImports, sharedStepImports, evaluatorImports, sharedEvaluatorImports } );
     // No edits performed
     if ( !rewrote ) {
       return callback( null, source, inputMap );

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

@@ -1,7 +1,7 @@
 import { describe, it, expect } from 'vitest';
 import { mkdtempSync, writeFileSync, rmSync, mkdirSync } from 'node:fs';
 import { tmpdir } from 'node:os';
-import { dirname, join } from 'node:path';
+import { join } from 'node:path';
 import loader from './index.mjs';
 
 function runLoader( source, resourcePath ) {
@@ -17,7 +17,7 @@ function runLoader( source, resourcePath ) {
 }
 
 describe( 'workflows_rewriter Webpack loader spec', () => {
-  it( 'rewrites ESM imports and converts fn arrow to function', async () => {
+  it( 'rewrites ESM step imports and leaves workflow calls intact', async () => {
     const dir = mkdtempSync( join( tmpdir(), 'ast-loader-esm-' ) );
     writeFileSync( join( dir, 'steps.js' ), 'export const StepA = step({ name: \'step.a\' });' );
     writeFileSync( join( dir, 'workflow.js' ), `
@@ -39,11 +39,11 @@ const obj = {
     const { code } = await runLoader( source, join( dir, 'file.js' ) );
 
     expect( code ).not.toMatch( /from '\.\/steps\.js'/ );
-    expect( code ).not.toMatch( /from '\.\/workflow\.js'/ );
+    expect( code ).toMatch( /from '\.\/workflow\.js'/ );
     expect( code ).toMatch( /fn:\s*async function \(x\)/ );
     expect( code ).toMatch( /this\.invokeStep\('step\.a',\s*1\)/ );
-    expect( code ).toMatch( /this\.startWorkflow\('flow\.a',\s*2\)/ );
-    expect( code ).toMatch( /this\.startWorkflow\('flow\.def',\s*3\)/ );
+    expect( code ).toMatch( /FlowA\(2\)/ );
+    expect( code ).toMatch( /FlowDef\(3\)/ );
 
     rmSync( dir, { recursive: true, force: true } );
   } );
@@ -98,7 +98,7 @@ const obj = {
     rmSync( dir, { recursive: true, force: true } );
   } );
 
-  it( 'rewrites CJS requires and converts fn arrow to function', async () => {
+  it( 'rewrites CJS step requires and leaves workflow calls intact', async () => {
     const dir = mkdtempSync( join( tmpdir(), 'ast-loader-cjs-' ) );
     writeFileSync( join( dir, 'steps.js' ), 'export const StepB = step({ name: \'step.b\' });' );
     writeFileSync( join( dir, 'workflow.js' ), 'export default workflow({ name: \'flow.c\' });' );
@@ -117,10 +117,10 @@ const obj = {
     const { code } = await runLoader( source, join( dir, 'file.js' ) );
 
     expect( code ).not.toMatch( /require\('\.\/steps\.js'\)/ );
-    expect( code ).not.toMatch( /require\('\.\/workflow\.js'\)/ );
+    expect( code ).toMatch( /require\('\.\/workflow\.js'\)/ );
     expect( code ).toMatch( /fn:\s*async function \(y\)/ );
     expect( code ).toMatch( /this\.invokeStep\('step\.b'\)/ );
-    expect( code ).toMatch( /this\.startWorkflow\('flow\.c'\)/ );
+    expect( code ).toMatch( /FlowDefault\(\)/ );
 
     rmSync( dir, { recursive: true, force: true } );
   } );
@@ -143,8 +143,8 @@ const obj = { fn: async () => { StepC(); FlowC(); FlowDef(); } }`;
 
     const { code } = await runLoader( source, join( dir, 'file.js' ) );
     expect( code ).toMatch( /this\.invokeStep\('step\.const'\)/ );
-    expect( code ).toMatch( /this\.startWorkflow\('wf\.const'\)/ );
-    expect( code ).toMatch( /this\.startWorkflow\('wf\.def'\)/ );
+    expect( code ).toMatch( /FlowC\(\)/ );
+    expect( code ).toMatch( /FlowDef\(\)/ );
     rmSync( dir, { recursive: true, force: true } );
   } );
 
@@ -196,78 +196,6 @@ const obj = {
     rmSync( dir, { recursive: true, force: true } );
   } );
 
-  it( 'rewrites ESM imports from @growthxlabs/workflows_catalog to startWorkflow', async () => {
-    const dir = mkdtempSync( join( tmpdir(), 'ast-loader-catalog-' ) );
-    const pkgRoot = join( dir, 'node_modules', '@growthxlabs', 'workflows_catalog' );
-    const srcDir = join( pkgRoot, 'src' );
-    mkdirSync( join( srcDir, 'workflows', 'wf' ), { recursive: true } );
-    writeFileSync( join( pkgRoot, 'package.json' ), JSON.stringify( {
-      name: '@growthxlabs/workflows_catalog',
-      type: 'module',
-      main: './src/index.js',
-      dependencies: { '@outputai/core': '1.0.0' }
-    } ) );
-    writeFileSync( join( srcDir, 'index.js' ), 'export { default as sumNumbers } from \'./workflows/wf/workflow.js\';\n' );
-    writeFileSync( join( srcDir, 'workflows', 'wf', 'workflow.js' ), 'export default workflow({ name: \'nest.cat\' });\n' );
-
-    const resourcePath = join( dir, 'workflows', 'mine', 'workflow.js' );
-    mkdirSync( dirname( resourcePath ), { recursive: true } );
-
-    const source = `
-import { sumNumbers } from '@growthxlabs/workflows_catalog';
-
-const obj = {
-  fn: async () => {
-    sumNumbers( 1 );
-  }
-}`;
-
-    const { code } = await runLoader( source, resourcePath );
-
-    expect( code ).not.toMatch( /@growthxlabs\/workflows_catalog/ );
-    expect( code ).toMatch( /this\.startWorkflow\('nest\.cat',\s*1\)/ );
-
-    rmSync( dir, { recursive: true, force: true } );
-  } );
-
-  it( 'rewrites imports through the output workflow bundle export condition', async () => {
-    const dir = mkdtempSync( join( tmpdir(), 'ast-loader-catalog-condition-' ) );
-    const pkgRoot = join( dir, 'node_modules', '@test', 'conditional_catalog' );
-    mkdirSync( join( pkgRoot, 'bundle' ), { recursive: true } );
-    writeFileSync( join( pkgRoot, 'package.json' ), JSON.stringify( {
-      name: '@test/conditional_catalog',
-      type: 'module',
-      main: './node-entry.js',
-      exports: {
-        '.': {
-          'output-workflow-bundle': './bundle/workflow.js',
-          default: './node-entry.js'
-        }
-      }
-    } ) );
-    writeFileSync( join( pkgRoot, 'node-entry.js' ), 'export const helper = () => 1;\n' );
-    writeFileSync( join( pkgRoot, 'bundle', 'workflow.js' ), 'export default workflow({ name: \'bundle.cat\' });\n' );
-
-    const resourcePath = join( dir, 'workflows', 'mine', 'workflow.js' );
-    mkdirSync( dirname( resourcePath ), { recursive: true } );
-
-    const source = `
-import BundleCatalog from '@test/conditional_catalog';
-
-const obj = {
-  fn: async () => {
-    BundleCatalog( 1 );
-  }
-}`;
-
-    const { code } = await runLoader( source, resourcePath );
-
-    expect( code ).not.toMatch( /@test\/conditional_catalog/ );
-    expect( code ).toMatch( /this\.startWorkflow\('bundle\.cat',\s*1\)/ );
-
-    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' ), `
@@ -282,7 +210,7 @@ import { StepX } from './steps.js';
 import WF from './workflow.js';
 const obj = { fn: async () => { StepX(); WF(); } }`;
 
-    await expect( runLoader( source, join( dir, 'file.js' ) ) ).rejects.toThrow( /Invalid (step|default workflow) name/ );
+    await expect( runLoader( source, join( dir, 'file.js' ) ) ).rejects.toThrow( /Invalid step name/ );
     rmSync( dir, { recursive: true, force: true } );
   } );
 } );