@outputai/core 0.7.0 → 0.7.1-next.0e958f3.0

package/src/worker/loader_tools.spec.js

@@ -11,6 +11,7 @@ import {
   findSharedActivitiesFromWorkflows,
   importComponents,
   findPackageRoot,
+  hashSourceCode,
   isPackageRoot,
   isPathDescendentFromNodeModules,
   resolveNodeModulesPath,
@@ -568,6 +569,41 @@ describe( 'findSharedActivitiesFromWorkflows', () => {
   } );
 } );
 
+describe( 'hashSourceCode', () => {
+  const writeSource = root => {
+    mkdirSync( join( root, 'src' ), { recursive: true } );
+    writeFileSync( join( root, 'package.json' ), JSON.stringify( { name: 'proj' } ) );
+    writeFileSync( join( root, 'src', 'workflow.js' ), 'export default {};\n' );
+  };
+
+  it( 'ignores excluded folders so accumulated run logs do not change the hash', async () => {
+    const baseline = join( TEMP_BASE, `hash-baseline-${Date.now()}` );
+    const withCruft = join( TEMP_BASE, `hash-cruft-${Date.now()}` );
+    writeSource( baseline );
+    writeSource( withCruft );
+
+    // The cruft tree is identical source plus large excluded artifacts that
+    // boot must not walk: local trace dumps under logs/ and build output under dist/.
+    for ( const excluded of [ 'logs', 'logs/runs', 'dist', 'node_modules' ] ) {
+      const dir = join( withCruft, excluded );
+      mkdirSync( dir, { recursive: true } );
+      writeFileSync( join( dir, 'dump.json' ), JSON.stringify( { blob: 'x'.repeat( 50_000 ) } ) );
+    }
+
+    expect( await hashSourceCode( withCruft ) ).toBe( await hashSourceCode( baseline ) );
+  } );
+
+  it( 'changes the hash when actual source changes', async () => {
+    const before = join( TEMP_BASE, `hash-src-before-${Date.now()}` );
+    const after = join( TEMP_BASE, `hash-src-after-${Date.now()}` );
+    writeSource( before );
+    writeSource( after );
+    writeFileSync( join( after, 'src', 'workflow.js' ), 'export default { changed: true };\n' );
+
+    expect( await hashSourceCode( after ) ).not.toBe( await hashSourceCode( before ) );
+  } );
+} );
+
 describe( 'staticMatchers', () => {
   describe( 'workflowFile', () => {
     it( 'matches paths ending with path separator and workflow.js', () => {

package/src/worker/{setup_telemetry.js → telemetry.js}

@@ -4,8 +4,11 @@ import { workerTelemetryIntervalMs } from './configs.js';
 const log = createChildLogger( 'Telemetry' );
 
 export const setupTelemetry = ( { worker } ) => {
-  if ( workerTelemetryIntervalMs > 0 ) {
-    setInterval( () => {
+  if ( workerTelemetryIntervalMs <= 0 ) {
+    return;
+  }
+  setInterval( () => {
+    try {
       log.info( 'Worker', {
         status: worker.getStatus(),
         memory: {
@@ -14,6 +17,8 @@ export const setupTelemetry = ( { worker } ) => {
           memoryUsage: process.memoryUsage()
         }
       } );
-    }, workerTelemetryIntervalMs ).unref();
-  }
+    } catch ( error ) {
+      log.warn( 'Failure', { error: error.message } );
+    }
+  }, workerTelemetryIntervalMs ).unref();
 };

package/src/worker/{setup_telemetry.spec.js → telemetry.spec.js}

@@ -1,7 +1,7 @@
 import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
 
 const configMock = vi.hoisted( () => ( { workerTelemetryIntervalMs: 0 } ) );
-const logMock = vi.hoisted( () => ( { info: vi.fn() } ) );
+const logMock = vi.hoisted( () => ( { info: vi.fn(), warn: vi.fn() } ) );
 const createChildLoggerMock = vi.hoisted( () => vi.fn( () => logMock ) );
 
 vi.mock( './configs.js', () => ( {
@@ -14,13 +14,13 @@ vi.mock( '#logger', () => ( { createChildLogger: createChildLoggerMock } ) );
 
 const loadSetupTelemetry = async () => {
   vi.resetModules();
-  return import( './setup_telemetry.js' );
+  return import( './telemetry.js' );
 };
 
 const mockSetInterval = unrefMock =>
   vi.spyOn( globalThis, 'setInterval' ).mockReturnValue( { unref: unrefMock } );
 
-describe( 'worker/setup_telemetry', () => {
+describe( 'worker/telemetry', () => {
   const availableMemoryMock = vi.fn();
   const constrainedMemoryMock = vi.fn();
   const memoryUsageMock = vi.fn();

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